name: "C#"
scopeName: "source.cs"
fileTypes: [
  "cs"
]
uuid: "f7de61e2-bdde-4e2a-a139-8221b179584e"
patterns: [
  {
    include: "#preprocessor"
  }
  {
    include: "#comment"
  }
  {
    include: "#directives"
  }
  {
    include: "#declarations"
  }
  {
    include: "#script-top-level"
  }
]
repository:
  directives:
    patterns: [
      {
        include: "#extern-alias-directive"
      }
      {
        include: "#using-directive"
      }
      {
        include: "#attribute-section"
      }
      {
        include: "#punctuation-semicolon"
      }
    ]
  declarations:
    patterns: [
      {
        include: "#namespace-declaration"
      }
      {
        include: "#type-declarations"
      }
      {
        include: "#punctuation-semicolon"
      }
    ]
  "script-top-level":
    patterns: [
      {
        include: "#statement"
      }
      {
        include: "#method-declaration"
      }
      {
        include: "#punctuation-semicolon"
      }
    ]
  "type-declarations":
    patterns: [
      {
        include: "#preprocessor"
      }
      {
        include: "#comment"
      }
      {
        include: "#storage-modifier"
      }
      {
        include: "#class-declaration"
      }
      {
        include: "#delegate-declaration"
      }
      {
        include: "#enum-declaration"
      }
      {
        include: "#interface-declaration"
      }
      {
        include: "#struct-declaration"
      }
      {
        include: "#record-declaration"
      }
      {
        include: "#attribute-section"
      }
      {
        include: "#punctuation-semicolon"
      }
    ]
  "class-or-struct-members":
    patterns: [
      {
        include: "#preprocessor"
      }
      {
        include: "#comment"
      }
      {
        include: "#storage-modifier"
      }
      {
        include: "#type-declarations"
      }
      {
        include: "#constructor-declaration"
      }
      {
        include: "#property-declaration"
      }
      {
        include: "#field-declaration"
      }
      {
        include: "#event-declaration"
      }
      {
        include: "#indexer-declaration"
      }
      {
        include: "#variable-initializer"
      }
      {
        include: "#destructor-declaration"
      }
      {
        include: "#operator-declaration"
      }
      {
        include: "#conversion-operator-declaration"
      }
      {
        include: "#method-declaration"
      }
      {
        include: "#attribute-section"
      }
      {
        include: "#punctuation-semicolon"
      }
    ]
  "interface-members":
    patterns: [
      {
        include: "#preprocessor"
      }
      {
        include: "#comment"
      }
      {
        include: "#storage-modifier"
      }
      {
        include: "#property-declaration"
      }
      {
        include: "#event-declaration"
      }
      {
        include: "#indexer-declaration"
      }
      {
        include: "#method-declaration"
      }
      {
        include: "#operator-declaration"
      }
      {
        include: "#attribute-section"
      }
      {
        include: "#punctuation-semicolon"
      }
    ]
  statement:
    patterns: [
      {
        include: "#preprocessor"
      }
      {
        include: "#comment"
      }
      {
        include: "#while-statement"
      }
      {
        include: "#do-statement"
      }
      {
        include: "#for-statement"
      }
      {
        include: "#foreach-statement"
      }
      {
        include: "#if-statement"
      }
      {
        include: "#else-part"
      }
      {
        include: "#goto-statement"
      }
      {
        include: "#return-statement"
      }
      {
        include: "#break-or-continue-statement"
      }
      {
        include: "#throw-statement"
      }
      {
        include: "#yield-statement"
      }
      {
        include: "#await-statement"
      }
      {
        include: "#try-statement"
      }
      {
        include: "#expression-operator-expression"
      }
      {
        include: "#context-control-statement"
      }
      {
        include: "#context-control-paren-statement"
      }
      {
        include: "#labeled-statement"
      }
      {
        include: "#object-creation-expression"
      }
      {
        include: "#array-creation-expression"
      }
      {
        include: "#anonymous-object-creation-expression"
      }
      {
        include: "#local-declaration"
      }
      {
        include: "#block"
      }
      {
        include: "#expression"
      }
      {
        include: "#punctuation-semicolon"
      }
    ]
  expression:
    patterns: [
      {
        include: "#preprocessor"
      }
      {
        include: "#comment"
      }
      {
        include: "#expression-operator-expression"
      }
      {
        include: "#type-operator-expression"
      }
      {
        include: "#default-literal-expression"
      }
      {
        include: "#throw-expression"
      }
      {
        include: "#raw-interpolated-string"
      }
      {
        include: "#interpolated-string"
      }
      {
        include: "#verbatim-interpolated-string"
      }
      {
        include: "#type-builtin"
      }
      {
        include: "#language-variable"
      }
      {
        include: "#switch-statement-or-expression"
      }
      {
        include: "#with-expression"
      }
      {
        include: "#conditional-operator"
      }
      {
        include: "#assignment-expression"
      }
      {
        include: "#expression-operators"
      }
      {
        include: "#await-expression"
      }
      {
        include: "#query-expression"
      }
      {
        include: "#as-expression"
      }
      {
        include: "#is-expression"
      }
      {
        include: "#anonymous-method-expression"
      }
      {
        include: "#object-creation-expression"
      }
      {
        include: "#array-creation-expression"
      }
      {
        include: "#anonymous-object-creation-expression"
      }
      {
        include: "#invocation-expression"
      }
      {
        include: "#member-access-expression"
      }
      {
        include: "#element-access-expression"
      }
      {
        include: "#cast-expression"
      }
      {
        include: "#literal"
      }
      {
        include: "#parenthesized-expression"
      }
      {
        include: "#tuple-deconstruction-assignment"
      }
      {
        include: "#initializer-expression"
      }
      {
        include: "#identifier"
      }
    ]
  "extern-alias-directive":
    begin: "\\b(extern)\\s+(alias)\\b"
    beginCaptures:
      "1":
        name: "keyword.other.directive.extern.cs"
      "2":
        name: "keyword.other.directive.alias.cs"
    end: "(?=;)"
    patterns: [
      {
        match: "\\@?[_[:alpha:]][_[:alnum:]]*"
        name: "variable.other.alias.cs"
      }
    ]
  "using-directive":
    patterns: [
      {
        begin: "\\b(?:(global)\\s+)?(using)\\s+(static)\\b\\s*(?:(unsafe)\\b\\s*)?"
        beginCaptures:
          "1":
            name: "keyword.other.directive.global.cs"
          "2":
            name: "keyword.other.directive.using.cs"
          "3":
            name: "keyword.other.directive.static.cs"
          "4":
            name: "storage.modifier.unsafe.cs"
        end: "(?=;)"
        patterns: [
          {
            include: "#type"
          }
        ]
      }
      {
        begin: "\\b(?:(global)\\s+)?(using)\\b\\s*(?:(unsafe)\\b\\s*)?(@?[_[:alpha:]][_[:alnum:]]*)\\s*(=)"
        beginCaptures:
          "1":
            name: "keyword.other.directive.global.cs"
          "2":
            name: "keyword.other.directive.using.cs"
          "3":
            name: "storage.modifier.unsafe.cs"
          "4":
            name: "entity.name.type.alias.cs"
          "5":
            name: "keyword.operator.assignment.cs"
        end: "(?=;)"
        patterns: [
          {
            include: "#comment"
          }
          {
            include: "#type"
          }
        ]
      }
      {
        begin: "\\b(?:(global)\\s+)?(using)\\b\\s*+(?!\\(|var\\b)"
        beginCaptures:
          "1":
            name: "keyword.other.directive.global.cs"
          "2":
            name: "keyword.other.directive.using.cs"
        end: "(?=;)"
        patterns: [
          {
            include: "#comment"
          }
          {
            name: "entity.name.type.namespace.cs"
            match: "\\@?[_[:alpha:]][_[:alnum:]]*"
          }
          {
            include: "#punctuation-accessor"
          }
          {
            include: "#operator-assignment"
          }
        ]
      }
    ]
  "attribute-section":
    begin: "(\\[)(assembly|module|field|event|method|param|property|return|type)?(\\:)?"
    beginCaptures:
      "1":
        name: "punctuation.squarebracket.open.cs"
      "2":
        name: "keyword.other.attribute-specifier.cs"
      "3":
        name: "punctuation.separator.colon.cs"
    end: "(\\])"
    endCaptures:
      "1":
        name: "punctuation.squarebracket.close.cs"
    patterns: [
      {
        include: "#comment"
      }
      {
        include: "#attribute"
      }
      {
        include: "#punctuation-comma"
      }
    ]
  attribute:
    patterns: [
      {
        include: "#type-name"
      }
      {
        include: "#type-arguments"
      }
      {
        include: "#attribute-arguments"
      }
    ]
  "attribute-arguments":
    begin: "(\\()"
    beginCaptures:
      "1":
        name: "punctuation.parenthesis.open.cs"
    end: "(\\))"
    endCaptures:
      "1":
        name: "punctuation.parenthesis.close.cs"
    patterns: [
      {
        include: "#attribute-named-argument"
      }
      {
        include: "#expression"
      }
      {
        include: "#punctuation-comma"
      }
    ]
  "attribute-named-argument":
    begin: "(@?[_[:alpha:]][_[:alnum:]]*)\\s*(?==)"
    beginCaptures:
      "1":
        name: "entity.name.variable.property.cs"
    end: "(?=(,|\\)))"
    patterns: [
      {
        include: "#operator-assignment"
      }
      {
        include: "#expression"
      }
    ]
  "namespace-declaration":
    begin: "\\b(namespace)\\s+"
    beginCaptures:
      "1":
        name: "storage.type.namespace.cs"
    end: "(?<=\\})|(?=;)"
    patterns: [
      {
        include: "#comment"
      }
      {
        name: "entity.name.type.namespace.cs"
        match: "@?[_[:alpha:]][_[:alnum:]]*"
      }
      {
        include: "#punctuation-accessor"
      }
      {
        begin: "\\{"
        beginCaptures:
          "0":
            name: "punctuation.curlybrace.open.cs"
        end: "\\}"
        endCaptures:
          "0":
            name: "punctuation.curlybrace.close.cs"
        patterns: [
          {
            include: "#declarations"
          }
          {
            include: "#using-directive"
          }
          {
            include: "#punctuation-semicolon"
          }
        ]
      }
    ]
  "storage-modifier":
    name: "storage.modifier.$1.cs"
    match: "(?<!\\.)\\b(new|public|protected|internal|private|abstract|virtual|override|sealed|static|partial|readonly|volatile|const|extern|async|unsafe|ref|required|file)\\b"
  "class-declaration":
    begin: "(?=(\\brecord\\b\\s+)?\\bclass\\b)"
    end: "(?<=\\})|(?=;)"
    patterns: [
      {
        begin: '''
          (?x)
          (\\b(record)\\b\\s+)?
          \\b(class)\\b\\s+
          (@?[_[:alpha:]][_[:alnum:]]*)\\s*
        '''
        beginCaptures:
          "2":
            name: "storage.type.record.cs"
          "3":
            name: "storage.type.class.cs"
          "4":
            name: "entity.name.type.class.cs"
        end: "(?=\\{)|(?=;)"
        patterns: [
          {
            include: "#comment"
          }
          {
            include: "#type-parameter-list"
          }
          {
            include: "#parenthesized-parameter-list"
          }
          {
            include: "#base-types"
          }
          {
            include: "#generic-constraints"
          }
        ]
      }
      {
        begin: "\\{"
        beginCaptures:
          "0":
            name: "punctuation.curlybrace.open.cs"
        end: "\\}"
        endCaptures:
          "0":
            name: "punctuation.curlybrace.close.cs"
        patterns: [
          {
            include: "#class-or-struct-members"
          }
        ]
      }
      {
        include: "#preprocessor"
      }
      {
        include: "#comment"
      }
    ]
  "delegate-declaration":
    begin: '''
      (?x)
      (?:\\b(delegate)\\b)\\s+
      (?<type_name>
        (?:
          (?:ref\\s+(?:readonly\\s+)?)?   # ref return
          (?:
            (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification
            (?<name_and_type_args> # identifier + type arguments (if any)
              \\g<identifier>\\s*
              (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?
            )
            (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?
            (?<tuple>\\s*\\((?:[^\\(\\)]|\\g<tuple>)+\\))
          )
          (?:\\s*\\?\\s*)? # nullable suffix?
          (?:\\s* # array suffix?
            \\[
              (?:\\s*,\\s*)* # commata for multi-dimensional arrays
            \\]
            \\s*
            (?:\\?)? # arrays can be nullable reference types
            \\s*
          )*
        )
      )\\s+
      (\\g<identifier>)\\s*
      (<([^<>]+)>)?\\s*
      (?=\\()
    '''
    beginCaptures:
      "1":
        name: "storage.type.delegate.cs"
      "2":
        patterns: [
          {
            include: "#type"
          }
        ]
      "7":
        name: "entity.name.type.delegate.cs"
      "8":
        patterns: [
          {
            include: "#type-parameter-list"
          }
        ]
    end: "(?=;)"
    patterns: [
      {
        include: "#comment"
      }
      {
        include: "#parenthesized-parameter-list"
      }
      {
        include: "#generic-constraints"
      }
    ]
  "enum-declaration":
    begin: "(?=\\benum\\b)"
    end: "(?<=\\})|(?=;)"
    patterns: [
      {
        begin: "(?=enum)"
        end: "(?=\\{)|(?=;)"
        patterns: [
          {
            include: "#comment"
          }
          {
            match: "(enum)\\s+(@?[_[:alpha:]][_[:alnum:]]*)"
            captures:
              "1":
                name: "storage.type.enum.cs"
              "2":
                name: "entity.name.type.enum.cs"
          }
          {
            begin: ":"
            beginCaptures:
              "0":
                name: "punctuation.separator.colon.cs"
            end: "(?=\\{)"
            patterns: [
              {
                include: "#type"
              }
            ]
          }
        ]
      }
      {
        begin: "\\{"
        beginCaptures:
          "0":
            name: "punctuation.curlybrace.open.cs"
        end: "\\}"
        endCaptures:
          "0":
            name: "punctuation.curlybrace.close.cs"
        patterns: [
          {
            include: "#preprocessor"
          }
          {
            include: "#comment"
          }
          {
            include: "#attribute-section"
          }
          {
            include: "#punctuation-comma"
          }
          {
            begin: "@?[_[:alpha:]][_[:alnum:]]*"
            beginCaptures:
              "0":
                name: "entity.name.variable.enum-member.cs"
            end: "(?=(,|\\}))"
            patterns: [
              {
                include: "#comment"
              }
              {
                include: "#variable-initializer"
              }
            ]
          }
        ]
      }
      {
        include: "#preprocessor"
      }
      {
        include: "#comment"
      }
    ]
  "interface-declaration":
    begin: "(?=\\binterface\\b)"
    end: "(?<=\\})|(?=;)"
    patterns: [
      {
        begin: '''
          (?x)
          (interface)\\b\\s+
          (@?[_[:alpha:]][_[:alnum:]]*)
        '''
        beginCaptures:
          "1":
            name: "storage.type.interface.cs"
          "2":
            name: "entity.name.type.interface.cs"
        end: "(?=\\{)|(?=;)"
        patterns: [
          {
            include: "#comment"
          }
          {
            include: "#type-parameter-list"
          }
          {
            include: "#base-types"
          }
          {
            include: "#generic-constraints"
          }
        ]
      }
      {
        begin: "\\{"
        beginCaptures:
          "0":
            name: "punctuation.curlybrace.open.cs"
        end: "\\}"
        endCaptures:
          "0":
            name: "punctuation.curlybrace.close.cs"
        patterns: [
          {
            include: "#interface-members"
          }
        ]
      }
      {
        include: "#preprocessor"
      }
      {
        include: "#comment"
      }
    ]
  "record-declaration":
    begin: "(?=\\brecord\\b)"
    end: "(?<=\\})|(?=;)"
    patterns: [
      {
        begin: '''
          (?x)
          (record)\\b\\s+
          (@?[_[:alpha:]][_[:alnum:]]*)
        '''
        beginCaptures:
          "1":
            name: "storage.type.record.cs"
          "2":
            name: "entity.name.type.class.cs"
        end: "(?=\\{)|(?=;)"
        patterns: [
          {
            include: "#comment"
          }
          {
            include: "#type-parameter-list"
          }
          {
            include: "#parenthesized-parameter-list"
          }
          {
            include: "#base-types"
          }
          {
            include: "#generic-constraints"
          }
        ]
      }
      {
        begin: "\\{"
        beginCaptures:
          "0":
            name: "punctuation.curlybrace.open.cs"
        end: "\\}"
        endCaptures:
          "0":
            name: "punctuation.curlybrace.close.cs"
        patterns: [
          {
            include: "#class-or-struct-members"
          }
        ]
      }
      {
        include: "#preprocessor"
      }
      {
        include: "#comment"
      }
    ]
  "struct-declaration":
    begin: "(?=(\\brecord\\b\\s+)?\\bstruct\\b)"
    end: "(?<=\\})|(?=;)"
    patterns: [
      {
        begin: '''
          (?x)
          (\\b(record)\\b\\s+)?
          (struct)\\b\\s+
          (@?[_[:alpha:]][_[:alnum:]]*)
        '''
        beginCaptures:
          "2":
            name: "storage.type.record.cs"
          "3":
            name: "storage.type.struct.cs"
          "4":
            name: "entity.name.type.struct.cs"
        end: "(?=\\{)|(?=;)"
        patterns: [
          {
            include: "#comment"
          }
          {
            include: "#type-parameter-list"
          }
          {
            include: "#parenthesized-parameter-list"
          }
          {
            include: "#base-types"
          }
          {
            include: "#generic-constraints"
          }
        ]
      }
      {
        begin: "\\{"
        beginCaptures:
          "0":
            name: "punctuation.curlybrace.open.cs"
        end: "\\}"
        endCaptures:
          "0":
            name: "punctuation.curlybrace.close.cs"
        patterns: [
          {
            include: "#class-or-struct-members"
          }
        ]
      }
      {
        include: "#preprocessor"
      }
      {
        include: "#comment"
      }
    ]
  "type-parameter-list":
    begin: "\\<"
    beginCaptures:
      "0":
        name: "punctuation.definition.typeparameters.begin.cs"
    end: "\\>"
    endCaptures:
      "0":
        name: "punctuation.definition.typeparameters.end.cs"
    patterns: [
      {
        match: "\\b(in|out)\\b"
        name: "storage.modifier.$1.cs"
      }
      {
        match: "(@?[_[:alpha:]][_[:alnum:]]*)\\b"
        name: "entity.name.type.type-parameter.cs"
      }
      {
        include: "#comment"
      }
      {
        include: "#punctuation-comma"
      }
      {
        include: "#attribute-section"
      }
    ]
  "base-types":
    begin: ":"
    beginCaptures:
      "0":
        name: "punctuation.separator.colon.cs"
    end: "(?=\\{|where|;)"
    patterns: [
      {
        include: "#base-class-constructor-call"
      }
      {
        include: "#type"
      }
      {
        include: "#punctuation-comma"
      }
      {
        include: "#preprocessor"
      }
    ]
  "base-class-constructor-call":
    begin: '''
      (?x)
      (?:
        (@?[_[:alpha:]][_[:alnum:]]*)\\s*(\\.)  # qualified name part
      )*
      (@?[_[:alpha:]][_[:alnum:]]*)\\s*        # type name
      (
        <
        (?<type_args>
          [^<>()]|
          \\((?:[^<>()]|<[^<>()]*>|\\([^<>()]*\\))*\\)|
          <\\g<type_args>*>
        )*
        >\\s*
      )?                                      # optional type arguments
      (?=\\()                                  # followed by argument list
    '''
    beginCaptures:
      "1":
        name: "entity.name.type.cs"
      "2":
        name: "punctuation.accessor.cs"
      "3":
        name: "entity.name.type.cs"
      "4":
        patterns: [
          {
            include: "#type-arguments"
          }
        ]
    end: "(?<=\\))"
    patterns: [
      {
        include: "#argument-list"
      }
    ]
  "generic-constraints":
    begin: "(where)\\s+(@?[_[:alpha:]][_[:alnum:]]*)\\s*(:)"
    beginCaptures:
      "1":
        name: "storage.modifier.where.cs"
      "2":
        name: "entity.name.type.type-parameter.cs"
      "3":
        name: "punctuation.separator.colon.cs"
    end: "(?=\\{|where|;|=>)"
    patterns: [
      {
        name: "storage.type.class.cs"
        match: "\\bclass\\b"
      }
      {
        name: "storage.type.struct.cs"
        match: "\\bstruct\\b"
      }
      {
        name: "keyword.other.constraint.default.cs"
        match: "\\bdefault\\b"
      }
      {
        name: "keyword.other.constraint.notnull.cs"
        match: "\\bnotnull\\b"
      }
      {
        name: "keyword.other.constraint.unmanaged.cs"
        match: "\\bunmanaged\\b"
      }
      {
        match: "(new)\\s*(\\()\\s*(\\))"
        captures:
          "1":
            name: "keyword.operator.expression.new.cs"
          "2":
            name: "punctuation.parenthesis.open.cs"
          "3":
            name: "punctuation.parenthesis.close.cs"
      }
      {
        include: "#type"
      }
      {
        include: "#punctuation-comma"
      }
      {
        include: "#generic-constraints"
      }
    ]
  "field-declaration":
    begin: '''
      (?x)
      (?<type_name>
        (?:
          (?:
            (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification
            (?<name_and_type_args> # identifier + type arguments (if any)
              \\g<identifier>\\s*
              (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?
            )
            (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?
            (?<tuple>\\s*\\((?:[^\\(\\)]|\\g<tuple>)+\\))
          )
          (?:\\s*\\?\\s*)? # nullable suffix?
          (?:\\s* # array suffix?
            \\[
              (?:\\s*,\\s*)* # commata for multi-dimensional arrays
            \\]
            \\s*
            (?:\\?)? # arrays can be nullable reference types
            \\s*
          )*
        )
      )\\s+
      (\\g<identifier>)\\s* # first field name
      (?!=>|==)(?=,|;|=|$)
    '''
    beginCaptures:
      "1":
        patterns: [
          {
            include: "#type"
          }
        ]
      "6":
        name: "entity.name.variable.field.cs"
    end: "(?=;)"
    patterns: [
      {
        name: "entity.name.variable.field.cs"
        match: "@?[_[:alpha:]][_[:alnum:]]*"
      }
      {
        include: "#punctuation-comma"
      }
      {
        include: "#comment"
      }
      {
        include: "#variable-initializer"
      }
      {
        include: "#class-or-struct-members"
      }
    ]
  "property-declaration":
    begin: '''
      (?x)
      
      # The negative lookahead below ensures that we don't match nested types
      # or other declarations as properties.
      (?![[:word:][:space:]]*\\b(?:class|interface|struct|enum|event)\\b)
      
      (?<return_type>
        (?<type_name>
          (?:
            (?:ref\\s+(?:readonly\\s+)?)?   # ref return
            (?:
              (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification
              (?<name_and_type_args> # identifier + type arguments (if any)
                \\g<identifier>\\s*
                (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?
              )
              (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?
              (?<tuple>\\s*\\((?:[^\\(\\)]|\\g<tuple>)+\\))
            )
            (?:\\s*\\?\\s*)? # nullable suffix?
            (?:\\s* # array suffix?
              \\[
                (?:\\s*,\\s*)* # commata for multi-dimensional arrays
              \\]
              \\s*
              (?:\\?)? # arrays can be nullable reference types
              \\s*
            )*
          )
        )\\s+
      )
      (?<interface_name>\\g<type_name>\\s*\\.\\s*)?
      (?<property_name>\\g<identifier>)\\s*
      (?=\\{|=>|//|/\\*|$)
    '''
    beginCaptures:
      "1":
        patterns: [
          {
            include: "#type"
          }
        ]
      "7":
        patterns: [
          {
            include: "#type"
          }
          {
            include: "#punctuation-accessor"
          }
        ]
      "8":
        name: "entity.name.variable.property.cs"
    end: "(?<=\\})|(?=;)"
    patterns: [
      {
        include: "#comment"
      }
      {
        include: "#property-accessors"
      }
      {
        include: "#accessor-getter-expression"
      }
      {
        include: "#variable-initializer"
      }
      {
        include: "#class-or-struct-members"
      }
    ]
  "indexer-declaration":
    begin: '''
      (?x)
      (?<return_type>
        (?<type_name>
          (?:
            (?:ref\\s+(?:readonly\\s+)?)?   # ref return
            (?:
              (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification
              (?<name_and_type_args> # identifier + type arguments (if any)
                \\g<identifier>\\s*
                (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?
              )
              (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?
              (?<tuple>\\s*\\((?:[^\\(\\)]|\\g<tuple>)+\\))
            )
            (?:\\s*\\?\\s*)? # nullable suffix?
            (?:\\s* # array suffix?
              \\[
                (?:\\s*,\\s*)* # commata for multi-dimensional arrays
              \\]
              \\s*
              (?:\\?)? # arrays can be nullable reference types
              \\s*
            )*
          )
        )\\s+
      )
      (?<interface_name>\\g<type_name>\\s*\\.\\s*)?
      (?<indexer_name>this)\\s*
      (?=\\[)
    '''
    beginCaptures:
      "1":
        patterns: [
          {
            include: "#type"
          }
        ]
      "7":
        patterns: [
          {
            include: "#type"
          }
          {
            include: "#punctuation-accessor"
          }
        ]
      "8":
        name: "variable.language.this.cs"
    end: "(?<=\\})|(?=;)"
    patterns: [
      {
        include: "#comment"
      }
      {
        include: "#bracketed-parameter-list"
      }
      {
        include: "#property-accessors"
      }
      {
        include: "#accessor-getter-expression"
      }
      {
        include: "#variable-initializer"
      }
    ]
  "event-declaration":
    begin: '''
      (?x)
      \\b(event)\\b\\s*
      (?<return_type>
        (?<type_name>
          (?:
            (?:
              (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification
              (?<name_and_type_args> # identifier + type arguments (if any)
                \\g<identifier>\\s*
                (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?
              )
              (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?
              (?<tuple>\\s*\\((?:[^\\(\\)]|\\g<tuple>)+\\))
            )
            (?:\\s*\\?\\s*)? # nullable suffix?
            (?:\\s* # array suffix?
              \\[
                (?:\\s*,\\s*)* # commata for multi-dimensional arrays
              \\]
              \\s*
              (?:\\?)? # arrays can be nullable reference types
              \\s*
            )*
          )
        )\\s+
      )
      (?<interface_name>\\g<type_name>\\s*\\.\\s*)?
      (\\g<identifier>)\\s* # first event name
      (?=\\{|;|,|=|//|/\\*|$)
    '''
    beginCaptures:
      "1":
        name: "storage.type.event.cs"
      "2":
        patterns: [
          {
            include: "#type"
          }
        ]
      "8":
        patterns: [
          {
            include: "#type"
          }
          {
            include: "#punctuation-accessor"
          }
        ]
      "9":
        name: "entity.name.variable.event.cs"
    end: "(?<=\\})|(?=;)"
    patterns: [
      {
        include: "#comment"
      }
      {
        include: "#event-accessors"
      }
      {
        name: "entity.name.variable.event.cs"
        match: "@?[_[:alpha:]][_[:alnum:]]*"
      }
      {
        include: "#punctuation-comma"
      }
      {
        begin: "="
        beginCaptures:
          "0":
            name: "keyword.operator.assignment.cs"
        end: "(?<=,)|(?=;)"
        patterns: [
          {
            include: "#expression"
          }
          {
            include: "#punctuation-comma"
          }
        ]
      }
    ]
  "property-accessors":
    begin: "\\{"
    beginCaptures:
      "0":
        name: "punctuation.curlybrace.open.cs"
    end: "\\}"
    endCaptures:
      "0":
        name: "punctuation.curlybrace.close.cs"
    patterns: [
      {
        include: "#comment"
      }
      {
        include: "#attribute-section"
      }
      {
        name: "storage.modifier.$1.cs"
        match: "\\b(private|protected|internal)\\b"
      }
      {
        begin: "\\b(get)\\b\\s*(?=\\{|;|=>|//|/\\*|$)"
        beginCaptures:
          "1":
            name: "storage.type.accessor.$1.cs"
        end: "(?<=\\}|;)|(?=\\})"
        patterns: [
          {
            include: "#accessor-getter"
          }
        ]
      }
      {
        begin: "\\b(set|init)\\b\\s*(?=\\{|;|=>|//|/\\*|$)"
        beginCaptures:
          "1":
            name: "storage.type.accessor.$1.cs"
        end: "(?<=\\}|;)|(?=\\})"
        patterns: [
          {
            include: "#accessor-setter"
          }
        ]
      }
    ]
  "event-accessors":
    begin: "\\{"
    beginCaptures:
      "0":
        name: "punctuation.curlybrace.open.cs"
    end: "\\}"
    endCaptures:
      "0":
        name: "punctuation.curlybrace.close.cs"
    patterns: [
      {
        include: "#comment"
      }
      {
        include: "#attribute-section"
      }
      {
        begin: "\\b(add|remove)\\b\\s*(?=\\{|;|=>|//|/\\*|$)"
        beginCaptures:
          "1":
            name: "storage.type.accessor.$1.cs"
        end: "(?<=\\}|;)|(?=\\})"
        patterns: [
          {
            include: "#accessor-setter"
          }
        ]
      }
    ]
  "accessor-getter":
    patterns: [
      {
        begin: "\\{"
        beginCaptures:
          "0":
            name: "punctuation.curlybrace.open.cs"
        end: "\\}"
        endCaptures:
          "0":
            name: "punctuation.curlybrace.close.cs"
        contentName: "meta.accessor.getter.cs"
        patterns: [
          {
            include: "#statement"
          }
        ]
      }
      {
        include: "#accessor-getter-expression"
      }
      {
        include: "#punctuation-semicolon"
      }
    ]
  "accessor-getter-expression":
    begin: "=>"
    beginCaptures:
      "0":
        name: "keyword.operator.arrow.cs"
    end: "(?=;|\\})"
    contentName: "meta.accessor.getter.cs"
    patterns: [
      {
        include: "#ref-modifier"
      }
      {
        include: "#expression"
      }
    ]
  "accessor-setter":
    patterns: [
      {
        begin: "\\{"
        beginCaptures:
          "0":
            name: "punctuation.curlybrace.open.cs"
        end: "\\}"
        endCaptures:
          "0":
            name: "punctuation.curlybrace.close.cs"
        contentName: "meta.accessor.setter.cs"
        patterns: [
          {
            include: "#statement"
          }
        ]
      }
      {
        begin: "=>"
        beginCaptures:
          "0":
            name: "keyword.operator.arrow.cs"
        end: "(?=;|\\})"
        contentName: "meta.accessor.setter.cs"
        patterns: [
          {
            include: "#ref-modifier"
          }
          {
            include: "#expression"
          }
        ]
      }
      {
        include: "#punctuation-semicolon"
      }
    ]
  "method-declaration":
    begin: '''
      (?x)
      (?<return_type>
        (?<type_name>
          (?:
            (?:ref\\s+(?:readonly\\s+)?)?   # ref return
            (?:
              (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification
              (?<name_and_type_args> # identifier + type arguments (if any)
                \\g<identifier>\\s*
                (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?
              )
              (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?
              (?<tuple>\\s*\\((?:[^\\(\\)]|\\g<tuple>)+\\))
            )
            (?:\\s*\\?\\s*)? # nullable suffix?
            (?:\\s* # array suffix?
              \\[
                (?:\\s*,\\s*)* # commata for multi-dimensional arrays
              \\]
              \\s*
              (?:\\?)? # arrays can be nullable reference types
              \\s*
            )*
          )
        )\\s+
      )
      (?<interface_name>\\g<type_name>\\s*\\.\\s*)?
      (\\g<identifier>)\\s*
      (<([^<>]+)>)?\\s*
      (?=\\()
    '''
    beginCaptures:
      "1":
        patterns: [
          {
            include: "#type"
          }
        ]
      "7":
        patterns: [
          {
            include: "#type"
          }
          {
            include: "#punctuation-accessor"
          }
        ]
      "8":
        name: "entity.name.function.cs"
      "9":
        patterns: [
          {
            include: "#type-parameter-list"
          }
        ]
    end: "(?<=\\})|(?=;)"
    patterns: [
      {
        include: "#comment"
      }
      {
        include: "#parenthesized-parameter-list"
      }
      {
        include: "#generic-constraints"
      }
      {
        include: "#expression-body"
      }
      {
        include: "#block"
      }
    ]
  "constructor-declaration":
    begin: "(@?[_[:alpha:]][_[:alnum:]]*)\\s*(?=\\(|$)"
    beginCaptures:
      "1":
        name: "entity.name.function.cs"
    end: "(?<=\\})|(?=;)"
    patterns: [
      {
        begin: "(:)"
        beginCaptures:
          "1":
            name: "punctuation.separator.colon.cs"
        end: "(?=\\{|=>)"
        patterns: [
          {
            include: "#constructor-initializer"
          }
        ]
      }
      {
        include: "#parenthesized-parameter-list"
      }
      {
        include: "#preprocessor"
      }
      {
        include: "#comment"
      }
      {
        include: "#expression-body"
      }
      {
        include: "#block"
      }
    ]
  "constructor-initializer":
    begin: "\\b(base|this)\\b\\s*(?=\\()"
    beginCaptures:
      "1":
        name: "variable.language.$1.cs"
    end: "(?<=\\))"
    patterns: [
      {
        include: "#argument-list"
      }
    ]
  "destructor-declaration":
    begin: "(~)(@?[_[:alpha:]][_[:alnum:]]*)\\s*(?=\\()"
    beginCaptures:
      "1":
        name: "punctuation.tilde.cs"
      "2":
        name: "entity.name.function.cs"
    end: "(?<=\\})|(?=;)"
    patterns: [
      {
        include: "#comment"
      }
      {
        include: "#parenthesized-parameter-list"
      }
      {
        include: "#expression-body"
      }
      {
        include: "#block"
      }
    ]
  "operator-declaration":
    begin: '''
      (?x)
      (?<type_name>
        (?:
          (?:ref\\s+(?:readonly\\s+)?)?   # ref return
          (?:
            (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification
            (?<name_and_type_args> # identifier + type arguments (if any)
              \\g<identifier>\\s*
              (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?
            )
            (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?
            (?<tuple>\\s*\\((?:[^\\(\\)]|\\g<tuple>)+\\))
          )
          (?:\\s*\\?\\s*)? # nullable suffix?
          (?:\\s* # array suffix?
            \\[
              (?:\\s*,\\s*)* # commata for multi-dimensional arrays
            \\]
            \\s*
            (?:\\?)? # arrays can be nullable reference types
            \\s*
          )*
        )
      )\\s*
      \\b(?<operator_keyword>operator)\\b\\s*
      (?<operator>[+\\-*/%&|\\^!=~<>]+|true|false)\\s*
      (?=\\()
    '''
    beginCaptures:
      "1":
        patterns: [
          {
            include: "#type"
          }
        ]
      "6":
        name: "storage.type.operator.cs"
      "7":
        name: "entity.name.function.cs"
    end: "(?<=\\})|(?=;)"
    patterns: [
      {
        include: "#comment"
      }
      {
        include: "#parenthesized-parameter-list"
      }
      {
        include: "#expression-body"
      }
      {
        include: "#block"
      }
    ]
  "conversion-operator-declaration":
    begin: '''
      (?x)
      (?<explicit_or_implicit_keyword>(?:\\b(?:explicit|implicit)))\\s*
      (?<operator_keyword>(?:\\b(?:operator)))\\s*
      (?<type_name>
        (?:
          (?:ref\\s+(?:readonly\\s+)?)?   # ref return
          (?:
            (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification
            (?<name_and_type_args> # identifier + type arguments (if any)
              \\g<identifier>\\s*
              (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?
            )
            (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?
            (?<tuple>\\s*\\((?:[^\\(\\)]|\\g<tuple>)+\\))
          )
          (?:\\s*\\?\\s*)? # nullable suffix?
          (?:\\s* # array suffix?
            \\[
              (?:\\s*,\\s*)* # commata for multi-dimensional arrays
            \\]
            \\s*
            (?:\\?)? # arrays can be nullable reference types
            \\s*
          )*
        )
      )\\s*
      (?=\\()
    '''
    beginCaptures:
      "1":
        patterns: [
          {
            match: "\\b(explicit)\\b"
            captures:
              "1":
                name: "storage.modifier.explicit.cs"
          }
          {
            match: "\\b(implicit)\\b"
            captures:
              "1":
                name: "storage.modifier.implicit.cs"
          }
        ]
      "2":
        name: "storage.type.operator.cs"
      "3":
        patterns: [
          {
            include: "#type"
          }
        ]
    end: "(?<=\\})|(?=;)"
    patterns: [
      {
        include: "#comment"
      }
      {
        include: "#parenthesized-parameter-list"
      }
      {
        include: "#expression-body"
      }
      {
        include: "#block"
      }
    ]
  block:
    begin: "\\{"
    beginCaptures:
      "0":
        name: "punctuation.curlybrace.open.cs"
    end: "\\}"
    endCaptures:
      "0":
        name: "punctuation.curlybrace.close.cs"
    patterns: [
      {
        include: "#statement"
      }
    ]
  "variable-initializer":
    begin: "(?<!=|!)(=)(?!=|>)"
    beginCaptures:
      "1":
        name: "keyword.operator.assignment.cs"
    end: "(?=[,\\)\\];}])"
    patterns: [
      {
        include: "#ref-modifier"
      }
      {
        include: "#expression"
      }
    ]
  "expression-body":
    begin: "=>"
    beginCaptures:
      "0":
        name: "keyword.operator.arrow.cs"
    end: "(?=[,\\);}])"
    patterns: [
      {
        include: "#ref-modifier"
      }
      {
        include: "#expression"
      }
    ]
  "goto-statement":
    begin: "(?<!\\.)\\b(goto)\\b"
    beginCaptures:
      "1":
        name: "keyword.control.flow.goto.cs"
    end: "(?=[;}])"
    patterns: [
      {
        begin: "\\b(case)\\b"
        beginCaptures:
          "1":
            name: "keyword.control.conditional.case.cs"
        end: "(?=[;}])"
        patterns: [
          {
            include: "#expression"
          }
        ]
      }
      {
        match: "\\b(default)\\b"
        captures:
          "1":
            name: "keyword.control.conditional.default.cs"
      }
      {
        name: "entity.name.label.cs"
        match: "@?[_[:alpha:]][_[:alnum:]]*"
      }
    ]
  "return-statement":
    begin: "(?<!\\.)\\b(return)\\b"
    beginCaptures:
      "1":
        name: "keyword.control.flow.return.cs"
    end: "(?=[;}])"
    patterns: [
      {
        include: "#ref-modifier"
      }
      {
        include: "#expression"
      }
    ]
  "break-or-continue-statement":
    match: "(?<!\\.)\\b(break|continue)\\b"
    name: "keyword.control.flow.$1.cs"
  "throw-statement":
    begin: "(?<!\\.)\\b(throw)\\b"
    beginCaptures:
      "1":
        name: "keyword.control.flow.throw.cs"
    end: "(?=[;}])"
    patterns: [
      {
        include: "#expression"
      }
    ]
  "yield-statement":
    patterns: [
      {
        include: "#yield-return-statement"
      }
      {
        include: "#yield-break-statement"
      }
    ]
  "yield-return-statement":
    begin: "(?<!\\.)\\b(yield)\\b\\s*\\b(return)\\b"
    beginCaptures:
      "1":
        name: "keyword.control.flow.yield.cs"
      "2":
        name: "keyword.control.flow.return.cs"
    end: "(?=[;}])"
    patterns: [
      {
        include: "#expression"
      }
    ]
  "yield-break-statement":
    match: "(?<!\\.)\\b(yield)\\b\\s*\\b(break)\\b"
    captures:
      "1":
        name: "keyword.control.flow.yield.cs"
      "2":
        name: "keyword.control.flow.break.cs"
  "await-statement":
    begin: "(?<!\\.\\s*)\\b(await)\\b"
    beginCaptures:
      "1":
        name: "keyword.operator.expression.await.cs"
    end: "(?<=})|(?=;|})"
    patterns: [
      {
        include: "#foreach-statement"
      }
      {
        include: "#using-statement"
      }
      {
        include: "#expression"
      }
    ]
  "if-statement":
    begin: "(?<!\\.)\\b(if)\\b\\s*(?=\\()"
    beginCaptures:
      "1":
        name: "keyword.control.conditional.if.cs"
    end: "(?<=})|(?=;)"
    patterns: [
      {
        begin: "\\("
        beginCaptures:
          "0":
            name: "punctuation.parenthesis.open.cs"
        end: "\\)"
        endCaptures:
          "0":
            name: "punctuation.parenthesis.close.cs"
        patterns: [
          {
            include: "#expression"
          }
        ]
      }
      {
        include: "#statement"
      }
    ]
  "else-part":
    begin: "(?<!\\.)\\b(else)\\b"
    beginCaptures:
      "1":
        name: "keyword.control.conditional.else.cs"
    end: "(?<=})|(?=;)"
    patterns: [
      {
        include: "#statement"
      }
    ]
  "switch-statement-or-expression":
    begin: "(?<!\\.)\\b(switch)\\b"
    beginCaptures:
      "1":
        name: "keyword.control.conditional.switch.cs"
    end: "(?<=})|(?=})"
    patterns: [
      {
        include: "#intrusive"
      }
      {
        begin: "(?=\\()"
        end: "(?<=\\})|(?=\\})"
        patterns: [
          {
            include: "#switch-statement"
          }
        ]
      }
      {
        begin: "(?=\\{)"
        end: "(?<=\\})|(?=\\})"
        patterns: [
          {
            include: "#switch-expression"
          }
        ]
      }
    ]
  "switch-statement":
    patterns: [
      {
        include: "#intrusive"
      }
      {
        begin: "\\("
        beginCaptures:
          "0":
            name: "punctuation.parenthesis.open.cs"
        end: "\\)"
        endCaptures:
          "0":
            name: "punctuation.parenthesis.close.cs"
        patterns: [
          {
            include: "#expression"
          }
        ]
      }
      {
        begin: "\\{"
        beginCaptures:
          "0":
            name: "punctuation.curlybrace.open.cs"
        end: "\\}"
        endCaptures:
          "0":
            name: "punctuation.curlybrace.close.cs"
        patterns: [
          {
            include: "#switch-label"
          }
          {
            include: "#statement"
          }
        ]
      }
    ]
  "switch-label":
    begin: "\\b(case|default)\\b"
    beginCaptures:
      "1":
        name: "keyword.control.conditional.$1.cs"
    end: "(:)|(?=})"
    endCaptures:
      "1":
        name: "punctuation.separator.colon.cs"
    patterns: [
      {
        begin: "\\b(when)\\b"
        beginCaptures:
          "1":
            name: "keyword.control.conditional.when.cs"
        end: "(?=:|})"
        patterns: [
          {
            include: "#case-guard"
          }
        ]
      }
      {
        begin: "(?!\\s)"
        end: "(?=\\bwhen\\b|:|})"
        patterns: [
          {
            include: "#pattern"
          }
        ]
      }
    ]
  "switch-expression":
    begin: "\\{"
    beginCaptures:
      "0":
        name: "punctuation.curlybrace.open.cs"
    end: "\\}"
    endCaptures:
      "0":
        name: "punctuation.curlybrace.close.cs"
    patterns: [
      {
        include: "#punctuation-comma"
      }
      {
        begin: "=>"
        beginCaptures:
          "0":
            name: "keyword.operator.arrow.cs"
        end: "(?=,|})"
        patterns: [
          {
            include: "#expression"
          }
        ]
      }
      {
        begin: "\\b(when)\\b"
        beginCaptures:
          "1":
            name: "keyword.control.conditional.when.cs"
        end: "(?==>|,|})"
        patterns: [
          {
            include: "#case-guard"
          }
        ]
      }
      {
        begin: "(?!\\s)"
        end: "(?=\\bwhen\\b|=>|,|})"
        patterns: [
          {
            include: "#pattern"
          }
        ]
      }
    ]
  "case-guard":
    patterns: [
      {
        include: "#parenthesized-expression"
      }
      {
        include: "#expression"
      }
    ]
  "is-expression":
    begin: "(?<!\\.)\\b(is)\\b"
    beginCaptures:
      "1":
        name: "keyword.operator.expression.pattern.is.cs"
    end: "(?=[)}\\],;:?=&|^]|!=)"
    patterns: [
      {
        include: "#pattern"
      }
    ]
  pattern:
    patterns: [
      {
        include: "#intrusive"
      }
      {
        include: "#combinator-pattern"
      }
      {
        include: "#discard-pattern"
      }
      {
        include: "#constant-pattern"
      }
      {
        include: "#relational-pattern"
      }
      {
        include: "#var-pattern"
      }
      {
        include: "#type-pattern"
      }
      {
        include: "#positional-pattern"
      }
      {
        include: "#property-pattern"
      }
      {
        include: "#list-pattern"
      }
      {
        include: "#slice-pattern"
      }
    ]
  "combinator-pattern":
    match: "\\b(and|or|not)\\b"
    name: "keyword.operator.expression.pattern.combinator.$1.cs"
  "discard-pattern":
    match: "_(?![_[:alnum:]])"
    name: "variable.language.discard.cs"
  "constant-pattern":
    patterns: [
      {
        include: "#boolean-literal"
      }
      {
        include: "#null-literal"
      }
      {
        include: "#numeric-literal"
      }
      {
        include: "#char-literal"
      }
      {
        include: "#string-literal"
      }
      {
        include: "#raw-string-literal"
      }
      {
        include: "#verbatim-string-literal"
      }
      {
        include: "#type-operator-expression"
      }
      {
        include: "#expression-operator-expression"
      }
      {
        include: "#expression-operators"
      }
      {
        include: "#casted-constant-pattern"
      }
    ]
  "casted-constant-pattern":
    begin: '''
      (?x)
      (\\()
        ([\\s.:@_[:alnum:]]+)
      (\\))
      (?=[\\s+\\-!~]*@?[_[:alnum:]('"]+)
    '''
    beginCaptures:
      "1":
        name: "punctuation.parenthesis.open.cs"
      "2":
        patterns: [
          {
            include: "#type-builtin"
          }
          {
            include: "#type-name"
          }
        ]
      "3":
        name: "punctuation.parenthesis.close.cs"
    end: "(?=[)}\\],;:?=&|^]|!=|\\b(and|or|when)\\b)"
    patterns: [
      {
        include: "#casted-constant-pattern"
      }
      {
        begin: "\\("
        beginCaptures:
          "0":
            name: "punctuation.parenthesis.open.cs"
        end: "\\)"
        endCaptures:
          "0":
            name: "punctuation.parenthesis.close.cs"
        patterns: [
          {
            include: "#constant-pattern"
          }
        ]
      }
      {
        include: "#constant-pattern"
      }
      {
        match: "(@?[_[:alpha:]][_[:alnum:]]*)\\s*(\\:\\:)"
        captures:
          "1":
            name: "entity.name.type.alias.cs"
          "2":
            name: "punctuation.separator.coloncolon.cs"
      }
      {
        match: "(@?[_[:alpha:]][_[:alnum:]]*)\\s*(\\.)"
        captures:
          "1":
            name: "entity.name.type.cs"
          "2":
            name: "punctuation.accessor.cs"
      }
      {
        match: "\\@?[_[:alpha:]][_[:alnum:]]*"
        name: "variable.other.constant.cs"
      }
    ]
  "relational-pattern":
    begin: "<=?|>=?"
    beginCaptures:
      "0":
        name: "keyword.operator.relational.cs"
    end: "(?=[)}\\],;:?=&|^]|!=|\\b(and|or|when)\\b)"
    patterns: [
      {
        include: "#expression"
      }
    ]
  "var-pattern":
    begin: "\\b(var)\\b"
    beginCaptures:
      "1":
        name: "storage.type.var.cs"
    end: "(?=[)}\\],;:?=&|^]|!=|\\b(and|or|when)\\b)"
    patterns: [
      {
        include: "#designation-pattern"
      }
    ]
  "designation-pattern":
    patterns: [
      {
        include: "#intrusive"
      }
      {
        begin: "\\("
        beginCaptures:
          "0":
            name: "punctuation.parenthesis.open.cs"
        end: "\\)"
        endCaptures:
          "0":
            name: "punctuation.parenthesis.close.cs"
        patterns: [
          {
            include: "#punctuation-comma"
          }
          {
            include: "#designation-pattern"
          }
        ]
      }
      {
        include: "#simple-designation-pattern"
      }
    ]
  "simple-designation-pattern":
    patterns: [
      {
        include: "#discard-pattern"
      }
      {
        match: "@?[_[:alpha:]][_[:alnum:]]*"
        name: "entity.name.variable.local.cs"
      }
    ]
  "type-pattern":
    begin: "(?=@?[_[:alpha:]][_[:alnum:]]*)"
    end: "(?=[)}\\],;:?=&|^]|!=|\\b(and|or|when)\\b)"
    patterns: [
      {
        begin: "\\G"
        end: "(?!\\G[@_[:alpha:]])(?=[\\({@_[:alpha:])}\\],;:=&|^]|(?:\\s|^)\\?|!=|\\b(and|or|when)\\b)"
        patterns: [
          {
            include: "#intrusive"
          }
          {
            include: "#type-subpattern"
          }
        ]
      }
      {
        begin: "(?=[\\({@_[:alpha:]])"
        end: "(?=[)}\\],;:?=&|^]|!=|\\b(and|or|when)\\b)"
        patterns: [
          {
            include: "#intrusive"
          }
          {
            include: "#positional-pattern"
          }
          {
            include: "#property-pattern"
          }
          {
            include: "#simple-designation-pattern"
          }
        ]
      }
    ]
  "type-subpattern":
    patterns: [
      {
        include: "#type-builtin"
      }
      {
        begin: "(@?[_[:alpha:]][_[:alnum:]]*)\\s*(::)"
        beginCaptures:
          "1":
            name: "entity.name.type.alias.cs"
          "2":
            name: "punctuation.separator.coloncolon.cs"
        end: "(?<=[_[:alnum:]])|(?=[.<\\[\\({)}\\],;:?=&|^]|!=|\\b(and|or|when)\\b)"
        patterns: [
          {
            include: "#intrusive"
          }
          {
            match: "\\@?[_[:alpha:]][_[:alnum:]]*"
            name: "entity.name.type.cs"
          }
        ]
      }
      {
        match: "\\@?[_[:alpha:]][_[:alnum:]]*"
        name: "entity.name.type.cs"
      }
      {
        begin: "\\."
        beginCaptures:
          "0":
            name: "punctuation.accessor.cs"
        end: "(?<=[_[:alnum:]])|(?=[<\\[\\({)}\\],;:?=&|^]|!=|\\b(and|or|when)\\b)"
        patterns: [
          {
            include: "#intrusive"
          }
          {
            match: "\\@?[_[:alpha:]][_[:alnum:]]*"
            name: "entity.name.type.cs"
          }
        ]
      }
      {
        include: "#type-arguments"
      }
      {
        include: "#type-array-suffix"
      }
      {
        match: "(?<!\\s)\\?"
        name: "punctuation.separator.question-mark.cs"
      }
    ]
  "positional-pattern":
    begin: "(?=\\()"
    end: "(?=[)}\\],;:?=&|^]|!=|\\b(and|or|when)\\b)"
    patterns: [
      {
        begin: "\\("
        beginCaptures:
          "0":
            name: "punctuation.parenthesis.open.cs"
        end: "\\)"
        endCaptures:
          "0":
            name: "punctuation.parenthesis.close.cs"
        patterns: [
          {
            include: "#subpattern"
          }
          {
            include: "#punctuation-comma"
          }
        ]
      }
      {
        begin: "(?<=\\))"
        end: "(?=[)}\\],;:?=&|^]|!=|\\b(and|or|when)\\b)"
        patterns: [
          {
            include: "#intrusive"
          }
          {
            include: "#property-pattern"
          }
          {
            include: "#simple-designation-pattern"
          }
        ]
      }
    ]
  "property-pattern":
    begin: "(?={)"
    end: "(?=[)}\\],;:?=&|^]|!=|\\b(and|or|when)\\b)"
    patterns: [
      {
        begin: "\\{"
        beginCaptures:
          "0":
            name: "punctuation.curlybrace.open.cs"
        end: "\\}"
        endCaptures:
          "0":
            name: "punctuation.curlybrace.close.cs"
        patterns: [
          {
            include: "#subpattern"
          }
          {
            include: "#punctuation-comma"
          }
        ]
      }
      {
        begin: "(?<=\\})"
        end: "(?=[)}\\],;:?=&|^]|!=|\\b(and|or|when)\\b)"
        patterns: [
          {
            include: "#intrusive"
          }
          {
            include: "#simple-designation-pattern"
          }
        ]
      }
    ]
  subpattern:
    patterns: [
      {
        match: "(@?[_[:alpha:]][_[:alnum:]]*(?:\\s*\\.\\s*@?[_[:alpha:]][_[:alnum:]]*)*)\\s*(:)"
        captures:
          "1":
            patterns: [
              {
                match: "\\@?[_[:alpha:]][_[:alnum:]]*"
                name: "variable.other.object.property.cs"
              }
              {
                include: "#punctuation-accessor"
              }
            ]
          "2":
            name: "punctuation.separator.colon.cs"
      }
      {
        include: "#pattern"
      }
    ]
  "list-pattern":
    begin: "(?=\\[)"
    end: "(?=[)}\\],;:?=&|^]|!=|\\b(and|or|when)\\b)"
    patterns: [
      {
        begin: "\\["
        beginCaptures:
          "0":
            name: "punctuation.squarebracket.open.cs"
        end: "\\]"
        endCaptures:
          "0":
            name: "punctuation.squarebracket.close.cs"
        patterns: [
          {
            include: "#pattern"
          }
          {
            include: "#punctuation-comma"
          }
        ]
      }
      {
        begin: "(?<=\\])"
        end: "(?=[)}\\],;:?=&|^]|!=|\\b(and|or|when)\\b)"
        patterns: [
          {
            include: "#intrusive"
          }
          {
            include: "#simple-designation-pattern"
          }
        ]
      }
    ]
  "slice-pattern":
    match: "\\.\\."
    name: "keyword.operator.range.cs"
  "do-statement":
    begin: "(?<!\\.)\\b(do)\\b"
    beginCaptures:
      "1":
        name: "keyword.control.loop.do.cs"
    end: "(?=;|})"
    patterns: [
      {
        include: "#statement"
      }
    ]
  "while-statement":
    begin: "(?<!\\.)\\b(while)\\b\\s*(?=\\()"
    beginCaptures:
      "1":
        name: "keyword.control.loop.while.cs"
    end: "(?<=\\})|(?=;)"
    patterns: [
      {
        begin: "\\("
        beginCaptures:
          "0":
            name: "punctuation.parenthesis.open.cs"
        end: "\\)"
        endCaptures:
          "0":
            name: "punctuation.parenthesis.close.cs"
        patterns: [
          {
            include: "#expression"
          }
        ]
      }
      {
        include: "#statement"
      }
    ]
  "for-statement":
    begin: "\\b(for)\\b"
    beginCaptures:
      "1":
        name: "keyword.control.loop.for.cs"
    end: "(?<=\\))|(?=;|})"
    patterns: [
      {
        begin: "\\("
        beginCaptures:
          "0":
            name: "punctuation.parenthesis.open.cs"
        end: "\\)"
        endCaptures:
          "0":
            name: "punctuation.parenthesis.close.cs"
        patterns: [
          {
            begin: "(?=[^;\\)])"
            end: "(?=;|\\))"
            patterns: [
              {
                include: "#intrusive"
              }
              {
                include: "#local-variable-declaration"
              }
              {
                include: "#local-tuple-var-deconstruction"
              }
              {
                include: "#tuple-deconstruction-assignment"
              }
              {
                include: "#expression"
              }
            ]
          }
          {
            begin: "(?=;)"
            end: "(?=\\))"
            patterns: [
              {
                include: "#intrusive"
              }
              {
                include: "#expression"
              }
              {
                include: "#punctuation-comma"
              }
              {
                include: "#punctuation-semicolon"
              }
            ]
          }
        ]
      }
    ]
  "foreach-statement":
    begin: "\\b(foreach)\\b"
    beginCaptures:
      "1":
        name: "keyword.control.loop.foreach.cs"
    end: "(?<=\\))|(?=;|})"
    patterns: [
      {
        include: "#intrusive"
      }
      {
        begin: "\\("
        beginCaptures:
          "0":
            name: "punctuation.parenthesis.open.cs"
        end: "\\)"
        endCaptures:
          "0":
            name: "punctuation.parenthesis.close.cs"
        patterns: [
          {
            include: "#intrusive"
          }
          {
            match: '''
              (?x)
              (?:
                (?:(\\bref)\\s+)?(\\bvar\\b)| # ref local
                (?<type_name>
                  (?:
                    (?:ref\\s+)?   # ref local
                    (?:
                      (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification
                      (?<name_and_type_args> # identifier + type arguments (if any)
                        \\g<identifier>\\s*
                        (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?
                      )
                      (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?
                      (?<tuple>\\s*\\((?:[^\\(\\)]|\\g<tuple>)+\\))
                    )
                    (?:\\s*\\?\\s*)? # nullable suffix?
                    (?:\\s* # array suffix?
                      \\[
                        (?:\\s*,\\s*)* # commata for multi-dimensional arrays
                      \\]
                      \\s*
                      (?:\\?)? # arrays can be nullable reference types
                      \\s*
                    )*
                  )
                )
              )\\s+
              (\\g<identifier>)\\s+
              \\b(in)\\b
            '''
            captures:
              "1":
                name: "storage.modifier.ref.cs"
              "2":
                name: "storage.type.var.cs"
              "3":
                patterns: [
                  {
                    include: "#type"
                  }
                ]
              "8":
                name: "entity.name.variable.local.cs"
              "9":
                name: "keyword.control.loop.in.cs"
          }
          {
            match: '''
              (?x) # match foreach (var (x, y) in ...)
              (?:\\b(var)\\b\\s*)?
              (?<tuple>\\((?:[^\\(\\)]|\\g<tuple>)+\\))\\s+
              \\b(in)\\b
            '''
            captures:
              "1":
                name: "storage.type.var.cs"
              "2":
                patterns: [
                  {
                    include: "#tuple-declaration-deconstruction-element-list"
                  }
                ]
              "3":
                name: "keyword.control.loop.in.cs"
          }
          {
            include: "#expression"
          }
        ]
      }
    ]
  "try-statement":
    patterns: [
      {
        include: "#try-block"
      }
      {
        include: "#catch-clause"
      }
      {
        include: "#finally-clause"
      }
    ]
  "try-block":
    begin: "(?<!\\.)\\b(try)\\b"
    beginCaptures:
      "1":
        name: "keyword.control.exception.try.cs"
    end: "(?<=\\})"
    patterns: [
      {
        include: "#comment"
      }
      {
        include: "#block"
      }
    ]
  "finally-clause":
    begin: "(?<!\\.)\\b(finally)\\b"
    beginCaptures:
      "1":
        name: "keyword.control.exception.finally.cs"
    end: "(?<=\\})"
    patterns: [
      {
        include: "#comment"
      }
      {
        include: "#block"
      }
    ]
  "catch-clause":
    begin: "(?<!\\.)\\b(catch)\\b"
    beginCaptures:
      "1":
        name: "keyword.control.exception.catch.cs"
    end: "(?<=\\})"
    patterns: [
      {
        begin: "\\("
        beginCaptures:
          "0":
            name: "punctuation.parenthesis.open.cs"
        end: "\\)"
        endCaptures:
          "0":
            name: "punctuation.parenthesis.close.cs"
        patterns: [
          {
            match: '''
              (?x)
              (?<type_name>
                (?:
                  (?:
                    (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification
                    (?<name_and_type_args> # identifier + type arguments (if any)
                      \\g<identifier>\\s*
                      (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?
                    )
                    (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?
                    (?<tuple>\\s*\\((?:[^\\(\\)]|\\g<tuple>)+\\))
                  )
                  (?:\\s*\\?\\s*)? # nullable suffix?
                  (?:\\s* # array suffix?
                    \\[
                      (?:\\s*,\\s*)* # commata for multi-dimensional arrays
                    \\]
                    \\s*
                    (?:\\?)? # arrays can be nullable reference types
                    \\s*
                  )*
                )
              )\\s*
              (?:(\\g<identifier>)\\b)?
            '''
            captures:
              "1":
                patterns: [
                  {
                    include: "#type"
                  }
                ]
              "6":
                name: "entity.name.variable.local.cs"
          }
        ]
      }
      {
        include: "#when-clause"
      }
      {
        include: "#comment"
      }
      {
        include: "#block"
      }
    ]
  "when-clause":
    begin: "(?<!\\.)\\b(when)\\b\\s*(\\()"
    beginCaptures:
      "1":
        name: "keyword.control.exception.when.cs"
      "2":
        name: "punctuation.parenthesis.open.cs"
    end: "\\)"
    endCaptures:
      "0":
        name: "punctuation.parenthesis.close.cs"
    patterns: [
      {
        include: "#expression"
      }
      {
        include: "#comment"
      }
    ]
  "context-control-statement":
    match: "\\b(checked|unchecked|unsafe)\\b(?!\\s*[@_[:alpha:](])"
    name: "keyword.control.context.$1.cs"
  "context-control-paren-statement":
    patterns: [
      {
        include: "#fixed-statement"
      }
      {
        include: "#lock-statement"
      }
      {
        include: "#using-statement"
      }
    ]
  "fixed-statement":
    begin: "\\b(fixed)\\b"
    beginCaptures:
      "1":
        name: "keyword.control.context.fixed.cs"
    end: "(?<=\\))|(?=;|})"
    patterns: [
      {
        include: "#intrusive"
      }
      {
        begin: "\\("
        beginCaptures:
          "0":
            name: "punctuation.parenthesis.open.cs"
        end: "\\)"
        endCaptures:
          "0":
            name: "punctuation.parenthesis.close.cs"
        patterns: [
          {
            include: "#intrusive"
          }
          {
            include: "#local-variable-declaration"
          }
        ]
      }
    ]
  "lock-statement":
    begin: "\\b(lock)\\b"
    beginCaptures:
      "1":
        name: "keyword.control.context.lock.cs"
    end: "(?<=\\))|(?=;|})"
    patterns: [
      {
        include: "#intrusive"
      }
      {
        begin: "\\("
        beginCaptures:
          "0":
            name: "punctuation.parenthesis.open.cs"
        end: "\\)"
        endCaptures:
          "0":
            name: "punctuation.parenthesis.close.cs"
        patterns: [
          {
            include: "#intrusive"
          }
          {
            include: "#expression"
          }
        ]
      }
    ]
  "using-statement":
    begin: "\\b(using)\\b"
    beginCaptures:
      "1":
        name: "keyword.control.context.using.cs"
    end: "(?<=\\))|(?=;|})"
    patterns: [
      {
        include: "#intrusive"
      }
      {
        begin: "\\("
        beginCaptures:
          "0":
            name: "punctuation.parenthesis.open.cs"
        end: "\\)"
        endCaptures:
          "0":
            name: "punctuation.parenthesis.close.cs"
        patterns: [
          {
            include: "#intrusive"
          }
          {
            include: "#await-expression"
          }
          {
            include: "#local-variable-declaration"
          }
          {
            include: "#expression"
          }
        ]
      }
      {
        include: "#local-variable-declaration"
      }
    ]
  "labeled-statement":
    match: "(@?[_[:alpha:]][_[:alnum:]]*)\\s*(:)"
    captures:
      "1":
        name: "entity.name.label.cs"
      "2":
        name: "punctuation.separator.colon.cs"
  "local-declaration":
    patterns: [
      {
        include: "#local-constant-declaration"
      }
      {
        include: "#local-variable-declaration"
      }
      {
        include: "#local-function-declaration"
      }
      {
        include: "#local-tuple-var-deconstruction"
      }
    ]
  "local-variable-declaration":
    begin: '''
      (?x)
      (?:
        (?:(\\bref)\\s+(?:(\\breadonly)\\s+)?)?(\\bvar\\b)| # ref local
        (?<type_name>
          (?:
            (?:ref\\s+(?:readonly\\s+)?)?   # ref local
            (?:
              (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification
              (?<name_and_type_args> # identifier + type arguments (if any)
                \\g<identifier>\\s*
                (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?
              )
              (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?
              (?<tuple>\\s*\\((?:[^\\(\\)]|\\g<tuple>)+\\))
            )
            (?:\\s*[?*]\\s*)? # nullable or pointer suffix?
            (?:\\s* # array suffix?
              \\[
                (?:\\s*,\\s*)* # commata for multi-dimensional arrays
              \\]
              \\s*
              (?:\\?)? # arrays can be nullable reference types
              \\s*
            )*
          )
        )
      )\\s+
      (\\g<identifier>)\\s*
      (?!=>)
      (?=,|;|=|\\))
    '''
    beginCaptures:
      "1":
        name: "storage.modifier.ref.cs"
      "2":
        name: "storage.modifier.readonly.cs"
      "3":
        name: "storage.type.var.cs"
      "4":
        patterns: [
          {
            include: "#type"
          }
        ]
      "9":
        name: "entity.name.variable.local.cs"
    end: "(?=[;)}])"
    patterns: [
      {
        name: "entity.name.variable.local.cs"
        match: "@?[_[:alpha:]][_[:alnum:]]*"
      }
      {
        include: "#punctuation-comma"
      }
      {
        include: "#comment"
      }
      {
        include: "#variable-initializer"
      }
    ]
  "local-constant-declaration":
    begin: '''
      (?x)
      (?<const_keyword>\\b(?:const)\\b)\\s*
      (?<type_name>
        (?:
          (?:
            (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification
            (?<name_and_type_args> # identifier + type arguments (if any)
              \\g<identifier>\\s*
              (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?
            )
            (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?
            (?<tuple>\\s*\\((?:[^\\(\\)]|\\g<tuple>)+\\))
          )
          (?:\\s*\\?\\s*)? # nullable suffix?
          (?:\\s* # array suffix?
            \\[
              (?:\\s*,\\s*)* # commata for multi-dimensional arrays
            \\]
            \\s*
            (?:\\?)? # arrays can be nullable reference types
            \\s*
          )*
        )
      )\\s+
      (\\g<identifier>)\\s*
      (?=,|;|=)
    '''
    beginCaptures:
      "1":
        name: "storage.modifier.const.cs"
      "2":
        patterns: [
          {
            include: "#type"
          }
        ]
      "7":
        name: "entity.name.variable.local.cs"
    end: "(?=;)"
    patterns: [
      {
        name: "entity.name.variable.local.cs"
        match: "@?[_[:alpha:]][_[:alnum:]]*"
      }
      {
        include: "#punctuation-comma"
      }
      {
        include: "#comment"
      }
      {
        include: "#variable-initializer"
      }
    ]
  "local-function-declaration":
    begin: '''
      (?x)
      \\b((?:(?:async|unsafe|static|extern)\\s+)*)
      (?<type_name>
        (?:ref\\s+(?:readonly\\s+)?)?   # ref return
        (?:
          (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification
          (?<name_and_type_args> # identifier + type arguments (if any)
            \\g<identifier>\\s*
            (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?
          )
          (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?
          (?<tuple>\\s*\\((?:[^\\(\\)]|\\g<tuple>)+\\))
        )
        (?:\\s*\\?)? # nullable suffix?
        (?:\\s* # array suffix?
          \\[
            \\s*(?:,\\s*)* # commata for multi-dimensional arrays
          \\]
          (?:\\s*\\?)? # arrays can be nullable reference types
        )*
      )\\s+
      (\\g<identifier>)\\s*
      (<[^<>]+>)?\\s*
      (?=\\()
    '''
    beginCaptures:
      "1":
        patterns: [
          {
            include: "#storage-modifier"
          }
        ]
      "2":
        patterns: [
          {
            include: "#type"
          }
        ]
      "7":
        name: "entity.name.function.cs"
      "8":
        patterns: [
          {
            include: "#type-parameter-list"
          }
        ]
    end: "(?<=\\})|(?=;)"
    patterns: [
      {
        include: "#comment"
      }
      {
        include: "#parenthesized-parameter-list"
      }
      {
        include: "#generic-constraints"
      }
      {
        include: "#expression-body"
      }
      {
        include: "#block"
      }
    ]
  "local-tuple-var-deconstruction":
    begin: '''
      (?x) # e.g. var (x, y) = GetPoint();
      (?:\\b(var)\\b\\s*)
      (?<tuple>\\((?:[^\\(\\)]|\\g<tuple>)+\\))\\s*
      (?=;|=|\\))
    '''
    beginCaptures:
      "1":
        name: "storage.type.var.cs"
      "2":
        patterns: [
          {
            include: "#tuple-declaration-deconstruction-element-list"
          }
        ]
    end: "(?=;|\\))"
    patterns: [
      {
        include: "#comment"
      }
      {
        include: "#variable-initializer"
      }
    ]
  "tuple-deconstruction-assignment":
    match: '''
      (?x)
      (?<tuple>\\s*\\((?:[^\\(\\)]|\\g<tuple>)+\\))\\s*
      (?!=>|==)(?==)
    '''
    captures:
      "1":
        patterns: [
          {
            include: "#tuple-deconstruction-element-list"
          }
        ]
  "tuple-declaration-deconstruction-element-list":
    begin: "\\("
    beginCaptures:
      "0":
        name: "punctuation.parenthesis.open.cs"
    end: "\\)"
    endCaptures:
      "0":
        name: "punctuation.parenthesis.close.cs"
    patterns: [
      {
        include: "#comment"
      }
      {
        include: "#tuple-declaration-deconstruction-element-list"
      }
      {
        include: "#declaration-expression-tuple"
      }
      {
        include: "#punctuation-comma"
      }
      {
        match: '''
          (?x) # e.g. x
          (@?[_[:alpha:]][_[:alnum:]]*)\\b\\s*
          (?=[,)])
        '''
        captures:
          "1":
            name: "entity.name.variable.tuple-element.cs"
      }
    ]
  "tuple-deconstruction-element-list":
    begin: "\\("
    beginCaptures:
      "0":
        name: "punctuation.parenthesis.open.cs"
    end: "\\)"
    endCaptures:
      "0":
        name: "punctuation.parenthesis.close.cs"
    patterns: [
      {
        include: "#comment"
      }
      {
        include: "#tuple-deconstruction-element-list"
      }
      {
        include: "#declaration-expression-tuple"
      }
      {
        include: "#punctuation-comma"
      }
      {
        match: '''
          (?x) # e.g. x
          (@?[_[:alpha:]][_[:alnum:]]*)\\b\\s*
          (?=[,)])
        '''
        captures:
          "1":
            name: "variable.other.readwrite.cs"
      }
    ]
  "declaration-expression-local":
    match: '''
      (?x) # e.g. int x OR var x
      (?:
        \\b(var)\\b|
        (?<type_name>
          (?:
            (?:
              (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification
              (?<name_and_type_args> # identifier + type arguments (if any)
                \\g<identifier>\\s*
                (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?
              )
              (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?
              (?<tuple>\\s*\\((?:[^\\(\\)]|\\g<tuple>)+\\))
            )
            (?:\\s*\\?\\s*)? # nullable suffix?
            (?:\\s* # array suffix?
              \\[
                (?:\\s*,\\s*)* # commata for multi-dimensional arrays
              \\]
              \\s*
              (?:\\?)? # arrays can be nullable reference types
              \\s*
            )*
          )
        )
      )\\s+
      (\\g<identifier>)\\b\\s*
      (?=[,)\\]])
    '''
    captures:
      "1":
        name: "storage.type.var.cs"
      "2":
        patterns: [
          {
            include: "#type"
          }
        ]
      "7":
        name: "entity.name.variable.local.cs"
  "declaration-expression-tuple":
    match: '''
      (?x) # e.g. int x OR var x
      (?:
        \\b(var)\\b|
        (?<type_name>
          (?:
            (?:
              (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification
              (?<name_and_type_args> # identifier + type arguments (if any)
                \\g<identifier>\\s*
                (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?
              )
              (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?
              (?<tuple>\\s*\\((?:[^\\(\\)]|\\g<tuple>)+\\))
            )
            (?:\\s*\\?\\s*)? # nullable suffix?
                      (?:\\s* # array suffix?
            \\[
              (?:\\s*,\\s*)* # commata for multi-dimensional arrays
            \\]
            \\s*
            (?:\\?)? # arrays can be nullable reference types
            \\s*
          )*
          )
        )
      )\\s+
      (\\g<identifier>)\\b\\s*
      (?=[,)])
    '''
    captures:
      "1":
        name: "storage.type.var.cs"
      "2":
        patterns: [
          {
            include: "#type"
          }
        ]
      "7":
        name: "entity.name.variable.tuple-element.cs"
  "expression-operator-expression":
    begin: "\\b(checked|unchecked|nameof)\\s*(\\()"
    beginCaptures:
      "1":
        name: "keyword.operator.expression.$1.cs"
      "2":
        name: "punctuation.parenthesis.open.cs"
    end: "\\)"
    endCaptures:
      "0":
        name: "punctuation.parenthesis.close.cs"
    patterns: [
      {
        include: "#expression"
      }
    ]
  "type-operator-expression":
    begin: "\\b(default|sizeof|typeof)\\s*(\\()"
    beginCaptures:
      "1":
        name: "keyword.operator.expression.$1.cs"
      "2":
        name: "punctuation.parenthesis.open.cs"
    end: "\\)"
    endCaptures:
      "0":
        name: "punctuation.parenthesis.close.cs"
    patterns: [
      {
        include: "#type"
      }
    ]
  "default-literal-expression":
    match: "\\b(default)\\b"
    captures:
      "1":
        name: "keyword.operator.expression.default.cs"
  "throw-expression":
    match: "\\b(throw)\\b"
    captures:
      "1":
        name: "keyword.control.flow.throw.cs"
  "interpolated-string":
    name: "string.quoted.double.cs"
    begin: "\\$\""
    beginCaptures:
      "0":
        name: "punctuation.definition.string.begin.cs"
    end: "(\")|((?:[^\\\\\\n])$)"
    endCaptures:
      "1":
        name: "punctuation.definition.string.end.cs"
      "2":
        name: "invalid.illegal.newline.cs"
    patterns: [
      {
        include: "#string-character-escape"
      }
      {
        include: "#interpolation"
      }
    ]
  "verbatim-interpolated-string":
    name: "string.quoted.double.cs"
    begin: "(?:\\$@|@\\$)\""
    beginCaptures:
      "0":
        name: "punctuation.definition.string.begin.cs"
    end: "\"(?=[^\"])"
    endCaptures:
      "0":
        name: "punctuation.definition.string.end.cs"
    patterns: [
      {
        include: "#verbatim-string-character-escape"
      }
      {
        include: "#interpolation"
      }
    ]
  interpolation:
    name: "meta.embedded.interpolation.cs"
    begin: "(?<=[^\\{]|^)((?:\\{\\{)*)(\\{)(?=[^\\{])"
    beginCaptures:
      "1":
        name: "string.quoted.double.cs"
      "2":
        name: "punctuation.definition.interpolation.begin.cs"
    end: "\\}"
    endCaptures:
      "0":
        name: "punctuation.definition.interpolation.end.cs"
    patterns: [
      {
        include: "#expression"
      }
    ]
  "raw-interpolated-string":
    patterns: [
      {
        include: "#raw-interpolated-string-five-or-more-quote-one-or-more-interpolation"
      }
      {
        include: "#raw-interpolated-string-three-or-more-quote-three-or-more-interpolation"
      }
      {
        include: "#raw-interpolated-string-quadruple-quote-double-interpolation"
      }
      {
        include: "#raw-interpolated-string-quadruple-quote-single-interpolation"
      }
      {
        include: "#raw-interpolated-string-triple-quote-double-interpolation"
      }
      {
        include: "#raw-interpolated-string-triple-quote-single-interpolation"
      }
    ]
  "raw-interpolated-string-triple-quote-single-interpolation":
    name: "string.quoted.double.cs"
    begin: "\\$\"\"\""
    beginCaptures:
      "0":
        name: "punctuation.definition.string.begin.cs"
    end: "\"\"\""
    endCaptures:
      "0":
        name: "punctuation.definition.string.end.cs"
    patterns: [
      {
        include: "#raw-interpolation"
      }
    ]
  "raw-interpolated-string-triple-quote-double-interpolation":
    name: "string.quoted.double.cs"
    begin: "\\$\\$\"\"\""
    beginCaptures:
      "0":
        name: "punctuation.definition.string.begin.cs"
    end: "\"\"\""
    endCaptures:
      "0":
        name: "punctuation.definition.string.end.cs"
    patterns: [
      {
        include: "#double-raw-interpolation"
      }
    ]
  "raw-interpolated-string-quadruple-quote-single-interpolation":
    name: "string.quoted.double.cs"
    begin: "\\$\"\"\"\""
    beginCaptures:
      "0":
        name: "punctuation.definition.string.begin.cs"
    end: "\"\"\"\""
    endCaptures:
      "0":
        name: "punctuation.definition.string.end.cs"
    patterns: [
      {
        include: "#raw-interpolation"
      }
    ]
  "raw-interpolated-string-quadruple-quote-double-interpolation":
    name: "string.quoted.double.cs"
    begin: "\\$\\$\"\"\"\""
    beginCaptures:
      "0":
        name: "punctuation.definition.string.begin.cs"
    end: "\"\"\"\""
    endCaptures:
      "0":
        name: "punctuation.definition.string.end.cs"
    patterns: [
      {
        include: "#double-raw-interpolation"
      }
    ]
  "raw-interpolated-string-three-or-more-quote-three-or-more-interpolation":
    name: "string.quoted.double.cs"
    begin: "\\$\\$\\$+\"\"\"+"
    beginCaptures:
      "0":
        name: "punctuation.definition.string.begin.cs"
    end: "\"\"\"+"
    endCaptures:
      "0":
        name: "punctuation.definition.string.end.cs"
  "raw-interpolated-string-five-or-more-quote-one-or-more-interpolation":
    name: "string.quoted.double.cs"
    begin: "\\$+\"\"\"\"\"+"
    beginCaptures:
      "0":
        name: "punctuation.definition.string.begin.cs"
    end: "\"\"\"\"\"+"
    endCaptures:
      "0":
        name: "punctuation.definition.string.end.cs"
  "raw-interpolation":
    name: "meta.embedded.interpolation.cs"
    begin: "(?<=[^\\{]|^)((?:\\{)*)(\\{)(?=[^\\{])"
    beginCaptures:
      "1":
        name: "string.quoted.double.cs"
      "2":
        name: "punctuation.definition.interpolation.begin.cs"
    end: "\\}"
    endCaptures:
      "0":
        name: "punctuation.definition.interpolation.end.cs"
    patterns: [
      {
        include: "#expression"
      }
    ]
  "double-raw-interpolation":
    name: "meta.embedded.interpolation.cs"
    begin: "(?<=[^\\{][^\\{]|^)((?:\\{)*)(\\{\\{)(?=[^\\{])"
    beginCaptures:
      "1":
        name: "string.quoted.double.cs"
      "2":
        name: "punctuation.definition.interpolation.begin.cs"
    end: "\\}\\}"
    endCaptures:
      "0":
        name: "punctuation.definition.interpolation.end.cs"
    patterns: [
      {
        include: "#expression"
      }
    ]
  literal:
    patterns: [
      {
        include: "#boolean-literal"
      }
      {
        include: "#null-literal"
      }
      {
        include: "#numeric-literal"
      }
      {
        include: "#char-literal"
      }
      {
        include: "#raw-string-literal"
      }
      {
        include: "#string-literal"
      }
      {
        include: "#verbatim-string-literal"
      }
      {
        include: "#tuple-literal"
      }
    ]
  "boolean-literal":
    patterns: [
      {
        name: "constant.language.boolean.true.cs"
        match: "(?<!\\.)\\btrue\\b"
      }
      {
        name: "constant.language.boolean.false.cs"
        match: "(?<!\\.)\\bfalse\\b"
      }
    ]
  "null-literal":
    name: "constant.language.null.cs"
    match: "(?<!\\.)\\bnull\\b"
  "numeric-literal":
    match: "(?<!\\w)\\.?\\d(?:(?:[0-9a-zA-Z_]|_)|(?<=[eE])[+-]|\\.\\d)*"
    captures:
      "0":
        patterns: [
          {
            begin: "(?=.)"
            end: "$"
            patterns: [
              {
                match: "(\\G(?=[0-9.])(?!0[xXbB]))([0-9](?:[0-9]|((?<=[0-9a-fA-F])_(?=[0-9a-fA-F])))*)?((?:(?<=[0-9])|\\.(?=[0-9])))([0-9](?:[0-9]|((?<=[0-9a-fA-F])_(?=[0-9a-fA-F])))*)?((?<!_)([eE])(\\+?)(\\-?)((?:[0-9](?:[0-9]|(?:(?<=[0-9a-fA-F])_(?=[0-9a-fA-F])))*)))?([fFdDmM](?!\\w))?$"
                captures:
                  "2":
                    name: "constant.numeric.decimal.cs"
                    patterns: [
                      {
                        match: "(?<=[0-9a-fA-F])_(?=[0-9a-fA-F])"
                        name: "constant.numeric.other.separator.thousands.cs"
                      }
                    ]
                  "3":
                    name: "constant.numeric.other.separator.thousands.cs"
                  "4":
                    name: "constant.numeric.other.separator.decimals.cs"
                  "5":
                    name: "constant.numeric.decimal.cs"
                    patterns: [
                      {
                        match: "(?<=[0-9a-fA-F])_(?=[0-9a-fA-F])"
                        name: "constant.numeric.other.separator.thousands.cs"
                      }
                    ]
                  "6":
                    name: "constant.numeric.other.separator.thousands.cs"
                  "8":
                    name: "constant.numeric.other.exponent.cs"
                  "9":
                    name: "keyword.operator.arithmetic.cs"
                  "10":
                    name: "keyword.operator.arithmetic.cs"
                  "11":
                    name: "constant.numeric.decimal.cs"
                    patterns: [
                      {
                        match: "(?<=[0-9a-fA-F])_(?=[0-9a-fA-F])"
                        name: "constant.numeric.other.separator.thousands.cs"
                      }
                    ]
                  "12":
                    name: "constant.numeric.other.suffix.cs"
              }
              {
                match: "(\\G0[bB])([01_](?:[01_]|((?<=[0-9a-fA-F])_(?=[0-9a-fA-F])))*)((?:(?:(?:(?:(?:[uU]|[uU]l)|[uU]L)|l[uU]?)|L[uU]?)|[fFdDmM])(?!\\w))?$"
                captures:
                  "1":
                    name: "constant.numeric.other.preffix.binary.cs"
                  "2":
                    name: "constant.numeric.binary.cs"
                    patterns: [
                      {
                        match: "(?<=[0-9a-fA-F])_(?=[0-9a-fA-F])"
                        name: "constant.numeric.other.separator.thousands.cs"
                      }
                    ]
                  "3":
                    name: "constant.numeric.other.separator.thousands.cs"
                  "4":
                    name: "constant.numeric.other.suffix.cs"
              }
              {
                match: "(\\G0[xX])([0-9a-fA-F](?:[0-9a-fA-F]|((?<=[0-9a-fA-F])_(?=[0-9a-fA-F])))*)((?:(?:(?:(?:(?:[uU]|[uU]l)|[uU]L)|l[uU]?)|L[uU]?)|[fFdDmM])(?!\\w))?$"
                captures:
                  "1":
                    name: "constant.numeric.other.preffix.hex.cs"
                  "2":
                    name: "constant.numeric.hex.cs"
                    patterns: [
                      {
                        match: "(?<=[0-9a-fA-F])_(?=[0-9a-fA-F])"
                        name: "constant.numeric.other.separator.thousands.cs"
                      }
                    ]
                  "3":
                    name: "constant.numeric.other.separator.thousands.cs"
                  "4":
                    name: "constant.numeric.other.suffix.cs"
              }
              {
                match: "(\\G(?=[0-9.])(?!0[xXbB]))([0-9](?:[0-9]|((?<=[0-9a-fA-F])_(?=[0-9a-fA-F])))*)((?<!_)([eE])(\\+?)(\\-?)((?:[0-9](?:[0-9]|(?:(?<=[0-9a-fA-F])_(?=[0-9a-fA-F])))*)))?((?:(?:(?:(?:(?:[uU]|[uU]l)|[uU]L)|l[uU]?)|L[uU]?)|[fFdDmM])(?!\\w))?$"
                captures:
                  "2":
                    name: "constant.numeric.decimal.cs"
                    patterns: [
                      {
                        match: "(?<=[0-9a-fA-F])_(?=[0-9a-fA-F])"
                        name: "constant.numeric.other.separator.thousands.cs"
                      }
                    ]
                  "3":
                    name: "constant.numeric.other.separator.thousands.cs"
                  "5":
                    name: "constant.numeric.other.exponent.cs"
                  "6":
                    name: "keyword.operator.arithmetic.cs"
                  "7":
                    name: "keyword.operator.arithmetic.cs"
                  "8":
                    name: "constant.numeric.decimal.cs"
                    patterns: [
                      {
                        match: "(?<=[0-9a-fA-F])_(?=[0-9a-fA-F])"
                        name: "constant.numeric.other.separator.thousands.cs"
                      }
                    ]
                  "9":
                    name: "constant.numeric.other.suffix.cs"
              }
              {
                match: "(?:(?:[0-9a-zA-Z_]|_)|(?<=[eE])[+-]|\\.\\d)+"
                name: "invalid.illegal.constant.numeric.cs"
              }
            ]
          }
        ]
  "char-literal":
    name: "string.quoted.single.cs"
    begin: "'"
    beginCaptures:
      "0":
        name: "punctuation.definition.char.begin.cs"
    end: "(\\')|((?:[^\\\\\\n])$)"
    endCaptures:
      "1":
        name: "punctuation.definition.char.end.cs"
      "2":
        name: "invalid.illegal.newline.cs"
    patterns: [
      {
        include: "#char-character-escape"
      }
    ]
  "char-character-escape":
    name: "constant.character.escape.cs"
    match: "\\\\(x[0-9a-fA-F]{1,4}|u[0-9a-fA-F]{4}|.)"
  "string-literal":
    name: "string.quoted.double.cs"
    begin: "(?<!@)\""
    beginCaptures:
      "0":
        name: "punctuation.definition.string.begin.cs"
    end: "(\")|((?:[^\\\\\\n])$)"
    endCaptures:
      "1":
        name: "punctuation.definition.string.end.cs"
      "2":
        name: "invalid.illegal.newline.cs"
    patterns: [
      {
        include: "#string-character-escape"
      }
    ]
  "string-character-escape":
    name: "constant.character.escape.cs"
    match: "\\\\(x[0-9a-fA-F]{1,4}|U[0-9a-fA-F]{8}|u[0-9a-fA-F]{4}|.)"
  "verbatim-string-literal":
    name: "string.quoted.double.cs"
    begin: "@\""
    beginCaptures:
      "0":
        name: "punctuation.definition.string.begin.cs"
    end: "\"(?=[^\"])"
    endCaptures:
      "0":
        name: "punctuation.definition.string.end.cs"
    patterns: [
      {
        include: "#verbatim-string-character-escape"
      }
    ]
  "verbatim-string-character-escape":
    name: "constant.character.escape.cs"
    match: "\"\""
  "raw-string-literal":
    patterns: [
      {
        include: "#raw-string-literal-more"
      }
      {
        include: "#raw-string-literal-quadruple"
      }
      {
        include: "#raw-string-literal-triple"
      }
    ]
  "raw-string-literal-triple":
    name: "string.quoted.double.cs"
    begin: "\"\"\""
    beginCaptures:
      "0":
        name: "punctuation.definition.string.begin.cs"
    end: "\"\"\""
    endCaptures:
      "0":
        name: "punctuation.definition.string.end.cs"
  "raw-string-literal-quadruple":
    name: "string.quoted.double.cs"
    begin: "\"\"\"\""
    beginCaptures:
      "0":
        name: "punctuation.definition.string.begin.cs"
    end: "\"\"\"\""
    endCaptures:
      "0":
        name: "punctuation.definition.string.end.cs"
  "raw-string-literal-more":
    name: "string.quoted.double.cs"
    begin: "\"\"\"\"\"+"
    beginCaptures:
      "0":
        name: "punctuation.definition.string.begin.cs"
    end: "\"\"\"\"\"+"
    endCaptures:
      "0":
        name: "punctuation.definition.string.end.cs"
  "tuple-literal":
    begin: "(\\()(?=.*[:,])"
    beginCaptures:
      "1":
        name: "punctuation.parenthesis.open.cs"
    end: "\\)"
    endCaptures:
      "0":
        name: "punctuation.parenthesis.close.cs"
    patterns: [
      {
        include: "#comment"
      }
      {
        include: "#tuple-literal-element"
      }
      {
        include: "#expression"
      }
      {
        include: "#punctuation-comma"
      }
    ]
  "tuple-literal-element":
    begin: '''
      (?x)
      (@?[_[:alpha:]][_[:alnum:]]*)\\s*
      (?=:)
    '''
    beginCaptures:
      "1":
        name: "entity.name.variable.tuple-element.cs"
    end: "(:)"
    endCaptures:
      "0":
        name: "punctuation.separator.colon.cs"
  "assignment-expression":
    begin: "(?:\\*|/|%|\\+|-|\\?\\?|\\&|\\^|<<|>>>?|\\|)?=(?!=|>)"
    beginCaptures:
      "0":
        patterns: [
          {
            include: "#assignment-operators"
          }
        ]
    end: "(?=[,\\)\\];}])"
    patterns: [
      {
        include: "#ref-modifier"
      }
      {
        include: "#expression"
      }
    ]
  "assignment-operators":
    patterns: [
      {
        name: "keyword.operator.assignment.compound.cs"
        match: "\\*=|/=|%=|\\+=|-=|\\?\\?="
      }
      {
        name: "keyword.operator.assignment.compound.bitwise.cs"
        match: "\\&=|\\^=|<<=|>>>?=|\\|="
      }
      {
        name: "keyword.operator.assignment.cs"
        match: "\\="
      }
    ]
  "expression-operators":
    patterns: [
      {
        name: "keyword.operator.bitwise.shift.cs"
        match: "<<|>>>?"
      }
      {
        name: "keyword.operator.comparison.cs"
        match: "==|!="
      }
      {
        name: "keyword.operator.relational.cs"
        match: "<=|>=|<|>"
      }
      {
        name: "keyword.operator.logical.cs"
        match: "\\!|&&|\\|\\|"
      }
      {
        name: "keyword.operator.bitwise.cs"
        match: "\\&|~|\\^|\\|"
      }
      {
        name: "keyword.operator.decrement.cs"
        match: "--"
      }
      {
        name: "keyword.operator.increment.cs"
        match: "\\+\\+"
      }
      {
        name: "keyword.operator.arithmetic.cs"
        match: "\\+|-(?!>)|\\*|/|%"
      }
      {
        name: "keyword.operator.null-coalescing.cs"
        match: "\\?\\?"
      }
      {
        name: "keyword.operator.range.cs"
        match: "\\.\\."
      }
    ]
  "with-expression":
    begin: "(?<!\\.)\\b(with)\\b\\s*(?=\\{|//|/\\*|$)"
    beginCaptures:
      "1":
        name: "keyword.operator.expression.with.cs"
    end: "(?<=\\})"
    patterns: [
      {
        include: "#comment"
      }
      {
        include: "#initializer-expression"
      }
    ]
  "conditional-operator":
    patterns: [
      {
        name: "keyword.operator.conditional.question-mark.cs"
        match: "\\?(?!\\?|\\s*[.\\[])"
      }
      {
        name: "keyword.operator.conditional.colon.cs"
        match: ":"
      }
    ]
  "await-expression":
    name: "keyword.operator.expression.await.cs"
    match: "(?<!\\.\\s*)\\b(await)\\b"
  "parenthesized-expression":
    begin: "\\("
    beginCaptures:
      "0":
        name: "punctuation.parenthesis.open.cs"
    end: "\\)"
    endCaptures:
      "0":
        name: "punctuation.parenthesis.close.cs"
    patterns: [
      {
        include: "#expression"
      }
    ]
  "initializer-expression":
    begin: "\\{"
    beginCaptures:
      "0":
        name: "punctuation.curlybrace.open.cs"
    end: "\\}"
    endCaptures:
      "0":
        name: "punctuation.curlybrace.close.cs"
    patterns: [
      {
        include: "#expression"
      }
      {
        include: "#punctuation-comma"
      }
    ]
  identifier:
    name: "variable.other.readwrite.cs"
    match: "@?[_[:alpha:]][_[:alnum:]]*"
  "cast-expression":
    match: '''
      (?x)
      (\\()\\s*
      (?<type_name>
        (?:
          (?:
            (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification
            (?<name_and_type_args> # identifier + type arguments (if any)
              \\g<identifier>\\s*
              (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?
            )
            (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?
            (?<tuple>\\s*\\((?:[^\\(\\)]|\\g<tuple>)+\\))
          )
          (?:\\s*\\?\\s*)? # nullable suffix?
          (?:\\s* # array suffix?
            \\[
              (?:\\s*,\\s*)* # commata for multi-dimensional arrays
            \\]
            \\s*
            (?:\\?)? # arrays can be nullable reference types
            \\s*
          )*
        )
      )\\s*
      (\\))(?=\\s*-*!*@?[_[:alnum:]\\(])
    '''
    captures:
      "1":
        name: "punctuation.parenthesis.open.cs"
      "2":
        patterns: [
          {
            include: "#type"
          }
        ]
      "7":
        name: "punctuation.parenthesis.close.cs"
  "as-expression":
    match: '''
      (?x)
      (?<!\\.)\\b(as)\\b\\s*
      (?<type_name>
        (?:
          (?:
            (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification
            (?<name_and_type_args> # identifier + type arguments (if any)
              \\g<identifier>\\s*
              (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?
            )
            (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?
            (?<tuple>\\s*\\((?:[^\\(\\)]|\\g<tuple>)+\\))
          )
          (?:\\s*\\?(?!\\?))? # nullable suffix?
          (?:\\s* # array suffix?
            \\[
              \\s*(?:,\\s*)* # commata for multi-dimensional arrays
            \\]
            (?:\\s*\\?(?!\\?))? # arrays can be nullable reference types
          )*
        )
      )?
    '''
    captures:
      "1":
        name: "keyword.operator.expression.as.cs"
      "2":
        patterns: [
          {
            include: "#type"
          }
        ]
  "language-variable":
    patterns: [
      {
        name: "variable.language.$1.cs"
        match: "\\b(base|this)\\b"
      }
      {
        name: "variable.other.$1.cs"
        match: "\\b(value)\\b"
      }
    ]
  "invocation-expression":
    begin: '''
      (?x)
      (?:
        (?:(\\?)\\s*)?                                    # preceding null-conditional operator?
        (\\.)\\s*|                                        # preceding dot?
        (->)\\s*                                         # preceding pointer arrow?
      )?
      (@?[_[:alpha:]][_[:alnum:]]*)\\s*                  # method name
      (
        <
        (?<type_args>
          [^<>()]|
          \\((?:[^<>()]|<[^<>()]*>|\\([^<>()]*\\))*\\)|
          <\\g<type_args>*>
        )*
        >\\s*
      )?                                                # type arguments
      (?=\\()                                            # open paren of argument list
    '''
    beginCaptures:
      "1":
        name: "keyword.operator.null-conditional.cs"
      "2":
        name: "punctuation.accessor.cs"
      "3":
        name: "punctuation.accessor.pointer.cs"
      "4":
        name: "entity.name.function.cs"
      "5":
        patterns: [
          {
            include: "#type-arguments"
          }
        ]
    end: "(?<=\\))"
    patterns: [
      {
        include: "#argument-list"
      }
    ]
  "element-access-expression":
    begin: '''
      (?x)
      (?:
        (?:(\\?)\\s*)?  # preceding null-conditional operator?
        (\\.)\\s*|      # preceding dot?
        (->)\\s*       # preceding pointer arrow?
      )?
      (?:(@?[_[:alpha:]][_[:alnum:]]*)\\s*)? # property name
      (?:(\\?)\\s*)?                        # null-conditional operator?
      (?=\\[)                              # open bracket of argument list
    '''
    beginCaptures:
      "1":
        name: "keyword.operator.null-conditional.cs"
      "2":
        name: "punctuation.accessor.cs"
      "3":
        name: "punctuation.accessor.pointer.cs"
      "4":
        name: "variable.other.object.property.cs"
      "5":
        name: "keyword.operator.null-conditional.cs"
    end: "(?<=\\])(?!\\s*\\[)"
    patterns: [
      {
        include: "#bracketed-argument-list"
      }
    ]
  "member-access-expression":
    patterns: [
      {
        match: '''
          (?x)
          (?:
            (?:(\\?)\\s*)?                    # preceding null-conditional operator?
            (\\.)\\s*|                        # preceding dot?
            (->)\\s*                         # preceding pointer arrow?
          )
          (@?[_[:alpha:]][_[:alnum:]]*)\\s*  # property name
          (?![_[:alnum:]]|\\(|(\\?)?\\[|<)     # next character is not alpha-numeric, nor a (, [, or <. Also, test for ?[
        '''
        captures:
          "1":
            name: "keyword.operator.null-conditional.cs"
          "2":
            name: "punctuation.accessor.cs"
          "3":
            name: "punctuation.accessor.pointer.cs"
          "4":
            name: "variable.other.object.property.cs"
      }
      {
        match: '''
          (?x)
          (\\.)?\\s*
          (@?[_[:alpha:]][_[:alnum:]]*)
          (?<type_params>\\s*<([^<>]|\\g<type_params>)+>\\s*)
          (?=
            (\\s*\\?)?
            \\s*\\.\\s*@?[_[:alpha:]][_[:alnum:]]*
          )
        '''
        captures:
          "1":
            name: "punctuation.accessor.cs"
          "2":
            name: "variable.other.object.cs"
          "3":
            patterns: [
              {
                include: "#type-arguments"
              }
            ]
      }
      {
        match: '''
          (?x)
          (@?[_[:alpha:]][_[:alnum:]]*)
          (?=
            \\s*(?:(?:\\?\\s*)?\\.|->)
            \\s*@?[_[:alpha:]][_[:alnum:]]*
          )
        '''
        captures:
          "1":
            name: "variable.other.object.cs"
      }
    ]
  "object-creation-expression":
    patterns: [
      {
        include: "#object-creation-expression-with-parameters"
      }
      {
        include: "#object-creation-expression-with-no-parameters"
      }
    ]
  "object-creation-expression-with-parameters":
    begin: '''
      (?x)
      (new)(?:\\s+
      (?<type_name>
        (?:
          (?:
            (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification
            (?<name_and_type_args> # identifier + type arguments (if any)
              \\g<identifier>\\s*
              (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?
            )
            (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?
            (?<tuple>\\s*\\((?:[^\\(\\)]|\\g<tuple>)+\\))
          )
          (?:\\s*\\?\\s*)? # nullable suffix?
          (?:\\s* # array suffix?
            \\[
              (?:\\s*,\\s*)* # commata for multi-dimensional arrays
            \\]
            \\s*
            (?:\\?)? # arrays can be nullable reference types
            \\s*
          )*
        )
      ))?\\s*
      (?=\\()
    '''
    beginCaptures:
      "1":
        name: "keyword.operator.expression.new.cs"
      "2":
        patterns: [
          {
            include: "#type"
          }
        ]
    end: "(?<=\\))"
    patterns: [
      {
        include: "#argument-list"
      }
    ]
  "object-creation-expression-with-no-parameters":
    match: '''
      (?x)
      (new)\\s+
      (?<type_name>
        (?:
          (?:
            (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification
            (?<name_and_type_args> # identifier + type arguments (if any)
              \\g<identifier>\\s*
              (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?
            )
            (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?
            (?<tuple>\\s*\\((?:[^\\(\\)]|\\g<tuple>)+\\))
          )
          (?:\\s*\\?\\s*)? # nullable suffix?
          (?:\\s* # array suffix?
            \\[
              (?:\\s*,\\s*)* # commata for multi-dimensional arrays
            \\]
            \\s*
            (?:\\?)? # arrays can be nullable reference types
            \\s*
          )*
        )
      )\\s*
      (?=\\{|//|/\\*|$)
    '''
    captures:
      "1":
        name: "keyword.operator.expression.new.cs"
      "2":
        patterns: [
          {
            include: "#type"
          }
        ]
  "array-creation-expression":
    begin: '''
      (?x)
      \\b(new|stackalloc)\\b\\s*
      (?<type_name>
        (?:
          (?:
            (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification
            (?<name_and_type_args> # identifier + type arguments (if any)
              \\g<identifier>\\s*
              (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?
            )
            (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?
            (?<tuple>\\s*\\((?:[^\\(\\)]|\\g<tuple>)+\\))
          )
          (?:\\s*\\?\\s*)? # nullable suffix?
          (?:\\s* # array suffix?
            \\[
              (?:\\s*,\\s*)* # commata for multi-dimensional arrays
            \\]
            \\s*
            (?:\\?)? # arrays can be nullable reference types
            \\s*
          )*
        )
      )?\\s*
      (?=\\[)
    '''
    beginCaptures:
      "1":
        name: "keyword.operator.expression.$1.cs"
      "2":
        patterns: [
          {
            include: "#type"
          }
        ]
    end: "(?<=\\])"
    patterns: [
      {
        include: "#bracketed-argument-list"
      }
    ]
  "anonymous-object-creation-expression":
    begin: "\\b(new)\\b\\s*(?=\\{|//|/\\*|$)"
    beginCaptures:
      "1":
        name: "keyword.operator.expression.new.cs"
    end: "(?<=\\})"
    patterns: [
      {
        include: "#comment"
      }
      {
        include: "#initializer-expression"
      }
    ]
  "bracketed-parameter-list":
    begin: "(?=(\\[))"
    beginCaptures:
      "1":
        name: "punctuation.squarebracket.open.cs"
    end: "(?=(\\]))"
    endCaptures:
      "1":
        name: "punctuation.squarebracket.close.cs"
    patterns: [
      {
        begin: "(?<=\\[)"
        end: "(?=\\])"
        patterns: [
          {
            include: "#comment"
          }
          {
            include: "#attribute-section"
          }
          {
            include: "#parameter"
          }
          {
            include: "#punctuation-comma"
          }
          {
            include: "#variable-initializer"
          }
        ]
      }
    ]
  "parenthesized-parameter-list":
    begin: "(\\()"
    beginCaptures:
      "0":
        name: "punctuation.parenthesis.open.cs"
    end: "(\\))"
    endCaptures:
      "0":
        name: "punctuation.parenthesis.close.cs"
    patterns: [
      {
        include: "#comment"
      }
      {
        include: "#attribute-section"
      }
      {
        include: "#parameter"
      }
      {
        include: "#punctuation-comma"
      }
      {
        include: "#variable-initializer"
      }
    ]
  parameter:
    match: '''
      (?x)
      (?:(?:\\b(ref|params|out|in|this)\\b)\\s+)?
      (?<type_name>
        (?:
          (?:ref\\s+)?   # ref return
          (?:
            (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification
            (?<name_and_type_args> # identifier + type arguments (if any)
              \\g<identifier>\\s*
              (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?
            )
            (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?
            (?<tuple>\\s*\\((?:[^()]|\\g<tuple>)+\\))
          )
          (?:\\s*\\?\\s*)? # nullable suffix?
          (?:\\s* # array suffix?
            \\[
              (?:\\s*,\\s*)* # commata for multi-dimensional arrays
            \\]
            \\s*
            (?:\\?)? # arrays can be nullable reference types
            \\s*
          )*
        )
      )\\s+
      (\\g<identifier>)
    '''
    captures:
      "1":
        name: "storage.modifier.$1.cs"
      "2":
        patterns: [
          {
            include: "#type"
          }
        ]
      "7":
        name: "entity.name.variable.parameter.cs"
  "argument-list":
    begin: "\\("
    beginCaptures:
      "0":
        name: "punctuation.parenthesis.open.cs"
    end: "\\)"
    endCaptures:
      "0":
        name: "punctuation.parenthesis.close.cs"
    patterns: [
      {
        include: "#named-argument"
      }
      {
        include: "#argument"
      }
      {
        include: "#punctuation-comma"
      }
    ]
  "bracketed-argument-list":
    begin: "\\["
    beginCaptures:
      "0":
        name: "punctuation.squarebracket.open.cs"
    end: "\\]"
    endCaptures:
      "0":
        name: "punctuation.squarebracket.close.cs"
    patterns: [
      {
        include: "#named-argument"
      }
      {
        include: "#argument"
      }
      {
        include: "#punctuation-comma"
      }
    ]
  "named-argument":
    begin: "(@?[_[:alpha:]][_[:alnum:]]*)\\s*(:)"
    beginCaptures:
      "1":
        name: "entity.name.variable.parameter.cs"
      "2":
        name: "punctuation.separator.colon.cs"
    end: "(?=(,|\\)|\\]))"
    patterns: [
      {
        include: "#argument"
      }
    ]
  argument:
    patterns: [
      {
        name: "storage.modifier.$1.cs"
        match: "\\b(ref|in)\\b"
      }
      {
        begin: "\\b(out)\\b"
        beginCaptures:
          "1":
            name: "storage.modifier.out.cs"
        end: "(?=,|\\)|\\])"
        patterns: [
          {
            include: "#declaration-expression-local"
          }
          {
            include: "#expression"
          }
        ]
      }
      {
        include: "#expression"
      }
    ]
  "query-expression":
    begin: '''
      (?x)
      \\b(from)\\b\\s*
      (?<type_name>
        (?:
          (?:
            (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification
            (?<name_and_type_args> # identifier + type arguments (if any)
              \\g<identifier>\\s*
              (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?
            )
            (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?
            (?<tuple>\\s*\\((?:[^\\(\\)]|\\g<tuple>)+\\))
          )
          (?:\\s*\\?\\s*)? # nullable suffix?
          (?:\\s* # array suffix?
            \\[
              (?:\\s*,\\s*)* # commata for multi-dimensional arrays
            \\]
            \\s*
            (?:\\?)? # arrays can be nullable reference types
            \\s*
          )*
        )
      )?
      \\s+(\\g<identifier>)\\b\\s*
      \\b(in)\\b\\s*
    '''
    beginCaptures:
      "1":
        name: "keyword.operator.expression.query.from.cs"
      "2":
        patterns: [
          {
            include: "#type"
          }
        ]
      "7":
        name: "entity.name.variable.range-variable.cs"
      "8":
        name: "keyword.operator.expression.query.in.cs"
    end: "(?=;|\\))"
    patterns: [
      {
        include: "#query-body"
      }
      {
        include: "#expression"
      }
    ]
  "query-body":
    patterns: [
      {
        include: "#let-clause"
      }
      {
        include: "#where-clause"
      }
      {
        include: "#join-clause"
      }
      {
        include: "#orderby-clause"
      }
      {
        include: "#select-clause"
      }
      {
        include: "#group-clause"
      }
    ]
  "let-clause":
    begin: '''
      (?x)
      \\b(let)\\b\\s*
      (@?[_[:alpha:]][_[:alnum:]]*)\\b\\s*
      (=)\\s*
    '''
    beginCaptures:
      "1":
        name: "keyword.operator.expression.query.let.cs"
      "2":
        name: "entity.name.variable.range-variable.cs"
      "3":
        name: "keyword.operator.assignment.cs"
    end: "(?=;|\\))"
    patterns: [
      {
        include: "#query-body"
      }
      {
        include: "#expression"
      }
    ]
  "where-clause":
    begin: '''
      (?x)
      \\b(where)\\b\\s*
    '''
    beginCaptures:
      "1":
        name: "keyword.operator.expression.query.where.cs"
    end: "(?=;|\\))"
    patterns: [
      {
        include: "#query-body"
      }
      {
        include: "#expression"
      }
    ]
  "join-clause":
    begin: '''
      (?x)
      \\b(join)\\b\\s*
      (?<type_name>
        (?:
          (?:
            (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification
            (?<name_and_type_args> # identifier + type arguments (if any)
              \\g<identifier>\\s*
              (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?
            )
            (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?
            (?<tuple>\\s*\\((?:[^\\(\\)]|\\g<tuple>)+\\))
          )
          (?:\\s*\\?\\s*)? # nullable suffix?
          (?:\\s* # array suffix?
            \\[
              (?:\\s*,\\s*)* # commata for multi-dimensional arrays
            \\]
            \\s*
            (?:\\?)? # arrays can be nullable reference types
            \\s*
          )*
        )
      )?
      \\s+(\\g<identifier>)\\b\\s*
      \\b(in)\\b\\s*
    '''
    beginCaptures:
      "1":
        name: "keyword.operator.expression.query.join.cs"
      "2":
        patterns: [
          {
            include: "#type"
          }
        ]
      "7":
        name: "entity.name.variable.range-variable.cs"
      "8":
        name: "keyword.operator.expression.query.in.cs"
    end: "(?=;|\\))"
    patterns: [
      {
        include: "#join-on"
      }
      {
        include: "#join-equals"
      }
      {
        include: "#join-into"
      }
      {
        include: "#query-body"
      }
      {
        include: "#expression"
      }
    ]
  "join-on":
    match: "\\b(on)\\b\\s*"
    captures:
      "1":
        name: "keyword.operator.expression.query.on.cs"
  "join-equals":
    match: "\\b(equals)\\b\\s*"
    captures:
      "1":
        name: "keyword.operator.expression.query.equals.cs"
  "join-into":
    match: '''
      (?x)
      \\b(into)\\b\\s*
      (@?[_[:alpha:]][_[:alnum:]]*)\\b\\s*
    '''
    captures:
      "1":
        name: "keyword.operator.expression.query.into.cs"
      "2":
        name: "entity.name.variable.range-variable.cs"
  "orderby-clause":
    begin: "\\b(orderby)\\b\\s*"
    beginCaptures:
      "1":
        name: "keyword.operator.expression.query.orderby.cs"
    end: "(?=;|\\))"
    patterns: [
      {
        include: "#ordering-direction"
      }
      {
        include: "#query-body"
      }
      {
        include: "#expression"
      }
      {
        include: "#punctuation-comma"
      }
    ]
  "ordering-direction":
    match: "\\b(ascending|descending)\\b"
    captures:
      "1":
        name: "keyword.operator.expression.query.$1.cs"
  "select-clause":
    begin: "\\b(select)\\b\\s*"
    beginCaptures:
      "1":
        name: "keyword.operator.expression.query.select.cs"
    end: "(?=;|\\))"
    patterns: [
      {
        include: "#query-body"
      }
      {
        include: "#expression"
      }
    ]
  "group-clause":
    begin: "\\b(group)\\b\\s*"
    beginCaptures:
      "1":
        name: "keyword.operator.expression.query.group.cs"
    end: "(?=;|\\))"
    patterns: [
      {
        include: "#group-by"
      }
      {
        include: "#group-into"
      }
      {
        include: "#query-body"
      }
      {
        include: "#expression"
      }
    ]
  "group-by":
    match: "\\b(by)\\b\\s*"
    captures:
      "1":
        name: "keyword.operator.expression.query.by.cs"
  "group-into":
    match: '''
      (?x)
      \\b(into)\\b\\s*
      (@?[_[:alpha:]][_[:alnum:]]*)\\b\\s*
    '''
    captures:
      "1":
        name: "keyword.operator.expression.query.into.cs"
      "2":
        name: "entity.name.variable.range-variable.cs"
  "anonymous-method-expression":
    patterns: [
      {
        begin: '''
          (?x)
          ((?:\\b(?:async|static)\\b\\s*)*)
          (?:
            (@?[_[:alpha:]][_[:alnum:]]*)\\b|
            (\\()
              (?<tuple>(?:[^()]|\\(\\g<tuple>\\))*)
            (\\))
          )\\s*
          (=>)
        '''
        beginCaptures:
          "1":
            patterns: [
              {
                match: "async|static"
                name: "storage.modifier.$0.cs"
              }
            ]
          "2":
            name: "entity.name.variable.parameter.cs"
          "3":
            name: "punctuation.parenthesis.open.cs"
          "4":
            patterns: [
              {
                include: "#comment"
              }
              {
                include: "#explicit-anonymous-function-parameter"
              }
              {
                include: "#implicit-anonymous-function-parameter"
              }
              {
                include: "#default-argument"
              }
              {
                include: "#punctuation-comma"
              }
            ]
          "5":
            name: "punctuation.parenthesis.close.cs"
          "6":
            name: "keyword.operator.arrow.cs"
        end: "(?=[,;)}])"
        patterns: [
          {
            include: "#intrusive"
          }
          {
            begin: "(?={)"
            end: "(?=[,;)}])"
            patterns: [
              {
                include: "#block"
              }
              {
                include: "#intrusive"
              }
            ]
          }
          {
            begin: "\\b(ref)\\b|(?=\\S)"
            beginCaptures:
              "1":
                name: "storage.modifier.ref.cs"
            end: "(?=[,;)}])"
            patterns: [
              {
                include: "#expression"
              }
            ]
          }
        ]
      }
      {
        begin: '''
          (?x)
          ((?:\\b(?:async|static)\\b\\s*)*)
          \\b(delegate)\\b\\s*
        '''
        beginCaptures:
          "1":
            patterns: [
              {
                match: "async|static"
                name: "storage.modifier.$0.cs"
              }
            ]
          "2":
            name: "storage.type.delegate.cs"
        end: "(?<=})|(?=[,;)}])"
        patterns: [
          {
            include: "#intrusive"
          }
          {
            begin: "\\("
            beginCaptures:
              "0":
                name: "punctuation.parenthesis.open.cs"
            end: "\\)"
            endCaptures:
              "0":
                name: "punctuation.parenthesis.close.cs"
            patterns: [
              {
                include: "#intrusive"
              }
              {
                include: "#explicit-anonymous-function-parameter"
              }
              {
                include: "#punctuation-comma"
              }
            ]
          }
          {
            include: "#block"
          }
        ]
      }
    ]
  "explicit-anonymous-function-parameter":
    match: '''
      (?x)
      (?:\\b(ref|params|out|in)\\b\\s*)?
      (?<type_name>
        (?:
          (?:
            (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification
            (?<name_and_type_args> # identifier + type arguments (if any)
              \\g<identifier>\\s*
              (?<type_args><(?:[^<>]|\\g<type_args>)*>\\s*)?
            )
            (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?
            (?<tuple>\\s*\\((?:[^()]|\\g<tuple>)*\\))
          )
          (?:\\s*\\?\\s*)? # nullable suffix?
          (?:\\s* # array suffix?
            \\[
              (?:\\s*,\\s*)* # commata for multi-dimensional arrays
            \\]
            \\s*
            (?:\\?)? # arrays can be nullable reference types
            \\s*
          )*
        )
      )\\s*
      \\b(\\g<identifier>)\\b
    '''
    captures:
      "1":
        name: "storage.modifier.$1.cs"
      "2":
        patterns: [
          {
            include: "#type"
          }
        ]
      "7":
        name: "entity.name.variable.parameter.cs"
  "implicit-anonymous-function-parameter":
    match: "\\@?[_[:alpha:]][_[:alnum:]]*\\b"
    name: "entity.name.variable.parameter.cs"
  "default-argument":
    begin: "="
    beginCaptures:
      "0":
        name: "keyword.operator.assignment.cs"
    end: "(?=,|\\))"
    patterns: [
      {
        include: "#expression"
      }
    ]
  type:
    patterns: [
      {
        include: "#comment"
      }
      {
        include: "#ref-modifier"
      }
      {
        include: "#readonly-modifier"
      }
      {
        include: "#tuple-type"
      }
      {
        include: "#type-builtin"
      }
      {
        include: "#type-name"
      }
      {
        include: "#type-arguments"
      }
      {
        include: "#type-array-suffix"
      }
      {
        include: "#type-nullable-suffix"
      }
      {
        include: "#type-pointer-suffix"
      }
    ]
  "ref-modifier":
    name: "storage.modifier.ref.cs"
    match: "\\bref\\b"
  "readonly-modifier":
    name: "storage.modifier.readonly.cs"
    match: "\\breadonly\\b"
  "tuple-type":
    begin: "\\("
    beginCaptures:
      "0":
        name: "punctuation.parenthesis.open.cs"
    end: "\\)"
    endCaptures:
      "0":
        name: "punctuation.parenthesis.close.cs"
    patterns: [
      {
        include: "#tuple-element"
      }
      {
        include: "#punctuation-comma"
      }
    ]
  "tuple-element":
    match: '''
      (?x)
      (?<type_name>
        (?:
          (?:
            (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification
            (?<name_and_type_args> # identifier + type arguments (if any)
              \\g<identifier>\\s*
              (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?
            )
            (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?
            (?<tuple>\\s*\\((?:[^\\(\\)]|\\g<tuple>)+\\))
          )
          (?:\\s*\\?\\s*)? # nullable suffix?
          (?:\\s* # array suffix?
            \\[
              (?:\\s*,\\s*)* # commata for multi-dimensional arrays
            \\]
            \\s*
            (?:\\?)? # arrays can be nullable reference types
            \\s*
          )*
        )
      )
      (?:(?<tuple_name>\\g<identifier>)\\b)?
    '''
    captures:
      "1":
        patterns: [
          {
            include: "#type"
          }
        ]
      "6":
        name: "entity.name.variable.tuple-element.cs"
  "type-builtin":
    match: "\\b(bool|s?byte|u?short|n?u?int|u?long|float|double|decimal|char|string|object|void|dynamic)\\b"
    captures:
      "1":
        name: "keyword.type.$1.cs"
  "type-name":
    patterns: [
      {
        match: "(@?[_[:alpha:]][_[:alnum:]]*)\\s*(\\:\\:)"
        captures:
          "1":
            name: "entity.name.type.alias.cs"
          "2":
            name: "punctuation.separator.coloncolon.cs"
      }
      {
        match: "(@?[_[:alpha:]][_[:alnum:]]*)\\s*(\\.)"
        captures:
          "1":
            name: "entity.name.type.cs"
          "2":
            name: "punctuation.accessor.cs"
      }
      {
        match: "(\\.)\\s*(@?[_[:alpha:]][_[:alnum:]]*)"
        captures:
          "1":
            name: "punctuation.accessor.cs"
          "2":
            name: "entity.name.type.cs"
      }
      {
        name: "entity.name.type.cs"
        match: "@?[_[:alpha:]][_[:alnum:]]*"
      }
    ]
  "type-arguments":
    begin: "<"
    beginCaptures:
      "0":
        name: "punctuation.definition.typeparameters.begin.cs"
    end: ">"
    endCaptures:
      "0":
        name: "punctuation.definition.typeparameters.end.cs"
    patterns: [
      {
        include: "#type"
      }
      {
        include: "#punctuation-comma"
      }
    ]
  "type-array-suffix":
    begin: "\\["
    beginCaptures:
      "0":
        name: "punctuation.squarebracket.open.cs"
    end: "\\]"
    endCaptures:
      "0":
        name: "punctuation.squarebracket.close.cs"
    patterns: [
      {
        include: "#intrusive"
      }
      {
        include: "#punctuation-comma"
      }
    ]
  "type-nullable-suffix":
    match: "\\?"
    name: "punctuation.separator.question-mark.cs"
  "type-pointer-suffix":
    match: "\\*"
    name: "punctuation.separator.asterisk.cs"
  "operator-assignment":
    name: "keyword.operator.assignment.cs"
    match: "(?<!=|!)(=)(?!=)"
  "punctuation-comma":
    name: "punctuation.separator.comma.cs"
    match: ","
  "punctuation-semicolon":
    name: "punctuation.terminator.statement.cs"
    match: ";"
  "punctuation-accessor":
    name: "punctuation.accessor.cs"
    match: "\\."
  intrusive:
    patterns: [
      {
        include: "#preprocessor"
      }
      {
        include: "#comment"
      }
    ]
  preprocessor:
    name: "meta.preprocessor.cs"
    begin: "^\\s*(\\#)\\s*"
    beginCaptures:
      "1":
        name: "punctuation.separator.hash.cs"
    end: "(?<=$)"
    patterns: [
      {
        include: "#preprocessor-comment"
      }
      {
        include: "#preprocessor-define-or-undef"
      }
      {
        include: "#preprocessor-if-or-elif"
      }
      {
        include: "#preprocessor-else-or-endif"
      }
      {
        include: "#preprocessor-warning-or-error"
      }
      {
        include: "#preprocessor-region"
      }
      {
        include: "#preprocessor-endregion"
      }
      {
        include: "#preprocessor-load"
      }
      {
        include: "#preprocessor-r"
      }
      {
        include: "#preprocessor-line"
      }
      {
        include: "#preprocessor-pragma-warning"
      }
      {
        include: "#preprocessor-pragma-checksum"
      }
      {
        include: "#preprocessor-app-directive"
      }
    ]
  "preprocessor-comment":
    patterns: [
      {
        name: "comment.line.double-slash.cs"
        match: "(//).*(?=$)"
        captures:
          "1":
            name: "punctuation.definition.comment.cs"
      }
      {
        name: "comment.block.cs"
        begin: "/\\*"
        end: "\\*/"
        captures:
          "0":
            name: "punctuation.definition.comment.cs"
      }
    ]
  "preprocessor-define-or-undef":
    match: "\\b(?:(define)|(undef))\\b\\s*\\b([_[:alpha:]][_[:alnum:]]*)\\b"
    captures:
      "1":
        name: "keyword.preprocessor.define.cs"
      "2":
        name: "keyword.preprocessor.undef.cs"
      "3":
        name: "entity.name.variable.preprocessor.symbol.cs"
  "preprocessor-if-or-elif":
    begin: "\\b(?:(if)|(elif))\\b"
    beginCaptures:
      "1":
        name: "keyword.preprocessor.if.cs"
      "2":
        name: "keyword.preprocessor.elif.cs"
    end: "(?=$)"
    patterns: [
      {
        include: "#preprocessor-comment"
      }
      {
        include: "#preprocessor-expression"
      }
    ]
  "preprocessor-else-or-endif":
    match: "\\b(?:(else)|(endif))\\b"
    captures:
      "1":
        name: "keyword.preprocessor.else.cs"
      "2":
        name: "keyword.preprocessor.endif.cs"
  "preprocessor-warning-or-error":
    match: "\\b(?:(warning)|(error))\\b\\s*(.*)(?=$)"
    captures:
      "1":
        name: "keyword.preprocessor.warning.cs"
      "2":
        name: "keyword.preprocessor.error.cs"
      "3":
        name: "string.unquoted.preprocessor.message.cs"
  "preprocessor-load":
    begin: "\\b(load)\\b"
    beginCaptures:
      "1":
        name: "keyword.preprocessor.load.cs"
    end: "(?=$)"
    patterns: [
      {
        match: "\\\"[^\"]*\\\""
        captures:
          "0":
            name: "string.quoted.double.cs"
      }
    ]
  "preprocessor-r":
    begin: "\\b(r)\\b"
    beginCaptures:
      "1":
        name: "keyword.preprocessor.r.cs"
    end: "(?=$)"
    patterns: [
      {
        match: "\\\"[^\"]*\\\""
        captures:
          "0":
            name: "string.quoted.double.cs"
      }
    ]
  "preprocessor-region":
    match: "\\b(region)\\b\\s*(.*)(?=$)"
    captures:
      "1":
        name: "keyword.preprocessor.region.cs"
      "2":
        name: "string.unquoted.preprocessor.message.cs"
  "preprocessor-endregion":
    match: "\\b(endregion)\\b"
    captures:
      "1":
        name: "keyword.preprocessor.endregion.cs"
  "preprocessor-line":
    begin: "\\b(line)\\b"
    beginCaptures:
      "1":
        name: "keyword.preprocessor.line.cs"
    end: "(?=$)"
    patterns: [
      {
        match: "\\b(?:(default|hidden))"
        captures:
          "1":
            name: "keyword.preprocessor.default.cs"
          "2":
            name: "keyword.preprocessor.hidden.cs"
      }
      {
        match: "[0-9]+"
        captures:
          "0":
            name: "constant.numeric.decimal.cs"
      }
      {
        match: "\\\"[^\"]*\\\""
        captures:
          "0":
            name: "string.quoted.double.cs"
      }
    ]
  "preprocessor-pragma-warning":
    match: "\\b(pragma)\\b\\s*\\b(warning)\\b\\s*\\b(?:(disable)|(restore))\\b(\\s*[0-9]+(?:\\s*,\\s*[0-9]+)?)?"
    captures:
      "1":
        name: "keyword.preprocessor.pragma.cs"
      "2":
        name: "keyword.preprocessor.warning.cs"
      "3":
        name: "keyword.preprocessor.disable.cs"
      "4":
        name: "keyword.preprocessor.restore.cs"
      "5":
        patterns: [
          {
            match: "[0-9]+"
            captures:
              "0":
                name: "constant.numeric.decimal.cs"
          }
          {
            include: "#punctuation-comma"
          }
        ]
  "preprocessor-pragma-checksum":
    match: "\\b(pragma)\\b\\s*\\b(checksum)\\b\\s*(\\\"[^\"]*\\\")\\s*(\\\"[^\"]*\\\")\\s*(\\\"[^\"]*\\\")"
    captures:
      "1":
        name: "keyword.preprocessor.pragma.cs"
      "2":
        name: "keyword.preprocessor.checksum.cs"
      "3":
        name: "string.quoted.double.cs"
      "4":
        name: "string.quoted.double.cs"
      "5":
        name: "string.quoted.double.cs"
  "preprocessor-app-directive":
    begin: "\\s*(:)\\s*"
    beginCaptures:
      "1":
        name: "punctuation.separator.colon.cs"
    end: "(?=$)"
    patterns: [
      {
        include: "#preprocessor-app-directive-package"
      }
      {
        include: "#preprocessor-app-directive-property"
      }
      {
        include: "#preprocessor-app-directive-project"
      }
      {
        include: "#preprocessor-app-directive-sdk"
      }
      {
        include: "#preprocessor-app-directive-generic"
      }
    ]
  "preprocessor-app-directive-package":
    match: "\\b(package)\\b\\s*([_[:alpha:]][_.[:alnum:]]*)?(@)?(.*)?\\s*"
    captures:
      "1":
        name: "keyword.preprocessor.package.cs"
      "2":
        patterns: [
          {
            include: "#preprocessor-app-directive-package-name"
          }
        ]
      "3":
        name: "punctuation.separator.at.cs"
      "4":
        name: "string.unquoted.preprocessor.message.cs"
  "preprocessor-app-directive-property":
    match: "\\b(property)\\b\\s*([_[:alpha:]][_[:alnum:]]*)?(=)?(.*)?\\s*"
    captures:
      "1":
        name: "keyword.preprocessor.property.cs"
      "2":
        name: "entity.name.variable.preprocessor.symbol.cs"
      "3":
        name: "punctuation.separator.equals.cs"
      "4":
        name: "string.unquoted.preprocessor.message.cs"
  "preprocessor-app-directive-project":
    match: "\\b(project)\\b\\s*(.*)?\\s*"
    captures:
      "1":
        name: "keyword.preprocessor.project.cs"
      "2":
        name: "string.unquoted.preprocessor.message.cs"
  "preprocessor-app-directive-sdk":
    match: "\\b(sdk)\\b\\s*([_[:alpha:]][_.[:alnum:]]*)?(@)?(.*)?\\s*"
    captures:
      "1":
        name: "keyword.preprocessor.sdk.cs"
      "2":
        patterns: [
          {
            include: "#preprocessor-app-directive-package-name"
          }
        ]
      "3":
        name: "punctuation.separator.at.cs"
      "4":
        name: "string.unquoted.preprocessor.message.cs"
  "preprocessor-app-directive-package-name":
    patterns: [
      {
        match: "(\\.)([_[:alpha:]][_[:alnum:]]*)"
        captures:
          "1":
            name: "punctuation.dot.cs"
          "2":
            name: "entity.name.variable.preprocessor.symbol.cs"
      }
      {
        name: "entity.name.variable.preprocessor.symbol.cs"
        match: "[_[:alpha:]][_[:alnum:]]*"
      }
    ]
  "preprocessor-app-directive-generic":
    match: "\\b(.*)?\\s*"
    captures:
      "1":
        name: "string.unquoted.preprocessor.message.cs"
  "preprocessor-expression":
    patterns: [
      {
        begin: "\\("
        beginCaptures:
          "0":
            name: "punctuation.parenthesis.open.cs"
        end: "\\)"
        endCaptures:
          "0":
            name: "punctuation.parenthesis.close.cs"
        patterns: [
          {
            include: "#preprocessor-expression"
          }
        ]
      }
      {
        match: "\\b(?:(true)|(false)|([_[:alpha:]][_[:alnum:]]*))\\b"
        captures:
          "1":
            name: "constant.language.boolean.true.cs"
          "2":
            name: "constant.language.boolean.false.cs"
          "3":
            name: "entity.name.variable.preprocessor.symbol.cs"
      }
      {
        match: "(==|!=)|(\\!|&&|\\|\\|)"
        captures:
          "1":
            name: "keyword.operator.comparison.cs"
          "2":
            name: "keyword.operator.logical.cs"
      }
    ]
  comment:
    patterns: [
      {
        name: "comment.block.documentation.cs"
        begin: "(^\\s+)?(///)(?!/)"
        while: "^(\\s*)(///)(?!/)"
        captures:
          "1":
            name: "punctuation.whitespace.comment.leading.cs"
          "2":
            name: "punctuation.definition.comment.cs"
        patterns: [
          {
            include: "#xml-doc-comment"
          }
        ]
      }
      {
        name: "comment.block.documentation.cs"
        begin: "(^\\s+)?(/\\*\\*)(?!/)"
        end: "(^\\s+)?(\\*/)"
        captures:
          "1":
            name: "punctuation.whitespace.comment.leading.cs"
          "2":
            name: "punctuation.definition.comment.cs"
        patterns: [
          {
            begin: "\\G(?=(?~\\*/)$)"
            while: "^(\\s*+)(\\*(?!/))?(?=(?~\\*/)$)"
            whileCaptures:
              "1":
                name: "punctuation.whitespace.comment.leading.cs"
              "2":
                name: "punctuation.definition.comment.cs"
            patterns: [
              {
                include: "#xml-doc-comment"
              }
            ]
          }
          {
            include: "#xml-doc-comment"
          }
        ]
      }
      {
        name: "comment.line.double-slash.cs"
        begin: "(^\\s+)?(//).*$"
        while: "^(\\s*)(//).*$"
        captures:
          "1":
            name: "punctuation.whitespace.comment.leading.cs"
          "2":
            name: "punctuation.definition.comment.cs"
      }
      {
        name: "comment.block.cs"
        begin: "/\\*"
        end: "\\*/"
        captures:
          "0":
            name: "punctuation.definition.comment.cs"
      }
    ]
  "xml-doc-comment":
    patterns: [
      {
        include: "#xml-comment"
      }
      {
        include: "#xml-character-entity"
      }
      {
        include: "#xml-cdata"
      }
      {
        include: "#xml-tag"
      }
    ]
  "xml-tag":
    name: "meta.tag.cs"
    begin: '''
      (?x)
      (</?)
      (
        (?:
          ([-_[:alnum:]]+)
          (:)
        )?
        ([-_[:alnum:]]+)
      )
    '''
    beginCaptures:
      "1":
        name: "punctuation.definition.tag.cs"
      "2":
        name: "entity.name.tag.cs"
      "3":
        name: "entity.name.tag.namespace.cs"
      "4":
        name: "punctuation.separator.colon.cs"
      "5":
        name: "entity.name.tag.localname.cs"
    end: "(/?>)"
    endCaptures:
      "1":
        name: "punctuation.definition.tag.cs"
    patterns: [
      {
        include: "#xml-attribute"
      }
    ]
  "xml-attribute":
    patterns: [
      {
        match: '''
          (?x)
          (?:^|\\s+)
          (
            (?:
              ([-_[:alnum:]]+)
              (:)
            )?
            ([-_[:alnum:]]+)
          )
          (=)
        '''
        captures:
          "1":
            name: "entity.other.attribute-name.cs"
          "2":
            name: "entity.other.attribute-name.namespace.cs"
          "3":
            name: "punctuation.separator.colon.cs"
          "4":
            name: "entity.other.attribute-name.localname.cs"
          "5":
            name: "punctuation.separator.equals.cs"
      }
      {
        include: "#xml-string"
      }
    ]
  "xml-cdata":
    name: "string.unquoted.cdata.cs"
    begin: "<!\\[CDATA\\["
    beginCaptures:
      "0":
        name: "punctuation.definition.string.begin.cs"
    end: "\\]\\]>"
    endCaptures:
      "0":
        name: "punctuation.definition.string.end.cs"
  "xml-string":
    patterns: [
      {
        name: "string.quoted.single.cs"
        begin: "\\'"
        beginCaptures:
          "0":
            name: "punctuation.definition.string.begin.cs"
        end: "\\'"
        endCaptures:
          "0":
            name: "punctuation.definition.string.end.cs"
        patterns: [
          {
            include: "#xml-character-entity"
          }
        ]
      }
      {
        name: "string.quoted.double.cs"
        begin: "\\\""
        beginCaptures:
          "0":
            name: "punctuation.definition.string.begin.cs"
        end: "\\\""
        endCaptures:
          "0":
            name: "punctuation.definition.string.end.cs"
        patterns: [
          {
            include: "#xml-character-entity"
          }
        ]
      }
    ]
  "xml-character-entity":
    patterns: [
      {
        name: "constant.character.entity.cs"
        match: '''
          (?x)
          (&)
          (
            (?:[[:alpha:]:_][[:alnum:]:_.-]*)|
            (?:\\#[[:digit:]]+)|
            (?:\\#x[[:xdigit:]]+)
          )
          (;)
        '''
        captures:
          "1":
            name: "punctuation.definition.constant.cs"
          "3":
            name: "punctuation.definition.constant.cs"
      }
      {
        name: "invalid.illegal.bad-ampersand.cs"
        match: "&"
      }
    ]
  "xml-comment":
    name: "comment.block.cs"
    begin: "<!--"
    beginCaptures:
      "0":
        name: "punctuation.definition.comment.cs"
    end: "-->"
    endCaptures:
      "0":
        name: "punctuation.definition.comment.cs"