typescript.tmLanguage.json

{
  "$schema": "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
  "name": "typescript",
  "scopeName": "source.ts",
  "patterns": [
    {
      "include": "#generic-arrow-function"
    },
    {
      "include": "#generic-call"
    },
    {
      "include": "#generic-call-eol"
    },
    {
      "include": "#generic-call-multiline"
    },
    {
      "include": "#cast"
    },
    {
      "include": "#shebang"
    },
    {
      "include": "#jsdoc"
    },
    {
      "include": "#directives"
    },
    {
      "include": "#linecomment"
    },
    {
      "include": "#blockcomment"
    },
    {
      "include": "#regex-literal-prefix-ops"
    },
    {
      "include": "#regex"
    },
    {
      "include": "#qstring-double"
    },
    {
      "include": "#qstring-single"
    },
    {
      "include": "#template"
    },
    {
      "include": "#decorator"
    },
    {
      "include": "#type-annotation-var"
    },
    {
      "include": "#type-annotation-return"
    },
    {
      "include": "#object-method-key"
    },
    {
      "include": "#new-expr"
    },
    {
      "include": "#arrow-function-params"
    },
    {
      "include": "#ternary-expression"
    },
    {
      "include": "#function-declaration"
    },
    {
      "include": "#function-anon-declaration"
    },
    {
      "include": "#class-declaration"
    },
    {
      "include": "#interface-declaration"
    },
    {
      "include": "#type-alias-declaration"
    },
    {
      "include": "#enum-declaration"
    },
    {
      "include": "#namespace-declaration"
    },
    {
      "include": "#module-declaration"
    },
    {
      "include": "#extends-definition"
    },
    {
      "include": "#let-destructure"
    },
    {
      "include": "#const-binding"
    },
    {
      "include": "#const-destructure"
    },
    {
      "include": "#var-destructure"
    },
    {
      "include": "#using-destructure"
    },
    {
      "include": "#import-export-all"
    },
    {
      "include": "#import-default-binding"
    },
    {
      "include": "#keyof-typekw"
    },
    {
      "include": "#type-predicate-operator"
    },
    {
      "include": "#extends-typekw"
    },
    {
      "include": "#unique-typekw"
    },
    {
      "include": "#as-typekw"
    },
    {
      "include": "#implements-typekw"
    },
    {
      "include": "#satisfies-typekw"
    },
    {
      "include": "#hexnumber"
    },
    {
      "include": "#octalnumber"
    },
    {
      "include": "#binarynumber"
    },
    {
      "include": "#bigint"
    },
    {
      "include": "#number"
    },
    {
      "include": "#scope-keyword-operator-expression"
    },
    {
      "include": "#scope-keyword-operator-expression-keyof"
    },
    {
      "include": "#scope-keyword-operator-expression-is"
    },
    {
      "include": "#scope-keyword-operator-expression-asserts"
    },
    {
      "include": "#scope-keyword-operator-expression-infer"
    },
    {
      "include": "#scope-keyword-operator-expression-satisfies"
    },
    {
      "include": "#scope-keyword-control-import"
    },
    {
      "include": "#scope-keyword-control-loop"
    },
    {
      "include": "#scope-keyword-control-flow"
    },
    {
      "include": "#scope-keyword-control-export"
    },
    {
      "include": "#scope-keyword-control-conditional"
    },
    {
      "include": "#scope-keyword-control-switch"
    },
    {
      "include": "#scope-keyword-control-trycatch"
    },
    {
      "include": "#scope-keyword-control"
    },
    {
      "include": "#scope-keyword-control-from-from"
    },
    {
      "include": "#scope-storage-modifier"
    },
    {
      "include": "#scope-keyword-other-extends"
    },
    {
      "include": "#scope-keyword-other"
    },
    {
      "include": "#scope-storage-type-function"
    },
    {
      "include": "#scope-storage-type-class"
    },
    {
      "include": "#scope-storage-type-property"
    },
    {
      "include": "#scope-storage-type"
    },
    {
      "include": "#scope-storage-type-interface-decl"
    },
    {
      "include": "#scope-storage-type-type-decl"
    },
    {
      "include": "#scope-storage-type-enum"
    },
    {
      "include": "#scope-storage-type-namespace-decl"
    },
    {
      "include": "#scope-storage-type-function-arrow"
    },
    {
      "include": "#scope-constant-language-boolean-true"
    },
    {
      "include": "#scope-constant-language-boolean-false"
    },
    {
      "include": "#scope-constant-language-null"
    },
    {
      "include": "#this-literal"
    },
    {
      "include": "#scope-support-type-primitive"
    },
    {
      "include": "#super-literal"
    },
    {
      "include": "#scope-support-variable"
    },
    {
      "include": "#scope-support-class"
    },
    {
      "include": "#method-call"
    },
    {
      "include": "#known-property-access"
    },
    {
      "include": "#property-access"
    },
    {
      "include": "#operator-overrides"
    },
    {
      "include": "#operators"
    },
    {
      "include": "#punctuation-accessor"
    },
    {
      "include": "#punctuation-comma"
    },
    {
      "include": "#scope-punctuation-bracket-square"
    },
    {
      "include": "#scope-punctuation-bracket-round"
    },
    {
      "include": "#scope-punctuation-bracket-curly"
    },
    {
      "include": "#punctuation-semicolon"
    },
    {
      "include": "#scope-punctuation-accessor-optional"
    },
    {
      "include": "#punctuation"
    },
    {
      "include": "#arrow-parameter"
    },
    {
      "include": "#function-call"
    },
    {
      "include": "#ident"
    },
    {
      "include": "#privatefield"
    },
    {
      "include": "#comparison"
    }
  ],
  "repository": {
    "generic-call": {
      "name": "meta.generic.ts",
      "begin": "(?<=[\\w$\\]\\)])(<)(?=\\s*[\\w$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}<>,\\s]*>\\s*[\\(`])",
      "beginCaptures": {
        "1": {
          "name": "punctuation.definition.typeparameters.begin.ts"
        }
      },
      "end": "(>)",
      "endCaptures": {
        "1": {
          "name": "punctuation.definition.typeparameters.end.ts"
        }
      },
      "patterns": [
        {
          "include": "#type"
        }
      ]
    },
    "generic-call-eol": {
      "name": "meta.generic.ts",
      "begin": "(?<=[\\w$\\]\\)])(<)(?=\\s*[\\w$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}<>,\\s]*>\\s*$)",
      "beginCaptures": {
        "1": {
          "name": "punctuation.definition.typeparameters.begin.ts"
        }
      },
      "end": "(>)",
      "endCaptures": {
        "1": {
          "name": "punctuation.definition.typeparameters.end.ts"
        }
      },
      "patterns": [
        {
          "include": "#type"
        }
      ]
    },
    "generic-call-multiline": {
      "name": "meta.angle-brackets.ts",
      "begin": "(?<=[\\w$\\]\\)])(<)(?!(?<B>[^<>]*(?:<\\g<B>>[^<>]*)*)>)",
      "beginCaptures": {
        "1": {
          "name": "punctuation.bracket.angle.open.ts"
        }
      },
      "end": "(>)(?=\\s*[\\(`])|(>)(?=\\s*$)|(>)|(?=[=\\^+/%~;])",
      "endCaptures": {
        "1": {
          "name": "punctuation.definition.typeparameters.end.ts"
        },
        "2": {
          "name": "punctuation.definition.typeparameters.end.ts"
        },
        "3": {
          "name": "keyword.operator.relational.ts"
        }
      },
      "patterns": [
        {
          "include": "#generic-type"
        },
        {
          "match": "(?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*(?=\\s*[,>])",
          "name": "entity.name.type.ts"
        },
        {
          "match": ",",
          "name": "punctuation.separator.comma.ts"
        },
        {
          "include": "#ident"
        },
        {
          "include": "#angle-bracket-continuation"
        }
      ]
    },
    "angle-bracket-continuation": {
      "begin": "(?=\\s*$)",
      "end": "(?=>)|(?=[=\\^+/%~;])",
      "patterns": [
        {
          "include": "#generic-type"
        },
        {
          "match": "(?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*(?=\\s*[,>]|\\s*$)",
          "name": "entity.name.type.ts"
        },
        {
          "match": ",",
          "name": "punctuation.separator.comma.ts"
        },
        {
          "include": "#ident"
        }
      ]
    },
    "generic-type": {
      "name": "meta.type.generic.ts",
      "begin": "((?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*)(<)",
      "beginCaptures": {
        "1": {
          "name": "entity.name.type.ts"
        },
        "2": {
          "name": "punctuation.definition.typeparameters.begin.ts"
        }
      },
      "end": "(>)",
      "endCaptures": {
        "1": {
          "name": "punctuation.definition.typeparameters.end.ts"
        }
      },
      "patterns": [
        {
          "include": "#type"
        }
      ]
    },
    "simple-type": {
      "match": "(?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*",
      "name": "entity.name.type.ts"
    },
    "comparison": {
      "match": "[<>]",
      "name": "keyword.operator.relational.ts"
    },
    "regex-literal-prefix-ops": {
      "name": "string.regexp.ts",
      "begin": "(?:(?<=[=|\\^&<>+\\-*%~,\\[(?:{;.])|(?<=\\bkeyof)|(?<=\\btypeof)|(?<=\\breadonly)|(?<=\\bis)|(?<=\\bnew)|(?<=\\bextends)|(?<=\\bunique)|(?<=\\bin)|(?<=\\bas)|(?<=\\b@new)|(?<=\\binstanceof)|(?<=\\bclass)|(?<=\\basync)|(?<=\\byield)|(?<=\\bsatisfies)|(?<=\\bfunction)|(?<=\\bget)|(?<=\\bset)|(?<=\\bpublic)|(?<=\\bprivate)|(?<=\\bprotected)|(?<=\\bstatic)|(?<=\\babstract)|(?<=\\boverride)|(?<=\\baccessor)|(?<=\\bexport)|(?<=\\bdeclare)|(?<=\\bout)|(?<=\\belse)|(?<=\\bdo)|(?<=\\breturn)|(?<=\\bthrow)|(?<=\\btry)|(?<=\\bfinally)|(?<=\\bcatch)|(?<=\\bof)|(?<=\\bcase)|(?<=\\bdefault)|(?<=\\bimport)|(?<=\\btype)|(?<=\\bconstructor)|(?<=\\bvoid)|(?<=\\bdelete)|(?<=\\bawait)|(?<=^))\\s*([!](?:\\s*[!])*)\\s*(?:((?:/\\*\\*(?!/)[\\s\\S]*?\\*/|/\\*[\\s\\S]*?\\*/)\\s*))?(/)(?![*/])",
      "beginCaptures": {
        "1": {
          "name": "keyword.operator.logical.prefix.ts"
        },
        "2": {
          "name": "comment.block.ts"
        },
        "3": {
          "name": "punctuation.definition.string.begin.regexp.ts"
        }
      },
      "end": "(/)([a-z]*)",
      "endCaptures": {
        "1": {
          "name": "punctuation.definition.string.end.regexp.ts"
        },
        "2": {
          "name": "keyword.other.regexp.ts"
        }
      },
      "patterns": [
        {
          "include": "#regexp"
        }
      ]
    },
    "regexp": {
      "patterns": [
        {
          "name": "keyword.control.anchor.regexp",
          "match": "\\\\[bB]|\\^|\\$"
        },
        {
          "match": "\\\\[1-9]\\d*|\\\\k<([a-zA-Z_$][\\w$]*)>",
          "captures": {
            "0": {
              "name": "keyword.other.back-reference.regexp"
            },
            "1": {
              "name": "variable.other.regexp"
            }
          }
        },
        {
          "name": "keyword.operator.quantifier.regexp",
          "match": "[?+*]|\\{(\\d+,\\d+|\\d+,|,\\d+|\\d+)\\}\\??"
        },
        {
          "name": "keyword.operator.or.regexp",
          "match": "\\|"
        },
        {
          "name": "meta.group.assertion.regexp",
          "begin": "(\\()((\\?=)|(\\?!)|(\\?<=)|(\\?<!))",
          "beginCaptures": {
            "1": {
              "name": "punctuation.definition.group.regexp"
            },
            "2": {
              "name": "punctuation.definition.group.assertion.regexp"
            },
            "3": {
              "name": "meta.assertion.look-ahead.regexp"
            },
            "4": {
              "name": "meta.assertion.negative-look-ahead.regexp"
            },
            "5": {
              "name": "meta.assertion.look-behind.regexp"
            },
            "6": {
              "name": "meta.assertion.negative-look-behind.regexp"
            }
          },
          "end": "(\\))",
          "endCaptures": {
            "1": {
              "name": "punctuation.definition.group.regexp"
            }
          },
          "patterns": [
            {
              "include": "#regexp"
            }
          ]
        },
        {
          "name": "meta.group.regexp",
          "begin": "\\((?:(\\?:)|(?:\\?<([a-zA-Z_$][\\w$]*)>))?",
          "beginCaptures": {
            "0": {
              "name": "punctuation.definition.group.regexp"
            },
            "1": {
              "name": "punctuation.definition.group.no-capture.regexp"
            },
            "2": {
              "name": "variable.other.regexp"
            }
          },
          "end": "\\)",
          "endCaptures": {
            "0": {
              "name": "punctuation.definition.group.regexp"
            }
          },
          "patterns": [
            {
              "include": "#regexp"
            }
          ]
        },
        {
          "name": "constant.other.character-class.set.regexp",
          "begin": "(\\[)(\\^)?",
          "beginCaptures": {
            "1": {
              "name": "punctuation.definition.character-class.regexp"
            },
            "2": {
              "name": "keyword.operator.negation.regexp"
            }
          },
          "end": "(\\])",
          "endCaptures": {
            "1": {
              "name": "punctuation.definition.character-class.regexp"
            }
          },
          "patterns": [
            {
              "name": "constant.other.character-class.range.regexp",
              "match": "(?:.|(\\\\(?:[0-7]{3}|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}))|(\\\\c[A-Z])|(\\\\.))\\-(?:[^\\]\\\\]|(\\\\(?:[0-7]{3}|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}))|(\\\\c[A-Z])|(\\\\.))",
              "captures": {
                "1": {
                  "name": "constant.character.numeric.regexp"
                },
                "2": {
                  "name": "constant.character.control.regexp"
                },
                "3": {
                  "name": "constant.character.escape.backslash.regexp"
                },
                "4": {
                  "name": "constant.character.numeric.regexp"
                },
                "5": {
                  "name": "constant.character.control.regexp"
                },
                "6": {
                  "name": "constant.character.escape.backslash.regexp"
                }
              }
            },
            {
              "include": "#regex-character-class"
            }
          ]
        },
        {
          "include": "#regex-character-class"
        }
      ]
    },
    "regex-character-class": {
      "patterns": [
        {
          "name": "constant.other.character-class.regexp",
          "match": "\\\\[wWsSdDtrnvf]|\\."
        },
        {
          "name": "constant.character.numeric.regexp",
          "match": "\\\\([0-7]{3}|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4})"
        },
        {
          "name": "constant.character.control.regexp",
          "match": "\\\\c[A-Z]"
        },
        {
          "name": "constant.character.escape.backslash.regexp",
          "match": "\\\\."
        }
      ]
    },
    "shebang": {
      "name": "comment.line.shebang.ts",
      "match": "^#![^\\n]*"
    },
    "docblock": {
      "patterns": [
        {
          "match": "(?x)\n((@)(?:access|api))\n\\s+\n(private|protected|public)\n\\b",
          "captures": {
            "1": {
              "name": "storage.type.class.jsdoc"
            },
            "2": {
              "name": "punctuation.definition.block.tag.jsdoc"
            },
            "3": {
              "name": "constant.language.access-type.jsdoc"
            }
          }
        },
        {
          "match": "(?x)\n((@)author)\n\\s+\n(\n  [^@\\s<>*/]\n  (?:[^@<>*/]|\\*[^/])*\n)\n(?:\n  \\s*\n  (<)\n  ([^>\\s]+)\n  (>)\n)?",
          "captures": {
            "1": {
              "name": "storage.type.class.jsdoc"
            },
            "2": {
              "name": "punctuation.definition.block.tag.jsdoc"
            },
            "3": {
              "name": "entity.name.type.instance.jsdoc"
            },
            "4": {
              "name": "punctuation.definition.bracket.angle.begin.jsdoc"
            },
            "5": {
              "name": "constant.other.email.link.underline.jsdoc"
            },
            "6": {
              "name": "punctuation.definition.bracket.angle.end.jsdoc"
            }
          }
        },
        {
          "match": "(?x)\n((@)borrows) \\s+\n((?:[^@\\s*/]|\\*[^/])+)    # <that namepath>\n\\s+ (as) \\s+              # as\n((?:[^@\\s*/]|\\*[^/])+)    # <this namepath>",
          "captures": {
            "1": {
              "name": "storage.type.class.jsdoc"
            },
            "2": {
              "name": "punctuation.definition.block.tag.jsdoc"
            },
            "3": {
              "name": "entity.name.type.instance.jsdoc"
            },
            "4": {
              "name": "keyword.operator.control.jsdoc"
            },
            "5": {
              "name": "entity.name.type.instance.jsdoc"
            }
          }
        },
        {
          "name": "meta.example.jsdoc",
          "begin": "((@)example)\\s+",
          "end": "(?=@|\\*/)",
          "beginCaptures": {
            "1": {
              "name": "storage.type.class.jsdoc"
            },
            "2": {
              "name": "punctuation.definition.block.tag.jsdoc"
            }
          },
          "patterns": [
            {
              "match": "^\\s\\*\\s+"
            },
            {
              "contentName": "constant.other.description.jsdoc",
              "begin": "\\G(<)caption(>)",
              "beginCaptures": {
                "0": {
                  "name": "entity.name.tag.inline.jsdoc"
                },
                "1": {
                  "name": "punctuation.definition.bracket.angle.begin.jsdoc"
                },
                "2": {
                  "name": "punctuation.definition.bracket.angle.end.jsdoc"
                }
              },
              "end": "(</)caption(>)|(?=\\*/)",
              "endCaptures": {
                "0": {
                  "name": "entity.name.tag.inline.jsdoc"
                },
                "1": {
                  "name": "punctuation.definition.bracket.angle.begin.jsdoc"
                },
                "2": {
                  "name": "punctuation.definition.bracket.angle.end.jsdoc"
                }
              }
            },
            {
              "match": "[^\\s@*](?:[^*]|\\*[^/])*",
              "captures": {
                "0": {
                  "name": "source.embedded.ts"
                }
              }
            }
          ]
        },
        {
          "match": "(?x) ((@)kind) \\s+ (class|constant|event|external|file|function|member|mixin|module|namespace|typedef) \\b",
          "captures": {
            "1": {
              "name": "storage.type.class.jsdoc"
            },
            "2": {
              "name": "punctuation.definition.block.tag.jsdoc"
            },
            "3": {
              "name": "constant.language.symbol-type.jsdoc"
            }
          }
        },
        {
          "match": "(?x)\n((@)see)\n\\s+\n(?:\n  # URL\n  (\n    (?=https?://)\n    (?:[^\\s*]|\\*[^/])+\n  )\n  |\n  # JSDoc namepath\n  (\n    (?!\n      # Avoid matching bare URIs (also acceptable as links)\n      https?://\n      |\n      # Avoid matching {@inline tags}; we match those below\n      (?:\\[[^\\[\\]]*\\])? # Possible description [preceding]{@tag}\n      {@(?:link|linkcode|linkplain|tutorial)\\b\n    )\n    # Matched namepath\n    (?:[^@\\s*/]|\\*[^/])+\n  )\n)",
          "captures": {
            "1": {
              "name": "storage.type.class.jsdoc"
            },
            "2": {
              "name": "punctuation.definition.block.tag.jsdoc"
            },
            "3": {
              "name": "variable.other.link.underline.jsdoc"
            },
            "4": {
              "name": "entity.name.type.instance.jsdoc"
            }
          }
        },
        {
          "match": "(?x)\n((@)template)\n\\s+\n(\\[)\\s*\n(                                  # 4: the declared type-parameter name\n  [A-Za-z_$][\\w$]*\n)\n(?:\n  \\s* (=) \\s*                      # 5: the `=` of the default\n  (                                # 6: the default type expression\n    (?>\n      \"(?:\\*(?!/)|\\\\(?!\")|[^*\\\\])*?\" |\n      '(?:\\*(?!/)|\\\\(?!')|[^*\\\\])*?' |\n      \\[ (?:\\*(?!/)|[^*])*? \\] |\n      (?:\\*(?!/)|\\s(?!\\s*\\])|[^*\\s\\[\\]])\n    )*\n  )\n)?\n\\s* (\\])",
          "captures": {
            "1": {
              "name": "storage.type.class.jsdoc"
            },
            "2": {
              "name": "punctuation.definition.block.tag.jsdoc"
            },
            "3": {
              "name": "punctuation.definition.optional-value.begin.bracket.square.jsdoc"
            },
            "4": {
              "name": "entity.name.type.jsdoc"
            },
            "5": {
              "name": "keyword.operator.assignment.jsdoc"
            },
            "6": {
              "name": "entity.name.type.jsdoc"
            },
            "7": {
              "name": "punctuation.definition.optional-value.end.bracket.square.jsdoc"
            }
          }
        },
        {
          "match": "(?x)\n((@)template)\n\\s+\n# One or more valid identifiers\n(\n  [A-Za-z_$]         # First character: non-numeric word character\n  [\\w$.\\[\\]]*        # Rest of identifier\n  (?:                # Possible list of additional identifiers\n    \\s* , \\s*\n    [A-Za-z_$]\n    [\\w$.\\[\\]]*\n  )*\n)",
          "captures": {
            "1": {
              "name": "storage.type.class.jsdoc"
            },
            "2": {
              "name": "punctuation.definition.block.tag.jsdoc"
            },
            "3": {
              "name": "variable.other.jsdoc"
            }
          }
        },
        {
          "begin": "(?x)((@)template)\\s+(?={)",
          "beginCaptures": {
            "1": {
              "name": "storage.type.class.jsdoc"
            },
            "2": {
              "name": "punctuation.definition.block.tag.jsdoc"
            }
          },
          "end": "(?=\\s|\\*/|[^{}\\[\\]A-Za-z_$])",
          "patterns": [
            {
              "include": "#jsdoctype"
            },
            {
              "name": "variable.other.jsdoc",
              "match": "([A-Za-z_$][\\w$.\\[\\]]*)"
            }
          ]
        },
        {
          "match": "(?x)\n(\n  (@)\n  (?:arg|argument|const|constant|member|namespace|param|var)\n)\n\\s+\n(\n  [A-Za-z_$]\n  [\\w$.\\[\\]]*\n)",
          "captures": {
            "1": {
              "name": "storage.type.class.jsdoc"
            },
            "2": {
              "name": "punctuation.definition.block.tag.jsdoc"
            },
            "3": {
              "name": "variable.other.jsdoc"
            }
          }
        },
        {
          "begin": "((@)typedef)\\s+(?={)",
          "beginCaptures": {
            "1": {
              "name": "storage.type.class.jsdoc"
            },
            "2": {
              "name": "punctuation.definition.block.tag.jsdoc"
            }
          },
          "end": "(?=\\s|\\*/|[^{}\\[\\]A-Za-z_$])",
          "patterns": [
            {
              "include": "#jsdoctype"
            },
            {
              "name": "entity.name.type.instance.jsdoc",
              "match": "(?:[^@\\s*/]|\\*[^/])+"
            }
          ]
        },
        {
          "begin": "((@)(?:arg|argument|const|constant|member|namespace|param|prop|property|var))\\s+(?={)",
          "beginCaptures": {
            "1": {
              "name": "storage.type.class.jsdoc"
            },
            "2": {
              "name": "punctuation.definition.block.tag.jsdoc"
            }
          },
          "end": "(?=\\s|\\*/|[^{}\\[\\]A-Za-z_$])",
          "patterns": [
            {
              "include": "#jsdoctype"
            },
            {
              "name": "variable.other.jsdoc",
              "match": "([A-Za-z_$][\\w$.\\[\\]]*)"
            },
            {
              "name": "variable.other.jsdoc",
              "match": "(?x)\n(\\[)\\s*\n[\\w$]+\n(?:\n  (?:\\[\\])?                                        # Foo[ ].bar properties within an array\n  \\.                                                # Foo.Bar namespaced parameter\n  [\\w$]+\n)*\n(?:\n  \\s*\n  (=)                                                # [foo=bar] Default parameter value\n  \\s*\n  (\n    # The inner regexes are to stop the match early at */ and to not stop at escaped quotes\n    (?>\n      \"(?:(?:\\*(?!/))|(?:\\\\(?!\"))|[^*\\\\])*?\" |                      # [foo=\"bar\"] Double-quoted\n      '(?:(?:\\*(?!/))|(?:\\\\(?!'))|[^*\\\\])*?' |                      # [foo='bar'] Single-quoted\n      \\[ (?:(?:\\*(?!/))|[^*])*? \\] |                                # [foo=[1,2]] Array literal\n      (?:(?:\\*(?!/))|\\s(?!\\s*\\])|\\[.*?(?:\\]|(?=\\*/))|[^*\\s\\[\\]])*   # Everything else\n    )*\n  )\n)?\n\\s*(?:(\\])((?:[^*\\s]|\\*[^\\s/])+)?|(?=\\*/))",
              "captures": {
                "1": {
                  "name": "punctuation.definition.optional-value.begin.bracket.square.jsdoc"
                },
                "2": {
                  "name": "keyword.operator.assignment.jsdoc"
                },
                "3": {
                  "name": "source.embedded.ts"
                },
                "4": {
                  "name": "punctuation.definition.optional-value.end.bracket.square.jsdoc"
                },
                "5": {
                  "name": "invalid.illegal.syntax.jsdoc"
                }
              }
            }
          ]
        },
        {
          "begin": "(?x)\n(\n  (@)\n  (?:define|enum|exception|export|extends|lends|implements|modifies\n  |namespace|private|protected|returns?|satisfies|suppress|this|throws|type\n  |yields?)\n)\n\\s+(?={)",
          "beginCaptures": {
            "1": {
              "name": "storage.type.class.jsdoc"
            },
            "2": {
              "name": "punctuation.definition.block.tag.jsdoc"
            }
          },
          "end": "(?=\\s|\\*/|[^{}\\[\\]A-Za-z_$])",
          "patterns": [
            {
              "include": "#jsdoctype"
            }
          ]
        },
        {
          "match": "(?x)\n(\n  (@)\n  (?:alias|augments|callback|constructs|emits|event|fires|exports?\n  |extends|external|function|func|host|lends|listens|interface|memberof!?\n  |method|module|mixes|mixin|name|requires|see|this|typedef|uses)\n)\n\\s+\n(\n  (?:\n    [^{}@\\s*] | \\*[^/]\n  )+\n)",
          "captures": {
            "1": {
              "name": "storage.type.class.jsdoc"
            },
            "2": {
              "name": "punctuation.definition.block.tag.jsdoc"
            },
            "3": {
              "name": "entity.name.type.instance.jsdoc"
            }
          }
        },
        {
          "contentName": "variable.other.jsdoc",
          "begin": "((@)(?:default(?:value)?|license|version))\\s+(([''\"]))",
          "beginCaptures": {
            "1": {
              "name": "storage.type.class.jsdoc"
            },
            "2": {
              "name": "punctuation.definition.block.tag.jsdoc"
            },
            "3": {
              "name": "variable.other.jsdoc"
            },
            "4": {
              "name": "punctuation.definition.string.begin.jsdoc"
            }
          },
          "end": "(\\3)|(?=$|\\*/)",
          "endCaptures": {
            "0": {
              "name": "variable.other.jsdoc"
            },
            "1": {
              "name": "punctuation.definition.string.end.jsdoc"
            }
          }
        },
        {
          "match": "((@)(?:default(?:value)?|license|tutorial|variation|version))\\s+([^\\s*]+)",
          "captures": {
            "1": {
              "name": "storage.type.class.jsdoc"
            },
            "2": {
              "name": "punctuation.definition.block.tag.jsdoc"
            },
            "3": {
              "name": "variable.other.jsdoc"
            }
          }
        },
        {
          "name": "storage.type.class.jsdoc",
          "match": "(?x) (@) (?:abstract|access|alias|api|arg|argument|async|attribute|augments|author|beta|borrows|bubbles |callback|chainable|class|classdesc|code|config|const|constant|constructor|constructs|copyright |default|defaultvalue|define|deprecated|desc|description|dict|emits|enum|event|example|exception |exports?|extends|extension(?:_?for)?|external|externs|file|fileoverview|final|fires|for|func |function|generator|global|hideconstructor|host|ignore|implements|implicitCast|inherit[Dd]oc |inner|instance|interface|internal|kind|lends|license|listens|main|member|memberof!?|method |mixes|mixins?|modifies|module|name|namespace|noalias|nocollapse|nocompile|nosideeffects |override|overview|package|param|polymer(?:Behavior)?|preserve|private|prop|property|protected |public|read[Oo]nly|record|require[ds]|returns?|see|since|static|struct|submodule|summary |suppress|template|this|throws|todo|tutorial|type|typedef|unrestricted|uses|var|variation |version|virtual|writeOnce|yields?) \\b",
          "captures": {
            "1": {
              "name": "punctuation.definition.block.tag.jsdoc"
            }
          }
        },
        {
          "include": "#inline-tags"
        },
        {
          "match": "((@)(?:[_$[:alpha:]][_$[:alnum:]]*))(?=\\s+)",
          "captures": {
            "1": {
              "name": "storage.type.class.jsdoc"
            },
            "2": {
              "name": "punctuation.definition.block.tag.jsdoc"
            }
          }
        }
      ]
    },
    "jsdoctype": {
      "patterns": [
        {
          "contentName": "entity.name.type.instance.jsdoc",
          "begin": "\\G({)",
          "beginCaptures": {
            "0": {
              "name": "entity.name.type.instance.jsdoc"
            },
            "1": {
              "name": "punctuation.definition.bracket.curly.begin.jsdoc"
            }
          },
          "end": "((}))\\s*|(?=\\*/)",
          "endCaptures": {
            "1": {
              "name": "entity.name.type.instance.jsdoc"
            },
            "2": {
              "name": "punctuation.definition.bracket.curly.end.jsdoc"
            }
          },
          "patterns": [
            {
              "include": "#brackets"
            }
          ]
        }
      ]
    },
    "inline-tags": {
      "patterns": [
        {
          "name": "constant.other.description.jsdoc",
          "match": "(\\[)[^\\]]+(\\])(?={@(?:link|linkcode|linkplain|tutorial))",
          "captures": {
            "1": {
              "name": "punctuation.definition.bracket.square.begin.jsdoc"
            },
            "2": {
              "name": "punctuation.definition.bracket.square.end.jsdoc"
            }
          }
        },
        {
          "name": "entity.name.type.instance.jsdoc",
          "begin": "({)((@)(?:link(?:code|plain)?|tutorial))\\s*",
          "beginCaptures": {
            "1": {
              "name": "punctuation.definition.bracket.curly.begin.jsdoc"
            },
            "2": {
              "name": "storage.type.class.jsdoc"
            },
            "3": {
              "name": "punctuation.definition.inline.tag.jsdoc"
            }
          },
          "end": "}|(?=\\*/)",
          "endCaptures": {
            "0": {
              "name": "punctuation.definition.bracket.curly.end.jsdoc"
            }
          },
          "patterns": [
            {
              "match": "\\G((?=https?://)(?:[^|}\\s*]|\\*[/])+)(\\|)?",
              "captures": {
                "1": {
                  "name": "variable.other.link.underline.jsdoc"
                },
                "2": {
                  "name": "punctuation.separator.pipe.jsdoc"
                }
              }
            },
            {
              "match": "\\G((?:[^{}@\\s|*]|\\*[^/])+)(\\|)?",
              "captures": {
                "1": {
                  "name": "variable.other.description.jsdoc"
                },
                "2": {
                  "name": "punctuation.separator.pipe.jsdoc"
                }
              }
            }
          ]
        }
      ]
    },
    "brackets": {
      "patterns": [
        {
          "begin": "{",
          "beginCaptures": {
            "0": {
              "name": "punctuation.definition.bracket.curly.begin.jsdoc"
            }
          },
          "end": "}|(?=\\*/)",
          "endCaptures": {
            "0": {
              "name": "punctuation.definition.bracket.curly.end.jsdoc"
            }
          },
          "patterns": [
            {
              "include": "#brackets"
            }
          ]
        },
        {
          "begin": "\\[",
          "beginCaptures": {
            "0": {
              "name": "punctuation.definition.bracket.square.begin.jsdoc"
            }
          },
          "end": "\\]|(?=\\*/)",
          "endCaptures": {
            "0": {
              "name": "punctuation.definition.bracket.square.end.jsdoc"
            }
          },
          "patterns": [
            {
              "include": "#brackets"
            }
          ]
        }
      ]
    },
    "jsdoc": {
      "name": "comment.block.documentation.ts",
      "begin": "/\\*\\*(?!/)",
      "end": "\\*/",
      "contentName": "meta.embedded.block.jsdoc",
      "beginCaptures": {
        "0": {
          "name": "punctuation.definition.comment.ts"
        }
      },
      "endCaptures": {
        "0": {
          "name": "punctuation.definition.comment.ts"
        }
      },
      "patterns": [
        {
          "include": "#docblock"
        }
      ]
    },
    "linecomment": {
      "name": "comment.line.double-slash.ts",
      "match": "//[^\\n]*"
    },
    "blockcomment": {
      "name": "comment.block.ts",
      "begin": "/\\*",
      "end": "\\*/"
    },
    "ident": {
      "name": "variable.other.readwrite.ts",
      "match": "(?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*"
    },
    "hexnumber": {
      "name": "constant.numeric.hex.ts",
      "match": "0[xX][0-9A-Fa-f]+(?:_[0-9A-Fa-f]+)*n?(?![0-9A-Za-z_$\\\\])"
    },
    "octalnumber": {
      "name": "constant.numeric.octal.ts",
      "match": "0[oO][0-7]+(?:_[0-7]+)*n?(?![0-9A-Za-z_$\\\\])"
    },
    "binarynumber": {
      "name": "constant.numeric.binary.ts",
      "match": "0[bB][01]+(?:_[01]+)*n?(?![0-9A-Za-z_$\\\\])"
    },
    "bigint": {
      "name": "constant.numeric.bigint.ts",
      "match": "[0-9]+(?:_[0-9]+)*n(?![0-9A-Za-z_$\\\\])"
    },
    "number": {
      "name": "constant.numeric.decimal.ts",
      "match": "(?:(?:0|[1-9][0-9]*(?:_[0-9]+)*)(?:\\.[0-9]*(?:_[0-9]+)*)?|\\.[0-9]+(?:_[0-9]+)*)(?:[eE][+\\-]?[0-9]+(?:_[0-9]+)*)?(?![0-9A-Za-z_$\\\\])"
    },
    "template": {
      "name": "string.quoted.other.template.ts",
      "begin": "`",
      "beginCaptures": {
        "0": {
          "name": "punctuation.definition.string.template.begin.ts"
        }
      },
      "end": "`",
      "endCaptures": {
        "0": {
          "name": "punctuation.definition.string.template.end.ts"
        }
      },
      "patterns": [
        {
          "match": "\\\\(?:[nrtbfv0'\"\\\\`$]|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}|u\\{[0-9A-Fa-f]+\\})",
          "name": "constant.character.escape.ts"
        },
        {
          "begin": "\\$\\{",
          "beginCaptures": {
            "0": {
              "name": "punctuation.definition.template-expression.begin.ts"
            }
          },
          "end": "\\}",
          "endCaptures": {
            "0": {
              "name": "punctuation.definition.template-expression.end.ts"
            }
          },
          "name": "meta.embedded.expression.ts",
          "patterns": [
            {
              "include": "$self"
            }
          ]
        }
      ]
    },
    "decorator": {
      "name": "entity.name.function.decorator.ts",
      "match": "@(?:(?:[a-zA-Z_$]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\}|\\.)*)?"
    },
    "privatefield": {
      "name": "variable.other.property.ts",
      "match": "#(?:[a-zA-Z_$]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*"
    },
    "type-paren": {
      "begin": "\\(",
      "end": "\\)",
      "patterns": [
        {
          "include": "#parameter-type-annotation"
        },
        {
          "include": "#param-bind-type-annotation"
        },
        {
          "include": "#type"
        }
      ]
    },
    "type-bracket": {
      "begin": "\\[",
      "beginCaptures": {
        "0": {
          "name": "punctuation.definition.block.ts"
        }
      },
      "end": "\\]",
      "endCaptures": {
        "0": {
          "name": "punctuation.definition.block.ts"
        }
      },
      "patterns": [
        {
          "match": "(?<=\\[)\\s*((?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*)\\s+(in)\\b",
          "captures": {
            "1": {
              "name": "entity.name.type.ts"
            },
            "2": {
              "name": "keyword.control.loop.ts"
            }
          }
        },
        {
          "match": "(?<=\\[)\\s*((?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*)(\\s*:)",
          "captures": {
            "1": {
              "name": "variable.parameter.ts"
            },
            "2": {
              "name": "keyword.operator.type.annotation.ts"
            }
          }
        },
        {
          "include": "#type"
        }
      ]
    },
    "type-object-member": {
      "name": "meta.type.annotation.member.ts",
      "begin": "(#?(?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*)(\\??)(\\s*:)",
      "beginCaptures": {
        "1": {
          "name": "variable.object.property.ts"
        },
        "2": {
          "name": "keyword.operator.optional.ts"
        },
        "3": {
          "name": "keyword.operator.type.annotation.ts"
        }
      },
      "end": "(?=[;},])",
      "patterns": [
        {
          "include": "#type"
        }
      ]
    },
    "type-conditional": {
      "begin": "(?<![_$[:alnum:]])(?:(?<=\\.\\.\\.)|(?<!\\.))(extends)\\s+",
      "beginCaptures": {
        "1": {
          "name": "keyword.other.extends.ts"
        }
      },
      "end": "(?<=:)|(?=[;>])",
      "patterns": [
        {
          "begin": "\\?",
          "beginCaptures": {
            "0": {
              "name": "keyword.operator.ternary.ts"
            }
          },
          "end": ":",
          "endCaptures": {
            "0": {
              "name": "keyword.operator.ternary.ts"
            }
          },
          "patterns": [
            {
              "include": "#type"
            }
          ]
        },
        {
          "include": "#type"
        }
      ]
    },
    "code-block": {
      "begin": "\\{",
      "beginCaptures": {
        "0": {
          "name": "punctuation.definition.block.ts"
        }
      },
      "end": "\\}",
      "endCaptures": {
        "0": {
          "name": "punctuation.definition.block.ts"
        }
      },
      "patterns": [
        {
          "include": "#code-block"
        },
        {
          "include": "$self"
        }
      ]
    },
    "declaration-body": {
      "begin": "\\{",
      "beginCaptures": {
        "0": {
          "name": "punctuation.definition.block.ts"
        }
      },
      "end": "\\}",
      "endCaptures": {
        "0": {
          "name": "punctuation.definition.block.ts"
        }
      },
      "patterns": [
        {
          "include": "#member-initializer-object"
        },
        {
          "include": "#declaration-body"
        },
        {
          "include": "#constructor-declaration"
        },
        {
          "include": "#method-signature"
        },
        {
          "include": "#member-type-annotation"
        },
        {
          "include": "#member-bind-type-annotation"
        },
        {
          "include": "$self"
        }
      ]
    },
    "nested-parens": {
      "begin": "\\(",
      "end": "\\)",
      "patterns": [
        {
          "include": "#nested-parens"
        },
        {
          "include": "$self"
        }
      ]
    },
    "param-bind-type-annotation": {
      "name": "meta.type.annotation.parameter.ts",
      "begin": "(?<=[}\\]])\\s*(\\??)\\s*(:)",
      "beginCaptures": {
        "1": {
          "name": "keyword.operator.optional.ts"
        },
        "2": {
          "name": "keyword.operator.type.annotation.ts"
        }
      },
      "end": "(?=[,)]|=(?!>))",
      "patterns": [
        {
          "include": "#type"
        }
      ]
    },
    "decl-return-type": {
      "name": "meta.type.annotation.return.ts",
      "begin": "(:)",
      "beginCaptures": {
        "1": {
          "name": "keyword.operator.type.annotation.ts"
        }
      },
      "end": "(?=[{;]|=>)",
      "patterns": [
        {
          "include": "#type"
        }
      ]
    },
    "declaration-params": {
      "name": "meta.parameters.ts",
      "begin": "\\(",
      "end": "\\)",
      "beginCaptures": {
        "0": {
          "name": "punctuation.definition.parameters.begin.ts"
        }
      },
      "endCaptures": {
        "0": {
          "name": "punctuation.definition.parameters.end.ts"
        }
      },
      "patterns": [
        {
          "include": "#parameter-type-annotation"
        },
        {
          "include": "#param-bind-type-annotation"
        },
        {
          "include": "#parameter-name"
        },
        {
          "include": "#nested-parens"
        },
        {
          "include": "$self"
        }
      ]
    },
    "arrow-type-parameters": {
      "name": "meta.type.parameters.ts",
      "begin": "(?:(?<=\\basync\\s)|(?<![\\w$)\\]}])(?<![\\w$)\\]}]\\s)(?<![\\w$)\\]}]\\s\\s)(?<![\\w$)\\]}]\\s\\s\\s)(?<![\\w$)\\]}]\\s\\s\\s\\s)(?<![\\w$)\\]}]\\s\\s\\s\\s\\s)(?<![\\w$)\\]}]\\s\\s\\s\\s\\s\\s)(?<![\\w$)\\]}]\\s\\s\\s\\s\\s\\s\\s)(?<![\\w$)\\]}]\\s\\s\\s\\s\\s\\s\\s\\s)(?<![\\w$)\\]}]\\s\\s\\s\\s\\s\\s\\s\\s\\s)(?<![\\w$)\\]}]\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s)(?<![\\w$)\\]}]\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s)(?<![\\w$)\\]}]\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s)(?<![\\w$)\\]}]\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s)(?<![\\w$)\\]}]\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s)(?<![\\w$)\\]}]\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s)(?<![\\w$)\\]}]\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s))(<)(?=[^>]*(?:>[^>]*)*?>\\s*\\(\\s*(?:\\)|\\.\\.\\.|(?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*\\s*[:,?)]|[{\\[]|$))",
      "beginCaptures": {
        "1": {
          "name": "punctuation.definition.typeparameters.begin.ts"
        }
      },
      "end": "(>)",
      "endCaptures": {
        "1": {
          "name": "punctuation.definition.typeparameters.end.ts"
        }
      },
      "patterns": [
        {
          "include": "#type-parameters"
        },
        {
          "match": "\\bconst\\b",
          "name": "storage.type.ts"
        },
        {
          "match": "\\bin\\b",
          "name": "keyword.control.loop.ts"
        },
        {
          "match": "\\bpublic\\b",
          "name": "storage.modifier.ts"
        },
        {
          "match": "\\bprivate\\b",
          "name": "storage.modifier.ts"
        },
        {
          "match": "\\bprotected\\b",
          "name": "storage.modifier.ts"
        },
        {
          "match": "\\breadonly\\b",
          "name": "storage.modifier.ts"
        },
        {
          "match": "\\bextends\\b",
          "name": "keyword.other.extends.ts"
        },
        {
          "include": "#type"
        },
        {
          "match": "=",
          "name": "keyword.operator.assignment.ts"
        },
        {
          "match": ",",
          "name": "punctuation.separator.comma.ts"
        }
      ]
    },
    "generic-arrow-function": {
      "begin": "(?:(?<=\\basync\\s)|(?<![\\w$)\\]}])(?<![\\w$)\\]}]\\s)(?<![\\w$)\\]}]\\s\\s)(?<![\\w$)\\]}]\\s\\s\\s)(?<![\\w$)\\]}]\\s\\s\\s\\s)(?<![\\w$)\\]}]\\s\\s\\s\\s\\s)(?<![\\w$)\\]}]\\s\\s\\s\\s\\s\\s)(?<![\\w$)\\]}]\\s\\s\\s\\s\\s\\s\\s)(?<![\\w$)\\]}]\\s\\s\\s\\s\\s\\s\\s\\s)(?<![\\w$)\\]}]\\s\\s\\s\\s\\s\\s\\s\\s\\s)(?<![\\w$)\\]}]\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s)(?<![\\w$)\\]}]\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s)(?<![\\w$)\\]}]\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s)(?<![\\w$)\\]}]\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s)(?<![\\w$)\\]}]\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s)(?<![\\w$)\\]}]\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s)(?<![\\w$)\\]}]\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s))(?=<[^>]*(?:>[^>]*)*?>\\s*\\(\\s*(?:\\)|\\.\\.\\.|(?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*\\s*[:,?)]|[{\\[]|$))",
      "end": "(?<=\\))",
      "patterns": [
        {
          "include": "#arrow-type-parameters"
        },
        {
          "include": "#arrow-function-params-generic"
        }
      ]
    },
    "function-declaration": {
      "name": "meta.function.ts",
      "begin": "\\b(function)\\s*(\\*)?\\s*((?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*)",
      "beginCaptures": {
        "1": {
          "name": "storage.type.function.ts"
        },
        "2": {
          "name": "keyword.operator.arithmetic.ts"
        },
        "3": {
          "name": "entity.name.function.ts"
        }
      },
      "patterns": [
        {
          "include": "#type-parameters"
        },
        {
          "include": "#declaration-params"
        },
        {
          "include": "#decl-return-type"
        },
        {
          "include": "#code-block"
        },
        {
          "include": "$self"
        }
      ],
      "end": "(?<=\\})|(?=;)"
    },
    "function-anon-declaration": {
      "name": "meta.function.ts",
      "begin": "\\b(function)\\s*(\\*)?\\s*(?=\\()",
      "beginCaptures": {
        "1": {
          "name": "storage.type.function.ts"
        },
        "2": {
          "name": "keyword.operator.arithmetic.ts"
        }
      },
      "end": "(?<=\\})",
      "patterns": [
        {
          "include": "#type-parameters"
        },
        {
          "include": "#declaration-params"
        },
        {
          "include": "#decl-return-type"
        },
        {
          "include": "#code-block"
        },
        {
          "include": "$self"
        }
      ]
    },
    "class-declaration": {
      "name": "meta.class.ts",
      "begin": "\\b(class)\\s+((?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*)",
      "beginCaptures": {
        "1": {
          "name": "storage.type.class.ts"
        },
        "2": {
          "name": "entity.name.type.class.ts"
        }
      },
      "patterns": [
        {
          "include": "#type-parameters"
        },
        {
          "include": "#declaration-body"
        },
        {
          "include": "$self"
        }
      ],
      "end": "(?<=\\})"
    },
    "interface-declaration": {
      "name": "meta.interface.ts",
      "begin": "\\b(interface)\\s+((?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*)",
      "beginCaptures": {
        "1": {
          "name": "storage.type.interface.ts"
        },
        "2": {
          "name": "entity.name.type.interface.ts"
        }
      },
      "patterns": [
        {
          "include": "#type-parameters"
        },
        {
          "include": "#declaration-body"
        },
        {
          "include": "$self"
        }
      ],
      "end": "(?<=\\})"
    },
    "type-body": {
      "name": "meta.type.body.ts",
      "begin": "(=)",
      "beginCaptures": {
        "1": {
          "name": "keyword.operator.assignment.ts"
        }
      },
      "end": "(?=[;])",
      "patterns": [
        {
          "include": "#type"
        }
      ]
    },
    "enum-member": {
      "match": "(?<=[{,])\\s*((?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*)(?=\\s*[=,}])",
      "captures": {
        "1": {
          "name": "variable.other.enummember.ts"
        }
      }
    },
    "enum-body": {
      "begin": "\\{",
      "beginCaptures": {
        "0": {
          "name": "punctuation.definition.block.ts"
        }
      },
      "end": "\\}",
      "endCaptures": {
        "0": {
          "name": "punctuation.definition.block.ts"
        }
      },
      "patterns": [
        {
          "include": "#code-block"
        },
        {
          "include": "#enum-member"
        },
        {
          "include": "$self"
        }
      ]
    },
    "enum-declaration": {
      "name": "meta.enum.ts",
      "begin": "\\b(enum)\\s+((?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*)",
      "beginCaptures": {
        "1": {
          "name": "storage.type.enum.ts"
        },
        "2": {
          "name": "entity.name.type.enum.ts"
        }
      },
      "patterns": [
        {
          "include": "#enum-body"
        },
        {
          "include": "$self"
        }
      ],
      "end": "(?<=\\})"
    },
    "namespace-declaration": {
      "name": "meta.namespace.ts",
      "begin": "\\b(namespace)\\s+((?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*)((?:\\s*\\.\\s*(?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*)*)",
      "beginCaptures": {
        "1": {
          "name": "storage.type.namespace.ts"
        },
        "2": {
          "name": "entity.name.type.module.ts"
        },
        "3": {
          "name": "entity.name.type.module.ts"
        }
      },
      "patterns": [
        {
          "include": "#declaration-body"
        },
        {
          "include": "$self"
        }
      ],
      "end": "(?<=\\})"
    },
    "module-declaration": {
      "name": "meta.module.ts",
      "begin": "\\b(module)\\s+((?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*)((?:\\s*\\.\\s*(?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*)*)",
      "beginCaptures": {
        "1": {
          "name": "storage.type.namespace.ts"
        },
        "2": {
          "name": "entity.name.type.module.ts"
        },
        "3": {
          "name": "entity.name.type.module.ts"
        }
      },
      "patterns": [
        {
          "include": "#declaration-body"
        },
        {
          "include": "$self"
        }
      ],
      "end": "(?<=\\})"
    },
    "constructor-declaration": {
      "name": "meta.constructor.ts",
      "begin": "\\b(constructor)",
      "beginCaptures": {
        "1": {
          "name": "storage.type.function.ts"
        }
      },
      "end": "(?<=\\})|(?=[;}])",
      "patterns": [
        {
          "include": "#declaration-params"
        },
        {
          "include": "#decl-return-type"
        },
        {
          "include": "#code-block"
        },
        {
          "include": "$self"
        }
      ]
    },
    "method-signature": {
      "name": "meta.method.ts",
      "begin": "\\b((?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*)(\\?)?\\s*(?=[<(])",
      "beginCaptures": {
        "1": {
          "name": "entity.name.function.ts"
        },
        "2": {
          "name": "keyword.operator.optional.ts"
        }
      },
      "end": "(?<=\\})|(?=[;\\}])",
      "patterns": [
        {
          "include": "#type-parameters"
        },
        {
          "include": "#declaration-params"
        },
        {
          "include": "#decl-return-type"
        },
        {
          "include": "#code-block"
        },
        {
          "include": "$self"
        }
      ]
    },
    "member-type-annotation": {
      "name": "meta.type.annotation.member.ts",
      "begin": "(#?(?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*)(\\??)(\\s*:)",
      "beginCaptures": {
        "1": {
          "name": "variable.object.property.ts"
        },
        "2": {
          "name": "keyword.operator.optional.ts"
        },
        "3": {
          "name": "keyword.operator.type.annotation.ts"
        }
      },
      "end": "(?=[;},)]|=(?!>))",
      "patterns": [
        {
          "include": "#type"
        }
      ]
    },
    "member-bind-type-annotation": {
      "name": "meta.type.annotation.member.ts",
      "begin": "(?<=[\\]])\\s*(\\??)\\s*(:)",
      "beginCaptures": {
        "1": {
          "name": "keyword.operator.optional.ts"
        },
        "2": {
          "name": "keyword.operator.type.annotation.ts"
        }
      },
      "end": "(?=[;},)]|=(?!>))",
      "patterns": [
        {
          "include": "#type"
        }
      ]
    },
    "member-initializer-object": {
      "begin": "(?<![=!<>+\\-*/%&|^~])(=)(?![=>])(?=\\s*\\{)",
      "beginCaptures": {
        "1": {
          "name": "keyword.operator.assignment.ts"
        }
      },
      "end": "(?<=\\})",
      "patterns": [
        {
          "include": "#code-block"
        }
      ]
    },
    "extends-definition": {
      "match": "\\b(extends)\\s+((?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*)",
      "captures": {
        "1": {
          "name": "keyword.other.extends.ts"
        },
        "2": {
          "name": "entity.other.inherited-class.ts"
        }
      }
    },
    "bind-default": {
      "begin": "(=)",
      "beginCaptures": {
        "1": {
          "name": "keyword.operator.assignment.ts"
        }
      },
      "end": "(?=[,}\\])])",
      "patterns": [
        {
          "include": "$self"
        }
      ]
    },
    "const-bind-prop": {
      "patterns": [
        {
          "match": "(\\.\\.\\.)",
          "name": "keyword.operator.rest.ts"
        },
        {
          "match": "((?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*)(\\s*)(:)",
          "captures": {
            "1": {
              "name": "variable.object.property.ts"
            },
            "3": {
              "name": "punctuation.destructuring.ts"
            }
          }
        },
        {
          "include": "#bind-default"
        },
        {
          "include": "#const-bind-object"
        },
        {
          "include": "#const-bind-array"
        },
        {
          "match": "((?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*)",
          "name": "variable.other.constant.ts"
        },
        {
          "match": ",",
          "name": "punctuation.separator.comma.ts"
        }
      ]
    },
    "const-bind-elem": {
      "patterns": [
        {
          "match": "(\\.\\.\\.)",
          "name": "keyword.operator.rest.ts"
        },
        {
          "include": "#bind-default"
        },
        {
          "include": "#const-bind-object"
        },
        {
          "include": "#const-bind-array"
        },
        {
          "match": "((?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*)",
          "name": "variable.other.constant.ts"
        },
        {
          "match": ",",
          "name": "punctuation.separator.comma.ts"
        }
      ]
    },
    "const-bind-object": {
      "begin": "\\{",
      "beginCaptures": {
        "0": {
          "name": "punctuation.definition.binding-pattern.object.ts"
        }
      },
      "end": "\\}",
      "endCaptures": {
        "0": {
          "name": "punctuation.definition.binding-pattern.object.ts"
        }
      },
      "patterns": [
        {
          "include": "#const-bind-prop"
        }
      ]
    },
    "const-bind-array": {
      "begin": "\\[",
      "beginCaptures": {
        "0": {
          "name": "punctuation.definition.binding-pattern.array.ts"
        }
      },
      "end": "\\]",
      "endCaptures": {
        "0": {
          "name": "punctuation.definition.binding-pattern.array.ts"
        }
      },
      "patterns": [
        {
          "include": "#const-bind-elem"
        }
      ]
    },
    "mut-bind-prop": {
      "patterns": [
        {
          "match": "(\\.\\.\\.)",
          "name": "keyword.operator.rest.ts"
        },
        {
          "match": "((?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*)(\\s*)(:)",
          "captures": {
            "1": {
              "name": "variable.object.property.ts"
            },
            "3": {
              "name": "punctuation.destructuring.ts"
            }
          }
        },
        {
          "include": "#bind-default"
        },
        {
          "include": "#mut-bind-object"
        },
        {
          "include": "#mut-bind-array"
        },
        {
          "match": "((?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*)",
          "name": "variable.other.readwrite.ts"
        },
        {
          "match": ",",
          "name": "punctuation.separator.comma.ts"
        }
      ]
    },
    "mut-bind-elem": {
      "patterns": [
        {
          "match": "(\\.\\.\\.)",
          "name": "keyword.operator.rest.ts"
        },
        {
          "include": "#bind-default"
        },
        {
          "include": "#mut-bind-object"
        },
        {
          "include": "#mut-bind-array"
        },
        {
          "match": "((?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*)",
          "name": "variable.other.readwrite.ts"
        },
        {
          "match": ",",
          "name": "punctuation.separator.comma.ts"
        }
      ]
    },
    "mut-bind-object": {
      "begin": "\\{",
      "beginCaptures": {
        "0": {
          "name": "punctuation.definition.binding-pattern.object.ts"
        }
      },
      "end": "\\}",
      "endCaptures": {
        "0": {
          "name": "punctuation.definition.binding-pattern.object.ts"
        }
      },
      "patterns": [
        {
          "include": "#mut-bind-prop"
        }
      ]
    },
    "mut-bind-array": {
      "begin": "\\[",
      "beginCaptures": {
        "0": {
          "name": "punctuation.definition.binding-pattern.array.ts"
        }
      },
      "end": "\\]",
      "endCaptures": {
        "0": {
          "name": "punctuation.definition.binding-pattern.array.ts"
        }
      },
      "patterns": [
        {
          "include": "#mut-bind-elem"
        }
      ]
    },
    "let-destructure": {
      "begin": "\\b(let)\\s+(?=[{\\[])",
      "beginCaptures": {
        "1": {
          "name": "storage.type.ts"
        }
      },
      "end": "(?<=[}\\]])",
      "patterns": [
        {
          "include": "#mut-bind-object"
        },
        {
          "include": "#mut-bind-array"
        }
      ]
    },
    "const-binding": {
      "match": "\\b(const)\\s+((?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*)(?=\\s*[=:;,]|\\s*$)",
      "captures": {
        "1": {
          "name": "storage.type.ts"
        },
        "2": {
          "name": "variable.other.constant.ts"
        }
      }
    },
    "const-destructure": {
      "begin": "\\b(const)\\s+(?=[{\\[])",
      "beginCaptures": {
        "1": {
          "name": "storage.type.ts"
        }
      },
      "end": "(?<=[}\\]])",
      "patterns": [
        {
          "include": "#const-bind-object"
        },
        {
          "include": "#const-bind-array"
        }
      ]
    },
    "var-destructure": {
      "begin": "\\b(var)\\s+(?=[{\\[])",
      "beginCaptures": {
        "1": {
          "name": "storage.type.ts"
        }
      },
      "end": "(?<=[}\\]])",
      "patterns": [
        {
          "include": "#mut-bind-object"
        },
        {
          "include": "#mut-bind-array"
        }
      ]
    },
    "using-destructure": {
      "begin": "\\b(using)\\s+(?=[{\\[])",
      "beginCaptures": {
        "1": {
          "name": "storage.type.ts"
        }
      },
      "end": "(?<=[}\\]])",
      "patterns": [
        {
          "include": "#mut-bind-object"
        },
        {
          "include": "#mut-bind-array"
        }
      ]
    },
    "import-export-all": {
      "match": "\\b(?:(import)\\s+(?:(defer)\\s+)?(\\*))",
      "captures": {
        "1": {
          "name": "keyword.control.import.ts"
        },
        "2": {
          "name": "keyword.control.import.phase.ts"
        },
        "3": {
          "name": "constant.language.import-export-all.ts"
        }
      }
    },
    "import-default-binding": {
      "match": "\\b(import)\\s+((?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*)(?=\\s*(?:(?:from)\\b|,))",
      "captures": {
        "1": {
          "name": "keyword.control.import.ts"
        },
        "2": {
          "name": "variable.other.readwrite.ts"
        }
      }
    },
    "function-call": {
      "match": "((?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*)(?=\\s*\\()",
      "captures": {
        "1": {
          "name": "entity.name.function.ts"
        }
      }
    },
    "object-method-key": {
      "match": "((?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*)(?=\\s*:\\s*(?:\\w+\\s+)?[\\(])",
      "captures": {
        "1": {
          "name": "entity.name.function.ts"
        }
      }
    },
    "method-call": {
      "match": "(?<=[\\w$\\]\\)])(\\.)\\s*((?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*)(?=\\s*\\()",
      "captures": {
        "1": {
          "name": "punctuation.accessor.ts"
        },
        "2": {
          "name": "entity.name.function.ts"
        }
      }
    },
    "known-property-access": {
      "match": "(?<=[\\w$\\]\\)])(\\.)\\s*(length|prototype|constructor)\\b",
      "captures": {
        "1": {
          "name": "punctuation.accessor.ts"
        },
        "2": {
          "name": "support.variable.property.ts"
        }
      }
    },
    "property-access": {
      "match": "(?<=[\\w$\\]\\)])(\\.)\\s*((?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*)",
      "captures": {
        "1": {
          "name": "punctuation.accessor.ts"
        },
        "2": {
          "name": "entity.other.property.ts"
        }
      }
    },
    "arrow-parameter": {
      "match": "\\b((?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*)\\s*(?==>)",
      "captures": {
        "1": {
          "name": "variable.parameter.ts"
        }
      }
    },
    "arrow-function-params": {
      "name": "meta.parameters.arrow.ts",
      "begin": "(\\()(?=[^()]*\\)\\s*(?::\\s*[^=>{]*)?\\s*=>)",
      "beginCaptures": {
        "1": {
          "name": "punctuation.definition.parameters.begin.ts"
        }
      },
      "end": "(\\))",
      "endCaptures": {
        "1": {
          "name": "punctuation.definition.parameters.end.ts"
        }
      },
      "patterns": [
        {
          "include": "#parameter-type-annotation"
        },
        {
          "include": "#param-bind-type-annotation"
        },
        {
          "match": "(?<=[,(])\\s*(\\.\\.\\.)?\\s*((?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*)(?=\\s*[,:)?=])",
          "captures": {
            "1": {
              "name": "keyword.operator.spread.ts"
            },
            "2": {
              "name": "variable.parameter.ts"
            }
          }
        },
        {
          "include": "#nested-parens"
        },
        {
          "include": "$self"
        }
      ]
    },
    "arrow-function-params-generic": {
      "name": "meta.parameters.arrow.ts",
      "begin": "(\\()",
      "beginCaptures": {
        "1": {
          "name": "punctuation.definition.parameters.begin.ts"
        }
      },
      "end": "(\\))",
      "endCaptures": {
        "1": {
          "name": "punctuation.definition.parameters.end.ts"
        }
      },
      "patterns": [
        {
          "include": "#parameter-type-annotation"
        },
        {
          "include": "#param-bind-type-annotation"
        },
        {
          "match": "(?<=[,(])\\s*(\\.\\.\\.)?\\s*((?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*)(?=\\s*[,:)?=])",
          "captures": {
            "1": {
              "name": "keyword.operator.spread.ts"
            },
            "2": {
              "name": "variable.parameter.ts"
            }
          }
        },
        {
          "include": "#nested-parens"
        },
        {
          "include": "$self"
        }
      ]
    },
    "ternary-expression": {
      "name": "meta.ternary-expression.ts",
      "begin": "(\\?)(?![:.?])",
      "beginCaptures": {
        "1": {
          "name": "keyword.operator.ternary.ts"
        }
      },
      "end": "(:)",
      "endCaptures": {
        "1": {
          "name": "keyword.operator.ternary.ts"
        }
      },
      "patterns": [
        {
          "include": "#ternary-expression"
        },
        {
          "include": "$self"
        }
      ]
    },
    "keyof-typekw": {
      "name": "meta.type.keyof.ts",
      "begin": "\\b(keyof)\\b(?=\\s+[[:alpha:][:digit:]_$\"`({\\[\\-]|\\s*$)",
      "beginCaptures": {
        "1": {
          "name": "keyword.operator.expression.keyof.ts"
        }
      },
      "end": "(?=[)}{\\],;=>]|\\b(?:keyof|is|extends|unique|as|implements|satisfies|if|else|switch|case|default|for|while|do|in|of|break|continue|return|await|yield|try|catch|finally|throw|debugger|with|import|defer|export|from|typeof|instanceof|new|delete|void|asserts|infer)\\b)",
      "patterns": [
        {
          "include": "#type"
        }
      ]
    },
    "extends-typekw": {
      "name": "meta.type.extends.ts",
      "begin": "\\b(extends)\\b",
      "beginCaptures": {
        "1": {
          "name": "keyword.other.extends.extends.ts"
        }
      },
      "end": "(?=[)}{\\],;=>]|\\b(?:keyof|is|extends|unique|as|implements|satisfies|if|else|switch|case|default|for|while|do|in|of|break|continue|return|await|yield|try|catch|finally|throw|debugger|with|import|defer|export|from|typeof|instanceof|new|delete|void|asserts|infer)\\b)",
      "patterns": [
        {
          "include": "#type"
        }
      ]
    },
    "unique-typekw": {
      "name": "meta.type.unique.ts",
      "begin": "\\b(unique)\\b",
      "beginCaptures": {
        "1": {
          "name": "keyword.other.unique.ts"
        }
      },
      "end": "(?=[)}{\\],;=>]|\\b(?:keyof|is|extends|unique|as|implements|satisfies|if|else|switch|case|default|for|while|do|in|of|break|continue|return|await|yield|try|catch|finally|throw|debugger|with|import|defer|export|from|typeof|instanceof|new|delete|void|asserts|infer)\\b)",
      "patterns": [
        {
          "include": "#type"
        }
      ]
    },
    "as-typekw": {
      "name": "meta.type.as.ts",
      "begin": "\\b(as)\\b",
      "beginCaptures": {
        "1": {
          "name": "keyword.operator.expression.as.ts"
        }
      },
      "end": "(?=[)}{\\],;=>]|\\b(?:keyof|is|extends|unique|as|implements|satisfies|if|else|switch|case|default|for|while|do|in|of|break|continue|return|await|yield|try|catch|finally|throw|debugger|with|import|defer|export|from|typeof|instanceof|new|delete|void|asserts|infer)\\b)",
      "patterns": [
        {
          "include": "#type"
        }
      ]
    },
    "implements-typekw": {
      "name": "meta.type.implements.ts",
      "begin": "\\b(implements)\\b",
      "beginCaptures": {
        "1": {
          "name": "keyword.other.extends.implements.ts"
        }
      },
      "end": "(?=[)}{\\],;=>]|\\b(?:keyof|is|extends|unique|as|implements|satisfies|if|else|switch|case|default|for|while|do|in|of|break|continue|return|await|yield|try|catch|finally|throw|debugger|with|import|defer|export|from|typeof|instanceof|new|delete|void|asserts|infer)\\b)",
      "patterns": [
        {
          "include": "#type"
        }
      ]
    },
    "satisfies-typekw": {
      "name": "meta.type.satisfies.ts",
      "begin": "\\b(satisfies)\\b(?=\\s+[[:alpha:][:digit:]_$\"`({\\[\\-]|\\s*$)",
      "beginCaptures": {
        "1": {
          "name": "keyword.operator.expression.satisfies.ts"
        }
      },
      "end": "(?=[)}{\\],;=>]|\\b(?:keyof|is|extends|unique|as|implements|satisfies|if|else|switch|case|default|for|while|do|in|of|break|continue|return|await|yield|try|catch|finally|throw|debugger|with|import|defer|export|from|typeof|instanceof|new|delete|void|asserts|infer)\\b)",
      "patterns": [
        {
          "include": "#type"
        }
      ]
    },
    "type-annotation-var": {
      "name": "meta.type.annotation.ts",
      "begin": "\\b(let|const|var|using)\\s+((?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*)(\\s*:)",
      "beginCaptures": {
        "1": {
          "name": "storage.type.ts"
        },
        "2": {
          "name": "variable.other.ts"
        },
        "3": {
          "name": "keyword.operator.type.annotation.ts"
        }
      },
      "end": "(?=[;,]|=(?!>))|^\\s*(?=(?:if|else|switch|case|default|for|while|do|in|of|break|continue|return|await|yield|try|catch|finally|throw|debugger|with|import|defer|export|from|let|const|var|using|function|constructor|class|interface|type|enum|namespace|module|public|private|protected|static|override|declare|async|accessor|get|set)\\b)",
      "patterns": [
        {
          "include": "#type"
        }
      ]
    },
    "type-annotation-return": {
      "name": "meta.type.annotation.return.ts",
      "begin": "(?<=\\))(:)",
      "beginCaptures": {
        "1": {
          "name": "keyword.operator.type.annotation.ts"
        }
      },
      "end": "(?=[{;]|=>)",
      "patterns": [
        {
          "include": "#type"
        }
      ]
    },
    "scope-keyword-operator-expression": {
      "match": "\\b(typeof|new|void|as|instanceof|delete)\\b",
      "name": "keyword.operator.expression.ts"
    },
    "scope-keyword-operator-expression-keyof": {
      "match": "\\b(keyof)\\b(?=\\s+[[:alpha:][:digit:]_$\"`({\\[\\-]|\\s*$)",
      "name": "keyword.operator.expression.ts"
    },
    "scope-keyword-operator-expression-is": {
      "match": "\\b(is)\\b(?=\\s+[[:alpha:][:digit:]_$\"`({\\[\\-]|\\s*$)",
      "name": "keyword.operator.expression.ts"
    },
    "scope-keyword-operator-expression-asserts": {
      "match": "\\b(asserts)\\b(?=\\s+[[:alpha:][:digit:]_$\"`({\\[\\-]|\\s*$)",
      "name": "keyword.operator.expression.ts"
    },
    "scope-keyword-operator-expression-infer": {
      "match": "\\b(infer)\\b(?=\\s+[[:alpha:][:digit:]_$\"`({\\[\\-]|\\s*$)",
      "name": "keyword.operator.expression.ts"
    },
    "scope-keyword-operator-expression-satisfies": {
      "match": "\\b(satisfies)\\b(?=\\s+[[:alpha:][:digit:]_$\"`({\\[\\-]|\\s*$)",
      "name": "keyword.operator.expression.ts"
    },
    "scope-storage-modifier": {
      "match": "\\b(readonly|abstract|async|public|private|protected|static|override|accessor|declare)\\b",
      "name": "storage.modifier.ts"
    },
    "scope-keyword-other-extends": {
      "match": "\\b(extends|implements)\\b",
      "name": "keyword.other.extends.ts"
    },
    "scope-constant-language-boolean-true": {
      "match": "\\b(true)\\b",
      "name": "constant.language.boolean.true.ts"
    },
    "scope-constant-language-boolean-false": {
      "match": "\\b(false)\\b",
      "name": "constant.language.boolean.false.ts"
    },
    "scope-constant-language-null": {
      "match": "\\b(null|undefined)\\b",
      "name": "constant.language.null.ts"
    },
    "scope-support-type-primitive": {
      "match": "\\b(void|string|number|boolean|object|symbol|bigint|any|unknown|never)\\b",
      "name": "support.type.primitive.ts"
    },
    "scope-keyword-other": {
      "match": "\\b(unique|@new|target|meta|out)\\b",
      "name": "keyword.other.ts"
    },
    "scope-keyword-control-import": {
      "match": "\\b(import)\\b",
      "name": "keyword.control.import.ts"
    },
    "scope-storage-type-function": {
      "match": "\\b(function|constructor)\\b",
      "name": "storage.type.function.ts"
    },
    "scope-keyword-control-loop": {
      "match": "\\b(in|for|while|do|break|continue|of)\\b",
      "name": "keyword.control.loop.ts"
    },
    "scope-storage-type-class": {
      "match": "\\b(class)\\b",
      "name": "storage.type.class.ts"
    },
    "scope-keyword-control-flow": {
      "match": "\\b(yield|await|return)\\b",
      "name": "keyword.control.flow.ts"
    },
    "scope-keyword-control-export": {
      "match": "\\b(export)\\b",
      "name": "keyword.control.export.ts"
    },
    "scope-storage-type-property": {
      "match": "\\b(get|set)\\b",
      "name": "storage.type.property.ts"
    },
    "scope-storage-type": {
      "match": "\\b(let|const|var|using)\\b",
      "name": "storage.type.ts"
    },
    "scope-keyword-control-conditional": {
      "match": "\\b(if|else)\\b",
      "name": "keyword.control.conditional.ts"
    },
    "scope-keyword-control-switch": {
      "match": "\\b(switch|case|default)\\b",
      "name": "keyword.control.switch.ts"
    },
    "scope-keyword-control-trycatch": {
      "match": "\\b(throw|try|catch|finally)\\b",
      "name": "keyword.control.trycatch.ts"
    },
    "scope-keyword-control": {
      "match": "\\b(debugger|with)\\b",
      "name": "keyword.control.ts"
    },
    "scope-storage-type-interface-decl": {
      "match": "\\b(interface)\\b(?!\\s*(?:\\.|\\?\\.))",
      "name": "storage.type.interface.ts"
    },
    "scope-storage-type-type-decl": {
      "match": "\\b(type)\\b(?!\\s*(?:\\.|\\?\\.))",
      "name": "storage.type.type.ts"
    },
    "scope-storage-type-enum": {
      "match": "\\b(enum)\\b",
      "name": "storage.type.enum.ts"
    },
    "scope-storage-type-namespace-decl": {
      "match": "\\b(module|namespace)\\b(?!\\s*(?:\\.|\\?\\.))",
      "name": "storage.type.namespace.ts"
    },
    "scope-support-variable": {
      "match": "\\b(module|global|console|window|document|process|require|exports|globalThis)\\b",
      "name": "support.variable.ts"
    },
    "scope-keyword-control-from-from": {
      "match": "\\bfrom\\b(?=\\s*[\"'])",
      "name": "keyword.control.from.ts"
    },
    "scope-support-class": {
      "match": "\\b(Promise|Array|Map|Set|WeakMap|WeakSet|Error|RegExp|Date|Object|Function|Symbol)\\b(?!\\s*(?:\\.|\\?\\.|\\())",
      "name": "support.class.ts"
    },
    "type-builtin-literals": {
      "match": "\\b(true|false|null|undefined)\\b",
      "name": "support.type.builtin.ts"
    },
    "type-storage-modifier": {
      "match": "\\b(readonly|abstract)\\b",
      "name": "storage.modifier.ts"
    },
    "scope-storage-type-function-arrow": {
      "match": "=>",
      "name": "storage.type.function.arrow.ts"
    },
    "operator-overrides": {
      "match": "(>>>=)|(\\*\\*=)|(<<=)|(>>=)|(\\?\\?=)|(\\|\\|=)|(&&=)|(===)|(!==)|(>>>)|(\\+=)|(-=)|(\\*=)|(/=)|(%=)|(&=)|(\\|=)|(\\^=)|(\\?\\?)|(\\|\\|)|(&&)|(==)|(!=)|(<=)|(>=)|(<<)|(>>)|(\\*\\*)|(\\+\\+)|(--)|(\\|)|(&)|(-)|(!)|(\\*)|(\\+)|(=)|(\\^)|(/)|(%)|(~)",
      "captures": {
        "1": {
          "name": "keyword.operator.assignment.ts"
        },
        "2": {
          "name": "keyword.operator.assignment.ts"
        },
        "3": {
          "name": "keyword.operator.assignment.ts"
        },
        "4": {
          "name": "keyword.operator.assignment.ts"
        },
        "5": {
          "name": "keyword.operator.assignment.ts"
        },
        "6": {
          "name": "keyword.operator.assignment.ts"
        },
        "7": {
          "name": "keyword.operator.assignment.ts"
        },
        "8": {
          "name": "keyword.operator.comparison.ts"
        },
        "9": {
          "name": "keyword.operator.comparison.ts"
        },
        "10": {
          "name": "keyword.operator.bitwise.shift.ts"
        },
        "11": {
          "name": "keyword.operator.assignment.ts"
        },
        "12": {
          "name": "keyword.operator.assignment.ts"
        },
        "13": {
          "name": "keyword.operator.assignment.ts"
        },
        "14": {
          "name": "keyword.operator.assignment.ts"
        },
        "15": {
          "name": "keyword.operator.assignment.ts"
        },
        "16": {
          "name": "keyword.operator.assignment.ts"
        },
        "17": {
          "name": "keyword.operator.assignment.ts"
        },
        "18": {
          "name": "keyword.operator.assignment.ts"
        },
        "19": {
          "name": "keyword.operator.logical.ts"
        },
        "20": {
          "name": "keyword.operator.logical.ts"
        },
        "21": {
          "name": "keyword.operator.logical.ts"
        },
        "22": {
          "name": "keyword.operator.comparison.ts"
        },
        "23": {
          "name": "keyword.operator.comparison.ts"
        },
        "24": {
          "name": "keyword.operator.relational.ts"
        },
        "25": {
          "name": "keyword.operator.relational.ts"
        },
        "26": {
          "name": "keyword.operator.bitwise.shift.ts"
        },
        "27": {
          "name": "keyword.operator.bitwise.shift.ts"
        },
        "28": {
          "name": "keyword.operator.arithmetic.ts"
        },
        "29": {
          "name": "keyword.operator.increment-decrement.ts"
        },
        "30": {
          "name": "keyword.operator.increment-decrement.ts"
        },
        "31": {
          "name": "keyword.operator.bitwise.ts"
        },
        "32": {
          "name": "keyword.operator.bitwise.ts"
        },
        "33": {
          "name": "keyword.operator.arithmetic.ts"
        },
        "34": {
          "name": "keyword.operator.logical.prefix.ts"
        },
        "35": {
          "name": "keyword.operator.arithmetic.ts"
        },
        "36": {
          "name": "keyword.operator.arithmetic.ts"
        },
        "37": {
          "name": "keyword.operator.assignment.ts"
        },
        "38": {
          "name": "keyword.operator.bitwise.ts"
        },
        "39": {
          "name": "keyword.operator.arithmetic.ts"
        },
        "40": {
          "name": "keyword.operator.arithmetic.ts"
        },
        "41": {
          "name": "keyword.operator.logical.prefix.ts"
        }
      }
    },
    "operators": {
      "match": "\\.\\.\\.",
      "name": "keyword.operator.ts"
    },
    "scope-punctuation-bracket-square": {
      "match": "\\[|\\]",
      "name": "punctuation.bracket.square.ts"
    },
    "scope-punctuation-bracket-round": {
      "match": "\\(|\\)",
      "name": "punctuation.bracket.round.ts"
    },
    "scope-punctuation-bracket-curly": {
      "match": "\\{|\\}",
      "name": "punctuation.bracket.curly.ts"
    },
    "scope-punctuation-accessor-optional": {
      "match": "\\?\\.",
      "name": "punctuation.accessor.optional.ts"
    },
    "punctuation": {
      "match": "\\?|:",
      "name": "punctuation.ts"
    },
    "expr-scope-keyword-control-loop": {
      "match": "\\b(in)\\b",
      "name": "keyword.control.loop.ts"
    },
    "expr-scope-keyword-control-flow": {
      "match": "\\b(yield)\\b",
      "name": "keyword.control.flow.ts"
    },
    "expr-scope-storage-modifier": {
      "match": "\\b(async)\\b",
      "name": "storage.modifier.ts"
    },
    "expr-scope-storage-type-namespace-decl": {
      "match": "\\b(module)\\b(?!\\s*(?:\\.|\\?\\.))",
      "name": "storage.type.namespace.ts"
    },
    "expression": {
      "patterns": [
        {
          "include": "#code-block"
        },
        {
          "include": "#generic-arrow-function"
        },
        {
          "include": "#generic-call"
        },
        {
          "include": "#generic-call-eol"
        },
        {
          "include": "#generic-call-multiline"
        },
        {
          "include": "#cast"
        },
        {
          "include": "#shebang"
        },
        {
          "include": "#jsdoc"
        },
        {
          "include": "#directives"
        },
        {
          "include": "#linecomment"
        },
        {
          "include": "#blockcomment"
        },
        {
          "include": "#regex-literal-prefix-ops"
        },
        {
          "include": "#regex"
        },
        {
          "include": "#qstring-double"
        },
        {
          "include": "#qstring-single"
        },
        {
          "include": "#template"
        },
        {
          "include": "#decorator"
        },
        {
          "include": "#type-annotation-return"
        },
        {
          "include": "#object-method-key"
        },
        {
          "include": "#new-expr"
        },
        {
          "include": "#arrow-function-params"
        },
        {
          "include": "#ternary-expression"
        },
        {
          "include": "#function-declaration"
        },
        {
          "include": "#function-anon-declaration"
        },
        {
          "include": "#class-declaration"
        },
        {
          "include": "#module-declaration"
        },
        {
          "include": "#extends-definition"
        },
        {
          "include": "#import-export-all"
        },
        {
          "include": "#import-default-binding"
        },
        {
          "include": "#keyof-typekw"
        },
        {
          "include": "#type-predicate-operator"
        },
        {
          "include": "#extends-typekw"
        },
        {
          "include": "#as-typekw"
        },
        {
          "include": "#implements-typekw"
        },
        {
          "include": "#satisfies-typekw"
        },
        {
          "include": "#hexnumber"
        },
        {
          "include": "#octalnumber"
        },
        {
          "include": "#binarynumber"
        },
        {
          "include": "#bigint"
        },
        {
          "include": "#number"
        },
        {
          "include": "#scope-keyword-operator-expression"
        },
        {
          "include": "#scope-keyword-operator-expression-keyof"
        },
        {
          "include": "#scope-keyword-operator-expression-is"
        },
        {
          "include": "#scope-keyword-operator-expression-asserts"
        },
        {
          "include": "#scope-keyword-operator-expression-infer"
        },
        {
          "include": "#scope-keyword-operator-expression-satisfies"
        },
        {
          "include": "#scope-keyword-control-import"
        },
        {
          "include": "#expr-scope-keyword-control-loop"
        },
        {
          "include": "#expr-scope-keyword-control-flow"
        },
        {
          "include": "#scope-keyword-control-from-from"
        },
        {
          "include": "#expr-scope-storage-modifier"
        },
        {
          "include": "#scope-keyword-other-extends"
        },
        {
          "include": "#scope-keyword-other"
        },
        {
          "include": "#scope-storage-type-function"
        },
        {
          "include": "#scope-storage-type-class"
        },
        {
          "include": "#expr-scope-storage-type-namespace-decl"
        },
        {
          "include": "#scope-storage-type-function-arrow"
        },
        {
          "include": "#scope-constant-language-boolean-true"
        },
        {
          "include": "#scope-constant-language-boolean-false"
        },
        {
          "include": "#scope-constant-language-null"
        },
        {
          "include": "#this-literal"
        },
        {
          "include": "#scope-support-type-primitive"
        },
        {
          "include": "#super-literal"
        },
        {
          "include": "#scope-support-variable"
        },
        {
          "include": "#scope-support-class"
        },
        {
          "include": "#method-call"
        },
        {
          "include": "#known-property-access"
        },
        {
          "include": "#property-access"
        },
        {
          "include": "#operator-overrides"
        },
        {
          "include": "#operators"
        },
        {
          "include": "#punctuation-accessor"
        },
        {
          "include": "#punctuation-comma"
        },
        {
          "include": "#scope-punctuation-bracket-square"
        },
        {
          "include": "#scope-punctuation-bracket-round"
        },
        {
          "include": "#scope-punctuation-bracket-curly"
        },
        {
          "include": "#punctuation-semicolon"
        },
        {
          "include": "#scope-punctuation-accessor-optional"
        },
        {
          "include": "#punctuation"
        },
        {
          "include": "#arrow-parameter"
        },
        {
          "include": "#function-call"
        },
        {
          "include": "#ident"
        },
        {
          "include": "#privatefield"
        },
        {
          "include": "#comparison"
        }
      ]
    },
    "type": {
      "patterns": [
        {
          "include": "#generic-type"
        },
        {
          "include": "#type-object"
        },
        {
          "include": "#type-paren"
        },
        {
          "include": "#hexnumber"
        },
        {
          "include": "#octalnumber"
        },
        {
          "include": "#binarynumber"
        },
        {
          "include": "#bigint"
        },
        {
          "include": "#number"
        },
        {
          "include": "#qstring-double"
        },
        {
          "include": "#qstring-single"
        },
        {
          "include": "#type-conditional"
        },
        {
          "include": "#shebang"
        },
        {
          "include": "#jsdoc"
        },
        {
          "include": "#directives"
        },
        {
          "include": "#linecomment"
        },
        {
          "include": "#blockcomment"
        },
        {
          "include": "#type-parameters"
        },
        {
          "include": "#type-builtin-literals"
        },
        {
          "include": "#type-storage-modifier"
        },
        {
          "include": "#scope-support-type-primitive"
        },
        {
          "include": "#scope-keyword-operator-expression"
        },
        {
          "include": "#scope-keyword-operator-expression-keyof"
        },
        {
          "include": "#scope-keyword-operator-expression-is"
        },
        {
          "include": "#scope-keyword-operator-expression-asserts"
        },
        {
          "include": "#scope-keyword-operator-expression-infer"
        },
        {
          "include": "#scope-keyword-operator-expression-satisfies"
        },
        {
          "include": "#simple-type"
        },
        {
          "match": "[\\|&]",
          "name": "keyword.operator.type.ts"
        },
        {
          "match": "\\[\\]",
          "name": "keyword.operator.type.array.ts"
        },
        {
          "include": "#type-bracket"
        },
        {
          "match": "=>",
          "name": "storage.type.function.arrow.ts"
        },
        {
          "match": ":",
          "name": "keyword.operator.type.annotation.ts"
        },
        {
          "match": ",",
          "name": "punctuation.separator.comma.ts"
        }
      ]
    },
    "qstring-double": {
      "name": "string.quoted.double.ts",
      "begin": "\"",
      "beginCaptures": {
        "0": {
          "name": "punctuation.definition.string.begin.ts"
        }
      },
      "end": "\"|$",
      "endCaptures": {
        "0": {
          "name": "punctuation.definition.string.end.ts"
        }
      },
      "patterns": [
        {
          "match": "\\\\(?:[nrtbfv0'\"\\\\]|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}|u\\{[0-9A-Fa-f]+\\})",
          "name": "constant.character.escape.ts"
        }
      ]
    },
    "qstring-single": {
      "name": "string.quoted.single.ts",
      "begin": "'",
      "beginCaptures": {
        "0": {
          "name": "punctuation.definition.string.begin.ts"
        }
      },
      "end": "'|$",
      "endCaptures": {
        "0": {
          "name": "punctuation.definition.string.end.ts"
        }
      },
      "patterns": [
        {
          "match": "\\\\(?:[nrtbfv0'\"\\\\]|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}|u\\{[0-9A-Fa-f]+\\})",
          "name": "constant.character.escape.ts"
        }
      ]
    },
    "punctuation-comma": {
      "match": ",",
      "name": "punctuation.separator.comma.ts"
    },
    "punctuation-semicolon": {
      "match": ";",
      "name": "punctuation.terminator.statement.ts"
    },
    "punctuation-accessor": {
      "match": "\\.",
      "name": "punctuation.accessor.ts"
    },
    "regex": {
      "name": "string.regexp.ts",
      "begin": "(?:(?<=[=|\\^&<>+\\-*%~,\\[(?:{;.])|(?<=\\bkeyof)|(?<=\\btypeof)|(?<=\\breadonly)|(?<=\\bis)|(?<=\\bnew)|(?<=\\bextends)|(?<=\\bunique)|(?<=\\bin)|(?<=\\bas)|(?<=\\b@new)|(?<=\\binstanceof)|(?<=\\bclass)|(?<=\\basync)|(?<=\\byield)|(?<=\\bsatisfies)|(?<=\\bfunction)|(?<=\\bget)|(?<=\\bset)|(?<=\\bpublic)|(?<=\\bprivate)|(?<=\\bprotected)|(?<=\\bstatic)|(?<=\\babstract)|(?<=\\boverride)|(?<=\\baccessor)|(?<=\\bexport)|(?<=\\bdeclare)|(?<=\\bout)|(?<=\\belse)|(?<=\\bdo)|(?<=\\breturn)|(?<=\\bthrow)|(?<=\\btry)|(?<=\\bfinally)|(?<=\\bcatch)|(?<=\\bof)|(?<=\\bcase)|(?<=\\bdefault)|(?<=\\bimport)|(?<=\\btype)|(?<=\\bconstructor)|(?<=\\bvoid)|(?<=\\bdelete)|(?<=\\bawait)|(?<=^))\\s*(?:((?:/\\*\\*(?!/)[\\s\\S]*?\\*/|/\\*[\\s\\S]*?\\*/)\\s*))?(/)(?![*/])",
      "beginCaptures": {
        "1": {
          "name": "comment.block.ts"
        },
        "2": {
          "name": "punctuation.definition.string.begin.regexp.ts"
        }
      },
      "end": "(/)([a-z]*)",
      "endCaptures": {
        "1": {
          "name": "punctuation.definition.string.end.regexp.ts"
        },
        "2": {
          "name": "keyword.other.regexp.ts"
        }
      },
      "patterns": [
        {
          "include": "#regexp"
        }
      ]
    },
    "new-expr": {
      "name": "meta.new-expr.ts",
      "begin": "\\b(new)\\b",
      "beginCaptures": {
        "1": {
          "name": "keyword.operator.expression.ts"
        }
      },
      "end": "(?=[()}\\],=<;])",
      "patterns": [
        {
          "match": "(?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*",
          "name": "entity.name.function.ts"
        }
      ]
    },
    "parameter-name": {
      "match": "(?<=[,(])\\s*(\\.\\.\\.)?\\s*((?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*)(?=\\s*[,)=])",
      "captures": {
        "1": {
          "name": "keyword.operator.spread.ts"
        },
        "2": {
          "name": "variable.parameter.ts"
        }
      }
    },
    "directives": {
      "name": "comment.line.triple-slash.ts",
      "match": "///[ \\t]*<[^\\n]*"
    },
    "this-literal": {
      "match": "\\b(this)\\b",
      "name": "variable.language.this.ts"
    },
    "super-literal": {
      "match": "\\b(super)\\b",
      "name": "variable.language.super.ts"
    },
    "type-parameters": {
      "name": "meta.type.parameters.ts",
      "begin": "<",
      "beginCaptures": {
        "0": {
          "name": "punctuation.definition.typeparameters.begin.ts"
        }
      },
      "end": ">",
      "endCaptures": {
        "0": {
          "name": "punctuation.definition.typeparameters.end.ts"
        }
      },
      "patterns": [
        {
          "include": "#type-parameters"
        },
        {
          "match": "\\bconst\\b",
          "name": "storage.type.ts"
        },
        {
          "match": "\\bin\\b",
          "name": "keyword.control.loop.ts"
        },
        {
          "match": "\\bpublic\\b",
          "name": "storage.modifier.ts"
        },
        {
          "match": "\\bprivate\\b",
          "name": "storage.modifier.ts"
        },
        {
          "match": "\\bprotected\\b",
          "name": "storage.modifier.ts"
        },
        {
          "match": "\\breadonly\\b",
          "name": "storage.modifier.ts"
        },
        {
          "match": "\\bextends\\b",
          "name": "keyword.other.extends.ts"
        },
        {
          "include": "#type"
        },
        {
          "match": "=",
          "name": "keyword.operator.assignment.ts"
        },
        {
          "match": ",",
          "name": "punctuation.separator.comma.ts"
        }
      ]
    },
    "type-alias-declaration": {
      "name": "meta.type.ts",
      "begin": "\\b(type)\\s+((?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*)",
      "beginCaptures": {
        "1": {
          "name": "storage.type.type.ts"
        },
        "2": {
          "name": "entity.name.type.alias.ts"
        }
      },
      "patterns": [
        {
          "include": "#type-parameters"
        },
        {
          "include": "#type-body"
        },
        {
          "include": "$self"
        }
      ],
      "while": "^(?=\\s*(?:[<,\\[|&(...?:{;\\-.!*]|(?:keyof|typeof|readonly|this|is|abstract|new|asserts|extends|infer|true|false|null|undefined|void|unique)\\b|//|/\\*|[>\\])}](?:\\s*[>\\])}])*\\s*(?=[<,\\[|&(...?:{;\\-.!*=])|(?!(?:if|else|switch|case|default|for|while|do|in|of|break|continue|return|await|yield|try|catch|finally|throw|debugger|with|import|defer|export|from|let|const|var|using|function|constructor|class|interface|type|enum|namespace|module|public|private|protected|static|override|declare|async|accessor|get|set)\\b)(?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*\\b(?!\\s*[.(])))"
    },
    "type-object": {
      "name": "meta.object-type.ts",
      "begin": "\\{",
      "beginCaptures": {
        "0": {
          "name": "punctuation.definition.block.ts"
        }
      },
      "end": "\\}",
      "endCaptures": {
        "0": {
          "name": "punctuation.definition.block.ts"
        }
      },
      "patterns": [
        {
          "include": "#method-signature"
        },
        {
          "include": "#type-object-member"
        },
        {
          "include": "#type"
        },
        {
          "match": ";",
          "name": "punctuation.separator.ts"
        }
      ]
    },
    "cast": {
      "name": "meta.cast.expr.ts",
      "begin": "(?<![\\w$)\\]])(?<![\\w$)\\]]\\s)(?<![\\w$)\\]]\\s\\s)(?<![\\w$)\\]]\\s\\s\\s)(?<![\\w$)\\]]\\s\\s\\s\\s)(?<![\\w$)\\]]\\s\\s\\s\\s\\s)(?<![\\w$)\\]]\\s\\s\\s\\s\\s\\s)(?<![\\w$)\\]]\\s\\s\\s\\s\\s\\s\\s)(?<![\\w$)\\]]\\s\\s\\s\\s\\s\\s\\s\\s)(?<![\\w$)\\]]\\s\\s\\s\\s\\s\\s\\s\\s\\s)(?<![\\w$)\\]]\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s)(?<![\\w$)\\]]\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s)(?<![\\w$)\\]]\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s)(?<![\\w$)\\]]\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s)(?<![\\w$)\\]]\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s)(?<![\\w$)\\]]\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s)(?<![\\w$)\\]]\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s\\s)(<)(?=\\s*[[:alpha:]_$({\\[][\\w$.,\\[\\]\\s|&<>]*>\\s*[[:alpha:][:digit:]_$\"`({\\[\\-])",
      "beginCaptures": {
        "1": {
          "name": "punctuation.definition.typeparameters.begin.ts"
        }
      },
      "end": "(>)",
      "endCaptures": {
        "1": {
          "name": "punctuation.definition.typeparameters.end.ts"
        }
      },
      "patterns": [
        {
          "include": "#type"
        }
      ]
    },
    "parameter-type-annotation": {
      "name": "meta.type.annotation.parameter.ts",
      "begin": "(\\.\\.\\.)?\\s*((?:[a-zA-Z_$\\p{L}\\p{Nl}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})(?:[a-zA-Z0-9_$\\p{L}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Pc}]|\\\\u[0-9A-Fa-f]{4}|\\\\u\\{[0-9A-Fa-f]+\\})*)(\\??)(\\s*:)",
      "beginCaptures": {
        "1": {
          "name": "keyword.operator.spread.ts"
        },
        "2": {
          "name": "variable.parameter.ts"
        },
        "3": {
          "name": "keyword.operator.optional.ts"
        },
        "4": {
          "name": "keyword.operator.type.annotation.ts"
        }
      },
      "end": "(?=[,)]|=(?!>))",
      "patterns": [
        {
          "include": "#type"
        }
      ]
    },
    "type-predicate-operator": {
      "name": "meta.type.is.ts",
      "begin": "\\b(is)\\b(?=\\s+[[:alpha:][:digit:]_$\"`({\\[\\-]|\\s*$)",
      "beginCaptures": {
        "1": {
          "name": "keyword.operator.expression.is.ts"
        }
      },
      "end": "(?=[)}{\\],;=>]|\\b(?:keyof|is|extends|unique|as|implements|satisfies|if|else|switch|case|default|for|while|do|in|of|break|continue|return|await|yield|try|catch|finally|throw|debugger|with|import|defer|export|from|typeof|instanceof|new|delete|void|asserts|infer)\\b)",
      "patterns": [
        {
          "include": "#type"
        }
      ]
    },
    "comment": {
      "patterns": [
        {
          "include": "#jsdoc"
        },
        {
          "include": "#directives"
        },
        {
          "include": "#linecomment"
        },
        {
          "include": "#blockcomment"
        }
      ]
    },
    "string": {
      "patterns": [
        {
          "include": "#qstring-single"
        },
        {
          "include": "#qstring-double"
        },
        {
          "include": "#template"
        }
      ]
    },
    "boolean-literal": {
      "patterns": [
        {
          "include": "#scope-constant-language-boolean-true"
        },
        {
          "include": "#scope-constant-language-boolean-false"
        }
      ]
    },
    "numeric-literal": {
      "patterns": [
        {
          "include": "#hexnumber"
        },
        {
          "include": "#binarynumber"
        },
        {
          "include": "#octalnumber"
        },
        {
          "include": "#number"
        },
        {
          "include": "#bigint"
        }
      ]
    },
    "return-type": {
      "patterns": [
        {
          "include": "#type-annotation-return"
        },
        {
          "include": "#decl-return-type"
        }
      ]
    }
  }
}