From 3ce2ad902b387d07e3e7095abe538faf31377100 Mon Sep 17 00:00:00 2001
From: Christoph Brandau <christoph.brandau@janus-engineering.com>
Date: Fri, 10 Jan 2025 08:06:42 +0100
Subject: [PATCH] first try

---
 syntaxes/tcl.tmLanguage.json | 5469 ++++++++++++++++++++++++++++++++++
 1 file changed, 5469 insertions(+)
 create mode 100644 syntaxes/tcl.tmLanguage.json

diff --git a/syntaxes/tcl.tmLanguage.json b/syntaxes/tcl.tmLanguage.json
new file mode 100644
index 0000000..2dbe685
--- /dev/null
+++ b/syntaxes/tcl.tmLanguage.json
@@ -0,0 +1,5469 @@
+{
+    "$schema": "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
+    "foldingStartMarker": "([{(\\[])",
+    "foldingEndMarker": "([})\\]])",
+    "name": "Tcl",
+    "patterns": [
+        {
+            "include": "#root"
+        }
+    ],
+    "repository": {
+        "root": {
+            "patterns": [
+                {
+                    "include": "#invariant"
+                },
+                {
+                    "include": "#brackets"
+                },
+                {
+                    "include": "#proc-call"
+                }
+            ]
+        },
+        "invariant": {
+            "patterns": [
+                {
+                    "include": "#ignore-long-lines"
+                },
+                {
+                    "include": "#no-starting-empty-brackets"
+                },
+                {
+                    "include": "#no-empty-square-brackets"
+                }
+            ]
+        },
+        "no-starting-empty-brackets": {
+            "patterns": [
+                {
+                    "match": "(?<=^)\\s*+(\\{\\}|\\[\\])",
+                    "captures": {
+                        "1": {
+                            "name": "invalid.illegal.termination.tcl"
+                        }
+                    }
+                }
+            ]
+        },
+        "no-empty-square-brackets": {
+            "patterns": [
+                {
+                    "match": "(\\[\\])",
+                    "captures": {
+                        "1": {
+                            "name": "string.empty.square.brace"
+                        }
+                    }
+                }
+            ]
+        },
+        "ignore-long-lines": {
+            "comment": "long lines are not parsed for performance",
+            "patterns": [
+                {
+                    "match": "^.{1000,}"
+                }
+            ]
+        },
+        "brackets": {
+            "patterns": [
+                {
+                    "include": "#invariant"
+                },
+                {
+                    "include": "#special-brackets"
+                },
+                {
+                    "include": "#empty-brackets"
+                },
+                {
+                    "include": "#square-brackets"
+                },
+                {
+                    "include": "#curly-brackets"
+                }
+            ]
+        },
+        "square-brackets": {
+            "patterns": [
+                {
+                    "begin": "\\s*+(?<!\\\\)(\\[)",
+                    "end": "(?:(?<!\\\\)|(?<=\\\\{2}))(\\])",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "meta.brace.square.open.tcl"
+                        }
+                    },
+                    "endCaptures": {
+                        "1": {
+                            "name": "meta.brace.square.close.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#line-escape"
+                        },
+                        {
+                            "include": "#invariant"
+                        },
+                        {
+                            "include": "#proc-call"
+                        }
+                    ]
+                }
+            ]
+        },
+        "curly-brackets": {
+            "patterns": [
+                {
+                    "begin": "\\s*+({)",
+                    "end": "(})",
+                    "name": "meta.curly.enclosed",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "meta.brace.curly.open.tcl"
+                        }
+                    },
+                    "endCaptures": {
+                        "1": {
+                            "name": "meta.brace.curly.close.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#invariant"
+                        },
+                        {
+                            "include": "#special-brackets"
+                        },
+                        {
+                            "include": "#curly-brackets"
+                        },
+                        {
+                            "include": "#proc-call"
+                        }
+                    ]
+                }
+            ]
+        },
+        "curly-string-brackets": {
+            "patterns": [
+                {
+                    "include": "#empty-brackets"
+                },
+                {
+                    "begin": "\\s*+({)",
+                    "end": "(})",
+                    "name": "meta.curly.enclosed",
+                    "contentName": "string.quote.bracketed.nosubstitution.tcl",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "meta.brace.curly.open.tcl"
+                        }
+                    },
+                    "endCaptures": {
+                        "1": {
+                            "name": "meta.brace.curly.close.tcl"
+                        },
+                        "2": {
+                            "name": "invalid.illegal.charafterbrace.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "match": "([\\[\\]])",
+                            "name": "string"
+                        },
+                        {
+                            "include": "#variable-non-substituting"
+                        },
+                        {
+                            "include": "#curly-string-brackets"
+                        },
+                        {
+                            "include": "#quoted-string"
+                        },
+                        {
+                            "include": "#bare-string"
+                        }
+                    ]
+                }
+            ]
+        },
+        "empty-brackets": {
+            "patterns": [
+                {
+                    "match": "\\s*+(?={)({})",
+                    "captures": {
+                        "1": {
+                            "name": "punctuation.definition.string.brackets.tcl"
+                        }
+                    }
+                },
+                {
+                    "comment": "enclosed brackets",
+                    "match": "\\s*+{([{}]*)}",
+                    "captures": {
+                        "1": {
+                            "name": "punctuation.definition.string.brackets.tcl"
+                        }
+                    }
+                }
+            ]
+        },
+        "special-brackets": {
+            "comment": "Support for special cases that brackets may be used",
+            "patterns": [
+                {
+                    "comment": "Need to handle the case that we have {*}$varname",
+                    "include": "#variable"
+                },
+                {
+                    "comment": "Need to handle the case we spread a command {*}[list one two]",
+                    "match": "\\s*({(\\*)}?)(?=\\[|{|\")",
+                    "captures": {
+                        "1": {
+                            "name": "entity.function.name.tcl.markup.italic"
+                        },
+                        "2": {
+                            "name": "support.type"
+                        }
+                    }
+                }
+            ]
+        },
+        "expression-brackets": {
+            "patterns": [
+                {
+                    "comment": "Expressions utilize special syntax highlighting",
+                    "begin": "(\\{)",
+                    "end": "(\\})",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "meta.expression.start.tcl"
+                        }
+                    },
+                    "endCaptures": {
+                        "1": {
+                            "name": "meta.expression.end.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#empty-brackets"
+                        },
+                        {
+                            "include": "#curly-string-brackets"
+                        },
+                        {
+                            "include": "#square-brackets"
+                        },
+                        {
+                            "include": "#expressions"
+                        }
+                    ]
+                }
+            ]
+        },
+        "proc-call": {
+            "comment": "handles a proc call",
+            "patterns": [
+                {
+                    "include": "#invariant"
+                },
+                {
+                    "include": "#comment-blocks"
+                },
+                {
+                    "include": "#variable-object"
+                },
+                {
+                    "include": "#variable"
+                },
+                {
+                    "include": "#quoted-string"
+                },
+                {
+                    "include": "#keywords"
+                },
+                {
+                    "include": "#proc-call-args"
+                }
+            ]
+        },
+        "proc-call-args": {
+            "comment": "Arguments given to a proc that is being called",
+            "patterns": [
+                {
+                    "include": "#special-brackets"
+                },
+                {
+                    "include": "#brackets"
+                },
+                {
+                    "include": "#line-escape"
+                },
+                {
+                    "include": "#opt"
+                },
+                {
+                    "include": "#quoted-string"
+                },
+                {
+                    "include": "#variable"
+                },
+                {
+                    "include": "#constant-numeric"
+                },
+                {
+                    "include": "#bare-string"
+                },
+                {
+                    "begin": "(?=::)",
+                    "end": "\\s|(?=[\\]};\n])",
+                    "patterns": [
+                        {
+                            "include": "#namespace-name"
+                        }
+                    ]
+                }
+            ]
+        },
+        "keywords": {
+            "patterns": [
+                {
+                    "include": "#square-brackets"
+                },
+                {
+                    "include": "#tcl-subst"
+                },
+                {
+                    "include": "#variable"
+                },
+                {
+                    "include": "#tcl-proc"
+                },
+                {
+                    "include": "#tcl-binary"
+                },
+                {
+                    "include": "#tcl-string"
+                },
+                {
+                    "include": "#tcl-throw"
+                },
+                {
+                    "include": "#tcl-switch"
+                },
+                {
+                    "include": "#tcl-info"
+                },
+                {
+                    "include": "#tcl-incr"
+                },
+                {
+                    "include": "#tcl-interp"
+                },
+                {
+                    "include": "#tcl-oo"
+                },
+                {
+                    "include": "#tcl-try-catch"
+                },
+                {
+                    "include": "#tcl-setters"
+                },
+                {
+                    "include": "#tcl-expression-keywords"
+                },
+                {
+                    "include": "#tcl-dict"
+                },
+                {
+                    "include": "#tcl-foreach"
+                },
+                {
+                    "include": "#tcl-namespace"
+                },
+                {
+                    "include": "#tcl-oo-keywords"
+                },
+                {
+                    "include": "#regexp"
+                },
+                {
+                    "include": "#tcl-lassign"
+                },
+                {
+                    "include": "#tcl-array"
+                },
+                {
+                    "include": "#tcl-catch"
+                },
+                {
+                    "include": "#tcl-ns-commands"
+                },
+                {
+                    "include": "#tcl-puts"
+                },
+                {
+                    "include": "#tcl-upvar"
+                },
+                {
+                    "include": "#tcl-global"
+                },
+                {
+                    "include": "#tcl-vwait"
+                },
+                {
+                    "include": "#tcl-entity-commands"
+                },
+                {
+                    "match": "(?<=^|[\\[;{])\\s*+([^\\s]*)\\s+\\b(destroy|new)\\b",
+                    "captures": {
+                        "1": {
+                            "patterns": [
+                                {
+                                    "include": "#keywords"
+                                }
+                            ]
+                        },
+                        "2": {
+                            "name": "keyword.control.special.tcl"
+                        }
+                    }
+                },
+                {
+                    "include": "#tcl-core-commands"
+                },
+                {
+                    "match": "(?:(?<=^|[\\[{;])\\s*|(?<=::)(?![\\s\"]))([^\\s}\\]{\\[;\\\\\"]*)(?=$|{}|[\\s\n\\]}\\[;])",
+                    "captures": {
+                        "1": {
+                            "patterns": [
+                                {
+                                    "include": "#namespace-name"
+                                }
+                            ]
+                        }
+                    }
+                }
+            ]
+        },
+        "tcl-core-commands": {
+            "patterns": [
+                {
+                    "comment": "imports & requires",
+                    "begin": "(?<=^|\\[|{|;)\\s*(::)?\\b(package|include|includes)\\b",
+                    "end": "(?=(?<!\\\\)(?:$|[\n;}\\]]))",
+                    "captures": {
+                        "1": {
+                            "name": "support.type.ns.separator"
+                        },
+                        "2": {
+                            "name": "keyword.control.import.package.tcl"
+                        },
+                        "3": {
+                            "name": "support.type.ns.separator"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "begin": "(?<=package)\\s*(require|provide)\\s*(?!$|\n)",
+                            "end": "(?=(?<!\\\\)(?:$|[\n;}\\]]))",
+                            "captures": {
+                                "1": {
+                                    "name": "keyword.control.package.require.tcl"
+                                }
+                            },
+                            "patterns": [
+                                {
+                                    "include": "#line-escape"
+                                },
+                                {
+                                    "include": "#constant-numeric"
+                                },
+                                {
+                                    "include": "#variable"
+                                },
+                                {
+                                    "include": "#namespace-name"
+                                }
+                            ]
+                        },
+                        {
+                            "begin": "(?<=include|includes)",
+                            "end": "(?=(?<!\\\\)(?:$|[\n;}\\]]))",
+                            "contentName": "string"
+                        }
+                    ]
+                },
+                {
+                    "include": "regexp"
+                },
+                {
+                    "begin": "(?<=^|\\[|{|;)\\s*(::)?\\b(format|scan)\\b",
+                    "end": "(?=(?<!\\\\)(?:$|[\n\\]};]))",
+                    "captures": {
+                        "1": {
+                            "name": "support.type"
+                        },
+                        "2": {
+                            "name": "keyword.control.format.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#line-escape"
+                        },
+                        {
+                            "include": "#square-brackets"
+                        },
+                        {
+                            "include": "#variable"
+                        },
+                        {
+                            "include": "#quoted-string"
+                        },
+                        {
+                            "include": "#constant-numeric"
+                        },
+                        {
+                            "match": "(%)([.])?([0-9]*)?([.duioxXcsfegG])",
+                            "captures": {
+                                "1": {
+                                    "name": "support.type.tcl"
+                                },
+                                "2": {
+                                    "name": "meta.class"
+                                },
+                                "3": {
+                                    "name": "meta.constant.tcl"
+                                },
+                                "4": {
+                                    "name": "entity.function.name.tcl"
+                                }
+                            }
+                        },
+                        {
+                            "match": "(?<=\\s)\\s*(?![%.$])([^\\s\\]}\\[{;\n]*)",
+                            "captures": {
+                                "1": {
+                                    "name": "variable",
+                                    "patterns": [
+                                        {
+                                            "include": "#variable-bare-italic"
+                                        }
+                                    ]
+                                }
+                            }
+                        },
+                        {
+                            "include": "#format-brackets"
+                        }
+                    ]
+                },
+                {
+                    "match": "(?:(?<=^|\\[|{|;)\\s*(::)?|(?<=::))\\b(try|apply|exit|flush|chan|lreverse|error|gets|for|lrepeat|lsearch|fconfigure|chan|open|close|next|while|format|lindex|linsert|concat|lsort|glob|tuapi|subst|upvar|uplevel|fileutil|continue|cluster|break|yield|load|split|switch|yieldto|catch|source|cd|file|wget|join|throw|lrange|lset|lmap|lassign|llength|lwhere|list|return|puts|clock|state|variable|after|task|return|interp)\\b(::)?",
+                    "name": "keyword.control.tcl",
+                    "captures": {
+                        "1": {
+                            "name": "support.type.ns.separator"
+                        },
+                        "2": {
+                            "name": "keyword.control.tcl"
+                        },
+                        "3": {
+                            "name": "support.type.ns.separator"
+                        }
+                    }
+                }
+            ]
+        },
+        "format-brackets": {
+            "patterns": [
+                {
+                    "begin": "\\s*({)",
+                    "end": "(})",
+                    "contentName": "string.format.contents.tcl",
+                    "patterns": [
+                        {
+                            "include": "#variable-non-substituting"
+                        },
+                        {
+                            "include": "#format-brackets"
+                        },
+                        {
+                            "include": "#empty-brackets"
+                        },
+                        {
+                            "match": "([#0-9+-])([duioxXcsfegG]?)",
+                            "captures": {
+                                "1": {
+                                    "name": "meta.constant"
+                                },
+                                "2": {
+                                    "name": "support.type"
+                                }
+                            }
+                        },
+                        {
+                            "match": "\\s*+(%)([.duioxXcsfegG])",
+                            "captures": {
+                                "1": {
+                                    "name": "support.type.tcl"
+                                },
+                                "2": {
+                                    "name": "entity.function.name.tcl"
+                                }
+                            }
+                        },
+                        {
+                            "match": "([;])",
+                            "name": "string"
+                        },
+                        {
+                            "include": "#constant-numeric"
+                        }
+                    ]
+                }
+            ]
+        },
+        "regular-expression": {
+            "patterns": [
+                {
+                    "match": "(?<!\\\\)(\\#.*)(?=\n|$)",
+                    "name": "comment"
+                },
+                {
+                    "match": "(\\.)([?+*])",
+                    "captures": {
+                        "1": {
+                            "name": "support.type.re.anychar.tcl"
+                        },
+                        "2": {
+                            "name": "variable.re.modifier.tcl"
+                        }
+                    }
+                },
+                {
+                    "match": "(?<={|^)\\s*(\\^)",
+                    "name": "meta.class.re.start.tcl"
+                },
+                {
+                    "match": "(?<!\\\\)(\\$)(?=\\s*}|\n)",
+                    "name": "meta.class.re.end.tcl"
+                },
+                {
+                    "match": "(\\\\)(?=\\s*})",
+                    "name": "invalid.illegal.re.tcl"
+                },
+                {
+                    "match": "(?<!\\\\)(\\|)",
+                    "name": "meta.constant.re.or.tcl"
+                },
+                {
+                    "comment": "the character whose value is 0",
+                    "match": "(?<!\\\\)(\\\\)0[^0-9a-fA-F]",
+                    "captures": {
+                        "1": {
+                            "name": "support.type.re.escape.tcl"
+                        },
+                        "2": {
+                            "name": "support.type.re.escaped.value.tcl"
+                        }
+                    }
+                },
+                {
+                    "comment": "(where X is any character) the character whose low-order 5 bits are the same as those of X, and whose other bits are all zero",
+                    "match": "(?<!\\\\)(\\\\)(c)(.)",
+                    "captures": {
+                        "1": {
+                            "name": "support.type.re.escape.tcl"
+                        },
+                        "2": {
+                            "name": "support.type.re.escaped.value.tcl"
+                        },
+                        "3": {
+                            "name": "entity.function.name.re.unicode.punctuation.italic.tcl"
+                        }
+                    }
+                },
+                {
+                    "comment": "(up to four hexadecimal digits) the Unicode character U+wxyz",
+                    "match": "(?<!\\\\)(\\\\)(u)([0-9a-fA-F]{1,4})",
+                    "captures": {
+                        "1": {
+                            "name": "support.type.re.escape.tcl"
+                        },
+                        "2": {
+                            "name": "support.type.re.escaped.value.tcl"
+                        },
+                        "3": {
+                            "name": "entity.function.name.re.unicode.punctuation.italic.tcl"
+                        }
+                    }
+                },
+                {
+                    "comment": "reserved for a Unicode extension up to 21 bits. The digits are parsed until the first non-hexadecimal character is encountered, the maximun of eight hexadecimal digits are reached, or an overflow would occur in the maximum value of U+10ffff.",
+                    "match": "(?<!\\\\)(\\\\)(U)([0-9a-fA-F]{1,8})",
+                    "captures": {
+                        "1": {
+                            "name": "support.type.re.escape.tcl"
+                        },
+                        "2": {
+                            "name": "support.type.re.escaped.value.tcl"
+                        },
+                        "3": {
+                            "name": "entity.function.name.re.unicode.punctuation.italic.tcl"
+                        }
+                    }
+                },
+                {
+                    "comment": "(where hh is one or two hexadecimal digits) the character whose hexadecimal value is 0xhh",
+                    "match": "(?<!\\\\)(\\\\)(x)([0-9a-fA-F]{1,2})",
+                    "captures": {
+                        "1": {
+                            "name": "support.type.re.escape.tcl"
+                        },
+                        "2": {
+                            "name": "support.type.re.escaped.value.tcl"
+                        },
+                        "3": {
+                            "name": "entity.function.name.re.unicode.punctuation.italic.tcl"
+                        }
+                    }
+                },
+                {
+                    "comment": "the character whose octal value is 0xy?z?. The first digit must be in the range 0-3, otherwise the two-digit form is assumed.",
+                    "match": "(?<!\\\\)(\\\\)([0-3][0-7]{2}|[0-7]{2})",
+                    "captures": {
+                        "1": {
+                            "name": "support.type.re.escape.tcl"
+                        },
+                        "2": {
+                            "name": "support.type.re.escaped.value.tcl"
+                        },
+                        "3": {
+                            "name": "entity.function.name.re.unicode.punctuation.italic.tcl"
+                        }
+                    }
+                },
+                {
+                    "match": "(?<!\\\\)(\\\\)([1-9][0-9]?[0-9]?)",
+                    "captures": {
+                        "1": {
+                            "name": "support.type.re.escape.tcl"
+                        },
+                        "2": {
+                            "name": "meta.constant.numeric.tcl"
+                        }
+                    }
+                },
+                {
+                    "match": "(?<!\\\\)(\\\\)([abBefnrtv0dswDSWAmMyYZ])?",
+                    "captures": {
+                        "1": {
+                            "name": "support.type.re.escape.tcl"
+                        },
+                        "2": {
+                            "name": "support.type.re.escaped.value.tcl"
+                        }
+                    }
+                },
+                {
+                    "begin": "(?<!\\\\)(\\()(\\?[!:=])",
+                    "end": "(?<!\\\\)(\\))",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "meta.constant.re.lookahead.close.punctuation.italic.tcl"
+                        },
+                        "2": {
+                            "name": "meta.class.re.lookahead.type.tcl"
+                        }
+                    },
+                    "endCaptures": {
+                        "1": {
+                            "name": "meta.constant.re.lookahead.close.punctuation.italic.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#regular-expression"
+                        }
+                    ]
+                },
+                {
+                    "begin": "(?<!\\\\)(\\()(\\?)(?![!:=\\)])",
+                    "end": "(?<!\\\\)(\\))",
+                    "contentName": "entity.function.name.punctuation.italic.underline.re.meta.flags.tcl",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "meta.constant.re.lookahead.open.punctuation.italic.tcl"
+                        },
+                        "2": {
+                            "name": "keyword.control.re.meta.tcl"
+                        }
+                    },
+                    "endCaptures": {
+                        "1": {
+                            "name": "meta.constant.re.lookahead.close.punctuation.italic.tcl"
+                        }
+                    }
+                },
+                {
+                    "begin": "(?<!\\\\)(\\[)(\\^)?",
+                    "end": "(?<!\\\\)([\\]])([*?+]([?+]?))?",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "meta.constant.re.lookahead.close.punctuation.italic.tcl"
+                        },
+                        "2": {
+                            "name": "meta.variable.re.negate.chars.tcl"
+                        }
+                    },
+                    "endCaptures": {
+                        "1": {
+                            "name": "meta.constant.re.lookahead.close.punctuation.italic.tcl"
+                        },
+                        "2": {
+                            "name": "variable.re.modifier.tcl"
+                        },
+                        "3": {
+                            "name": "support.type.re.nongreedy.punctuation.italic.tcl"
+                        }
+                    },
+                    "contentName": "meta.class",
+                    "patterns": [
+                        {
+                            "match": "(?<!\\\\)(\\\\)(.)",
+                            "captures": {
+                                "1": {
+                                    "name": "support.type.re.escape.tcl"
+                                },
+                                "2": {
+                                    "name": "meta.class"
+                                }
+                            }
+                        },
+                        {
+                            "begin": "(?<!-)(\\[[:=])",
+                            "end": "([:=]\\])(?!-)",
+                            "beginCaptures": {
+                                "1": {
+                                    "name": "entity.function.name.re.bracket.expression.open.punctuation.italic.tcl"
+                                }
+                            },
+                            "endCaptures": {
+                                "1": {
+                                    "name": "entity.function.name.re.bracket.expression.close.punctuation.italic.tcl"
+                                }
+                            },
+                            "patterns": [
+                                {
+                                    "match": "([^:=\\]]*)(?=[:=]\\])",
+                                    "name": "support.type.punctuation.italic.tcl"
+                                }
+                            ]
+                        },
+                        {
+                            "match": "(\\\\)([abBefnrtv0dsw])",
+                            "captures": {
+                                "1": {
+                                    "name": "support.type.re.escape.tcl"
+                                },
+                                "2": {
+                                    "name": "support.type.re.escaped.value.tcl"
+                                }
+                            }
+                        },
+                        {
+                            "match": "(?<!(?<!\\\\)\\\\)(-)",
+                            "name": "entity.function.name"
+                        }
+                    ]
+                },
+                {
+                    "begin": "(?<!\\\\)(\\()",
+                    "end": "(?<!\\\\)(\\))",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "keyword.control"
+                        }
+                    },
+                    "endCaptures": {
+                        "1": {
+                            "name": "keyword.control"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#regular-expression"
+                        }
+                    ]
+                },
+                {
+                    "match": "(?<!\\\\)({([0-9]*)(\\,)?([0-9]*)?})",
+                    "captures": {
+                        "1": {
+                            "name": "entity.function.name"
+                        },
+                        "2": {
+                            "name": "meta.constant.re.number.tcl"
+                        },
+                        "3": {
+                            "name": "support.type.re.expand.tcl"
+                        },
+                        "4": {
+                            "name": "meta.constant.re.number.tcl"
+                        }
+                    }
+                },
+                {
+                    "match": "(?:(?<!\\\\\\.)(?<=\\.))(?<=\\.|\\])((?<!\\\\)[*?+])",
+                    "name": "meta.constant.re.tcl"
+                },
+                {
+                    "match": "(?<=\\*|\\+)((?<!\\\\)[*?+])",
+                    "name": "support.type.re.tcl"
+                },
+                {
+                    "match": "(?<!\\\\)(\\*)",
+                    "name": "variable.re.modifier.tcl"
+                },
+                {
+                    "match": "((?<!\\\\)[.?^!$+])",
+                    "name": "variable.re.modifier.tcl"
+                },
+                {
+                    "match": "(?<=\\.)((?<!\\\\)[*?])",
+                    "name": "variable.re.modifier.tcl"
+                }
+            ]
+        },
+        "expressions": {
+            "patterns": [
+                {
+                    "include": "#variable"
+                },
+                {
+                    "include": "#curly-string-brackets"
+                },
+                {
+                    "include": "#square-brackets"
+                },
+                {
+                    "include": "#expression-functions"
+                },
+                {
+                    "include": "#constant-numeric"
+                },
+                {
+                    "include": "#expression-operators"
+                },
+                {
+                    "comment": "order-of-operations",
+                    "begin": "(\\()",
+                    "end": "\\s*(\\))",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "entity.function.name.expression.brace.ooo.open.tcl"
+                        }
+                    },
+                    "endCaptures": {
+                        "1": {
+                            "name": "entity.function.name.expression.brace.ooo.close.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#expressions"
+                        }
+                    ]
+                },
+                {
+                    "include": "#quoted-string"
+                }
+            ]
+        },
+        "constant-numeric": {
+            "patterns": [
+                {
+                    "match": "\\s*+((?:#?|\\.)?(?:\\B[-+])?(?:\\b0[bB][0-1]*|\\b0[oO][0-7]*|\\b(0([xX]))[0-9a-fA-F]*|(\\B\\.[0-9]+|\\b[0-9]+(\\.[0-9]*)?)([eE][-+]?[0-9]+)?))",
+                    "captures": {
+                        "1": {
+                            "name": "meta.constant.numeric"
+                        },
+                        "2": {
+                            "name": "punctuation.italic"
+                        },
+                        "3": {
+                            "name": "support.type"
+                        }
+                    }
+                },
+                {
+                    "match": "\\s*+\\b(true|false|bool|entier|integer|float|null)\\b",
+                    "name": "meta.constant.punctuation.italic"
+                }
+            ]
+        },
+        "expression-operators": {
+            "patterns": [
+                {
+                    "comment": "expression word operators",
+                    "match": "\\b(in|ni|eq|ne)\\b",
+                    "name": "support.type.operator.punctuation.italic.tcl"
+                },
+                {
+                    "comment": "expression operators",
+                    "match": "(=|\\+|-|\\*|/|%)",
+                    "name": "support.type.operator.tcl"
+                },
+                {
+                    "comment": "expression comparisons",
+                    "match": "([<>])",
+                    "name": "support.type.expression.operator.tcl"
+                },
+                {
+                    "comment": "expression bitwise",
+                    "match": "([|^&!~])",
+                    "name": "support.type.expression.operator.tcl"
+                },
+                {
+                    "comment": "expression ternary",
+                    "match": "([?:])",
+                    "name": "support.type.expression.operator.tcl"
+                }
+            ]
+        },
+        "expression-functions": {
+            "patterns": [
+                {
+                    "begin": "\\b(abs|acos|asin|atan|atan2|bool|ceil|cos|cosh|double|entier|exp|floor|fmod|hypot|int|isqrt|log|log10|max|min|pow|rand|round|sin|sinh|sqrt|srand|tan|tanh|wide)\\b(\\()",
+                    "end": "(\\))",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "entity.function.name.math.function.punctuatio.italic.tcl"
+                        },
+                        "2": {
+                            "name": "entity.function.name.math.function.brace.open.tcl"
+                        }
+                    },
+                    "endCaptures": {
+                        "1": {
+                            "name": "entity.function.name.math.function.brace.close.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#expressions"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-vwait": {
+            "patterns": [
+                {
+                    "include": "#line-escape"
+                },
+                {
+                    "comment": "vwait varName",
+                    "begin": "(?<=^|\\[|{|;)\\s*(::)?\\b(vwait)\\b\\s*+(?!$|\n|;|^|\\]|})",
+                    "end": "(?=$|\n|;|\\]|}|\\s)\\s*([^$\n^\\];}\\[\\\\]*)?(\\\\(?!\n))?",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "support.type.ns.tcl"
+                        },
+                        "2": {
+                            "name": "keyword.control.vwait.tcl"
+                        }
+                    },
+                    "endCaptures": {
+                        "1": {
+                            "name": "invalid.illegal.numargs.tcl"
+                        },
+                        "2": {
+                            "name": "invalid.illegal.escape.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#line-escape"
+                        },
+                        {
+                            "include": "#variable"
+                        },
+                        {
+                            "include": "#variable-bare-italic"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-proc": {
+            "patterns": [
+                {
+                    "begin": "(?<=^|[\\[{;])\\s*(::)?\\b(proc)\\b\\s+([^\\s\n]+)\\s+(?={|\\b|\\[|\"|\\\\$)",
+                    "end": "(?=(?<!\\\\)$)",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "support.type"
+                        },
+                        "2": {
+                            "name": "keyword.control.proc.tcl"
+                        },
+                        "3": {
+                            "patterns": [
+                                {
+                                    "include": "#variable"
+                                },
+                                {
+                                    "include": "#brackets"
+                                },
+                                {
+                                    "include": "#namespace-name"
+                                }
+                            ]
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#quoted-string"
+                        },
+                        {
+                            "include": "#proc-arguments"
+                        },
+                        {
+                            "include": "#brackets"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-subst": {
+            "patterns": [
+                {
+                    "begin": "(?<=^|[\\[{;])\\s*((?:::)?\\bsubst\\b)(?!\\s*$)",
+                    "end": "(?=(?<!\\\\)(?:$|[;\\]}]))|(?<=})",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "keyword.control.subst.tcl",
+                            "patterns": [
+                                {
+                                    "include": "#namespace-separator"
+                                }
+                            ]
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "begin": "(?<=subst)\\b((?:\\s+(?:-nobackslashes|-nocommands|-novariables))?)(?!\\s*$)",
+                            "end": "(?=(?<!\\\\)(?:$|[;\\]}]))|(?<=})",
+                            "beginCaptures": {
+                                "1": {
+                                    "patterns": [
+                                        {
+                                            "include": "#opt"
+                                        }
+                                    ]
+                                }
+                            },
+                            "patterns": [
+                                {
+                                    "include": "#proc-call-args"
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-throw": {
+            "patterns": [
+                {
+                    "begin": "(?<=^|\\[|{|;)\\s*(::)?\\b(throw)\\b\\s+(?!\n)([^\\s]*)",
+                    "end": "\\s*(?=$|\n|}|\\]|;)",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "support.type"
+                        },
+                        "2": {
+                            "name": "keyword.control.throw.tcl"
+                        },
+                        "3": {
+                            "name": "support.type",
+                            "patterns": [
+                                {
+                                    "include": "#variable"
+                                }
+                            ]
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#line-escape"
+                        },
+                        {
+                            "include": "#proc-call-args"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-binary": {
+            "patterns": [
+                {
+                    "begin": "(?<=^|\\[|{|;)\\s*(::)?\\b(binary)\\b\\s+(?!\n)([^\\s\\[{;\n\\]]*)",
+                    "end": "\\s*(?=$|\n|\\]|;|})",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "support.type"
+                        },
+                        "2": {
+                            "name": "keyword.control.throw.tcl"
+                        },
+                        "3": {
+                            "name": "entity.function.name.binary.tcl",
+                            "patterns": [
+                                {
+                                    "include": "#variable"
+                                }
+                            ]
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#line-escape"
+                        },
+                        {
+                            "begin": "(?<=scan|format)\\s+(?!\n)",
+                            "end": "(?=(?<!\\\\)(?:$|[\n\\]};]))",
+                            "patterns": [
+                                {
+                                    "include": "#line-escape"
+                                },
+                                {
+                                    "include": "#variable"
+                                },
+                                {
+                                    "include": "#glob-match"
+                                }
+                            ]
+                        },
+                        {
+                            "include": "#proc-call-args"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-switch": {
+            "patterns": [
+                {
+                    "begin": "(?<=^|\\[|{|;)\\s*(::)?\\b(switch)\\b",
+                    "end": "(?=(?<!\\\\)(?:$|[;\\]}]))|(?<=})",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "support.type"
+                        },
+                        "2": {
+                            "name": "keyword.control.switch.tcl"
+                        },
+                        "3": {
+                            "name": "entity.function.name.state.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "begin": "(?<=switch)\\b(\\s+(?!$)(?:(?:-|\\$)[^\\s\n]*\\s+|\\[[^\\]\n]*(?=\\]))*+)(?!\\s*{|\\[|\\s*$)",
+                            "end": "(?=(?<!\\\\)(?:$|[;\\]}]))",
+                            "beginCaptures": {
+                                "1": {
+                                    "patterns": [
+                                        {
+                                            "include": "#line-escape"
+                                        },
+                                        {
+                                            "include": "#opt"
+                                        },
+                                        {
+                                            "include": "#double-dash"
+                                        },
+                                        {
+                                            "include": "#variable"
+                                        },
+                                        {
+                                            "include": "#square-brackets"
+                                        }
+                                    ]
+                                }
+                            },
+                            "patterns": [
+                                {
+                                    "include": "#line-escape"
+                                },
+                                {
+                                    "include": "#variable"
+                                },
+                                {
+                                    "match": "(default)",
+                                    "name": "keyword.control.default.switch.unbraced.tcl"
+                                },
+                                {
+                                    "include": "#brackets"
+                                },
+                                {
+                                    "include": "#bare-string"
+                                }
+                            ]
+                        },
+                        {
+                            "begin": "(?<=switch)\\b(\\s+(?!$)(?:(?:-|\\$)[^\\s]*\\s+|\\[[^\\]\n]*(?=\\]))*+)(?=\\s*{)",
+                            "end": "(?=(?<!\\\\)(?:$|[;\\]}]))|(?<=})",
+                            "beginCaptures": {
+                                "1": {
+                                    "patterns": [
+                                        {
+                                            "include": "#line-escape"
+                                        },
+                                        {
+                                            "include": "#opt"
+                                        },
+                                        {
+                                            "include": "#double-dash"
+                                        },
+                                        {
+                                            "include": "#variable"
+                                        },
+                                        {
+                                            "include": "#square-brackets"
+                                        }
+                                    ]
+                                }
+                            },
+                            "patterns": [
+                                {
+                                    "include": "#line-escape"
+                                },
+                                {
+                                    "include": "#variable"
+                                },
+                                {
+                                    "begin": "\\s*+({)",
+                                    "end": "(})",
+                                    "beginCaptures": {
+                                        "1": {
+                                            "name": "meta.brace.switch.open.tcl"
+                                        }
+                                    },
+                                    "endCaptures": {
+                                        "1": {
+                                            "name": "meta.brace.switch.close.tcl"
+                                        }
+                                    },
+                                    "patterns": [
+                                        {
+                                            "include": "#variable-non-substituting"
+                                        },
+                                        {
+                                            "include": "#empty-brackets"
+                                        },
+                                        {
+                                            "match": "\\s?(-)\\s",
+                                            "name": "meta.constant.switch.next.tcl"
+                                        },
+                                        {
+                                            "match": "\\s*\\b(default)\\b\\s+(?={)",
+                                            "name": "keyword.control.punctuation.italic.tcl"
+                                        },
+                                        {
+                                            "include": "#brackets"
+                                        },
+                                        {
+                                            "include": "#glob-match"
+                                        },
+                                        {
+                                            "include": "#bare-string"
+                                        }
+                                    ]
+                                },
+                                {
+                                    "match": "(default)",
+                                    "name": "keyword.control.default.switch.unbraced.tcl"
+                                },
+                                {
+                                    "include": "#brackets"
+                                },
+                                {
+                                    "include": "#bare-string"
+                                }
+                            ]
+                        },
+                        {
+                            "begin": "(?<=switch)\\b(\\s+(?!$)(?:(?!(?<!\\\\)$)(?:-|\\$)[^\\s]*(?:(?!\\s*$)\\s+)?|\\[[^\\]\n]*(?=\\]))*+)",
+                            "end": "(?=(?<!\\\\)(?:$|[;\\]}]))|(?<=})",
+                            "beginCaptures": {
+                                "1": {
+                                    "patterns": [
+                                        {
+                                            "include": "#line-escape"
+                                        },
+                                        {
+                                            "include": "#opt"
+                                        },
+                                        {
+                                            "include": "#double-dash"
+                                        },
+                                        {
+                                            "include": "#variable"
+                                        },
+                                        {
+                                            "include": "#square-brackets"
+                                        }
+                                    ]
+                                }
+                            },
+                            "patterns": [
+                                {
+                                    "include": "#line-escape"
+                                },
+                                {
+                                    "include": "#variable"
+                                },
+                                {
+                                    "match": "(default)",
+                                    "name": "keyword.control.default.switch.unbraced.tcl"
+                                },
+                                {
+                                    "include": "#brackets"
+                                },
+                                {
+                                    "include": "#bare-string"
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-puts": {
+            "patterns": [
+                {
+                    "begin": "(?<=^|\\[|{|;)\\s*\\b(puts)\\b",
+                    "end": "(?=$|\n|}|\\]|;)",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "keyword.control.puts.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#line-escape"
+                        },
+                        {
+                            "include": "#opt"
+                        },
+                        {
+                            "match": "(?:(?<=puts)|^|(?<=-nonewline))\\s*+(?!\n|$)([^\\s$\n;}\\]\\[{\"]*+)(?!\\s*(?:$|\n|}|\\]|;|^))",
+                            "name": "support.type.puts.channel.punctuation.italic.tcl"
+                        },
+                        {
+                            "include": "#square-brackets"
+                        },
+                        {
+                            "include": "#curly-string-brackets"
+                        },
+                        {
+                            "include": "#quoted-string"
+                        },
+                        {
+                            "include": "#bare-string"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-global": {
+            "patterns": [
+                {
+                    "begin": "(?<=^|{|\\[|;)\\s*\\b(global)\\b",
+                    "end": "(?=$|\n|\\]|}|;)",
+                    "captures": {
+                        "1": {
+                            "name": "keyword.control.global.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#variable-bare-italic"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-state-keywords": {
+            "patterns": [
+                {
+                    "include": "#line-escape"
+                },
+                {
+                    "match": "(?<=state)\\s+\\b(set|get|pull|register|apply_middleware|configure|push|subscription|query|json|serialize)\\b",
+                    "name": "entity.function.state.name.tcl"
+                },
+                {
+                    "match": "(?<=state::)([^\\s\\]};]*)",
+                    "captures": {
+                        "1": {
+                            "name": "entity.function.state.name.tcl",
+                            "patterns": [
+                                {
+                                    "include": "#namespace-separator"
+                                }
+                            ]
+                        }
+                    }
+                }
+            ]
+        },
+        "tcl-state-configure": {
+            "patterns": [
+                {
+                    "begin": "(?<=configure|apply_middleware)\\s+(?!$|\n|;|\\]|}|^)([^\\s$}\\]\\[{;\\\\]*)",
+                    "end": "(?=$|\n|\\]|}|;)",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "meta.class"
+                        },
+                        "2": {
+                            "patterns": [
+                                {
+                                    "include": "#tcl-class-name"
+                                }
+                            ]
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#line-escape"
+                        },
+                        {
+                            "include": "#proc-call-args"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-state-register": {
+            "patterns": [
+                {
+                    "begin": "(?<=register)(\\s+[^\\s\\[\\];\n]+)?",
+                    "end": "(?<=})",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "meta.constant",
+                            "patterns": [
+                                {
+                                    "include": "#tcl-class-name"
+                                }
+                            ]
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#line-escape"
+                        },
+                        {
+                            "include": "#square-brackets"
+                        },
+                        {
+                            "begin": "\\s*({)",
+                            "end": "\\s*(})",
+                            "captures": {
+                                "1": {
+                                    "name": "meta.bracket.state.register.tcl"
+                                }
+                            },
+                            "patterns": [
+                                {
+                                    "include": "#tcl-state-option-title"
+                                },
+                                {
+                                    "include": "#tcl-state-option-items"
+                                },
+                                {
+                                    "begin": "(?<=^|\\s)(middlewares|config|default)\\b(?=\\s*{)",
+                                    "end": "(?<=})",
+                                    "beginCaptures": {
+                                        "1": {
+                                            "name": "keyword.state.register.tcl"
+                                        }
+                                    },
+                                    "patterns": [
+                                        {
+                                            "include": "#variable-non-substituting"
+                                        },
+                                        {
+                                            "begin": "(?<=config|default)\\s+({)",
+                                            "end": "\\s*(})",
+                                            "captures": {
+                                                "1": {
+                                                    "name": "meta.bracket.state.config.tcl"
+                                                }
+                                            },
+                                            "patterns": [
+                                                {
+                                                    "include": "#variable-non-substituting"
+                                                },
+                                                {
+                                                    "begin": "\\s*([^\\s|}|{|;]*)\\s+({)",
+                                                    "end": "(})",
+                                                    "beginCaptures": {
+                                                        "1": {
+                                                            "name": "variable"
+                                                        }
+                                                    },
+                                                    "patterns": [
+                                                        {
+                                                            "include": "#property-list"
+                                                        }
+                                                    ]
+                                                },
+                                                {
+                                                    "match": "\\s*([^\\s|}|{|;]*)(\\s+[^}|{|;]*)",
+                                                    "captures": {
+                                                        "1": {
+                                                            "name": "variable",
+                                                            "patterns": [
+                                                                {
+                                                                    "include": "#variable"
+                                                                }
+                                                            ]
+                                                        },
+                                                        "2": {
+                                                            "name": "string",
+                                                            "patterns": [
+                                                                {
+                                                                    "include": "#constant-numeric"
+                                                                }
+                                                            ]
+                                                        }
+                                                    }
+                                                },
+                                                {
+                                                    "include": "#curly-string-brackets"
+                                                }
+                                            ]
+                                        },
+                                        {
+                                            "begin": "(?<=middlewares)\\s*+({)",
+                                            "end": "\\s*(})",
+                                            "patterns": [
+                                                {
+                                                    "match": "\\s*([^\\s|}|;]*)",
+                                                    "captures": {
+                                                        "1": {
+                                                            "name": "meta.class.state.middleware.tcl"
+                                                        }
+                                                    }
+                                                }
+                                            ]
+                                        }
+                                    ]
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-state-unsubscribe": {
+            "patterns": [
+                {
+                    "begin": "\\b(unsubscribe)\\b",
+                    "end": "(?=$|\n|;|\\]|})",
+                    "patterns": [
+                        {
+                            "include": "#opt"
+                        },
+                        {
+                            "include": "#glob-match"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-state-subscribe": {
+            "patterns": [
+                {
+                    "begin": "\\s*\\b(subscribe)\\b",
+                    "end": "(?<=})|(?=$|\n|;|\\])",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "entity.function.name.state.subscribe.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "match": "(?<=subscribe)\\b(?!\\[)(\\s+[^\\s\n]*)(?:(?!\\s*(?:$|;|}|\\]))\\s*)?",
+                            "name": "meta.class.state.name",
+                            "captures": {
+                                "1": {
+                                    "patterns": [
+                                        {
+                                            "include": "#variable"
+                                        }
+                                    ]
+                                }
+                            }
+                        },
+                        {
+                            "match": "(?=\\s*\\$)(\\s*[^\\s]*)(?:(?!\\s*(?:$|;|}|\\]))\\s*)?",
+                            "captures": {
+                                "1": {
+                                    "patterns": [
+                                        {
+                                            "include": "#variable"
+                                        }
+                                    ]
+                                }
+                            }
+                        },
+                        {
+                            "include": "#square-brackets"
+                        },
+                        {
+                            "include": "#empty-brackets"
+                        },
+                        {
+                            "begin": "(?<!})\\s*({)",
+                            "end": "\\s*(})",
+                            "beginCaptures": {
+                                "1": {
+                                    "name": "meta.brace.state.subscribe.params.open.tcl"
+                                }
+                            },
+                            "endCaptures": {
+                                "1": {
+                                    "name": "meta.brace.state.subscribe.params.close.tcl"
+                                }
+                            },
+                            "patterns": [
+                                {
+                                    "include": "#tcl-state-common-options"
+                                },
+                                {
+                                    "include": "#variable-non-substituting"
+                                },
+                                {
+                                    "include": "#tcl-state-id"
+                                },
+                                {
+                                    "begin": "(?<=^|\\s|;)\\s*(conditions)\\b",
+                                    "end": "(?<=})",
+                                    "beginCaptures": {
+                                        "1": {
+                                            "name": "keyword.state.register.tcl"
+                                        }
+                                    },
+                                    "patterns": [
+                                        {
+                                            "include": "#tcl-state-conditions"
+                                        }
+                                    ]
+                                }
+                            ]
+                        },
+                        {
+                            "include": "#brackets"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-state-common-options": {
+            "patterns": [
+                {
+                    "include": "#tcl-state-option-title"
+                },
+                {
+                    "include": "#tcl-state-option-items"
+                },
+                {
+                    "match": "(?<=^|;)\\s*(config|vendor)",
+                    "name": "keyword.control.tcl"
+                },
+                {
+                    "begin": "(?<=config|default|vendor)\\s*+({)",
+                    "end": "\\s*(})",
+                    "patterns": [
+                        {
+                            "match": "(\\s*[^\\s|}|{|;]*)(\\s+[^\\s|}|{|;]*)",
+                            "captures": {
+                                "1": {
+                                    "name": "variable"
+                                },
+                                "2": {
+                                    "name": "string",
+                                    "patterns": [
+                                        {
+                                            "include": "#constant-numeric"
+                                        }
+                                    ]
+                                }
+                            }
+                        },
+                        {
+                            "include": "#curly-string-brackets"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-state-option-title": {
+            "patterns": [
+                {
+                    "match": "(?<=^|\\s)\\s*(title)\\b(\\s+[^$|\n|;]*)",
+                    "captures": {
+                        "1": {
+                            "name": "keyword.state.register.tcl"
+                        },
+                        "2": {
+                            "patterns": [
+                                {
+                                    "include": "#quoted-string"
+                                },
+                                {
+                                    "include": "#curly-string-brackets"
+                                },
+                                {
+                                    "match": "\\b([^\\s]*)\\b\\s*([^$|\n]*)?",
+                                    "captures": {
+                                        "1": {
+                                            "name": "string"
+                                        },
+                                        "2": {
+                                            "name": "invalid.illegal.state.title.tcl"
+                                        }
+                                    }
+                                }
+                            ]
+                        }
+                    }
+                }
+            ]
+        },
+        "tcl-state-option-attributes": {
+            "patterns": [
+                {
+                    "begin": "(?<=^|\\s)\\s*(attributes|formatters)\\b\\s+{",
+                    "end": "\\s*(})",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "keyword.control.state.attributes.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#variable-non-substituting"
+                        },
+                        {
+                            "begin": "\\s*\\[",
+                            "end": "\\s*]",
+                            "patterns": [
+                                {
+                                    "include": "#variable-non-substituting"
+                                },
+                                {
+                                    "include": "#proc-call"
+                                }
+                            ]
+                        },
+                        {
+                            "match": "(?<!\\|)(\\s+[^\\s|\\$|\\[|\\]|}|{|;]*)(\\s+[^\\s|\\$|\\[|\\]|}|{|;]*)",
+                            "captures": {
+                                "1": {
+                                    "name": "variable"
+                                },
+                                "2": {
+                                    "name": "support.type.state.attribute.name.tcl"
+                                }
+                            }
+                        },
+                        {
+                            "match": "\\s*(\\|)",
+                            "name": "entity.function.name.separator.tcl"
+                        },
+                        {
+                            "include": "#variable-non-substituting"
+                        },
+                        {
+                            "include": "#constant-numeric"
+                        },
+                        {
+                            "include": "#curly-string-brackets"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-state-option-descriptions": {
+            "patterns": [
+                {
+                    "include": "#tcl-state-option-descriptions-titles"
+                },
+                {
+                    "include": "#tcl-state-option-descriptions-descriptions"
+                }
+            ]
+        },
+        "tcl-state-option-descriptions-titles": {
+            "patterns": [
+                {
+                    "begin": "(?<=^|\\s)\\s*(titles)\\b\\s+{",
+                    "end": "\\s*(})",
+                    "contentName": "variable",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "keyword.control.state.attributes.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#tcl-state-option-descriptions-patterns"
+                        },
+                        {
+                            "include": "#tcl-state-option-descriptions-titles"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-state-option-descriptions-descriptions": {
+            "patterns": [
+                {
+                    "begin": "(?<=^|\\s)\\s*(descriptions)\\b\\s+{",
+                    "end": "\\s*}",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "keyword.control.state.attributes.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#quoted-string"
+                        },
+                        {
+                            "include": "#tcl-state-option-descriptions-patterns"
+                        },
+                        {
+                            "begin": "\\s*({)",
+                            "end": "\\s*}",
+                            "patterns": [
+                                {
+                                    "include": "#tcl-state-option-descriptions-patterns"
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-state-option-descriptions-patterns": {
+            "patterns": [
+                {
+                    "include": "#variable-non-substituting"
+                },
+                {
+                    "include": "#quoted-string"
+                },
+                {
+                    "begin": "(?<=^|{)\\s*([^\\s]*)\\s+(?=\")",
+                    "end": "(?<=\")",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "support.type"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#quoted-string"
+                        }
+                    ]
+                },
+                {
+                    "include": "#constant-numeric"
+                },
+                {
+                    "begin": "(?<=^|{)\\s*(items)\\s+{",
+                    "end": "\\s*(})",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "support.type"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#tcl-state-option-descriptions-patterns"
+                        },
+                        {
+                            "include": "#quoted-string"
+                        }
+                    ]
+                },
+                {
+                    "begin": "(?<=^|{)\\s*([^\\s]*)\\s+(?={)",
+                    "end": "(?<=})",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "support.type"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#html-curly-brackets"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-state-option-items": {
+            "patterns": [
+                {
+                    "begin": "(?<=^|\\s)\\s*(items)\\b",
+                    "end": "(?<=})",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "keyword.state.register.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "begin": "\\s*+({)",
+                            "end": "\\s*(})",
+                            "patterns": [
+                                {
+                                    "begin": "(?<=^|;)\\s*\\b(optional|required|key)?\\b\\s+(string|bool|number|string|ip|json|mac|enum|ni|match|include|range|percent|greater|less|dict|array|numberArray)\\b\\s+([^\\s|\\||;|}]*)",
+                                    "end": "\\s*(?=$|;|\n)",
+                                    "beginCaptures": {
+                                        "1": {
+                                            "name": "meta.constant",
+                                            "patterns": [
+                                                {
+                                                    "match": "(key)",
+                                                    "name": "markup.bold"
+                                                }
+                                            ]
+                                        },
+                                        "2": {
+                                            "name": "support.type"
+                                        },
+                                        "3": {
+                                            "name": "variable"
+                                        }
+                                    },
+                                    "patterns": [
+                                        {
+                                            "begin": "\\s*+(\\|)",
+                                            "end": "(?=$|;|\n)",
+                                            "beginCaptures": {
+                                                "1": {
+                                                    "name": "support.type"
+                                                }
+                                            },
+                                            "name": "string",
+                                            "patterns": [
+                                                {
+                                                    "include": "#constant-numeric"
+                                                }
+                                            ]
+                                        }
+                                    ]
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-state-option-evaluate": {
+            "patterns": [
+                {
+                    "applyEndPatternLast": 1,
+                    "begin": "(?<=^|\\s)\\s*(evaluate)\\b\\s*",
+                    "end": "(?<=})",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "keyword.state.register.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#proc-arguments"
+                        },
+                        {
+                            "include": "#brackets"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-state-id": {
+            "patterns": [
+                {
+                    "match": "(?<=^|\\s)\\s*(id)\\b(\\s+[^$|\n|;]*)",
+                    "captures": {
+                        "1": {
+                            "name": "markup.bold.keyword.state.register.tcl"
+                        },
+                        "2": {
+                            "patterns": [
+                                {
+                                    "include": "#quoted-string"
+                                },
+                                {
+                                    "include": "#curly-string-brackets"
+                                },
+                                {
+                                    "match": "\\b([^\\s]*)\\b\\s*([^$|\n]*)?",
+                                    "captures": {
+                                        "1": {
+                                            "name": "string"
+                                        },
+                                        "2": {
+                                            "name": "invalid.illegal.state.title.tcl"
+                                        }
+                                    }
+                                }
+                            ]
+                        }
+                    }
+                }
+            ]
+        },
+        "tcl-state-conditions": {
+            "patterns": [
+                {
+                    "include": "#variable-non-substituting"
+                },
+                {
+                    "begin": "\\s*+({)",
+                    "end": "\\s*(})",
+                    "patterns": [
+                        {
+                            "include": "#tcl-state-conditions"
+                        },
+                        {
+                            "include": "#constant-numeric"
+                        },
+                        {
+                            "match": "(?<=\\s|{|^)(\\*)\\s",
+                            "name": "meta.class"
+                        },
+                        {
+                            "match": "(?<={|^|;)\\s*([^\\s|}|\\*|;]*)\\s+",
+                            "captures": {
+                                "1": {
+                                    "name": "variable"
+                                }
+                            }
+                        },
+                        {
+                            "match": "\\b(set|modified|change(?:d|s)|created|removed|deleted|existed|defined|exists|created|added)\\b\\s*(?=$|}|;)",
+                            "name": "entity.function.name"
+                        },
+                        {
+                            "match": "([^\\s]*)\\s*(?=$)",
+                            "name": "meta.class"
+                        },
+                        {
+                            "match": "\\b(is|becomes|was|not|reverse)\\b(?!\\s*\\|)",
+                            "name": "punctuation.italic.entity.name.function"
+                        },
+                        {
+                            "match": "(?<=\\s)(\\b(?:rises above|include|ne|not equal|eq|equal|greater equal|ge|greather than|ge|less equal|le|falls below|divisible by|is in|in|not in|ni|match|regexp|notInclude|startsWith|starts with|endsWith|ends with|command|isType|eval)\\b|(?:\\>|=|==|<=|>=|>_|_<|%))(?=\\s*\\|)",
+                            "name": "support.type"
+                        },
+                        {
+                            "begin": "\\s*+(\\|)",
+                            "end": "(?=$|;|\n|}|\\])",
+                            "beginCaptures": {
+                                "1": {
+                                    "name": "entity.function.name.condition.tcl"
+                                }
+                            },
+                            "name": "string",
+                            "patterns": [
+                                {
+                                    "include": "#variable-non-substituting"
+                                },
+                                {
+                                    "include": "#glob-match"
+                                },
+                                {
+                                    "include": "#constant-numeric"
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-state-setter-getter": {
+            "patterns": [
+                {
+                    "begin": "(?<=set|get|pull|push)\\b",
+                    "end": "(?=(?<!\\\\)$|[\n;\\]}])",
+                    "patterns": [
+                        {
+                            "include": "#line-escape"
+                        },
+                        {
+                            "begin": "(?<=set|get|pull|push)\\b\\s*",
+                            "end": "(?=$|[\\s\\]};])",
+                            "patterns": [
+                                {
+                                    "include": "#tcl-class-name"
+                                }
+                            ]
+                        },
+                        {
+                            "begin": "\\s*({)",
+                            "end": "(})",
+                            "beginCaptures": {
+                                "1": {
+                                    "name": "entity.function.name.state.brace.open.tcl"
+                                }
+                            },
+                            "endCaptures": {
+                                "1": {
+                                    "name": "entity.function.name.state.brace.close.tcl"
+                                }
+                            },
+                            "patterns": [
+                                {
+                                    "match": "\\s*([^\\s|}|\\]|$|\n]*)\\s+([^\\s|}]*)",
+                                    "captures": {
+                                        "1": {
+                                            "name": "string"
+                                        },
+                                        "2": {
+                                            "name": "variable"
+                                        }
+                                    }
+                                }
+                            ]
+                        },
+                        {
+                            "include": "#brackets"
+                        },
+                        {
+                            "include": "#variable"
+                        },
+                        {
+                            "include": "#variable-bare"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-class-name": {
+            "patterns": [
+                {
+                    "include": "#line-escape"
+                },
+                {
+                    "include": "#variable"
+                },
+                {
+                    "include": "#namespace-separator"
+                },
+                {
+                    "include": "#square-brackets"
+                },
+                {
+                    "match": "(?:(?=\\s)\\s*)?(\\w+)",
+                    "name": "meta.class"
+                }
+            ]
+        },
+        "tcl-incr": {
+            "patterns": [
+                {
+                    "begin": "(?<=^|\\[|{|;)\\s*(::)?\\b(incr)\\b",
+                    "end": "\\s*(?=$|\n|}|\\]|;)",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "support.type"
+                        },
+                        "2": {
+                            "name": "keyword.control.incr.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#line-escape"
+                        },
+                        {
+                            "include": "#constant-numeric"
+                        },
+                        {
+                            "include": "#brackets"
+                        },
+                        {
+                            "include": "#variable"
+                        },
+                        {
+                            "include": "#variable-bare-italic"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-lassign": {
+            "patterns": [
+                {
+                    "begin": "(?<=^|\\[|{|;)\\s*(::)?\\b(lassign)\\b",
+                    "end": "\\s*(?=$|\n|\\]|})",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "support.type"
+                        },
+                        "2": {
+                            "name": "keyword.control.lassign.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#line-escape"
+                        },
+                        {
+                            "include": "#brackets"
+                        },
+                        {
+                            "include": "#variable"
+                        },
+                        {
+                            "include": "#variable-bare-italic"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-entity-commands": {
+            "patterns": [
+                {
+                    "begin": "\\s*(::)?\\b(tailcall)\\b",
+                    "end": "(?=(?<!\\\\)(?:$|[\n;\\]}]))",
+                    "captures": {
+                        "1": {
+                            "name": "support.type.ns.separator.tcl"
+                        },
+                        "2": {
+                            "name": "keyword.control.tailcall.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#line-escape"
+                        },
+                        {
+                            "include": "#proc-call"
+                        },
+                        {
+                            "include": "#namespace-name"
+                        }
+                    ]
+                },
+                {
+                    "begin": "(?<=^|[\\[{;]|tailcall)\\s*(::)?\\b(info|eof|read|fileevent|fblocked|flush|gets|chan|coroutine|eval|tls|http|clock|array|encoding|binary|file|task|after|tailcall|rename|callback|state|json|exec|pubsub)\\b",
+                    "end": "(?=(?<!\\\\)(?:$|[\n;\\]}]))",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "support.type"
+                        },
+                        "2": {
+                            "name": "keyword.control.ent.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#line-escape"
+                        },
+                        {
+                            "include": "#opt"
+                        },
+                        {
+                            "match": "(?<=(?:info|clock|http|binary|coroutine|chan|encoding|file|task|array|after|tailcall|rename|callback|state|json|exec|pubsub))\\s+(?:(?!$|{|\\[|;|\n)([^\\s\\]}\\[{;\n\"]*))?",
+                            "captures": {
+                                "1": {
+                                    "patterns": [
+                                        {
+                                            "include": "#variable"
+                                        },
+                                        {
+                                            "include": "#constant-numeric"
+                                        },
+                                        {
+                                            "include": "#opt"
+                                        },
+                                        {
+                                            "include": "#namespace-name"
+                                        }
+                                    ]
+                                }
+                            }
+                        },
+                        {
+                            "include": "#proc-call-args"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-array": {
+            "patterns": [
+                {
+                    "include": "#namespace-separator"
+                },
+                {
+                    "begin": "(?<=^|[\\[{;]|tailcall\\s)\\s*(?:::)?(array\\b)",
+                    "end": "(?=(?<!\\\\)(?:$|[\n;\\]}]))",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "keyword.control.array.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#tcl-array-set"
+                        },
+                        {
+                            "include": "#tcl-array-get"
+                        },
+                        {
+                            "include": "#tcl-array-commands"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-array-commands": {
+            "patterns": [
+                {
+                    "begin": "(?<=array)(?:::)?\\s+(names|donesearch|anymore|exists|nextelement|size|startsearch|statistics|unset)\\b",
+                    "end": "(?=(?<!\\\\)(?:$|[\n;\\]}]))",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "entity.function.name.array.command.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#proc-call-args"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-array-set": {
+            "patterns": [
+                {
+                    "begin": "(?<=array)(?:::)?\\s+(set)\\b",
+                    "end": "(?=(?<!\\\\)(?:$|[\n;\\]}]))",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "entity.function.name.array.set.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "begin": "(?<=set)\\s+(?!$|[\n;}\\]])([^\\s\\];]*)",
+                            "end": "(?=(?<!\\\\)(?:$|[\n;\\]}]))",
+                            "beginCaptures": {
+                                "1": {
+                                    "patterns": [
+                                        {
+                                            "include": "#variable"
+                                        },
+                                        {
+                                            "include": "#variable-bare"
+                                        }
+                                    ]
+                                }
+                            },
+                            "patterns": [
+                                {
+                                    "include": "#empty-brackets"
+                                },
+                                {
+                                    "include": "#property-list-brackets"
+                                },
+                                {
+                                    "include": "#proc-call-args"
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-array-get": {
+            "patterns": [
+                {
+                    "begin": "(?<=array)(?:::)?\\s+(get)\\b",
+                    "end": "(?=(?<!\\\\)(?:$|[\n;\\]}]))",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "entity.function.name.array.get.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "begin": "(?<=get)(\\s+(?!$|[\n;\\]])[^\\s\\]};\n]*)",
+                            "end": "(?=(?<!\\\\)(?:$|[\n;\\]}]))",
+                            "captures": {
+                                "1": {
+                                    "patterns": [
+                                        {
+                                            "include": "#variable-bare"
+                                        }
+                                    ]
+                                }
+                            },
+                            "patterns": [
+                                {
+                                    "include": "#proc-call-args"
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-oo": {
+            "comment": "handle tcl specific commands and evaluation",
+            "patterns": [
+                {
+                    "begin": "(?<=^|[\\[{;]|tailcall)\\s*((?:::)?(oo)::)?\\b((?:module|mixin|define|(?:meta)?class|objdefine|Helpers|InfoObject|copy|object|Slot|UnknownDefinition)\\b|Obj[0-9]*)",
+                    "end": "(?=$|[\n;}\\]\\[{])",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "entity.function.name.tcl"
+                        },
+                        "2": {
+                            "name": "keyword.control.oo.tcl"
+                        },
+                        "3": {
+                            "name": "keyword.control.oo.command"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#opt"
+                        },
+                        {
+                            "include": "#variable"
+                        },
+                        {
+                            "include": "#tcl-oo-commands"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-oo-commands": {
+            "patterns": [
+                {
+                    "include": "#tcl-oo-create"
+                },
+                {
+                    "include": "#tcl-oo-define"
+                }
+            ]
+        },
+        "tcl-oo-create": {
+            "patterns": [
+                {
+                    "begin": "(?<=class|module|metaclass)\\b\\s+\\b(create)\\b",
+                    "end": "(?=$|[\n;\\]])|(?<=})",
+                    "captures": {
+                        "1": {
+                            "name": "entity.function.name.oo.create.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "begin": "(?<=create)\\s+(?!$|[\\]\n\\[$;\\}])",
+                            "end": "\\s",
+                            "patterns": [
+                                {
+                                    "include": "#variable"
+                                },
+                                {
+                                    "include": "#tcl-class-name"
+                                }
+                            ]
+                        },
+                        {
+                            "include": "#tcl-oo-eval-brackets"
+                        },
+                        {
+                            "include": "#variable"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-oo-define": {
+            "patterns": [
+                {
+                    "begin": "(?<=define)",
+                    "end": "(?=(?<!\\\\)(?:$|[\n;\\]}]))",
+                    "patterns": [
+                        {
+                            "begin": "(?<=define)\\s+(?!$|[\n;\\]}\\[$])",
+                            "end": "\\s",
+                            "patterns": [
+                                {
+                                    "include": "#line-escape"
+                                },
+                                {
+                                    "include": "#tcl-class-name"
+                                }
+                            ]
+                        },
+                        {
+                            "include": "#line-escape"
+                        },
+                        {
+                            "include": "#variable"
+                        },
+                        {
+                            "include": "#square-brackets"
+                        },
+                        {
+                            "include": "#opt"
+                        },
+                        {
+                            "include": "#tcl-oo-define-constructor"
+                        },
+                        {
+                            "include": "#tcl-oo-define-destructor"
+                        },
+                        {
+                            "include": "#tcl-oo-define-method"
+                        },
+                        {
+                            "include": "#tcl-oo-eval-brackets"
+                        },
+                        {
+                            "include": "#namespace-name"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-oo-define-destructor": {
+            "patterns": [
+                {
+                    "begin": "(destructor)",
+                    "end": "(?=(?<!\\\\)(?:$|[\n;\\]}]))",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "keyword.control.oo.define.constructor.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#brackets"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-oo-define-constructor": {
+            "patterns": [
+                {
+                    "begin": "(constructor)\\s+(?!$|[\n;\\]}])",
+                    "end": "(?=(?<!\\\\)(?:$|[\n;\\]}]))",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "keyword.control.oo.define.constructor.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#proc-arguments"
+                        },
+                        {
+                            "include": "#brackets"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-oo-define-method": {
+            "patterns": [
+                {
+                    "begin": "(method)\\s+([^\\s]*)\\s+(?!$|[\n;\\]}])",
+                    "end": "(?=(?<!\\\\)(?:$|[\n;\\]}]))",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "keyword.control.oo.define.method.tcl"
+                        },
+                        "2": {
+                            "patterns": [
+                                {
+                                    "include": "#namespace-name"
+                                }
+                            ]
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#proc-arguments"
+                        },
+                        {
+                            "include": "#brackets"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-oo-eval-brackets": {
+            "comment": "evaluating inside of a class create or define",
+            "patterns": [
+                {
+                    "begin": "\\s*(\\{)",
+                    "end": "\\s*(\\})",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "meta.bracket.curly.oo.open.tcl"
+                        }
+                    },
+                    "endCaptures": {
+                        "1": {
+                            "name": "meta.bracket.curly.oo.close.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#line-escape"
+                        },
+                        {
+                            "include": "#tcl-oo-my"
+                        },
+                        {
+                            "include": "#tcl-oo-constructor"
+                        },
+                        {
+                            "include": "#tcl-oo-destructor"
+                        },
+                        {
+                            "include": "#tcl-oo-method"
+                        },
+                        {
+                            "include": "#tcl-oo-variable"
+                        },
+                        {
+                            "include": "#tcl-oo-mixin"
+                        },
+                        {
+                            "include": "#tcl-oo-exports"
+                        },
+                        {
+                            "include": "#proc-call"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-oo-keywords": {
+            "patterns": [
+                {
+                    "include": "#tcl-oo-my"
+                },
+                {
+                    "include": "#tcl-oo-self"
+                }
+            ]
+        },
+        "tcl-oo-exports": {
+            "patterns": [
+                {
+                    "begin": "(?<=^|[{;])\\s*(unexport|export)",
+                    "end": "(?=(?<!\\\\)(?:$|[\n;]))",
+                    "captures": {
+                        "1": {
+                            "name": "keyword.control.oo.unexport.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#line-escape"
+                        },
+                        {
+                            "include": "#namespace-name"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-oo-method": {
+            "patterns": [
+                {
+                    "applyEndPatternLast": 1,
+                    "begin": "\\s*(method)\\s+([^\\s]*)\\s*",
+                    "end": "\\s*",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "keyword.control.oo.method.tcl\""
+                        },
+                        "2": {
+                            "name": "entity.function.name.oo.method.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#proc-arguments"
+                        },
+                        {
+                            "include": "#tcl-oo-brackets"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-oo-my": {
+            "patterns": [
+                {
+                    "begin": "(?<=^|\\[|{|;)\\s*+\\b(my)\\b",
+                    "end": "\\s*(?=$|\n|;|\\]|})",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "keyword.control.oo.my.punctuation.italic.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "begin": "(?<=my)\\b\\s+\\b(variable)\\b",
+                            "end": "(?=$|^|\n|;)",
+                            "beginCaptures": {
+                                "1": {
+                                    "name": "keyword.control.my.variable.oo.tcl"
+                                }
+                            },
+                            "patterns": [
+                                {
+                                    "include": "#line-escape"
+                                },
+                                {
+                                    "match": "([^\\s|\\]|}|$])",
+                                    "name": "variable"
+                                }
+                            ]
+                        },
+                        {
+                            "match": "(?<=my)\\b\\s+([^\\s\\]};]*)",
+                            "captures": {
+                                "1": {
+                                    "name": "entity.function.name.my.method.oo.tcl"
+                                }
+                            }
+                        },
+                        {
+                            "include": "#proc-call-args"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-oo-self": {
+            "patterns": [
+                {
+                    "match": "(?<=^|\\[)\\s*(self)",
+                    "captures": {
+                        "1": {
+                            "name": "keyword.control.oo.my.punctuation.italic.tcl"
+                        }
+                    }
+                },
+                {
+                    "match": "(?<=self)\\s+(next)",
+                    "captures": {
+                        "1": {
+                            "name": "entity.function.name.punctuation.italic.tcl"
+                        }
+                    }
+                }
+            ]
+        },
+        "tcl-oo-variable": {
+            "patterns": [
+                {
+                    "begin": "(?<=^|[;{])\\s*(variable)\\b",
+                    "end": "\\s*(?=(?<!\\\\)(?:$|[;\n]))",
+                    "captures": {
+                        "1": {
+                            "name": "keyword.control.oo.variable.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#line-escape"
+                        },
+                        {
+                            "include": "#variable-bare-italic"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-oo-constructor": {
+            "patterns": [
+                {
+                    "begin": "(?<=^|{)\\s*\\b(constructor)\\b(?:(?!$)\\s+)?",
+                    "end": "(?<=})",
+                    "captures": {
+                        "1": {
+                            "name": "keyword.control.oo.eval.constructor.tcl"
+                        },
+                        "2": {
+                            "name": "variable.other.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#proc-arguments"
+                        },
+                        {
+                            "include": "#brackets"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-oo-destructor": {
+            "patterns": [
+                {
+                    "begin": "(?<=^|{)\\s*\\b(destructor)\\b",
+                    "end": "(?<=})",
+                    "captures": {
+                        "1": {
+                            "name": "keyword.contorl.oo.eval.destructor.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#brackets"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-oo-mixin": {
+            "patterns": [
+                {
+                    "begin": "\\s*\\b(mixin|superclass)\\b",
+                    "end": "(?=(?<!\\\\)(?:$|[\n;\\]}]))",
+                    "captures": {
+                        "1": {
+                            "name": "keyword.control.oo.mixin.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#tcl-class-name"
+                        }
+                    ]
+                }
+            ]
+        },
+        "classname": {
+            "patterns": [
+                {
+                    "include": "#line-escape"
+                },
+                {
+                    "match": "(?<=\\s)\\s*([^\\s;\\\\\\[]*)",
+                    "name": "meta.class"
+                },
+                {
+                    "include": "#square-brackets"
+                }
+            ]
+        },
+        "tcl-expression-keywords": {
+            "patterns": [
+                {
+                    "applyEndPatternLast": 1,
+                    "begin": "\\s*+((::|-)?(if|expr|while))\\b\\s+(?={)",
+                    "end": "(?<=})",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "keyword.control.if.tcl",
+                            "patterns": [
+                                {
+                                    "include": "#namespace-separator"
+                                },
+                                {
+                                    "include": "#opt"
+                                }
+                            ]
+                        },
+                        "2": {
+                            "name": "support.type"
+                        },
+                        "3": {
+                            "name": "keyword.control.if.tcl"
+                        }
+                    },
+                    "endCaptures": {
+                        "1": {
+                            "name": "keyword.control.if.end.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#if-handlers"
+                        }
+                    ]
+                },
+                {
+                    "begin": "(?<=^|\\[|{|;)\\s*(::|-)?(expr)\\b",
+                    "end": "(?=$|;|}|\\])",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "support.type.expr.ns.tcl"
+                        },
+                        "2": {
+                            "name": "keyword.control.expr.unbraced.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#line-escape"
+                        },
+                        {
+                            "include": "#expressions"
+                        }
+                    ]
+                }
+            ]
+        },
+        "if-handlers": {
+            "patterns": [
+                {
+                    "include": "#expression-brackets"
+                },
+                {
+                    "include": "#if-else-if"
+                },
+                {
+                    "include": "#if-else"
+                },
+                {
+                    "include": "#curly-brackets"
+                }
+            ]
+        },
+        "if-else-if": {
+            "patterns": [
+                {
+                    "begin": "(?<=\\})\\s+(elseif)\\s+",
+                    "end": "\\s*",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "keyword.control.elseif.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#expression-brackets"
+                        },
+                        {
+                            "include": "#brackets"
+                        }
+                    ]
+                }
+            ]
+        },
+        "if-else": {
+            "patterns": [
+                {
+                    "begin": "(?<=\\})\\s+(else)\\s+(?=\\{)",
+                    "end": "(?<=\\}|$)",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "keyword.control.else.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#brackets"
+                        }
+                    ]
+                }
+            ]
+        },
+        "if-block": {
+            "patterns": [
+                {
+                    "applyEndPatternLast": 1,
+                    "begin": "(?<=\\})\\s+(\\{)",
+                    "end": "(\\})",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "keyword.control"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "$self"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-try-catch": {
+            "patterns": [
+                {
+                    "applyEndPatternLast": 1,
+                    "begin": "(?<=^|[\\[{;]|tailcall)\\s*(::)?\\b(try)\\b",
+                    "end": "(?=(?<!\\\\)(?:$|[\n;\\]}]))",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "support.type.ns.separator"
+                        },
+                        "2": {
+                            "name": "keyword.control.try.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#line-escape"
+                        },
+                        {
+                            "include": "#tcl-try-trap"
+                        },
+                        {
+                            "include": "#tcl-try-on"
+                        },
+                        {
+                            "include": "#tcl-try-finally"
+                        },
+                        {
+                            "include": "#brackets"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-try-on": {
+            "patterns": [
+                {
+                    "applyEndPatternLast": 1,
+                    "begin": "(?<=}|\\])\\s+\\b(on)\\b\\s+\\b(error|return|break|continue|ok|[0-9]*)\\b(?:\\s+(?={|\\b|\\$|\"|\\[|\\\\\n)|\\s+(?!$|\n))",
+                    "end": "\\s*(?=$|[{\\[;\n])",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "keyword.control.try.on.tcl"
+                        },
+                        "2": {
+                            "name": "keyword.control.try.on.tcl",
+                            "patterns": [
+                                {
+                                    "include": "#constant-numeric"
+                                }
+                            ]
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#line-escape"
+                        },
+                        {
+                            "include": "#arguments-braced"
+                        },
+                        {
+                            "match": "(?!\\s)([^\\s;\\]}\n$]*)(?=\\s+(?:{|\\[|\n|\\\\\n))",
+                            "captures": {
+                                "1": {
+                                    "name": "variable.name"
+                                }
+                            }
+                        },
+                        {
+                            "include": "#variable"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-try-trap": {
+            "patterns": [
+                {
+                    "applyEndPatternLast": 1,
+                    "begin": "(?<=}|\\])\\s+\\b(trap)\\b",
+                    "end": "(?=\\s*{)",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "keyword.control.try.trap.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#line-escape"
+                        },
+                        {
+                            "include": "#variable"
+                        },
+                        {
+                            "include": "#square-brackets"
+                        },
+                        {
+                            "match": "(?<=trap)\\s+(?=\\b)([^\\s;\\]\\[}\n$]+)(?:(?!\n|$|\\\\)\\s+)?",
+                            "captures": {
+                                "1": {
+                                    "name": "support.type.try.trap.name.tcl"
+                                }
+                            }
+                        },
+                        {
+                            "begin": "(?<=trap)\\s+({)",
+                            "end": "(})(?:\\s+(?!\n|$|^))?",
+                            "contentName": "support.type.try.trap.name.tcl"
+                        },
+                        {
+                            "include": "#arguments-braced"
+                        },
+                        {
+                            "match": "([^\\s$\n;\\[{}\\]]+)(?=\\s+{)",
+                            "name": "variable"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-try-finally": {
+            "patterns": [
+                {
+                    "begin": "(?<=})\\s+(finally)\\s+(?=[{\\[])",
+                    "end": "(?<=[}\\];])",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "keyword.control.try.onerror.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#brackets"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-setters": {
+            "patterns": [
+                {
+                    "include": "#tcl-set"
+                },
+                {
+                    "include": "#tcl-unset"
+                },
+                {
+                    "include": "#tcl-append"
+                }
+            ]
+        },
+        "tcl-set": {
+            "patterns": [
+                {
+                    "begin": "(?<=^|[\\[{;]|tailcall)\\s*(::)?\\b(set|variable)\\b\\s+(?!\n|$)",
+                    "end": "(?=(?<!\\\\)(?:$|[;\\]}]))",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "support.type"
+                        },
+                        "2": {
+                            "name": "keyword.control.set.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#line-escape"
+                        },
+                        {
+                            "include": "#variable"
+                        },
+                        {
+                            "include": "#variable-bare"
+                        },
+                        {
+                            "include": "#regexp"
+                        },
+                        {
+                            "include": "#proc-call-args"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-append": {
+            "patterns": [
+                {
+                    "begin": "(?<=^|[\\[{;]|tailcall)\\s*(::)?\\b(append|lappend)\\b(?:(\\s+[^\\s]*))?",
+                    "end": "(?=$|^|;|}|\\])",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "support.type"
+                        },
+                        "2": {
+                            "name": "keyword.control.set.tcl"
+                        },
+                        "3": {
+                            "patterns": [
+                                {
+                                    "include": "#variable-bare-italic"
+                                },
+                                {
+                                    "include": "#variable"
+                                }
+                            ]
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#proc-call-args"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-unset": {
+            "patterns": [
+                {
+                    "contentName": "punctuation.variable.set.italic.tcl",
+                    "begin": "(?<=^|\\[|{|;)\\s*(::)?\\b(unset)",
+                    "end": "\\s*(?=$|;|\n|}|\\])",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "support.type"
+                        },
+                        "2": {
+                            "name": "keyword.control.unset.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#line-escape"
+                        },
+                        {
+                            "include": "#opt"
+                        },
+                        {
+                            "include": "#brackets"
+                        },
+                        {
+                            "match": "\\s*([^\\s|}|\\]|;]*)",
+                            "captures": {
+                                "1": {
+                                    "name": "punctuation.variable.set.italic.tcl"
+                                }
+                            }
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-namespace": {
+            "patterns": [
+                {
+                    "begin": "(?<=^|[{\\[;]|tailcall)\\s*(::)?\\b(namespace)\\b",
+                    "end": "(?=(?<!\\\\)$)|(?=[\\];}])",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "support.type"
+                        },
+                        "2": {
+                            "name": "keyword.control.namespace.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#line-escape"
+                        },
+                        {
+                            "include": "#tcl-namespace-eval"
+                        },
+                        {
+                            "include": "#tcl-namespace-entity-commands"
+                        },
+                        {
+                            "include": "#tcl-namespace-subcommands"
+                        },
+                        {
+                            "include": "#proc-call-args"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-namespace-eval": {
+            "begin": "\\s*\\b(eval|exists)\\b\\s*",
+            "end": "(?=(?<!\\\\\n)$|(?<!\\\\)\n|[}\\];{\\[])",
+            "beginCaptures": {
+                "1": {
+                    "name": "keyword.control.namespace.eval.tcl"
+                }
+            },
+            "patterns": [
+                {
+                    "include": "#line-escape"
+                },
+                {
+                    "include": "#namespace-name"
+                },
+                {
+                    "include": "#brackets"
+                }
+            ]
+        },
+        "tcl-namespace-entity-commands": {
+            "begin": "\\s*\\b(delete)\\b\\s*",
+            "end": "(?=(?<!\\\\\n)$|(?<!\\\\)\n|[}\\];{\\[])",
+            "beginCaptures": {
+                "1": {
+                    "name": "keyword.control.name.namespace.eval.tcl"
+                }
+            },
+            "patterns": [
+                {
+                    "include": "#variable"
+                },
+                {
+                    "include": "#line-escape"
+                },
+                {
+                    "include": "#namespace-name"
+                },
+                {
+                    "include": "#brackets"
+                }
+            ]
+        },
+        "tcl-namespace-subcommands": {
+            "match": "\\s*\\b(exists|ensemble|children|code|current|export|forget|import|inscope|origin|parent|path|qualifiers|tail|upvar|unknown|which)\\b",
+            "captures": {
+                "1": {
+                    "name": "entity.function.name.namespace.subcommand.tcl"
+                }
+            }
+        },
+        "namespace-name": {
+            "patterns": [
+                {
+                    "include": "#line-escape"
+                },
+                {
+                    "include": "#variable"
+                },
+                {
+                    "include": "#namespace-separator"
+                },
+                {
+                    "match": "(?![\\s{}\\[\\]])([^\\s:$\\[\\]}{;\n]+)",
+                    "name": "entity.function.name.tcl"
+                }
+            ]
+        },
+        "namespace-separator": {
+            "patterns": [
+                {
+                    "match": "(?<!:)(:)(?!:)|(?<=::)(:)(?!:)",
+                    "name": "string"
+                },
+                {
+                    "match": "(::)",
+                    "name": "support.type"
+                }
+            ]
+        },
+        "tcl-foreach": {
+            "patterns": [
+                {
+                    "begin": "(?<=^|\\[|{|;)\\s*(::)?\\b(foreach)\\b(?:(?=\\s+{)\\s+)?",
+                    "end": "(?=(?<!\\\\)$)|(?<=})",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "support.type"
+                        },
+                        "2": {
+                            "name": "keyword.keyword.foreach.loop.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#arguments-braced"
+                        },
+                        {
+                            "include": "#brackets"
+                        },
+                        {
+                            "include": "#variable"
+                        },
+                        {
+                            "include": "#variable-bare-italic"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-catch": {
+            "patterns": [
+                {
+                    "begin": "(?<=\\[|{|^|tailcall)\\s*(::)?\\b(catch)\\b(?=\\s)",
+                    "end": "(?=\\]|}|$|(?<!\\\\)\n|;)",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "support.type"
+                        },
+                        "2": {
+                            "name": "keyword.control.string.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#brackets"
+                        },
+                        {
+                            "include": "#variable-bare-italic"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-upvar": {
+            "patterns": [
+                {
+                    "begin": "(?<=\\[|\\{|^|tailcall)\\s*(::)?\\b(upvar)\\b",
+                    "end": "\\s*(?=\\]|}|$|;)",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "support.type"
+                        },
+                        "2": {
+                            "name": "keyword.control.string.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#line-escape"
+                        },
+                        {
+                            "include": "#constant-numeric"
+                        },
+                        {
+                            "include": "#variable"
+                        },
+                        {
+                            "include": "#variable-bare-italic"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-info": {
+            "patterns": [
+                {
+                    "begin": "(?<=\\[|\\{|^|tailcall)\\s*(::)?\\b(info)\\b",
+                    "end": "(?=(?<!\\\\)$|[\n;\\]}])",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "support.type"
+                        },
+                        "2": {
+                            "name": "keyword.control.string.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#line-escape"
+                        },
+                        {
+                            "include": "#square-brackets"
+                        },
+                        {
+                            "include": "#tcl-info-exists"
+                        },
+                        {
+                            "include": "#tcl-info-oo"
+                        },
+                        {
+                            "include": "#tcl-info-subcommands"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-info-exists": {
+            "patterns": [
+                {
+                    "begin": "\\b(exists)\\b",
+                    "end": "(?=(?<!\\\\)(?:$|[\n;\\]}]))",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "entity.function.name.info.exists.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#variable"
+                        },
+                        {
+                            "include": "#line-escape"
+                        },
+                        {
+                            "include": "#square-brackets"
+                        },
+                        {
+                            "include": "#variable-bare-italic"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-info-oo": {
+            "patterns": [
+                {
+                    "begin": "(?<=info)\\s+(class|object)\\b",
+                    "end": "(?=(?<!\\\\)$|[\n;\\]}])",
+                    "captures": {
+                        "1": {
+                            "name": "entity.function.name.info.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#line-escape"
+                        },
+                        {
+                            "begin": "(?<=object)\\s+\\b(isa|vars|class)\\b",
+                            "end": "(?=(?<!\\\\)$|[\n;\\]}])",
+                            "captures": {
+                                "1": {
+                                    "name": "keyword.control.info.class.tcl"
+                                }
+                            },
+                            "patterns": [
+                                {
+                                    "include": "#line-escape"
+                                },
+                                {
+                                    "include": "#square-brackets"
+                                },
+                                {
+                                    "include": "#tcl-class-name"
+                                }
+                            ]
+                        },
+                        {
+                            "begin": "(?<=class)\\s+\\b(constructor|destructor|instances|subclasses|superclasses)\\b",
+                            "end": "(?=(?<!\\\\)$|[\n;\\]}])",
+                            "captures": {
+                                "1": {
+                                    "name": "keyword.control.info.class.tcl"
+                                }
+                            },
+                            "patterns": [
+                                {
+                                    "include": "#line-escape"
+                                },
+                                {
+                                    "include": "#opt"
+                                },
+                                {
+                                    "include": "#square-brackets"
+                                },
+                                {
+                                    "include": "#tcl-class-name"
+                                }
+                            ]
+                        },
+                        {
+                            "begin": "(?<=class|object)\\s+\\b(call|definition|filters|forward|methods|methodtype|mixins|variables)\\b",
+                            "end": "(?=(?<!\\\\)$|[\n;\\]}])",
+                            "captures": {
+                                "1": {
+                                    "name": "keyword.control.info.class.tcl"
+                                }
+                            },
+                            "patterns": [
+                                {
+                                    "include": "#line-escape"
+                                },
+                                {
+                                    "include": "#opt"
+                                },
+                                {
+                                    "include": "#tcl-class-name"
+                                }
+                            ]
+                        },
+                        {
+                            "include": "#proc-call-args"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-info-pattern-commands": {
+            "patterns": [
+                {
+                    "begin": "\\b(command(?:s)?|globals|locals|procs|vars|functions)\\b",
+                    "end": "\\s*(?=$|\n|}|\\]|;)",
+                    "captures": {
+                        "1": {
+                            "name": "entity.function.name.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#constant-numeric"
+                        },
+                        {
+                            "include": "#namespace-name"
+                        },
+                        {
+                            "include": "#glob-match"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-info-subcommands": {
+            "patterns": [
+                {
+                    "include": "#tcl-info-pattern-commands"
+                },
+                {
+                    "begin": "\\b(level|frame|coroutine|nameofexecutable|nameofexe|args|body|cmdcount|complete|default|hostname|library|loaded|patchlevel|script|sharedlibextension|tclversion)\\b\\s*",
+                    "end": "\\s*(?=$|\n|}|\\]|;)",
+                    "captures": {
+                        "1": {
+                            "name": "entity.function.name.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#constant-numeric"
+                        },
+                        {
+                            "include": "#namespace-name"
+                        },
+                        {
+                            "include": "#proc-call-args"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-string": {
+            "patterns": [
+                {
+                    "begin": "(?<=^|[\\[{;]|tailcall)\\s*(::)?\\b(string)\\b",
+                    "end": "(?=}|\\]|;|$|\n)",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "support.type"
+                        },
+                        "2": {
+                            "name": "keyword.control.string.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#tcl-string-is"
+                        },
+                        {
+                            "include": "#tcl-string-match"
+                        },
+                        {
+                            "include": "#tcl-string-matchfirst"
+                        },
+                        {
+                            "include": "#tcl-string-map"
+                        },
+                        {
+                            "include": "#tcl-string-subcommands"
+                        },
+                        {
+                            "include": "#proc-call-args"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-string-is": {
+            "patterns": [
+                {
+                    "match": "\\s*\\b(is)\\b\\s+([^\\s}\\];]*)",
+                    "captures": {
+                        "1": {
+                            "name": "entity.function.name.string.is.tcl"
+                        },
+                        "2": {
+                            "name": "support.type",
+                            "patterns": [
+                                {
+                                    "include": "#variable"
+                                }
+                            ]
+                        }
+                    }
+                }
+            ]
+        },
+        "tcl-string-match": {
+            "patterns": [
+                {
+                    "begin": "(?<=string)\\s+\\b(match)\\b",
+                    "end": "(?=$|\n|\\]|}|;)",
+                    "captures": {
+                        "1": {
+                            "name": "entity.function.name.string.is.tcl"
+                        },
+                        "2": {
+                            "name": "string"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#line-escape"
+                        },
+                        {
+                            "include": "#variable"
+                        },
+                        {
+                            "include": "#glob-match"
+                        },
+                        {
+                            "include": "#curly-string-brackets"
+                        },
+                        {
+                            "include": "#square-brackets"
+                        },
+                        {
+                            "include": "#constant-numeric"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-string-matchfirst": {
+            "patterns": [
+                {
+                    "begin": "\\s*\\b(matchfirst)\\b",
+                    "end": "\\s*(?=\\]|}|$|;)",
+                    "captures": {
+                        "1": {
+                            "name": "entity.function.name.string.is.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#line-escape"
+                        },
+                        {
+                            "include": "#curly-string-brackets"
+                        },
+                        {
+                            "include": "#constant-numeric"
+                        },
+                        {
+                            "include": "#glob-match"
+                        },
+                        {
+                            "include": "#variable"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-string-map": {
+            "patterns": [
+                {
+                    "begin": "(?<=string)\\b\\s+(map)\\b",
+                    "end": "(?=$|\n|\\]|}|{|\\[)",
+                    "captures": {
+                        "1": {
+                            "name": "entity.function.name.string.map.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#square-brackets"
+                        },
+                        {
+                            "include": "#variable"
+                        },
+                        {
+                            "begin": "\\s*({)",
+                            "end": "\\s*(})",
+                            "patterns": [
+                                {
+                                    "match": "(?<=[^\\\\]\\\\\\\\)(.)",
+                                    "name": "string"
+                                },
+                                {
+                                    "match": "([\\[\\]])",
+                                    "name": "string"
+                                },
+                                {
+                                    "include": "#quoted-string"
+                                },
+                                {
+                                    "include": "#curly-string-brackets"
+                                },
+                                {
+                                    "include": "#bare-string"
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-string-subcommands": {
+            "patterns": [
+                {
+                    "match": "(?<=string)\\b\\s+(match|compact|toupper|tolower|bytelength|compare|cat|first|index|is|last|length|map|range|repeat|replace|reverse|totitle|trim|trimleft|trimright|wordend|wordstart|equal)\\s+",
+                    "name": "entity.function.name.string.subcommands.tcl"
+                }
+            ]
+        },
+        "tcl-dict": {
+            "patterns": [
+                {
+                    "begin": "(?<=^|[\\[{;]|tailcall)\\s*(::)?\\b(dict)\\b",
+                    "end": "($)|(?=$|[;\\]}])",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "support.type"
+                        },
+                        "2": {
+                            "name": "keyword.control.dict.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#line-escape"
+                        },
+                        {
+                            "include": "#tcl-dict-keywords"
+                        },
+                        {
+                            "include": "#tcl-dict-subcommands"
+                        },
+                        {
+                            "include": "#proc-call-args"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-dict-keywords": {
+            "patterns": [
+                {
+                    "include": "#tcl-dict-blocks"
+                },
+                {
+                    "include": "#tcl-dict-setters"
+                }
+            ]
+        },
+        "property-list-brackets": {
+            "patterns": [
+                {
+                    "begin": "\\s*({)",
+                    "end": "(})",
+                    "patterns": [
+                        {
+                            "include": "#property-list"
+                        }
+                    ]
+                }
+            ]
+        },
+        "property-list": {
+            "begin": "(?=.)",
+            "end": "\\s|(?=(?<!\\\\)$|[\\]])|(?<=})",
+            "patterns": [
+                {
+                    "include": "#empty-brackets"
+                },
+                {
+                    "include": "#square-brackets"
+                },
+                {
+                    "include": "#tcl-expression-keywords"
+                },
+                {
+                    "begin": "([^\\s\\]]*)\\s+({)",
+                    "end": "(})",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "variable",
+                            "patterns": [
+                                {
+                                    "include": "#variable"
+                                },
+                                {
+                                    "include": "#opt"
+                                }
+                            ]
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#empty-brackets"
+                        },
+                        {
+                            "include": "#property-list"
+                        }
+                    ]
+                },
+                {
+                    "begin": "\\s*(?!$|\\]|\\\\)([^\\s\\]}{]*)\\s+(?!$|[{\n])",
+                    "end": "(?=\\s|\\]|(?<!\\\\)$)|(?<=})",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "variable",
+                            "patterns": [
+                                {
+                                    "include": "#constant-numeric"
+                                },
+                                {
+                                    "include": "#opt"
+                                },
+                                {
+                                    "include": "#variable"
+                                }
+                            ]
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#line-escape"
+                        },
+                        {
+                            "include": "#opt"
+                        },
+                        {
+                            "include": "#empty-brackets"
+                        },
+                        {
+                            "include": "#special-brackets"
+                        },
+                        {
+                            "include": "#square-brackets"
+                        },
+                        {
+                            "include": "#variable"
+                        },
+                        {
+                            "include": "#constant-numeric"
+                        },
+                        {
+                            "match": "(?!\\s|\\])([^\\s\\]]+)",
+                            "name": "string"
+                        }
+                    ]
+                },
+                {
+                    "include": "#variable"
+                },
+                {
+                    "include": "#bare-string"
+                }
+            ]
+        },
+        "tcl-dict-blocks": {
+            "begin": "(?<=dict)\\b\\s+\\b(for|update|with)\\b(?:(?!$|\n|\\]|}|;|\\[|{)\\s+)?",
+            "end": "(?<=})|(?=(?<!\\\\)(?:$|[;\\]}\n]))",
+            "beginCaptures": {
+                "1": {
+                    "name": "entity.function.name.dict.for.tcl"
+                }
+            },
+            "patterns": [
+                {
+                    "include": "#arguments-braced"
+                },
+                {
+                    "include": "#curly-brackets"
+                },
+                {
+                    "include": "#variable"
+                },
+                {
+                    "include": "#variable-bare-italic"
+                },
+                {
+                    "include": "#brackets"
+                }
+            ]
+        },
+        "tcl-dict-setters": {
+            "patterns": [
+                {
+                    "begin": "(?<=dict)\\s+\\b(set|pull|unset|lappend|incr|push)\\b",
+                    "end": "(?=(?<!\\\\)(?:$|[\n;\\]}]))",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "entity.function.name.dict.setters.subcommand.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#line-escape"
+                        },
+                        {
+                            "include": "#square-brackets"
+                        },
+                        {
+                            "begin": "(?<=pull|push)\\b",
+                            "end": "(?=(?<!\\\\)(?:$|[\n;\\]{}]))",
+                            "patterns": [
+                                {
+                                    "include": "#line-escape"
+                                },
+                                {
+                                    "match": "(?<=push)\\s+(\\-\\>)",
+                                    "captures": {
+                                        "1": {
+                                            "name": "meta.constant"
+                                        }
+                                    }
+                                },
+                                {
+                                    "include": "#variable"
+                                },
+                                {
+                                    "include": "#square-brackets"
+                                },
+                                {
+                                    "include": "#variable-bare"
+                                },
+                                {
+                                    "begin": "\\s*({)",
+                                    "end": "(})",
+                                    "patterns": [
+                                        {
+                                            "match": "(?<={)\\s*([^\\s}]*)",
+                                            "name": "string.pull.prop.tcl"
+                                        },
+                                        {
+                                            "begin": "(?<=\\s)([^\\s}]*)",
+                                            "end": "(?=})",
+                                            "captures": {
+                                                "1": {
+                                                    "patterns": [
+                                                        {
+                                                            "include": "#variable-bare-italic"
+                                                        }
+                                                    ]
+                                                }
+                                            },
+                                            "patterns": [
+                                                {
+                                                    "include": "#constant-numeric"
+                                                },
+                                                {
+                                                    "begin": "\\s*({)",
+                                                    "end": "(})",
+                                                    "contentName": "string.dict.pull.default.tcl",
+                                                    "captures": {
+                                                        "1": {
+                                                            "name": "entity.function.name.dict.pull.props.tcl"
+                                                        }
+                                                    }
+                                                },
+                                                {
+                                                    "include": "#bare-string"
+                                                }
+                                            ]
+                                        },
+                                        {
+                                            "include": "#constant-numeric"
+                                        }
+                                    ]
+                                }
+                            ]
+                        },
+                        {
+                            "begin": "(?<=set|unset|lappend|incr)\\b",
+                            "end": "(?=(?<!\\\\)(?:$|[\n;\\]{}]))",
+                            "patterns": [
+                                {
+                                    "begin": "(?<=set|unset|lappend|incr)\\b\\s+",
+                                    "end": "\\s",
+                                    "patterns": [
+                                        {
+                                            "include": "#variable-bare-italic"
+                                        }
+                                    ]
+                                },
+                                {
+                                    "include": "#proc-call-args"
+                                }
+                            ]
+                        },
+                        {
+                            "include": "#proc-call-args"
+                        },
+                        {
+                            "include": "#variable"
+                        }
+                    ]
+                }
+            ]
+        },
+        "tcl-dict-subcommands": {
+            "patterns": [
+                {
+                    "begin": "(?<=dict)\\s+(create)\\b(?:\\s+(?!$))?",
+                    "end": "(?=\\])|(?<!\\\\)$",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "entity.function.name.dict.subcommand.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#line-escape"
+                        },
+                        {
+                            "include": "#property-list"
+                        }
+                    ]
+                },
+                {
+                    "match": "(?!\\])\\s*\\b(append|exists|filter|get|get\\?|incr|info|keys|lappend|map|merge|remove|replace|set|size|unset|update|values|with|pull|push|pullFrom)\\b",
+                    "name": "entity.function.name.dict.subcommand.tcl"
+                }
+            ]
+        },
+        "proc-arguments": {
+            "patterns": [
+                {
+                    "include": "#proc-args-braced"
+                },
+                {
+                    "include": "#proc-args-singular"
+                }
+            ]
+        },
+        "proc-args-singular": {
+            "patterns": [
+                {
+                    "match": "(?!{|\\[|\\s|}|\\]|$)([^\\s}\\];]*)(?=\\s|}|\\])",
+                    "captures": {
+                        "1": {
+                            "name": "punctuation.definition.variable.tcl"
+                        }
+                    }
+                }
+            ]
+        },
+        "proc-args-braced": {
+            "begin": "(?={)({)",
+            "end": "\\s*(})",
+            "beginCaptures": {
+                "1": {
+                    "name": "meta.brace.curly.proc.args.open.tcl"
+                }
+            },
+            "endCaptures": {
+                "1": {
+                    "name": "meta.brace.curly.proc.args.close.tcl"
+                }
+            },
+            "patterns": [
+                {
+                    "include": "#proc-arguments-nested"
+                },
+                {
+                    "include": "#variable-bare"
+                }
+            ]
+        },
+        "proc-arguments-nested": {
+            "patterns": [
+                {
+                    "begin": "\\s*+({)",
+                    "end": "(})",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "entity.function.name"
+                        }
+                    },
+                    "endCaptures": {
+                        "1": {
+                            "name": "entity.function.name"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#quoted-string"
+                        },
+                        {
+                            "include": "#empty-brackets"
+                        },
+                        {
+                            "match": "\\s*([^\\s|{|}]*)\\s*([^\\s|{|}]*)(?=\\s*?})",
+                            "contentName": "variable",
+                            "captures": {
+                                "1": {
+                                    "name": "variable"
+                                },
+                                "2": {
+                                    "name": "string.proc.argument",
+                                    "patterns": [
+                                        {
+                                            "include": "#constant-numeric"
+                                        }
+                                    ]
+                                }
+                            }
+                        },
+                        {
+                            "include": "#curly-string-brackets"
+                        },
+                        {
+                            "match": "\\s*([^\\s|{|}]*)",
+                            "name": "variable.proc.argument"
+                        }
+                    ]
+                }
+            ]
+        },
+        "arguments-braced": {
+            "patterns": [
+                {
+                    "begin": "({)(?:(?!$|\n|\\]|}|;|\\[|{)\\s*)?",
+                    "end": "(})",
+                    "patterns": [
+                        {
+                            "match": "(?:(?!$|\n|\\]|}|;|\\[|{)\\s*)?([^\\s|{|}]*)(?:(?!$|\n|\\]|}|;|\\[|{)\\s*)?",
+                            "name": "variable"
+                        }
+                    ]
+                }
+            ]
+        },
+        "double-dash": {
+            "match": "\\s(--)\\s",
+            "captures": {
+                "1": {
+                    "name": "keyword.control.tcl"
+                }
+            }
+        },
+        "quoted-string": {
+            "patterns": [
+                {
+                    "comment": "when inside curly bracket, {\"}",
+                    "match": "(?<={)\\s*+(\"\\s*(?=})(?!\"))",
+                    "name": "string.quoted.tcl"
+                },
+                {
+                    "begin": "\\s*+(?<!\\\\)(\")",
+                    "end": "(?<!\\\\)((?:\\\\{2})*)(\")",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "string.quoted.double.open.tcl"
+                        }
+                    },
+                    "endCaptures": {
+                        "1": {
+                            "name": "constant.character.escape"
+                        },
+                        "2": {
+                            "name": "string.quoted.double.close.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#square-brackets"
+                        },
+                        {
+                            "include": "#string-content"
+                        },
+                        {
+                            "match": "(\\*)",
+                            "name": "bare.string"
+                        },
+                        {
+                            "match": "([{}])",
+                            "name": "string.quoted.tcl"
+                        }
+                    ]
+                }
+            ]
+        },
+        "string-content": {
+            "patterns": [
+                {
+                    "include": "#string-escapes"
+                },
+                {
+                    "include": "#variable"
+                },
+                {
+                    "include": "#square-brackets"
+                },
+                {
+                    "include": "#bare-string"
+                }
+            ]
+        },
+        "string-escapes": {
+            "patterns": [
+                {
+                    "name": "constant.character.escape.newline.tcl",
+                    "match": "\\\\\n"
+                },
+                {
+                    "name": "constant.character.escape",
+                    "match": "\\s*+\\\\[\\]\"\\\\nrtbfv0`\\[]"
+                },
+                {
+                    "name": "constant.character.escape",
+                    "match": "\\\\u(({[0-9a-fA-F]+\\})|[0-9a-fA-F]{4})"
+                },
+                {
+                    "name": "constant.character.escape",
+                    "match": "\\\\x[0-9a-fA-F]{2}"
+                },
+                {
+                    "name": "constant.character.escape",
+                    "match": "(?<!\\\\)(\\\\)([;])",
+                    "captures": {
+                        "1": {
+                            "name": "constant.character.escape"
+                        },
+                        "2": {
+                            "name": "string"
+                        }
+                    }
+                }
+            ]
+        },
+        "bare-string": {
+            "patterns": [
+                {
+                    "include": "#opt"
+                },
+                {
+                    "include": "#string-escapes"
+                },
+                {
+                    "match": "\\s*(\\$)(?=$|\n|\\]|}|\"|;|\\s)",
+                    "name": "bare.string.tcl"
+                },
+                {
+                    "match": "(\\\\[^\\]\"\\\\nrtbfv0`\\[])",
+                    "name": "bare.string.tcl"
+                },
+                {
+                    "match": "(?<!::)(?!;|\\]|}|\\*|\"|;)([^\\*}\\\\;\\]{\\[\"\\$\n\\-\\)\\(]+)",
+                    "captures": {
+                        "1": {
+                            "name": "bare.string.tcl",
+                            "patterns": [
+                                {
+                                    "match": "(?:(?<=::)|(?=[^\\s:]*(?=::)))(?!\\s)([^\\s]*)",
+                                    "captures": {
+                                        "1": {
+                                            "patterns": [
+                                                {
+                                                    "include": "#namespace-name"
+                                                }
+                                            ]
+                                        }
+                                    }
+                                },
+                                {
+                                    "include": "#variable"
+                                }
+                            ]
+                        }
+                    }
+                },
+                {
+                    "match": "(-)(?=\\s|;|}|\\]|\"|-)",
+                    "name": "bare.string.tcl"
+                },
+                {
+                    "match": "(?<=-)(-)",
+                    "name": "bare.string.tcl"
+                },
+                {
+                    "include": "#variable"
+                }
+            ]
+        },
+        "html-curly-brackets": {
+            "begin": "\\s*({)",
+            "end": "(})",
+            "patterns": [
+                {
+                    "include": "text.html.basic"
+                }
+            ]
+        },
+        "regexp": {
+            "patterns": [
+                {
+                    "begin": "(?<=^|\\[|{|;)\\s*(::)?\\b(regexp|regsub)\\b",
+                    "end": "(?=(?<!\\\\)(?:$|.*[\n;}\\]]))",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "support.type.ns.separator.tcl"
+                        },
+                        "2": {
+                            "name": "keyword.control.regexp.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#line-escape"
+                        },
+                        {
+                            "include": "#double-dash"
+                        },
+                        {
+                            "include": "#quoted-string"
+                        },
+                        {
+                            "match": "\\s*(->)",
+                            "name": "meta.constant.re.trashvar.tcl"
+                        },
+                        {
+                            "include": "#opt"
+                        },
+                        {
+                            "begin": "\\s*({|\")",
+                            "end": "(}|\")(?=\\s+(?:\\\\\n|$|\n|\\[|\\$|\\b|\"|;|}|-))",
+                            "contentName": "string.tcl",
+                            "patterns": [
+                                {
+                                    "include": "#regular-expression"
+                                }
+                            ]
+                        },
+                        {
+                            "include": "#quoted-string"
+                        },
+                        {
+                            "include": "#variable"
+                        },
+                        {
+                            "include": "#variable-bare-italic"
+                        }
+                    ]
+                },
+                {
+                    "begin": "(?<=_regexp|_re)\\s+(?={|\")",
+                    "end": "(?=(?<!\\\\)$)|(?<=\")|(?<=})",
+                    "patterns": [
+                        {
+                            "begin": "({)",
+                            "end": "(})",
+                            "contentName": "string.tcl",
+                            "patterns": [
+                                {
+                                    "include": "#regular-expression"
+                                }
+                            ]
+                        },
+                        {
+                            "begin": "(\")",
+                            "end": "(\")",
+                            "contentName": "string.tcl",
+                            "patterns": [
+                                {
+                                    "include": "#regular-expression"
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        },
+        "comment-blocks": {
+            "patterns": [
+                {
+                    "contentName": "comment.line.number-sign.tcl",
+                    "begin": "(?<=^|;|{)\\s*((#))",
+                    "end": "(?=$|\n)|((#))(?=\\s*(?:[}\n]))",
+                    "captures": {
+                        "1": {
+                            "name": "comment.line.number-sign.tcl"
+                        },
+                        "2": {
+                            "name": "punctuation.definition.comment.tcl"
+                        }
+                    }
+                },
+                {
+                    "contentName": "comment.block.tcl",
+                    "begin": "(?<=^|;|\\{)\\s*((?:\\%\\s+\\{)|(?:\\bif\\s+{?0}?\\s+{))",
+                    "end": "\\s*(\\})",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "comment.block.multi.start.tcl"
+                        },
+                        "2": {
+                            "name": "punctuation.definition.comment.tcl"
+                        }
+                    },
+                    "endCaptures": {
+                        "1": {
+                            "name": "comment.block.multi.end.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#annotate"
+                        },
+                        {
+                            "include": "#variable-non-substituting"
+                        }
+                    ]
+                }
+            ]
+        },
+        "annotate": {
+            "patterns": [
+                {
+                    "include": "#annotate-control-block"
+                },
+                {
+                    "include": "#annotate-properties"
+                },
+                {
+                    "include": "#annotate-title"
+                },
+                {
+                    "include": "#annotate-header"
+                },
+                {
+                    "include": "#annotate-highlight"
+                },
+                {
+                    "include": "#annotate-type"
+                },
+                {
+                    "include": "#annotate-list"
+                }
+            ]
+        },
+        "annotate-title": {
+            "patterns": [
+                {
+                    "comment": "adding @ in a multi-line will make the line emphasized",
+                    "contentName": "meta.class.comment.annotate.tcl",
+                    "begin": "\\s*+(@)",
+                    "end": "(?={|\\s-|>)|(@|}|$|\n)|\\|",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "support.type.annotate.tcl"
+                        }
+                    },
+                    "endCaptures": {
+                        "1": {
+                            "name": "support.type.annotate.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#variable-non-substituting"
+                        },
+                        {
+                            "include": "#namespace-separator"
+                        }
+                    ]
+                }
+            ]
+        },
+        "annotate-properties": {
+            "begin": "(?=\\s*@[^\\s\n])",
+            "end": "(?=$|[\n}@])",
+            "patterns": [
+                {
+                    "comment": "special @ values that are meant as property values",
+                    "match": "\\s*+(@)\\b(type)\\b(\\s+[^{}|@\\[<>-]*)?",
+                    "captures": {
+                        "1": {
+                            "name": "meta.constant.annotate.property.tcl"
+                        },
+                        "2": {
+                            "name": "support.type.name.tcl"
+                        },
+                        "3": {
+                            "name": "entity.function.property.name.tcl"
+                        }
+                    }
+                },
+                {
+                    "comment": "special @ values that are meant as property values",
+                    "match": "\\s*+(@)\\b(arg(?:s)?|returns|key|prop|if|example|param|params|opt|option|argument|val|value)\\b(\\s+[^\\/{}|@\\[<>]*)?",
+                    "captures": {
+                        "1": {
+                            "name": "support.type.annotate.property.tcl"
+                        },
+                        "2": {
+                            "name": "variable.property.name.tcl"
+                        },
+                        "3": {
+                            "name": "support.type",
+                            "patterns": [
+                                {
+                                    "include": "#opt"
+                                }
+                            ]
+                        }
+                    }
+                },
+                {
+                    "comment": "@<other> (no space after @)",
+                    "match": "\\s*+(@)\\b([^\\s]*)\\b(\\s+[^\\/{}|@\\[<>-]*)?",
+                    "captures": {
+                        "1": {
+                            "name": "meta.constant.annotate.property.tcl"
+                        },
+                        "2": {
+                            "name": "entity.function.property.name.tcl"
+                        },
+                        "3": {
+                            "name": "support.type.tcl"
+                        }
+                    }
+                },
+                {
+                    "include": "#annotate"
+                }
+            ]
+        },
+        "annotate-control-block": {
+            "patterns": [
+                {
+                    "comment": "bracketed within a comment",
+                    "contentName": "keyword.operator",
+                    "begin": "^\\s*+(?={)",
+                    "end": "(?<=})",
+                    "patterns": [
+                        {
+                            "include": "#brackets"
+                        }
+                    ]
+                }
+            ]
+        },
+        "annotate-proc-call": {
+            "patterns": [
+                {
+                    "begin": "(\\[)",
+                    "end": "(\\])",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "support.type.annotate.proc-call.tcl"
+                        }
+                    },
+                    "endCaptures": {
+                        "1": {
+                            "name": "support.type.annotate.proc-call.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#proc-call"
+                        }
+                    ]
+                }
+            ]
+        },
+        "annotate-type": {
+            "patterns": [
+                {
+                    "comment": "adding @ in a multi-line will make the line emphasized",
+                    "contentName": "entity.function.name.comment.annotate.tcl",
+                    "begin": "\\s*+({)",
+                    "end": "\\s*(})",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "meta.constant.comment.annotate.tcl"
+                        }
+                    },
+                    "endCaptures": {
+                        "1": {
+                            "name": "meta.constant.comment.annotate.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#annotate-regular-expression"
+                        },
+                        {
+                            "include": "#annotate-proc-call"
+                        },
+                        {
+                            "begin": "(<)",
+                            "end": "(>)|(?=[}])",
+                            "contentName": "support.type.comment.annotate.property.punctuation.italic.tcl",
+                            "patterns": [
+                                {
+                                    "include": "#annotate-regular-expression"
+                                },
+                                {
+                                    "match": "(\\|)",
+                                    "name": "entity.function.name.tcl"
+                                },
+                                {
+                                    "include": "#variable-non-substituting"
+                                },
+                                {
+                                    "match": "([,])",
+                                    "name": "entity.function.name.annotate.opt.tcl"
+                                },
+                                {
+                                    "match": "([-])",
+                                    "name": "meta.constant.annotate.opt.tcl"
+                                }
+                            ]
+                        },
+                        {
+                            "match": "(?:(?<={|\\|)([?*])|([?*])(?=}|\\|))",
+                            "name": "variable.modifier.annotate.punctuation.italic.tcl"
+                        },
+                        {
+                            "match": "(\\|)",
+                            "name": "meta.constant.comment.annotate.tcl"
+                        }
+                    ]
+                }
+            ]
+        },
+        "annotate-regular-expression": {
+            "patterns": [
+                {
+                    "begin": "(/)",
+                    "end": "(/|$)",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "support.type.annotate.re.brace.open.tcl"
+                        }
+                    },
+                    "endCaptures": {
+                        "1": {
+                            "name": "support.type.annotate.re.brace.close.tcl"
+                        }
+                    },
+                    "contentName": "string.re.expression.comment.annotate.contents.tcl",
+                    "patterns": [
+                        {
+                            "include": "#regular-expression"
+                        }
+                    ]
+                }
+            ]
+        },
+        "annotate-highlight": {
+            "patterns": [
+                {
+                    "comment": "adding | in a multi-line will make the line highlighted (string)",
+                    "match": "(?<=\\|)\\s*([^|]*)",
+                    "captures": {
+                        "1": {
+                            "name": "string.quote.annotate.comment.tcl",
+                            "patterns": [
+                                {
+                                    "include": "#annotate-type"
+                                },
+                                {
+                                    "include": "#annotate-proc-call"
+                                },
+                                {
+                                    "include": "#variable-non-substituting"
+                                },
+                                {
+                                    "match": "\\b(http://([^\\s]*))",
+                                    "name": "entity.function.name.markup.underline"
+                                }
+                            ]
+                        }
+                    }
+                }
+            ]
+        },
+        "annotate-header": {
+            "patterns": [
+                {
+                    "comment": "adding > in a multi-line will make the line emphasized",
+                    "begin": "\\s*+(>)",
+                    "end": "(<)|(?=$|>)",
+                    "contentName": "meta.constant.annotate.header.tcl",
+                    "captures": {
+                        "1": {
+                            "name": "entity.function.name.annotate.tcl"
+                        },
+                        "2": {
+                            "name": "meta.constant.annotate.header.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#annotate"
+                        }
+                    ]
+                }
+            ]
+        },
+        "annotate-list": {
+            "patterns": [
+                {
+                    "match": "^\\s*([0-9]\\.)\\s+",
+                    "name": "meta.class"
+                }
+            ]
+        },
+        "opt": {
+            "patterns": [
+                {
+                    "comment": "Handle options sent to commands at various points (cmd -name1 value -name2 value)",
+                    "match": "\\s*+(?<=\\s|^|\"|\\()((-)(?!-|\\s|\"|;|\n|>)[^\\s$\n\\[\\];\"{)(}]*)",
+                    "captures": {
+                        "1": {
+                            "name": "support.type.opt.tcl"
+                        },
+                        "2": {
+                            "name": "meta.constant.opt.start.tcl"
+                        }
+                    }
+                }
+            ]
+        },
+        "line-escape": {
+            "begin": "\\s*+(\\\\\n)$",
+            "end": "(^)(?:\\s*(?!$))?",
+            "beginCaptures": {
+                "1": {
+                    "name": "constant.character.escape.newline.tcl"
+                }
+            },
+            "endCaptures": {
+                "1": {
+                    "name": "meta.lineescape.highlight.tcl"
+                }
+            }
+        },
+        "glob-match": {
+            "patterns": [
+                {
+                    "begin": "({)",
+                    "end": "(})",
+                    "patterns": [
+                        {
+                            "include": "#glob-match"
+                        }
+                    ]
+                },
+                {
+                    "match": "\\s*+(\\*)",
+                    "name": "meta.class"
+                },
+                {
+                    "include": "#string-escapes"
+                },
+                {
+                    "begin": "(?<!\\\\)(\")",
+                    "end": "(?<!\\\\)(\")",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "string.double.quoted.glob.match.open.tcl"
+                        }
+                    },
+                    "endCaptures": {
+                        "1": {
+                            "name": "string.double.quoted.glob.match.close.tcl"
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#glob-match"
+                        }
+                    ]
+                },
+                {
+                    "begin": "(?<!\\\\)(\\[)",
+                    "end": "(?<!\\\\)(\\])",
+                    "contentName": "support.type",
+                    "beginCaptures": {
+                        "1": {
+                            "name": "meta.class"
+                        }
+                    },
+                    "endCaptures": {
+                        "1": {
+                            "name": "meta.class"
+                        }
+                    }
+                },
+                {
+                    "include": "#square-brackets"
+                },
+                {
+                    "include": "#bare-string"
+                }
+            ]
+        },
+        "spread-variable-only": {
+            "comment": "Only allow a variable if it is spread using {*}",
+            "patterns": [
+                {
+                    "match": "(?<=^|\\[)\\s*(?<!\\{\\*\\})(\\$)(([a-zA-Z0-9_]|::)+(\\([^\\)]+\\))?|\\{[^\\}]*\\})",
+                    "captures": {
+                        "1": {
+                            "name": "invalid.illegal.nospread.tcl"
+                        },
+                        "2": {
+                            "name": "invalid.illegal.nospread.tcl"
+                        }
+                    }
+                },
+                {
+                    "include": "#variable"
+                }
+            ]
+        },
+        "spread-variable": {
+            "patterns": [
+                {
+                    "match": "\\s*+({(\\*)}?)(?=\\$)",
+                    "captures": {
+                        "1": {
+                            "name": "entity.function.name.tcl.markup.italic"
+                        },
+                        "2": {
+                            "name": "support.type"
+                        }
+                    }
+                }
+            ]
+        },
+        "variable-bare-italic": {
+            "patterns": [
+                {
+                    "begin": "\\s*(?!$|[$\\[;\n{])",
+                    "end": "(?=(?<!\\\\)$|[\n\\];\\[{}\\s])",
+                    "patterns": [
+                        {
+                            "include": "#quoted-string"
+                        },
+                        {
+                            "include": "#variable"
+                        },
+                        {
+                            "include": "#brackets"
+                        },
+                        {
+                            "begin": "\\s*(\\()",
+                            "end": "(\\))",
+                            "contentName": "punctuation.italic",
+                            "beginCaptures": {
+                                "1": {
+                                    "name": "entity.function.name.array.open.tcl"
+                                }
+                            },
+                            "endCaptures": {
+                                "1": {
+                                    "name": "entity.function.name.array.close.tcl"
+                                }
+                            },
+                            "patterns": [
+                                {
+                                    "include": "#opt"
+                                },
+                                {
+                                    "include": "#proc-call-args"
+                                }
+                            ]
+                        },
+                        {
+                            "include": "#namespace-separator"
+                        },
+                        {
+                            "match": "(?!\\s)([^\\s\\[(?:::){;\\$\"\\]};]*)",
+                            "name": "punctuation.italic.variable"
+                        },
+                        {
+                            "match": "(?<=\\*)(?!\\s)([^\\s\\[(?:::){;$\"\\];}]*)",
+                            "name": "punctuation.italic.variable"
+                        }
+                    ]
+                }
+            ]
+        },
+        "variable-bare": {
+            "patterns": [
+                {
+                    "begin": "(?<=\\s|^|\\*|{)\\s*(?!$|[$\n;}{\\]\\[])",
+                    "end": "(?=(?<!\\\\)$|[\n\\];\\[{}]|(?=\\s))",
+                    "patterns": [
+                        {
+                            "include": "#variable"
+                        },
+                        {
+                            "include": "#quoted-string"
+                        },
+                        {
+                            "begin": "(\\()",
+                            "end": "(\\))",
+                            "contentName": "punctuation.italic",
+                            "beginCaptures": {
+                                "1": {
+                                    "name": "entity.function.name.array.open.tcl"
+                                }
+                            },
+                            "endCaptures": {
+                                "1": {
+                                    "name": "entity.function.name.array.close.tcl"
+                                }
+                            },
+                            "patterns": [
+                                {
+                                    "include": "#opt"
+                                },
+                                {
+                                    "include": "#proc-call-args"
+                                }
+                            ]
+                        },
+                        {
+                            "include": "#namespace-separator"
+                        },
+                        {
+                            "match": "([,])",
+                            "name": "variable"
+                        },
+                        {
+                            "match": "(?!(?<!\\\\)$|\\[|\\])([^:\\s}\\]\\[\\({\",;$]*)",
+                            "name": "variable"
+                        },
+                        {
+                            "match": "(?<=\\*)(?!\\s|$|\\[|\\])([^:\\s}\\[{\\]\",;]*)",
+                            "name": "variable"
+                        },
+                        {
+                            "match": "(:)",
+                            "name": "string"
+                        },
+                        {
+                            "include": "#proc-call-args"
+                        }
+                    ]
+                },
+                {
+                    "include": "#variable"
+                }
+            ]
+        },
+        "variable-braced": {
+            "patterns": [
+                {
+                    "begin": "(?={)({)",
+                    "end": "(}|\\s)",
+                    "patterns": [
+                        {
+                            "include": "#variable-bare"
+                        }
+                    ]
+                }
+            ]
+        },
+        "variable-object": {
+            "patterns": [
+                {
+                    "begin": "(?<=^|[\\[{;])(?!\\s*$|[\n\\]};])\\s*((\\$)([^\\s\n\\]}]+))(?:(?!\\s*$|\\s*[\n}\\];])\\s*([^\\s\n\\]};]*))?",
+                    "end": "(?=(?<!\\\\)(?:$|[\n\\];\\[{}]))",
+                    "beginCaptures": {
+                        "1": {
+                            "match": "(?<={)\\s*([^\\s]*)\\s*(?=})",
+                            "captures": {
+                                "1": {
+                                    "patterns": [
+                                        {
+                                            "include": "#variable-non-substituting"
+                                        }
+                                    ]
+                                }
+                            }
+                        },
+                        "2": {
+                            "name": "support.type"
+                        },
+                        "3": {
+                            "name": "meta.class",
+                            "patterns": [
+                                {
+                                    "include": "#namespace-separator"
+                                }
+                            ]
+                        },
+                        "4": {
+                            "patterns": [
+                                {
+                                    "include": "#line-escape"
+                                },
+                                {
+                                    "match": "(destroy|new|create)",
+                                    "name": "keyword.oo.special.tcl"
+                                },
+                                {
+                                    "include": "#namespace-name"
+                                }
+                            ]
+                        }
+                    },
+                    "patterns": [
+                        {
+                            "include": "#line-escape"
+                        },
+                        {
+                            "include": "#proc-call-args"
+                        }
+                    ]
+                }
+            ]
+        },
+        "variable": {
+            "patterns": [
+                {
+                    "include": "#spread-variable"
+                },
+                {
+                    "match": "^\\s*(\\$)\\s*(?=\n|$|\\]|})",
+                    "name": "support.type"
+                },
+                {
+                    "match": "\\s*(?:(?![\\]\n\"};])|(?=[$]))(?<!(?<!\\\\)\\\\)(\\$)(?:({)([^}\\s\\]\"\\)\\(\\$]*)(\\([^\\(\\)]*\\))?(})([^\\s\\[\\];\n\"{}]*)?|(?=[A-Za-z0-9_:])([^\\s\\*\\[}\\]/\"\\);\\(\\\\$,\\-\\+'\\*]*)(\\([^\\s\\['\\\\;}\\]\")($,+*]*\\))?)",
+                    "captures": {
+                        "1": {
+                            "name": "support.type.variable.indicator.tcl"
+                        },
+                        "2": {
+                            "name": "entity.function.name.variable.brace.open.tcl"
+                        },
+                        "3": {
+                            "patterns": [
+                                {
+                                    "include": "#namespace-separator"
+                                },
+                                {
+                                    "include": "#variable"
+                                },
+                                {
+                                    "match": "([^\\s:\"}{]+)",
+                                    "name": "variable.name"
+                                }
+                            ]
+                        },
+                        "4": {
+                            "patterns": [
+                                {
+                                    "begin": "(\\()",
+                                    "end": "(\\))",
+                                    "contentName": "punctuation.italic",
+                                    "beginCaptures": {
+                                        "1": {
+                                            "name": "support.type"
+                                        }
+                                    },
+                                    "endCaptures": {
+                                        "1": {
+                                            "name": "support.type"
+                                        }
+                                    },
+                                    "patterns": [
+                                        {
+                                            "include": "#opt"
+                                        },
+                                        {
+                                            "include": "#proc-call-args"
+                                        }
+                                    ]
+                                }
+                            ]
+                        },
+                        "5": {
+                            "name": "entity.function.name.variable.brace.close.tcl"
+                        },
+                        "6": {
+                            "patterns": [
+                                {
+                                    "include": "#proc-call-args"
+                                },
+                                {
+                                    "include": "#bare-string"
+                                }
+                            ]
+                        },
+                        "7": {
+                            "patterns": [
+                                {
+                                    "include": "#namespace-separator"
+                                },
+                                {
+                                    "match": "([^\\s:\"}{\\\\\\]\\[]+)",
+                                    "name": "variable.name"
+                                }
+                            ]
+                        },
+                        "8": {
+                            "patterns": [
+                                {
+                                    "begin": "(\\()",
+                                    "end": "(\\))",
+                                    "contentName": "punctuation.italic",
+                                    "beginCaptures": {
+                                        "1": {
+                                            "name": "entity.function.name.tcl"
+                                        }
+                                    },
+                                    "endCaptures": {
+                                        "1": {
+                                            "name": "entity.function.name.tcl"
+                                        }
+                                    },
+                                    "patterns": [
+                                        {
+                                            "include": "#opt"
+                                        },
+                                        {
+                                            "include": "#proc-call-args"
+                                        }
+                                    ]
+                                }
+                            ]
+                        }
+                    }
+                }
+            ]
+        },
+        "variable-non-substituting": {
+            "patterns": [
+                {
+                    "include": "#spread-variable"
+                },
+                {
+                    "match": "^\\s*+(\\$)\\s*(?=\n|$)",
+                    "name": "support.type"
+                },
+                {
+                    "match": "\\s*+(?:(?!\\]|\n|\"|>|<|,))(?<!(?<!\\\\)\\\\)(\\$)(?:({)([^}\\s\\]\"\\)\\(\\$]*)(\\(.*\\))?(})|(?=[A-Za-z0-9_:])([^\\s\\,<>\\*}\\]/\"\\);\\(\\\\\\$,\\-\\+\\*]*)(\\([^\\s\\\\;\\*}\\]\"\\)\\(\\$,\\-\\+\\*<>]*\\))?)",
+                    "captures": {
+                        "1": {
+                            "name": "support.type.variable.indicator.tcl"
+                        },
+                        "2": {
+                            "name": "entity.function.name.variable.brace.open.tcl"
+                        },
+                        "3": {
+                            "patterns": [
+                                {
+                                    "include": "#namespace-separator"
+                                },
+                                {
+                                    "include": "#variable"
+                                },
+                                {
+                                    "match": "([^\\s:\"}{]+)",
+                                    "name": "meta.constant.tcl"
+                                }
+                            ]
+                        },
+                        "4": {
+                            "patterns": [
+                                {
+                                    "begin": "(\\()",
+                                    "end": "(\\))",
+                                    "contentName": "punctuation.italic.meta.constant",
+                                    "beginCaptures": {
+                                        "1": {
+                                            "name": "support.type"
+                                        }
+                                    },
+                                    "endCaptures": {
+                                        "1": {
+                                            "name": "support.type"
+                                        }
+                                    },
+                                    "patterns": [
+                                        {
+                                            "include": "#proc-call-args"
+                                        }
+                                    ]
+                                }
+                            ]
+                        },
+                        "5": {
+                            "name": "entity.function.name.variable.brace.close.tcl"
+                        },
+                        "6": {
+                            "patterns": [
+                                {
+                                    "include": "#namespace-separator"
+                                },
+                                {
+                                    "match": "([^\\s:\"}{\\\\\\]\\[]+)",
+                                    "name": "meta.constant"
+                                }
+                            ]
+                        },
+                        "7": {
+                            "patterns": [
+                                {
+                                    "begin": "(\\()",
+                                    "end": "(\\))",
+                                    "contentName": "punctuation.italic.meta.constant",
+                                    "beginCaptures": {
+                                        "1": {
+                                            "name": "entity.function.name"
+                                        }
+                                    },
+                                    "endCaptures": {
+                                        "1": {
+                                            "name": "entity.function.name"
+                                        }
+                                    },
+                                    "patterns": [
+                                        {
+                                            "include": "#proc-call-args"
+                                        }
+                                    ]
+                                }
+                            ]
+                        }
+                    }
+                }
+            ]
+        }
+    },
+    "scopeName": "source.tcl"
+}
\ No newline at end of file