diff --git a/.gitignore b/.gitignore
index ae169af..6a0ad3f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,7 +1,8 @@
node_modules
lib
+tests/*.js
+tests/*.map
+tests/baselines/local
!src/lib
-tests
-!tests/baselines
!src/tests
spec/*.grammar.html
\ No newline at end of file
diff --git a/package.json b/package.json
index 1f73d63..bfd6ec5 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
{
"name": "grammarkdown",
- "version": "1.0.2",
+ "version": "1.0.3",
"description": "Markdown-like DSL for defining syntactic grammars for programming languages.",
"license": "Apache-2.0",
"keywords": [
diff --git a/src/lib/checker.ts b/src/lib/checker.ts
index 9e410a1..0be5858 100644
--- a/src/lib/checker.ts
+++ b/src/lib/checker.ts
@@ -1064,6 +1064,10 @@ export class Checker {
return this.reportGrammarErrorForNode(node.operatorToken, Diagnostics.Unexpected_token_0_, tokenToString(node.operatorToken.kind));
}
+ if (!node.operatorToken && !this.noStrictParametricProductions) {
+ return this.reportGrammarError(node.pos, Diagnostics._0_expected, formatList([SyntaxKind.QuestionToken, SyntaxKind.PlusToken, SyntaxKind.TildeToken]));
+ }
+
return false;
}
diff --git a/tests/baselines/reference/es6.grammar.emu.html b/tests/baselines/reference/es6.grammar.emu.html
new file mode 100644
index 0000000..1a54490
--- /dev/null
+++ b/tests/baselines/reference/es6.grammar.emu.html
@@ -0,0 +1,1994 @@
+
+ any Unicode code point
+
+
+ WhiteSpace
+ LineTerminator
+ Comment
+ CommonToken
+ DivPunctuator
+ RightBracePunctuator
+
+
+ WhiteSpace
+ LineTerminator
+ Comment
+ CommonToken
+ RightBracePunctuator
+ RegularExpressionLiteral
+
+
+ WhiteSpace
+ LineTerminator
+ Comment
+ CommonToken
+ RegularExpressionLiteral
+ TemplateSubstitutionTail
+
+
+ WhiteSpace
+ LineTerminator
+ Comment
+ CommonToken
+ DivPunctuator
+ TemplateSubstitutionTail
+
+
+ <TAB>
+ <VT>
+ <FF>
+ <SP>
+ <NBSP>
+ <ZWNBSP>
+ <USP>
+
+
+ <LF>
+ <CR>
+ <LS>
+ <PS>
+
+
+ <LF>
+
+ <CR>
+ lookahead ≠ <LF>
+
+ <LS>
+ <PS>
+
+ <CR>
+ <LF>
+
+
+
+ MultiLineComment
+ SingleLineComment
+
+
+
+ /*
+ MultiLineCommentChars
+ */
+
+
+
+
+ MultiLineNotAsteriskChar
+ MultiLineCommentChars
+
+
+ *
+ PostAsteriskCommentChars
+
+
+
+
+ MultiLineNotForwardSlashOrAsteriskChar
+ MultiLineCommentChars
+
+
+ *
+ PostAsteriskCommentChars
+
+
+
+ SourceCharacter but not *
+
+
+ SourceCharacter but not one of / or *
+
+
+
+ //
+ SingleLineCommentChars
+
+
+
+
+ SingleLineCommentChar
+ SingleLineCommentChars
+
+
+
+ SourceCharacter but not LineTerminator
+
+
+ IdentifierName
+ Punctuator
+ NumericLiteral
+ StringLiteral
+ Template
+
+
+ IdentifierStart
+
+ IdentifierName
+ IdentifierPart
+
+
+
+ UnicodeIDStart
+ $
+ _
+
+ \
+ UnicodeEscapeSequence
+
+
+
+ UnicodeIDContinue
+ $
+ _
+
+ \
+ UnicodeEscapeSequence
+
+ <ZWNJ>
+ <ZWJ>
+
+
+ any Unicode code point with the Unicode property "ID_Start" or "Other_ID_Start"
+
+
+ any Unicode code point with the Unicode property "ID_Continue" or "Other_ID_Continue", or "Other_ID_Start"
+
+
+ Keyword
+ FutureReservedWord
+ NullLiteral
+ BooleanLiteral
+
+
+ break do in typeof case else instanceof var catch export new void class extends return while const finally super with continue for switch yield debugger function this default if throw delete import try
+
+
+ enum await implements package protected interface private public
+
+
+ { } ( ) [ ] . ; , < > <= >= == != === !== + - * % ++ -- << >> >>> & | ^ ! ~ && || ? :: = += -= *= %= <<= >>= >>>= &= |= ^= =>
+
+
+ / /=
+
+
+ )
+
+
+ null
+
+
+ true
+ false
+
+
+ DecimalLiteral
+ BinaryIntegerLiteral
+ OctalIntegerLiteral
+ HexIntegerLiteral
+
+
+
+ DecimalIntegerLiteral
+ .
+ DecimalDigits
+ ExponentPart
+
+
+ .
+ DecimalDigits
+ ExponentPart
+
+
+ DecimalIntegerLiteral
+ ExponentPart
+
+
+
+ 0
+
+ NonZeroDigit
+ DecimalDigits
+
+
+
+ DecimalDigit
+
+ DecimalDigits
+ DecimalDigit
+
+
+
+ 0 1 2 3 4 5 6 7 8 9
+
+
+ 1 2 3 4 5 6 7 8 9
+
+
+
+ ExponentIndicator
+ SignedInteger
+
+
+
+ e E
+
+
+ DecimalDigits
+
+ +
+ DecimalDigits
+
+
+ -
+ DecimalDigits
+
+
+
+
+ 0b
+ BinaryDigits
+
+
+ 0B
+ BinaryDigits
+
+
+
+ BinaryDigit
+
+ BinaryDigits
+ BinaryDigit
+
+
+
+ 0 1
+
+
+
+ 0o
+ OctalDigits
+
+
+ 0O
+ OctalDigits
+
+
+
+ OctalDigit
+
+ OctalDigits
+ OctalDigit
+
+
+
+ 0 1 2 3 4 5 6 7
+
+
+
+ 0x
+ HexDigits
+
+
+ 0X
+ HexDigits
+
+
+
+ HexDigit
+
+ HexDigits
+ HexDigit
+
+
+
+ 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F
+
+
+
+ "
+ DoubleStringCharacters
+ "
+
+
+ '
+ SingleStringCharacters
+ '
+
+
+
+
+ DoubleStringCharacter
+ DoubleStringCharacters
+
+
+
+
+ SingleStringCharacter
+ SingleStringCharacters
+
+
+
+ SourceCharacter but not one of " or \ or LineTerminator
+
+ \
+ EscapeSequence
+
+ LineContinuation
+
+
+ SourceCharacter but not one of ' or \ or LineTerminator
+
+ \
+ EscapeSequence
+
+ LineContinuation
+
+
+
+ \
+ LineTerminatorSequence
+
+
+
+ CharacterEscapeSequence
+
+ 0
+ lookahead ≠ DecimalDigit
+
+ HexEscapeSequence
+ UnicodeEscapeSequence
+
+
+ SingleEscapeCharacter
+ NonEscapeCharacter
+
+
+ ' " \ b f n r t v
+
+
+ SourceCharacter but not one of EscapeCharacter or LineTerminator
+
+
+ SingleEscapeCharacter
+ DecimalDigit
+ x
+ u
+
+
+
+ x
+ HexDigit
+ HexDigit
+
+
+
+
+ u
+ Hex4Digits
+
+
+ u{
+ HexDigits
+ }
+
+
+
+
+ HexDigit
+ HexDigit
+ HexDigit
+ HexDigit
+
+
+
+
+ /
+ RegularExpressionBody
+ /
+ RegularExpressionFlags
+
+
+
+
+ RegularExpressionFirstChar
+ RegularExpressionChars
+
+
+
+ empty
+
+ RegularExpressionChars
+ RegularExpressionChar
+
+
+
+ RegularExpressionNonTerminator but not one of * or \ or / or [
+ RegularExpressionBackslashSequence
+ RegularExpressionClass
+
+
+ RegularExpressionNonTerminator but not one of \ or / or [
+ RegularExpressionBackslashSequence
+ RegularExpressionClass
+
+
+
+ \
+ RegularExpressionNonTerminator
+
+
+
+ SourceCharacter but not LineTerminator
+
+
+
+ [
+ RegularExpressionClassChars
+ ]
+
+
+
+ empty
+
+ RegularExpressionClassChars
+ RegularExpressionClassChar
+
+
+
+ RegularExpressionNonTerminator but not one of ] or \
+ RegularExpressionBackslashSequence
+
+
+ empty
+
+ RegularExpressionFlags
+ IdentifierPart
+
+
+
+ NoSubstitutionTemplate
+ TemplateHead
+
+
+
+ `
+ TemplateCharacters
+ `
+
+
+
+
+ `
+ TemplateCharacters
+ ${
+
+
+
+ TemplateMiddle
+ TemplateTail
+
+
+
+ }
+ TemplateCharacters
+ ${
+
+
+
+
+ }
+ TemplateCharacters
+ `
+
+
+
+
+ TemplateCharacter
+ TemplateCharacters
+
+
+
+
+ $
+ lookahead ≠ {
+
+
+ \
+ EscapeSequence
+
+ LineContinuation
+ LineTerminatorSequence
+ SourceCharacter but not one of ` or \ or $ or LineTerminator
+
+
+ Identifier
+ yield
+
+
+ Identifier
+ yield
+
+
+ Identifier
+ yield
+
+
+ IdentifierName but not ReservedWord
+
+
+ this
+ IdentifierReference
+ Literal
+ ArrayLiteral
+ ObjectLiteral
+ FunctionExpression
+ ClassExpression
+ GeneratorExpression
+ RegularExpressionLiteral
+ TemplateLiteral
+ CoverParenthesizedExpressionAndArrowParameterList
+
+
+
+ (
+ Expression
+ )
+
+
+ (
+ )
+
+
+ (
+ ...
+ BindingIdentifier
+ )
+
+
+ (
+ Expression
+ ,
+ ...
+ BindingIdentifier
+ )
+
+
+
+ NullLiteral
+ BooleanLiteral
+ NumericLiteral
+ StringLiteral
+
+
+
+ [
+ Elision
+ ]
+
+
+ [
+ ElementList
+ ]
+
+
+ [
+ ElementList
+ ,
+ Elision
+ ]
+
+
+
+
+ Elision
+ AssignmentExpression
+
+
+ Elision
+ SpreadElement
+
+
+ ElementList
+ ,
+ Elision
+ AssignmentExpression
+
+
+ ElementList
+ ,
+ Elision
+ SpreadElement
+
+
+
+ ,
+
+ Elision
+ ,
+
+
+
+
+ ...
+ AssignmentExpression
+
+
+
+
+ {
+ }
+
+
+ {
+ PropertyDefinitionList
+ }
+
+
+ {
+ PropertyDefinitionList
+ ,
+ }
+
+
+
+ PropertyDefinition
+
+ PropertyDefinitionList
+ ,
+ PropertyDefinition
+
+
+
+ IdentifierReference
+ CoverInitializedName
+
+ PropertyName
+ :
+ AssignmentExpression
+
+ MethodDefinition
+
+
+ LiteralPropertyName
+ ComputedPropertyName
+
+
+ IdentifierName
+ StringLiteral
+ NumericLiteral
+
+
+
+ [
+ AssignmentExpression
+ ]
+
+
+
+
+ IdentifierReference
+ Initializer
+
+
+
+
+ =
+ AssignmentExpression
+
+
+
+ NoSubstitutionTemplate
+
+ TemplateHead
+ Expression
+ TemplateSpans
+
+
+
+ TemplateTail
+
+ TemplateMiddleList
+ TemplateTail
+
+
+
+
+ TemplateMiddle
+ Expression
+
+
+ TemplateMiddleList
+ TemplateMiddle
+ Expression
+
+
+
+ PrimaryExpression
+
+ MemberExpression
+ [
+ Expression
+ ]
+
+
+ MemberExpression
+ .
+ IdentifierName
+
+
+ MemberExpression
+ TemplateLiteral
+
+ SuperProperty
+ MetaProperty
+
+ new
+ MemberExpression
+ Arguments
+
+
+
+
+ super
+ [
+ Expression
+ ]
+
+
+ super
+ .
+ IdentifierName
+
+
+
+ NewTarget
+
+
+
+ new
+ .
+ target
+
+
+
+ MemberExpression
+
+ new
+ NewExpression
+
+
+
+
+ MemberExpression
+ Arguments
+
+ SuperCall
+
+ CallExpression
+ Arguments
+
+
+ CallExpression
+ [
+ Expression
+ ]
+
+
+ CallExpression
+ .
+ IdentifierName
+
+
+ CallExpression
+ TemplateLiteral
+
+
+
+
+ super
+ Arguments
+
+
+
+
+ (
+ )
+
+
+ (
+ ArgumentList
+ )
+
+
+
+ AssignmentExpression
+
+ ...
+ AssignmentExpression
+
+
+ ArgumentList
+ ,
+ AssignmentExpression
+
+
+ ArgumentList
+ ,
+ ...
+ AssignmentExpression
+
+
+
+ NewExpression
+ CallExpression
+
+
+ LeftHandSideExpression
+
+ LeftHandSideExpression
+ no LineTerminator here
+ ++
+
+
+ LeftHandSideExpression
+ no LineTerminator here
+ --
+
+
+
+ PostfixExpression
+
+ delete
+ UnaryExpression
+
+
+ void
+ UnaryExpression
+
+
+ typeof
+ UnaryExpression
+
+
+ ++
+ UnaryExpression
+
+
+ --
+ UnaryExpression
+
+
+ +
+ UnaryExpression
+
+
+ -
+ UnaryExpression
+
+
+ ~
+ UnaryExpression
+
+
+ !
+ UnaryExpression
+
+
+
+ UnaryExpression
+
+ MultiplicativeExpression
+ MultiplicativeOperator
+ UnaryExpression
+
+
+
+ * / %
+
+
+ MultiplicativeExpression
+
+ AdditiveExpression
+ +
+ MultiplicativeExpression
+
+
+ AdditiveExpression
+ -
+ MultiplicativeExpression
+
+
+
+ AdditiveExpression
+
+ ShiftExpression
+ <<
+ AdditiveExpression
+
+
+ ShiftExpression
+ >>
+ AdditiveExpression
+
+
+ ShiftExpression
+ >>>
+ AdditiveExpression
+
+
+
+ ShiftExpression
+
+ RelationalExpression
+ <
+ ShiftExpression
+
+
+ RelationalExpression
+ >
+ ShiftExpression
+
+
+ RelationalExpression
+ <=
+ ShiftExpression
+
+
+ RelationalExpression
+ >=
+ ShiftExpression
+
+
+ RelationalExpression
+ instanceof
+ ShiftExpression
+
+
+ RelationalExpression
+ in
+ ShiftExpression
+
+
+
+ RelationalExpression
+
+ EqualityExpression
+ ==
+ RelationalExpression
+
+
+ EqualityExpression
+ !=
+ RelationalExpression
+
+
+ EqualityExpression
+ ===
+ RelationalExpression
+
+
+ EqualityExpression
+ !==
+ RelationalExpression
+
+
+
+ EqualityExpression
+
+ BitwiseANDExpression
+ &
+ EqualityExpression
+
+
+
+ BitwiseANDExpression
+
+ BitwiseXORExpression
+ ^
+ BitwiseANDExpression
+
+
+
+ BitwiseXORExpression
+
+ BitwiseORExpression
+ |
+ BitwiseXORExpression
+
+
+
+ BitwiseORExpression
+
+ LogicalANDExpression
+ &&
+ BitwiseORExpression
+
+
+
+ LogicalANDExpression
+
+ LogicalORExpression
+ ||
+ LogicalANDExpression
+
+
+
+ LogicalORExpression
+
+ LogicalORExpression
+ ?
+ AssignmentExpression
+ :
+ AssignmentExpression
+
+
+
+ ConditionalExpression
+ YieldExpression
+ ArrowFunction
+
+ LeftHandSideExpression
+ =
+ AssignmentExpression
+
+
+ LeftHandSideExpression
+ AssignmentOperator
+ AssignmentExpression
+
+
+
+ *= /= %= += -= <<= >>= >>>= &= ^= |=
+
+
+ AssignmentExpression
+
+ Expression
+ ,
+ AssignmentExpression
+
+
+
+ BlockStatement
+ VariableStatement
+ EmptyStatement
+ ExpressionStatement
+ IfStatement
+ BreakableStatement
+ ContinueStatement
+ BreakStatement
+ ReturnStatement
+ WithStatement
+ LabelledStatement
+ ThrowStatement
+ TryStatement
+ DebuggerStatement
+
+
+ HoistableDeclaration
+ ClassDeclaration
+ LexicalDeclaration
+
+
+ FunctionDeclaration
+ GeneratorDeclaration
+
+
+ IterationStatement
+ SwitchStatement
+
+
+ Block
+
+
+
+ {
+ StatementList
+ }
+
+
+
+ StatementListItem
+
+ StatementList
+ StatementListItem
+
+
+
+ Statement
+ Declaration
+
+
+
+ LetOrConst
+ BindingList
+ ;
+
+
+
+ let
+ const
+
+
+ LexicalBinding
+
+ BindingList
+ ,
+ LexicalBinding
+
+
+
+
+ BindingIdentifier
+ Initializer
+
+
+ BindingPattern
+ Initializer
+
+
+
+
+ var
+ VariableDeclarationList
+ ;
+
+
+
+ VariableDeclaration
+
+ VariableDeclarationList
+ ,
+ VariableDeclaration
+
+
+
+
+ BindingIdentifier
+ Initializer
+
+
+ BindingPattern
+ Initializer
+
+
+
+ ObjectBindingPattern
+ ArrayBindingPattern
+
+
+
+ {
+ }
+
+
+ {
+ BindingPropertyList
+ }
+
+
+ {
+ BindingPropertyList
+ ,
+ }
+
+
+
+
+ [
+ Elision
+ BindingRestElement
+ ]
+
+
+ [
+ BindingElementList
+ ]
+
+
+ [
+ BindingElementList
+ ,
+ Elision
+ BindingRestElement
+ ]
+
+
+
+ BindingProperty
+
+ BindingPropertyList
+ ,
+ BindingProperty
+
+
+
+ BindingElisionElement
+
+ BindingElementList
+ ,
+ BindingElisionElement
+
+
+
+
+ Elision
+ BindingElement
+
+
+
+ SingleNameBinding
+
+ PropertyName
+ :
+ BindingElement
+
+
+
+ SingleNameBinding
+
+ BindingPattern
+ Initializer
+
+
+
+
+ BindingIdentifier
+ Initializer
+
+
+
+
+ ...
+ BindingIdentifier
+
+
+
+ ;
+
+
+
+ lookahead ∉ { {, function, class, let
+ [ }
+ Expression
+ ;
+
+
+
+
+ if
+ (
+ Expression
+ )
+ Statement
+ else
+ Statement
+
+
+ if
+ (
+ Expression
+ )
+ Statement
+
+
+
+
+ do
+ Statement
+ while
+ (
+ Expression
+ )
+ ;
+
+
+ while
+ (
+ Expression
+ )
+ Statement
+
+
+ for
+ (
+ lookahead ∉ { let
+ [ }
+ Expression
+ ;
+ Expression
+ ;
+ Expression
+ )
+ Statement
+
+
+ for
+ (
+ var
+ VariableDeclarationList
+ ;
+ Expression
+ ;
+ Expression
+ )
+ Statement
+
+
+ for
+ (
+ LexicalDeclaration
+ Expression
+ ;
+ Expression
+ )
+ Statement
+
+
+ for
+ (
+ lookahead ∉ { let
+ [ }
+ LeftHandSideExpression
+ in
+ Expression
+ )
+ Statement
+
+
+ for
+ (
+ var
+ ForBinding
+ in
+ Expression
+ )
+ Statement
+
+
+ for
+ (
+ ForDeclaration
+ in
+ Expression
+ )
+ Statement
+
+
+ for
+ (
+ lookahead ≠ let
+ LeftHandSideExpression
+ of
+ AssignmentExpression
+ )
+ Statement
+
+
+ for
+ (
+ var
+ ForBinding
+ of
+ AssignmentExpression
+ )
+ Statement
+
+
+ for
+ (
+ ForDeclaration
+ of
+ AssignmentExpression
+ )
+ Statement
+
+
+
+
+ LetOrConst
+ ForBinding
+
+
+
+ BindingIdentifier
+ BindingPattern
+
+
+
+ continue
+ ;
+
+
+ continue
+ no LineTerminator here
+ LabelIdentifier
+ ;
+
+
+
+
+ break
+ ;
+
+
+ break
+ no LineTerminator here
+ LabelIdentifier
+ ;
+
+
+
+
+ return
+ ;
+
+
+ return
+ no LineTerminator here
+ Expression
+ ;
+
+
+
+
+ with
+ (
+ Expression
+ )
+ Statement
+
+
+
+
+ switch
+ (
+ Expression
+ )
+ CaseBlock
+
+
+
+
+ {
+ CaseClauses
+ }
+
+
+ {
+ CaseClauses
+ DefaultClause
+ CaseClauses
+ }
+
+
+
+ CaseClause
+
+ CaseClauses
+ CaseClause
+
+
+
+
+ case
+ Expression
+ :
+ StatementList
+
+
+
+
+ default
+ :
+ StatementList
+
+
+
+
+ LabelIdentifier
+ :
+ LabelledItem
+
+
+
+ Statement
+ FunctionDeclaration
+
+
+
+ throw
+ no LineTerminator here
+ Expression
+ ;
+
+
+
+
+ try
+ Block
+ Catch
+
+
+ try
+ Block
+ Finally
+
+
+ try
+ Block
+ Catch
+ Finally
+
+
+
+
+ catch
+ (
+ CatchParameter
+ )
+ Block
+
+
+
+
+ finally
+ Block
+
+
+
+ BindingIdentifier
+ BindingPattern
+
+
+
+ debugger
+ ;
+
+
+
+
+ function
+ BindingIdentifier
+ (
+ FormalParameters
+ )
+ {
+ FunctionBody
+ }
+
+
+ function
+ (
+ FormalParameters
+ )
+ {
+ FunctionBody
+ }
+
+
+
+
+ function
+ BindingIdentifier
+ (
+ FormalParameters
+ )
+ {
+ FunctionBody
+ }
+
+
+
+ FormalParameters
+
+
+ empty
+ FormalParameterList
+
+
+ FunctionRestParameter
+ FormalsList
+
+ FormalsList
+ ,
+ FunctionRestParameter
+
+
+
+ FormalParameter
+
+ FormalsList
+ ,
+ FormalParameter
+
+
+
+ BindingRestElement
+
+
+ BindingElement
+
+
+ FunctionStatementList
+
+
+ StatementList
+
+
+
+ ArrowParameters
+ no LineTerminator here
+ =>
+ ConciseBody
+
+
+
+ BindingIdentifier
+ CoverParenthesizedExpressionAndArrowParameterList
+
+
+
+ lookahead ≠ {
+ AssignmentExpression
+
+
+ {
+ FunctionBody
+ }
+
+
+
+
+ PropertyName
+ (
+ StrictFormalParameters
+ )
+ {
+ FunctionBody
+ }
+
+ GeneratorMethod
+
+ get
+ PropertyName
+ (
+ )
+ {
+ FunctionBody
+ }
+
+
+ set
+ PropertyName
+ (
+ PropertySetParameterList
+ )
+ {
+ FunctionBody
+ }
+
+
+
+ FormalParameter
+
+
+
+ *
+ PropertyName
+ (
+ StrictFormalParameters
+ )
+ {
+ GeneratorBody
+ }
+
+
+
+
+ function
+ *
+ BindingIdentifier
+ (
+ FormalParameters
+ )
+ {
+ GeneratorBody
+ }
+
+
+ function
+ *
+ (
+ FormalParameters
+ )
+ {
+ GeneratorBody
+ }
+
+
+
+
+ function
+ *
+ BindingIdentifier
+ (
+ FormalParameters
+ )
+ {
+ GeneratorBody
+ }
+
+
+
+ FunctionBody
+
+
+ yield
+
+ yield
+ no LineTerminator here
+ AssignmentExpression
+
+
+ yield
+ no LineTerminator here
+ *
+ AssignmentExpression
+
+
+
+
+ class
+ BindingIdentifier
+ ClassTail
+
+
+ class
+ ClassTail
+
+
+
+
+ class
+ BindingIdentifier
+ ClassTail
+
+
+
+
+ ClassHeritage
+ {
+ ClassBody
+ }
+
+
+
+
+ extends
+ LeftHandSideExpression
+
+
+
+ ClassElementList
+
+
+ ClassElement
+
+ ClassElementList
+ ClassElement
+
+
+
+ MethodDefinition
+
+ static
+ MethodDefinition
+
+ ;
+
+
+ ScriptBody
+
+
+ StatementList
+
+
+ ModuleBody
+
+
+ ModuleItemList
+
+
+ ModuleItem
+
+ ModuleItemList
+ ModuleItem
+
+
+
+ ImportDeclaration
+ ExportDeclaration
+ StatementListItem
+
+
+
+ import
+ ImportClause
+ FromClause
+ ;
+
+
+ import
+ ModuleSpecifier
+ ;
+
+
+
+ ImportedDefaultBinding
+ NameSpaceImport
+ NamedImports
+
+ ImportedDefaultBinding
+ ,
+ NameSpaceImport
+
+
+ ImportedDefaultBinding
+ ,
+ NamedImports
+
+
+
+ ImportedBinding
+
+
+
+ *
+ as
+ ImportedBinding
+
+
+
+
+ {
+ }
+
+
+ {
+ ImportsList
+ }
+
+
+ {
+ ImportsList
+ ,
+ }
+
+
+
+
+ from
+ ModuleSpecifier
+
+
+
+ ImportSpecifier
+
+ ImportsList
+ ,
+ ImportSpecifier
+
+
+
+ ImportedBinding
+
+ IdentifierName
+ as
+ ImportedBinding
+
+
+
+ StringLiteral
+
+
+ BindingIdentifier
+
+
+
+ export
+ *
+ FromClause
+ ;
+
+
+ export
+ ExportClause
+ FromClause
+ ;
+
+
+ export
+ ExportClause
+ ;
+
+
+ export
+ VariableStatement
+
+
+ export
+ Declaration
+
+
+ export
+ default
+ HoistableDeclaration
+
+
+ export
+ default
+ ClassDeclaration
+
+
+ export
+ default
+ lookahead ∉ { function, class }
+ AssignmentExpression
+ ;
+
+
+
+
+ {
+ }
+
+
+ {
+ ExportsList
+ }
+
+
+ {
+ ExportsList
+ ,
+ }
+
+
+
+ ExportSpecifier
+
+ ExportsList
+ ,
+ ExportSpecifier
+
+
+
+ IdentifierName
+
+ IdentifierName
+ as
+ IdentifierName
+
+
\ No newline at end of file
diff --git a/tests/baselines/reference/es6.grammar.md b/tests/baselines/reference/es6.grammar.md
new file mode 100644
index 0000000..6c2bb77
--- /dev/null
+++ b/tests/baselines/reference/es6.grammar.md
@@ -0,0 +1,974 @@
+ *SourceCharacter* **::**
+ any Unicode code point
+
+ *InputElementDiv* **::**
+ *[WhiteSpace](#WhiteSpace)*
+ *[LineTerminator](#LineTerminator)*
+ *[Comment](#Comment)*
+ *[CommonToken](#CommonToken)*
+ *[DivPunctuator](#DivPunctuator)*
+ *[RightBracePunctuator](#RightBracePunctuator)*
+
+ *InputElementRegExp* **::**
+ *[WhiteSpace](#WhiteSpace)*
+ *[LineTerminator](#LineTerminator)*
+ *[Comment](#Comment)*
+ *[CommonToken](#CommonToken)*
+ *[RightBracePunctuator](#RightBracePunctuator)*
+ *[RegularExpressionLiteral](#RegularExpressionLiteral)*
+
+ *InputElementRegExpOrTemplateTail* **::**
+ *[WhiteSpace](#WhiteSpace)*
+ *[LineTerminator](#LineTerminator)*
+ *[Comment](#Comment)*
+ *[CommonToken](#CommonToken)*
+ *[RegularExpressionLiteral](#RegularExpressionLiteral)*
+ *[TemplateSubstitutionTail](#TemplateSubstitutionTail)*
+
+ *InputElementTemplateTail* **::**
+ *[WhiteSpace](#WhiteSpace)*
+ *[LineTerminator](#LineTerminator)*
+ *[Comment](#Comment)*
+ *[CommonToken](#CommonToken)*
+ *[DivPunctuator](#DivPunctuator)*
+ *[TemplateSubstitutionTail](#TemplateSubstitutionTail)*
+
+ *WhiteSpace* **::**
+ <TAB>
+ <VT>
+ <FF>
+ <SP>
+ <NBSP>
+ <ZWNBSP>
+ <USP>
+
+ *LineTerminator* **::**
+ <LF>
+ <CR>
+ <LS>
+ <PS>
+
+ *LineTerminatorSequence* **::**
+ <LF>
+ <CR> [lookahead ≠ <LF>]
+ <LS>
+ <PS>
+ <CR> <LF>
+
+ *Comment* **::**
+ *[MultiLineComment](#MultiLineComment)*
+ *[SingleLineComment](#SingleLineComment)*
+
+ *MultiLineComment* **::**
+ `` /* `` *[MultiLineCommentChars](#MultiLineCommentChars)*opt `` */ ``
+
+ *MultiLineCommentChars* **::**
+ *[MultiLineNotAsteriskChar](#MultiLineNotAsteriskChar)* *[MultiLineCommentChars](#MultiLineCommentChars)*opt
+ `` * `` *[PostAsteriskCommentChars](#PostAsteriskCommentChars)*opt
+
+ *PostAsteriskCommentChars* **::**
+ *[MultiLineNotForwardSlashOrAsteriskChar](#MultiLineNotForwardSlashOrAsteriskChar)* *[MultiLineCommentChars](#MultiLineCommentChars)*opt
+ `` * `` *[PostAsteriskCommentChars](#PostAsteriskCommentChars)*opt
+
+ *MultiLineNotAsteriskChar* **::**
+ *[SourceCharacter](#SourceCharacter)* **but not** `` * ``
+
+ *MultiLineNotForwardSlashOrAsteriskChar* **::**
+ *[SourceCharacter](#SourceCharacter)* **but not** **one of** `` / `` **or** `` * ``
+
+ *SingleLineComment* **::**
+ `` // `` *[SingleLineCommentChars](#SingleLineCommentChars)*opt
+
+ *SingleLineCommentChars* **::**
+ *[SingleLineCommentChar](#SingleLineCommentChar)* *[SingleLineCommentChars](#SingleLineCommentChars)*opt
+
+ *SingleLineCommentChar* **::**
+ *[SourceCharacter](#SourceCharacter)* **but not** *[LineTerminator](#LineTerminator)*
+
+ *CommonToken* **::**
+ *[IdentifierName](#IdentifierName)*
+ *[Punctuator](#Punctuator)*
+ *[NumericLiteral](#NumericLiteral)*
+ *[StringLiteral](#StringLiteral)*
+ *[Template](#Template)*
+
+ *IdentifierName* **::**
+ *[IdentifierStart](#IdentifierStart)*
+ *[IdentifierName](#IdentifierName)* *[IdentifierPart](#IdentifierPart)*
+
+ *IdentifierStart* **::**
+ *[UnicodeIDStart](#UnicodeIDStart)*
+ `` $ ``
+ `` _ ``
+ `` \ `` *[UnicodeEscapeSequence](#UnicodeEscapeSequence)*
+
+ *IdentifierPart* **::**
+ *[UnicodeIDContinue](#UnicodeIDContinue)*
+ `` $ ``
+ `` _ ``
+ `` \ `` *[UnicodeEscapeSequence](#UnicodeEscapeSequence)*
+ <ZWNJ>
+ <ZWJ>
+
+ *UnicodeIDStart* **::**
+ any Unicode code point with the Unicode property "ID_Start" or "Other_ID_Start"
+
+ *UnicodeIDContinue* **::**
+ any Unicode code point with the Unicode property "ID_Continue" or "Other_ID_Continue", or "Other_ID_Start"
+
+ *ReservedWord* **::**
+ *[Keyword](#Keyword)*
+ *[FutureReservedWord](#FutureReservedWord)*
+ *[NullLiteral](#NullLiteral)*
+ *[BooleanLiteral](#BooleanLiteral)*
+
+ *Keyword* **::** **one of**
+
break
do
in
typeof
case
+ else
instanceof
var
catch
export
+ new
void
class
extends
return
+ while
const
finally
super
with
+ continue
for
switch
yield
debugger
+ function
this
default
if
throw
+ delete
import
try
+
+ *FutureReservedWord* **::** **one of**
+ enum
await
implements
package
protected
+ interface
private
public
+
+ *Punctuator* **::** **one of**
+ {
}
(
)
[
]
.
;
,
<
+ >
<=
>=
==
!=
===
!==
+
-
*
+ %
++
--
<<
>>
>>>
&
|
^
!
+ ~
&&
||
?
::
=
+=
-=
*=
%=
+ <<=
>>=
>>>=
&=
|=
^=
=>
+
+ *DivPunctuator* **::** **one of**
+ /
/=
+
+ *RightBracePunctuator* **::** **one of**
+ )
+
+ *NullLiteral* **::**
+ `` null ``
+
+ *BooleanLiteral* **::**
+ `` true ``
+ `` false ``
+
+ *NumericLiteral* **::**
+ *[DecimalLiteral](#DecimalLiteral)*
+ *[BinaryIntegerLiteral](#BinaryIntegerLiteral)*
+ *[OctalIntegerLiteral](#OctalIntegerLiteral)*
+ *[HexIntegerLiteral](#HexIntegerLiteral)*
+
+ *DecimalLiteral* **::**
+ *[DecimalIntegerLiteral](#DecimalIntegerLiteral)* `` . `` *[DecimalDigits](#DecimalDigits)*opt *[ExponentPart](#ExponentPart)*opt
+ `` . `` *[DecimalDigits](#DecimalDigits)* *[ExponentPart](#ExponentPart)*opt
+ *[DecimalIntegerLiteral](#DecimalIntegerLiteral)* *[ExponentPart](#ExponentPart)*opt
+
+ *DecimalIntegerLiteral* **::**
+ `` 0 ``
+ *[NonZeroDigit](#NonZeroDigit)* *[DecimalDigits](#DecimalDigits)*opt
+
+ *DecimalDigits* **::**
+ *[DecimalDigit](#DecimalDigit)*
+ *[DecimalDigits](#DecimalDigits)* *[DecimalDigit](#DecimalDigit)*
+
+ *DecimalDigit* **::** **one of**
+ 0
1
2
3
4
5
6
7
8
9
+
+ *NonZeroDigit* **::** **one of**
+ 1
2
3
4
5
6
7
8
9
+
+ *ExponentPart* **::**
+ *[ExponentIndicator](#ExponentIndicator)* *[SignedInteger](#SignedInteger)*
+
+ *ExponentIndicator* **::** **one of**
+ e
E
+
+ *SignedInteger* **::**
+ *[DecimalDigits](#DecimalDigits)*
+ `` + `` *[DecimalDigits](#DecimalDigits)*
+ `` - `` *[DecimalDigits](#DecimalDigits)*
+
+ *BinaryIntegerLiteral* **::**
+ `` 0b `` *[BinaryDigits](#BinaryDigits)*
+ `` 0B `` *[BinaryDigits](#BinaryDigits)*
+
+ *BinaryDigits* **::**
+ *[BinaryDigit](#BinaryDigit)*
+ *[BinaryDigits](#BinaryDigits)* *[BinaryDigit](#BinaryDigit)*
+
+ *BinaryDigit* **::** **one of**
+ 0
1
+
+ *OctalIntegerLiteral* **::**
+ `` 0o `` *[OctalDigits](#OctalDigits)*
+ `` 0O `` *[OctalDigits](#OctalDigits)*
+
+ *OctalDigits* **::**
+ *[OctalDigit](#OctalDigit)*
+ *[OctalDigits](#OctalDigits)* *[OctalDigit](#OctalDigit)*
+
+ *OctalDigit* **::** **one of**
+ 0
1
2
3
4
5
6
7
+
+ *HexIntegerLiteral* **::**
+ `` 0x `` *[HexDigits](#HexDigits)*
+ `` 0X `` *[HexDigits](#HexDigits)*
+
+ *HexDigits* **::**
+ *[HexDigit](#HexDigit)*
+ *[HexDigits](#HexDigits)* *[HexDigit](#HexDigit)*
+
+ *HexDigit* **::** **one of**
+ 0
1
2
3
4
5
6
7
8
9
+ a
b
c
d
e
f
A
B
C
D
+ E
F
+
+ *StringLiteral* **::**
+ `` " `` *[DoubleStringCharacters](#DoubleStringCharacters)*opt `` " ``
+ `` ' `` *[SingleStringCharacters](#SingleStringCharacters)*opt `` ' ``
+
+ *DoubleStringCharacters* **::**
+ *[DoubleStringCharacter](#DoubleStringCharacter)* *[DoubleStringCharacters](#DoubleStringCharacters)*opt
+
+ *SingleStringCharacters* **::**
+ *[SingleStringCharacter](#SingleStringCharacter)* *[SingleStringCharacters](#SingleStringCharacters)*opt
+
+ *DoubleStringCharacter* **::**
+ *[SourceCharacter](#SourceCharacter)* **but not** **one of** `` " `` **or** `` \ `` **or** *[LineTerminator](#LineTerminator)*
+ `` \ `` *[EscapeSequence](#EscapeSequence)*
+ *[LineContinuation](#LineContinuation)*
+
+ *SingleStringCharacter* **::**
+ *[SourceCharacter](#SourceCharacter)* **but not** **one of** `` ' `` **or** `` \ `` **or** *[LineTerminator](#LineTerminator)*
+ `` \ `` *[EscapeSequence](#EscapeSequence)*
+ *[LineContinuation](#LineContinuation)*
+
+ *LineContinuation* **::**
+ `` \ `` *[LineTerminatorSequence](#LineTerminatorSequence)*
+
+ *EscapeSequence* **::**
+ *[CharacterEscapeSequence](#CharacterEscapeSequence)*
+ `` 0 `` [lookahead ≠ *[DecimalDigit](#DecimalDigit)*]
+ *[HexEscapeSequence](#HexEscapeSequence)*
+ *[UnicodeEscapeSequence](#UnicodeEscapeSequence)*
+
+ *CharacterEscapeSequence* **::**
+ *[SingleEscapeCharacter](#SingleEscapeCharacter)*
+ *[NonEscapeCharacter](#NonEscapeCharacter)*
+
+ *SingleEscapeCharacter* **::** **one of**
+ '
"
\
b
f
n
r
t
v
+
+ *NonEscapeCharacter* **::**
+ *[SourceCharacter](#SourceCharacter)* **but not** **one of** *[EscapeCharacter](#EscapeCharacter)* **or** *[LineTerminator](#LineTerminator)*
+
+ *EscapeCharacter* **::**
+ *[SingleEscapeCharacter](#SingleEscapeCharacter)*
+ *[DecimalDigit](#DecimalDigit)*
+ `` x ``
+ `` u ``
+
+ *HexEscapeSequence* **::**
+ `` x `` *[HexDigit](#HexDigit)* *[HexDigit](#HexDigit)*
+
+ *UnicodeEscapeSequence* **::**
+ `` u `` *[Hex4Digits](#Hex4Digits)*
+ `` u{ `` *[HexDigits](#HexDigits)* `` } ``
+
+ *Hex4Digits* **::**
+ *[HexDigit](#HexDigit)* *[HexDigit](#HexDigit)* *[HexDigit](#HexDigit)* *[HexDigit](#HexDigit)*
+
+ *RegularExpressionLiteral* **::**
+ `` / `` *[RegularExpressionBody](#RegularExpressionBody)* `` / `` *[RegularExpressionFlags](#RegularExpressionFlags)*
+
+ *RegularExpressionBody* **::**
+ *[RegularExpressionFirstChar](#RegularExpressionFirstChar)* *[RegularExpressionChars](#RegularExpressionChars)*
+
+ *RegularExpressionChars* **::**
+ [empty]
+ *[RegularExpressionChars](#RegularExpressionChars)* *[RegularExpressionChar](#RegularExpressionChar)*
+
+ *RegularExpressionFirstChar* **::**
+ *[RegularExpressionNonTerminator](#RegularExpressionNonTerminator)* **but not** **one of** `` * `` **or** `` \ `` **or** `` / `` **or** `` [ ``
+ *[RegularExpressionBackslashSequence](#RegularExpressionBackslashSequence)*
+ *[RegularExpressionClass](#RegularExpressionClass)*
+
+ *RegularExpressionChar* **::**
+ *[RegularExpressionNonTerminator](#RegularExpressionNonTerminator)* **but not** **one of** `` \ `` **or** `` / `` **or** `` [ ``
+ *[RegularExpressionBackslashSequence](#RegularExpressionBackslashSequence)*
+ *[RegularExpressionClass](#RegularExpressionClass)*
+
+ *RegularExpressionBackslashSequence* **::**
+ `` \ `` *[RegularExpressionNonTerminator](#RegularExpressionNonTerminator)*
+
+ *RegularExpressionNonTerminator* **::**
+ *[SourceCharacter](#SourceCharacter)* **but not** *[LineTerminator](#LineTerminator)*
+
+ *RegularExpressionClass* **::**
+ `` [ `` *[RegularExpressionClassChars](#RegularExpressionClassChars)* `` ] ``
+
+ *RegularExpressionClassChars* **::**
+ [empty]
+ *[RegularExpressionClassChars](#RegularExpressionClassChars)* *[RegularExpressionClassChar](#RegularExpressionClassChar)*
+
+ *RegularExpressionClassChar* **::**
+ *[RegularExpressionNonTerminator](#RegularExpressionNonTerminator)* **but not** **one of** `` ] `` **or** `` \ ``
+ *[RegularExpressionBackslashSequence](#RegularExpressionBackslashSequence)*
+
+ *RegularExpressionFlags* **::**
+ [empty]
+ *[RegularExpressionFlags](#RegularExpressionFlags)* *[IdentifierPart](#IdentifierPart)*
+
+ *Template* **::**
+ *[NoSubstitutionTemplate](#NoSubstitutionTemplate)*
+ *[TemplateHead](#TemplateHead)*
+
+ *NoSubstitutionTemplate* **::**
+ `` ` `` *[TemplateCharacters](#TemplateCharacters)*opt `` ` ``
+
+ *TemplateHead* **::**
+ `` ` `` *[TemplateCharacters](#TemplateCharacters)*opt `` ${ ``
+
+ *TemplateSubstitutionTail* **::**
+ *[TemplateMiddle](#TemplateMiddle)*
+ *[TemplateTail](#TemplateTail)*
+
+ *TemplateMiddle* **::**
+ `` } `` *[TemplateCharacters](#TemplateCharacters)*opt `` ${ ``
+
+ *TemplateTail* **::**
+ `` } `` *[TemplateCharacters](#TemplateCharacters)*opt `` ` ``
+
+ *TemplateCharacters* **::**
+ *[TemplateCharacter](#TemplateCharacter)* *[TemplateCharacters](#TemplateCharacters)*opt
+
+ *TemplateCharacter* **::**
+ `` $ `` [lookahead ≠ `` { ``]
+ `` \ `` *[EscapeSequence](#EscapeSequence)*
+ *[LineContinuation](#LineContinuation)*
+ *[LineTerminatorSequence](#LineTerminatorSequence)*
+ *[SourceCharacter](#SourceCharacter)* **but not** **one of** `` ` `` **or** `` \ `` **or** `` $ `` **or** *[LineTerminator](#LineTerminator)*
+
+ *IdentifierReference*[Yield] **:**
+ *[Identifier](#Identifier)*
+ [~Yield] `` yield ``
+
+ *BindingIdentifier*[Yield] **:**
+ *[Identifier](#Identifier)*
+ [~Yield] `` yield ``
+
+ *LabelIdentifier*[Yield] **:**
+ *[Identifier](#Identifier)*
+ [~Yield] `` yield ``
+
+ *Identifier* **:**
+ *[IdentifierName](#IdentifierName)* **but not** *[ReservedWord](#ReservedWord)*
+
+ *PrimaryExpression*[Yield] **:**
+ `` this ``
+ *[IdentifierReference](#IdentifierReference)*[?Yield]
+ *[Literal](#Literal)*
+ *[ArrayLiteral](#ArrayLiteral)*[?Yield]
+ *[ObjectLiteral](#ObjectLiteral)*[?Yield]
+ *[FunctionExpression](#FunctionExpression)*
+ *[ClassExpression](#ClassExpression)*[?Yield]
+ *[GeneratorExpression](#GeneratorExpression)*
+ *[RegularExpressionLiteral](#RegularExpressionLiteral)*
+ *[TemplateLiteral](#TemplateLiteral)*[?Yield]
+ *[CoverParenthesizedExpressionAndArrowParameterList](#CoverParenthesizedExpressionAndArrowParameterList)*[?Yield]
+
+ *CoverParenthesizedExpressionAndArrowParameterList*[Yield] **:**
+ `` ( `` *[Expression](#Expression)*[+In, ?Yield] `` ) ``
+ `` ( `` `` ) ``
+ `` ( `` `` ... `` *[BindingIdentifier](#BindingIdentifier)*[?Yield] `` ) ``
+ `` ( `` *[Expression](#Expression)*[+In, ?Yield] `` , `` `` ... `` *[BindingIdentifier](#BindingIdentifier)*[?Yield] `` ) ``
+
+ *Literal* **:**
+ *[NullLiteral](#NullLiteral)*
+ *[BooleanLiteral](#BooleanLiteral)*
+ *[NumericLiteral](#NumericLiteral)*
+ *[StringLiteral](#StringLiteral)*
+
+ *ArrayLiteral*[Yield] **:**
+ `` [ `` *[Elision](#Elision)*opt `` ] ``
+ `` [ `` *[ElementList](#ElementList)*[?Yield] `` ] ``
+ `` [ `` *[ElementList](#ElementList)*[?Yield] `` , `` *[Elision](#Elision)*opt `` ] ``
+
+ *ElementList*[Yield] **:**
+ *[Elision](#Elision)*opt *[AssignmentExpression](#AssignmentExpression)*[In, ?Yield]
+ *[Elision](#Elision)*opt *[SpreadElement](#SpreadElement)*[?Yield]
+ *[ElementList](#ElementList)*[?Yield] `` , `` *[Elision](#Elision)*opt *[AssignmentExpression](#AssignmentExpression)*[In, ?Yield]
+ *[ElementList](#ElementList)*[?Yield] `` , `` *[Elision](#Elision)*opt *[SpreadElement](#SpreadElement)*[?Yield]
+
+ *Elision* **:**
+ `` , ``
+ *[Elision](#Elision)* `` , ``
+
+ *SpreadElement*[Yield] **:**
+ `` ... `` *[AssignmentExpression](#AssignmentExpression)*[In, ?Yield]
+
+ *ObjectLiteral*[Yield] **:**
+ `` { `` `` } ``
+ `` { `` *[PropertyDefinitionList](#PropertyDefinitionList)*[?Yield] `` } ``
+ `` { `` *[PropertyDefinitionList](#PropertyDefinitionList)*[?Yield] `` , `` `` } ``
+
+ *PropertyDefinitionList*[Yield] **:**
+ *[PropertyDefinition](#PropertyDefinition)*[?Yield]
+ *[PropertyDefinitionList](#PropertyDefinitionList)*[?Yield] `` , `` *[PropertyDefinition](#PropertyDefinition)*[?Yield]
+
+ *PropertyDefinition*[Yield] **:**
+ *[IdentifierReference](#IdentifierReference)*[?Yield]
+ *[CoverInitializedName](#CoverInitializedName)*[?Yield]
+ *[PropertyName](#PropertyName)*[?Yield] `` : `` *[AssignmentExpression](#AssignmentExpression)*[In, ?Yield]
+ *[MethodDefinition](#MethodDefinition)*[?Yield]
+
+ *PropertyName*[Yield] **:**
+ *[LiteralPropertyName](#LiteralPropertyName)*
+ *[ComputedPropertyName](#ComputedPropertyName)*[?Yield]
+
+ *LiteralPropertyName* **:**
+ *[IdentifierName](#IdentifierName)*
+ *[StringLiteral](#StringLiteral)*
+ *[NumericLiteral](#NumericLiteral)*
+
+ *ComputedPropertyName*[Yield] **:**
+ `` [ `` *[AssignmentExpression](#AssignmentExpression)*[In, ?Yield] `` ] ``
+
+ *CoverInitializedName*[Yield] **:**
+ *[IdentifierReference](#IdentifierReference)*[?Yield] *[Initializer](#Initializer)*[In, ?Yield]
+
+ *Initializer*[In, Yield] **:**
+ `` = `` *[AssignmentExpression](#AssignmentExpression)*[?In, ?Yield]
+
+ *TemplateLiteral*[Yield] **:**
+ *[NoSubstitutionTemplate](#NoSubstitutionTemplate)*
+ *[TemplateHead](#TemplateHead)* *[Expression](#Expression)*[In, ?Yield] *[TemplateSpans](#TemplateSpans)*[?Yield]
+
+ *TemplateSpans*[Yield] **:**
+ *[TemplateTail](#TemplateTail)*
+ *[TemplateMiddleList](#TemplateMiddleList)*[?Yield] *[TemplateTail](#TemplateTail)*
+
+ *TemplateMiddleList*[Yield] **:**
+ *[TemplateMiddle](#TemplateMiddle)* *[Expression](#Expression)*[In, ?Yield]
+ *[TemplateMiddleList](#TemplateMiddleList)*[?Yield] *[TemplateMiddle](#TemplateMiddle)* *[Expression](#Expression)*[In, ?Yield]
+
+ *MemberExpression*[Yield] **:**
+ *[PrimaryExpression](#PrimaryExpression)*[?Yield]
+ *[MemberExpression](#MemberExpression)*[?Yield] `` [ `` *[Expression](#Expression)*[In, ?Yield] `` ] ``
+ *[MemberExpression](#MemberExpression)*[?Yield] `` . `` *[IdentifierName](#IdentifierName)*
+ *[MemberExpression](#MemberExpression)*[?Yield] *[TemplateLiteral](#TemplateLiteral)*[?Yield]
+ *[SuperProperty](#SuperProperty)*[?Yield]
+ *[MetaProperty](#MetaProperty)*
+ `` new `` *[MemberExpression](#MemberExpression)*[?Yield] *[Arguments](#Arguments)*[?Yield]
+
+ *SuperProperty*[Yield] **:**
+ `` super `` `` [ `` *[Expression](#Expression)*[In, ?Yield] `` ] ``
+ `` super `` `` . `` *[IdentifierName](#IdentifierName)*
+
+ *MetaProperty* **:**
+ *[NewTarget](#NewTarget)*
+
+ *NewTarget* **:**
+ `` new `` `` . `` `` target ``
+
+ *NewExpression*[Yield] **:**
+ *[MemberExpression](#MemberExpression)*[?Yield]
+ `` new `` *[NewExpression](#NewExpression)*[?Yield]
+
+ *CallExpression*[Yield] **:**
+ *[MemberExpression](#MemberExpression)*[?Yield] *[Arguments](#Arguments)*[?Yield]
+ *[SuperCall](#SuperCall)*[?Yield]
+ *[CallExpression](#CallExpression)*[?Yield] *[Arguments](#Arguments)*[?Yield]
+ *[CallExpression](#CallExpression)*[?Yield] `` [ `` *[Expression](#Expression)*[In, ?Yield] `` ] ``
+ *[CallExpression](#CallExpression)*[?Yield] `` . `` *[IdentifierName](#IdentifierName)*
+ *[CallExpression](#CallExpression)*[?Yield] *[TemplateLiteral](#TemplateLiteral)*[?Yield]
+
+ *SuperCall*[Yield] **:**
+ `` super `` *[Arguments](#Arguments)*[?Yield]
+
+ *Arguments*[Yield] **:**
+ `` ( `` `` ) ``
+ `` ( `` *[ArgumentList](#ArgumentList)*[?Yield] `` ) ``
+
+ *ArgumentList*[Yield] **:**
+ *[AssignmentExpression](#AssignmentExpression)*[In, ?Yield]
+ `` ... `` *[AssignmentExpression](#AssignmentExpression)*[In, ?Yield]
+ *[ArgumentList](#ArgumentList)*[?Yield] `` , `` *[AssignmentExpression](#AssignmentExpression)*[In, ?Yield]
+ *[ArgumentList](#ArgumentList)*[?Yield] `` , `` `` ... `` *[AssignmentExpression](#AssignmentExpression)*[In, ?Yield]
+
+ *LeftHandSideExpression*[Yield] **:**
+ *[NewExpression](#NewExpression)*[?Yield]
+ *[CallExpression](#CallExpression)*[?Yield]
+
+ *PostfixExpression*[Yield] **:**
+ *[LeftHandSideExpression](#LeftHandSideExpression)*[?Yield]
+ *[LeftHandSideExpression](#LeftHandSideExpression)*[?Yield] [no *[LineTerminator](#LineTerminator)* here] `` ++ ``
+ *[LeftHandSideExpression](#LeftHandSideExpression)*[?Yield] [no *[LineTerminator](#LineTerminator)* here] `` -- ``
+
+ *UnaryExpression*[Yield] **:**
+ *[PostfixExpression](#PostfixExpression)*[?Yield]
+ `` delete `` *[UnaryExpression](#UnaryExpression)*[?Yield]
+ `` void `` *[UnaryExpression](#UnaryExpression)*[?Yield]
+ `` typeof `` *[UnaryExpression](#UnaryExpression)*[?Yield]
+ `` ++ `` *[UnaryExpression](#UnaryExpression)*[?Yield]
+ `` -- `` *[UnaryExpression](#UnaryExpression)*[?Yield]
+ `` + `` *[UnaryExpression](#UnaryExpression)*[?Yield]
+ `` - `` *[UnaryExpression](#UnaryExpression)*[?Yield]
+ `` ~ `` *[UnaryExpression](#UnaryExpression)*[?Yield]
+ `` ! `` *[UnaryExpression](#UnaryExpression)*[?Yield]
+
+ *MultiplicativeExpression*[Yield] **:**
+ *[UnaryExpression](#UnaryExpression)*[?Yield]
+ *[MultiplicativeExpression](#MultiplicativeExpression)*[?Yield] *[MultiplicativeOperator](#MultiplicativeOperator)* *[UnaryExpression](#UnaryExpression)*[?Yield]
+
+ *MultiplicativeOperator* **:** **one of**
+ *
/
%
+
+ *AdditiveExpression*[Yield] **:**
+ *[MultiplicativeExpression](#MultiplicativeExpression)*[?Yield]
+ *[AdditiveExpression](#AdditiveExpression)*[?Yield] `` + `` *[MultiplicativeExpression](#MultiplicativeExpression)*[?Yield]
+ *[AdditiveExpression](#AdditiveExpression)*[?Yield] `` - `` *[MultiplicativeExpression](#MultiplicativeExpression)*[?Yield]
+
+ *ShiftExpression*[Yield] **:**
+ *[AdditiveExpression](#AdditiveExpression)*[?Yield]
+ *[ShiftExpression](#ShiftExpression)*[?Yield] `` << `` *[AdditiveExpression](#AdditiveExpression)*[?Yield]
+ *[ShiftExpression](#ShiftExpression)*[?Yield] `` >> `` *[AdditiveExpression](#AdditiveExpression)*[?Yield]
+ *[ShiftExpression](#ShiftExpression)*[?Yield] `` >>> `` *[AdditiveExpression](#AdditiveExpression)*[?Yield]
+
+ *RelationalExpression*[In, Yield] **:**
+ *[ShiftExpression](#ShiftExpression)*[?Yield]
+ *[RelationalExpression](#RelationalExpression)*[?In, ?Yield] `` < `` *[ShiftExpression](#ShiftExpression)*[?Yield]
+ *[RelationalExpression](#RelationalExpression)*[?In, ?Yield] `` > `` *[ShiftExpression](#ShiftExpression)*[?Yield]
+ *[RelationalExpression](#RelationalExpression)*[?In, ?Yield] `` <= `` *[ShiftExpression](#ShiftExpression)*[?Yield]
+ *[RelationalExpression](#RelationalExpression)*[?In, ?Yield] `` >= `` *[ShiftExpression](#ShiftExpression)*[?Yield]
+ *[RelationalExpression](#RelationalExpression)*[?In, ?Yield] `` instanceof `` *[ShiftExpression](#ShiftExpression)*[?Yield]
+ [+In] *[RelationalExpression](#RelationalExpression)*[In, ?Yield] `` in `` *[ShiftExpression](#ShiftExpression)*[?Yield]
+
+ *EqualityExpression*[In, Yield] **:**
+ *[RelationalExpression](#RelationalExpression)*[?In, ?Yield]
+ *[EqualityExpression](#EqualityExpression)*[?In, ?Yield] `` == `` *[RelationalExpression](#RelationalExpression)*[?In, ?Yield]
+ *[EqualityExpression](#EqualityExpression)*[?In, ?Yield] `` != `` *[RelationalExpression](#RelationalExpression)*[?In, ?Yield]
+ *[EqualityExpression](#EqualityExpression)*[?In, ?Yield] `` === `` *[RelationalExpression](#RelationalExpression)*[?In, ?Yield]
+ *[EqualityExpression](#EqualityExpression)*[?In, ?Yield] `` !== `` *[RelationalExpression](#RelationalExpression)*[?In, ?Yield]
+
+ *BitwiseANDExpression*[In, Yield] **:**
+ *[EqualityExpression](#EqualityExpression)*[?In, ?Yield]
+ *[BitwiseANDExpression](#BitwiseANDExpression)*[?In, ?Yield] `` & `` *[EqualityExpression](#EqualityExpression)*[?In, ?Yield]
+
+ *BitwiseXORExpression*[In, Yield] **:**
+ *[BitwiseANDExpression](#BitwiseANDExpression)*[?In, ?Yield]
+ *[BitwiseXORExpression](#BitwiseXORExpression)*[?In, ?Yield] `` ^ `` *[BitwiseANDExpression](#BitwiseANDExpression)*[?In, ?Yield]
+
+ *BitwiseORExpression*[In, Yield] **:**
+ *[BitwiseXORExpression](#BitwiseXORExpression)*[?In, ?Yield]
+ *[BitwiseORExpression](#BitwiseORExpression)*[?In, ?Yield] `` | `` *[BitwiseXORExpression](#BitwiseXORExpression)*[?In, ?Yield]
+
+ *LogicalANDExpression*[In, Yield] **:**
+ *[BitwiseORExpression](#BitwiseORExpression)*[?In, ?Yield]
+ *[LogicalANDExpression](#LogicalANDExpression)*[?In, ?Yield] `` && `` *[BitwiseORExpression](#BitwiseORExpression)*[?In, ?Yield]
+
+ *LogicalORExpression*[In, Yield] **:**
+ *[LogicalANDExpression](#LogicalANDExpression)*[?In, ?Yield]
+ *[LogicalORExpression](#LogicalORExpression)*[?In, ?Yield] `` || `` *[LogicalANDExpression](#LogicalANDExpression)*[?In, ?Yield]
+
+ *ConditionalExpression*[In, Yield] **:**
+ *[LogicalORExpression](#LogicalORExpression)*[?In, ?Yield]
+ *[LogicalORExpression](#LogicalORExpression)*[?In, ?Yield] `` ? `` *[AssignmentExpression](#AssignmentExpression)*[In, ?Yield] `` : `` *[AssignmentExpression](#AssignmentExpression)*[?In, ?Yield]
+
+ *AssignmentExpression*[In, Yield] **:**
+ *[ConditionalExpression](#ConditionalExpression)*[?In, ?Yield]
+ [+Yield] *[YieldExpression](#YieldExpression)*[?In]
+ *[ArrowFunction](#ArrowFunction)*[?In, ?Yield]
+ *[LeftHandSideExpression](#LeftHandSideExpression)*[?Yield] `` = `` *[AssignmentExpression](#AssignmentExpression)*[?In, ?Yield]
+ *[LeftHandSideExpression](#LeftHandSideExpression)*[?Yield] *[AssignmentOperator](#AssignmentOperator)* *[AssignmentExpression](#AssignmentExpression)*[?In, ?Yield]
+
+ *AssignmentOperator* **:** **one of**
+ *=
/=
%=
+=
-=
<<=
>>=
>>>=
&=
^=
+ |=
+
+ *Expression*[In, Yield] **:**
+ *[AssignmentExpression](#AssignmentExpression)*[?In, ?Yield]
+ *[Expression](#Expression)*[?In, ?Yield] `` , `` *[AssignmentExpression](#AssignmentExpression)*[?In, ?Yield]
+
+ *Statement*[Yield, Return] **:**
+ *[BlockStatement](#BlockStatement)*[?Yield, ?Return]
+ *[VariableStatement](#VariableStatement)*[?Yield]
+ *[EmptyStatement](#EmptyStatement)*
+ *[ExpressionStatement](#ExpressionStatement)*[?Yield]
+ *[IfStatement](#IfStatement)*[?Yield, ?Return]
+ *[BreakableStatement](#BreakableStatement)*[?Yield, ?Return]
+ *[ContinueStatement](#ContinueStatement)*[?Yield]
+ *[BreakStatement](#BreakStatement)*[?Yield]
+ [+Return] *[ReturnStatement](#ReturnStatement)*[?Yield]
+ *[WithStatement](#WithStatement)*[?Yield, ?Return]
+ *[LabelledStatement](#LabelledStatement)*[?Yield, ?Return]
+ *[ThrowStatement](#ThrowStatement)*[?Yield]
+ *[TryStatement](#TryStatement)*[?Yield, ?Return]
+ *[DebuggerStatement](#DebuggerStatement)*
+
+ *Declaration*[Yield] **:**
+ *[HoistableDeclaration](#HoistableDeclaration)*[?Yield]
+ *[ClassDeclaration](#ClassDeclaration)*[?Yield]
+ *[LexicalDeclaration](#LexicalDeclaration)*[In, ?Yield]
+
+ *HoistableDeclaration*[Yield, Default] **:**
+ *[FunctionDeclaration](#FunctionDeclaration)*[?Yield, ?Default]
+ *[GeneratorDeclaration](#GeneratorDeclaration)*[?Yield, ?Default]
+
+ *BreakableStatement*[Yield, Return] **:**
+ *[IterationStatement](#IterationStatement)*[?Yield, ?Return]
+ *[SwitchStatement](#SwitchStatement)*[?Yield, ?Return]
+
+ *BlockStatement*[Yield, Return] **:**
+ *[Block](#Block)*[?Yield, ?Return]
+
+ *Block*[Yield, Return] **:**
+ `` { `` *[StatementList](#StatementList)*[?Yield, ?Return]opt `` } ``
+
+ *StatementList*[Yield, Return] **:**
+ *[StatementListItem](#StatementListItem)*[?Yield, ?Return]
+ *[StatementList](#StatementList)*[?Yield, ?Return] *[StatementListItem](#StatementListItem)*[?Yield, ?Return]
+
+ *StatementListItem*[Yield, Return] **:**
+ *[Statement](#Statement)*[?Yield, ?Return]
+ *[Declaration](#Declaration)*[?Yield]
+
+ *LexicalDeclaration*[In, Yield] **:**
+ *[LetOrConst](#LetOrConst)* *[BindingList](#BindingList)*[?In, ?Yield] `` ; ``
+
+ *LetOrConst* **:**
+ `` let ``
+ `` const ``
+
+ *BindingList*[In, Yield] **:**
+ *[LexicalBinding](#LexicalBinding)*[?In, ?Yield]
+ *[BindingList](#BindingList)*[?In, ?Yield] `` , `` *[LexicalBinding](#LexicalBinding)*[?In, ?Yield]
+
+ *LexicalBinding*[In, Yield] **:**
+ *[BindingIdentifier](#BindingIdentifier)*[?Yield] *[Initializer](#Initializer)*[?In, ?Yield]opt
+ *[BindingPattern](#BindingPattern)*[?Yield] *[Initializer](#Initializer)*[?In, ?Yield]
+
+ *VariableStatement*[Yield] **:**
+ `` var `` *[VariableDeclarationList](#VariableDeclarationList)*[In, ?Yield] `` ; ``
+
+ *VariableDeclarationList*[In, Yield] **:**
+ *[VariableDeclaration](#VariableDeclaration)*[?In, ?Yield]
+ *[VariableDeclarationList](#VariableDeclarationList)*[?In, ?Yield] `` , `` *[VariableDeclaration](#VariableDeclaration)*[?In, ?Yield]
+
+ *VariableDeclaration*[In, Yield] **:**
+ *[BindingIdentifier](#BindingIdentifier)*[?Yield] *[Initializer](#Initializer)*[?In, ?Yield]opt
+ *[BindingPattern](#BindingPattern)*[?Yield] *[Initializer](#Initializer)*[?In, ?Yield]
+
+ *BindingPattern*[Yield] **:**
+ *[ObjectBindingPattern](#ObjectBindingPattern)*[?Yield]
+ *[ArrayBindingPattern](#ArrayBindingPattern)*[?Yield]
+
+ *ObjectBindingPattern*[Yield] **:**
+ `` { `` `` } ``
+ `` { `` *[BindingPropertyList](#BindingPropertyList)*[?Yield] `` } ``
+ `` { `` *[BindingPropertyList](#BindingPropertyList)*[?Yield] `` , `` `` } ``
+
+ *ArrayBindingPattern*[Yield] **:**
+ `` [ `` *[Elision](#Elision)*opt *[BindingRestElement](#BindingRestElement)*[?Yield]opt `` ] ``
+ `` [ `` *[BindingElementList](#BindingElementList)*[?Yield] `` ] ``
+ `` [ `` *[BindingElementList](#BindingElementList)*[?Yield] `` , `` *[Elision](#Elision)*opt *[BindingRestElement](#BindingRestElement)*[?Yield]opt `` ] ``
+
+ *BindingPropertyList*[Yield] **:**
+ *[BindingProperty](#BindingProperty)*[?Yield]
+ *[BindingPropertyList](#BindingPropertyList)*[?Yield] `` , `` *[BindingProperty](#BindingProperty)*[?Yield]
+
+ *BindingElementList*[Yield] **:**
+ *[BindingElisionElement](#BindingElisionElement)*[?Yield]
+ *[BindingElementList](#BindingElementList)*[?Yield] `` , `` *[BindingElisionElement](#BindingElisionElement)*[?Yield]
+
+ *BindingElisionElement*[Yield] **:**
+ *[Elision](#Elision)*opt *[BindingElement](#BindingElement)*[?Yield]
+
+ *BindingProperty*[Yield] **:**
+ *[SingleNameBinding](#SingleNameBinding)*[?Yield]
+ *[PropertyName](#PropertyName)*[?Yield] `` : `` *[BindingElement](#BindingElement)*[?Yield]
+
+ *BindingElement*[Yield] **:**
+ *[SingleNameBinding](#SingleNameBinding)*[?Yield]
+ *[BindingPattern](#BindingPattern)*[?Yield] *[Initializer](#Initializer)*[In, ?Yield]opt
+
+ *SingleNameBinding*[Yield] **:**
+ *[BindingIdentifier](#BindingIdentifier)*[?Yield] *[Initializer](#Initializer)*[In, ?Yield]opt
+
+ *BindingRestElement*[Yield] **:**
+ `` ... `` *[BindingIdentifier](#BindingIdentifier)*[?Yield]
+
+ *EmptyStatement* **:**
+ `` ; ``
+
+ *ExpressionStatement*[Yield] **:**
+ [lookahead ∉ { `` { ``, `` function ``, `` class ``, `` let `` `` [ `` }] *[Expression](#Expression)*[In, ?Yield] `` ; ``
+
+ *IfStatement*[Yield, Return] **:**
+ `` if `` `` ( `` *[Expression](#Expression)*[In, ?Yield] `` ) `` *[Statement](#Statement)*[?Yield, ?Return] `` else `` *[Statement](#Statement)*[?Yield, ?Return]
+ `` if `` `` ( `` *[Expression](#Expression)*[In, ?Yield] `` ) `` *[Statement](#Statement)*[?Yield, ?Return]
+
+ *IterationStatement*[Yield, Return] **:**
+ `` do `` *[Statement](#Statement)*[?Yield, ?Return] `` while `` `` ( `` *[Expression](#Expression)*[In, ?Yield] `` ) `` `` ; ``
+ `` while `` `` ( `` *[Expression](#Expression)*[In, ?Yield] `` ) `` *[Statement](#Statement)*[?Yield, ?Return]
+ `` for `` `` ( `` [lookahead ∉ { `` let `` `` [ `` }] *[Expression](#Expression)*[?Yield]opt `` ; `` *[Expression](#Expression)*[In, ?Yield]opt `` ; `` *[Expression](#Expression)*[In, ?Yield]opt `` ) `` *[Statement](#Statement)*[?Yield, ?Return]
+ `` for `` `` ( `` `` var `` *[VariableDeclarationList](#VariableDeclarationList)*[?Yield] `` ; `` *[Expression](#Expression)*[In, ?Yield]opt `` ; `` *[Expression](#Expression)*[In, ?Yield]opt `` ) `` *[Statement](#Statement)*[?Yield, ?Return]
+ `` for `` `` ( `` *[LexicalDeclaration](#LexicalDeclaration)*[?Yield] *[Expression](#Expression)*[In, ?Yield]opt `` ; `` *[Expression](#Expression)*[In, ?Yield]opt `` ) `` *[Statement](#Statement)*[?Yield, ?Return]
+ `` for `` `` ( `` [lookahead ∉ { `` let `` `` [ `` }] *[LeftHandSideExpression](#LeftHandSideExpression)*[?Yield] `` in `` *[Expression](#Expression)*[In, ?Yield] `` ) `` *[Statement](#Statement)*[?Yield, ?Return]
+ `` for `` `` ( `` `` var `` *[ForBinding](#ForBinding)*[?Yield] `` in `` *[Expression](#Expression)*[In, ?Yield] `` ) `` *[Statement](#Statement)*[?Yield, ?Return]
+ `` for `` `` ( `` *[ForDeclaration](#ForDeclaration)*[?Yield] `` in `` *[Expression](#Expression)*[In, ?Yield] `` ) `` *[Statement](#Statement)*[?Yield, ?Return]
+ `` for `` `` ( `` [lookahead ≠ `` let ``] *[LeftHandSideExpression](#LeftHandSideExpression)*[?Yield] `` of `` *[AssignmentExpression](#AssignmentExpression)*[In, ?Yield] `` ) `` *[Statement](#Statement)*[?Yield, ?Return]
+ `` for `` `` ( `` `` var `` *[ForBinding](#ForBinding)*[?Yield] `` of `` *[AssignmentExpression](#AssignmentExpression)*[In, ?Yield] `` ) `` *[Statement](#Statement)*[?Yield, ?Return]
+ `` for `` `` ( `` *[ForDeclaration](#ForDeclaration)*[?Yield] `` of `` *[AssignmentExpression](#AssignmentExpression)*[In, ?Yield] `` ) `` *[Statement](#Statement)*[?Yield, ?Return]
+
+ *ForDeclaration*[Yield] **:**
+ *[LetOrConst](#LetOrConst)* *[ForBinding](#ForBinding)*[?Yield]
+
+ *ForBinding*[Yield] **:**
+ *[BindingIdentifier](#BindingIdentifier)*[?Yield]
+ *[BindingPattern](#BindingPattern)*[?Yield]
+
+ *ContinueStatement*[Yield] **:**
+ `` continue `` `` ; ``
+ `` continue `` [no *[LineTerminator](#LineTerminator)* here] *[LabelIdentifier](#LabelIdentifier)*[?Yield] `` ; ``
+
+ *BreakStatement*[Yield] **:**
+ `` break `` `` ; ``
+ `` break `` [no *[LineTerminator](#LineTerminator)* here] *[LabelIdentifier](#LabelIdentifier)*[?Yield] `` ; ``
+
+ *ReturnStatement*[Yield] **:**
+ `` return `` `` ; ``
+ `` return `` [no *[LineTerminator](#LineTerminator)* here] *[Expression](#Expression)*[In, ?Yield] `` ; ``
+
+ *WithStatement*[Yield, Return] **:**
+ `` with `` `` ( `` *[Expression](#Expression)*[In, ?Yield] `` ) `` *[Statement](#Statement)*[?Yield, ?Return]
+
+ *SwitchStatement*[Yield, Return] **:**
+ `` switch `` `` ( `` *[Expression](#Expression)*[In, ?Yield] `` ) `` *[CaseBlock](#CaseBlock)*[?Yield, ?Return]
+
+ *CaseBlock*[Yield, Return] **:**
+ `` { `` *[CaseClauses](#CaseClauses)*[?Yield, ?Return]opt `` } ``
+ `` { `` *[CaseClauses](#CaseClauses)*[?Yield, ?Return]opt *[DefaultClause](#DefaultClause)*[?Yield, ?Return] *[CaseClauses](#CaseClauses)*[?Yield, ?Return]opt `` } ``
+
+ *CaseClauses*[Yield, Return] **:**
+ *[CaseClause](#CaseClause)*[?Yield, ?Return]
+ *[CaseClauses](#CaseClauses)*[?Yield, ?Return] *[CaseClause](#CaseClause)*[?Yield, ?Return]
+
+ *CaseClause*[Yield, Return] **:**
+ `` case `` *[Expression](#Expression)*[In, ?Yield] `` : `` *[StatementList](#StatementList)*[?Yield, ?Return]opt
+
+ *DefaultClause*[Yield, Return] **:**
+ `` default `` `` : `` *[StatementList](#StatementList)*[?Yield, ?Return]opt
+
+ *LabelledStatement*[Yield, Return] **:**
+ *[LabelIdentifier](#LabelIdentifier)*[?Yield] `` : `` *[LabelledItem](#LabelledItem)*[?Yield, ?Return]
+
+ *LabelledItem*[Yield, Return] **:**
+ *[Statement](#Statement)*[?Yield, ?Return]
+ *[FunctionDeclaration](#FunctionDeclaration)*[?Yield]
+
+ *ThrowStatement*[Yield] **:**
+ `` throw `` [no *[LineTerminator](#LineTerminator)* here] *[Expression](#Expression)*[In, ?Yield] `` ; ``
+
+ *TryStatement*[Yield, Return] **:**
+ `` try `` *[Block](#Block)*[?Yield, ?Return] *[Catch](#Catch)*[?Yield, ?Return]
+ `` try `` *[Block](#Block)*[?Yield, ?Return] *[Finally](#Finally)*[?Yield, ?Return]
+ `` try `` *[Block](#Block)*[?Yield, ?Return] *[Catch](#Catch)*[?Yield, ?Return] *[Finally](#Finally)*[?Yield, ?Return]
+
+ *Catch*[Yield, Return] **:**
+ `` catch `` `` ( `` *[CatchParameter](#CatchParameter)*[?Yield] `` ) `` *[Block](#Block)*[?Yield, ?Return]
+
+ *Finally*[Yield, Return] **:**
+ `` finally `` *[Block](#Block)*[?Yield, ?Return]
+
+ *CatchParameter*[Yield] **:**
+ *[BindingIdentifier](#BindingIdentifier)*[?Yield]
+ *[BindingPattern](#BindingPattern)*[?Yield]
+
+ *DebuggerStatement* **:**
+ `` debugger `` `` ; ``
+
+ *FunctionDeclaration*[Yield, Default] **:**
+ `` function `` *[BindingIdentifier](#BindingIdentifier)*[?Yield] `` ( `` *[FormalParameters](#FormalParameters)* `` ) `` `` { `` *[FunctionBody](#FunctionBody)* `` } ``
+ [+Default] `` function `` `` ( `` *[FormalParameters](#FormalParameters)* `` ) `` `` { `` *[FunctionBody](#FunctionBody)* `` } ``
+
+ *FunctionExpression* **:**
+ `` function `` *[BindingIdentifier](#BindingIdentifier)*opt `` ( `` *[FormalParameters](#FormalParameters)* `` ) `` `` { `` *[FunctionBody](#FunctionBody)* `` } ``
+
+ *StrictFormalParameters*[Yield] **:**
+ *[FormalParameters](#FormalParameters)*[?Yield]
+
+ *FormalParameters*[Yield] **:**
+ [empty]
+ *[FormalParameterList](#FormalParameterList)*[?Yield]
+
+ *FormalParameterList*[Yield] **:**
+ *[FunctionRestParameter](#FunctionRestParameter)*[?Yield]
+ *[FormalsList](#FormalsList)*[?Yield]
+ *[FormalsList](#FormalsList)*[?Yield] `` , `` *[FunctionRestParameter](#FunctionRestParameter)*[?Yield]
+
+ *FormalsList*[Yield] **:**
+ *[FormalParameter](#FormalParameter)*[?Yield]
+ *[FormalsList](#FormalsList)*[?Yield] `` , `` *[FormalParameter](#FormalParameter)*[?Yield]
+
+ *FunctionRestParameter*[Yield] **:**
+ *[BindingRestElement](#BindingRestElement)*[?Yield]
+
+ *FormalParameter*[Yield] **:**
+ *[BindingElement](#BindingElement)*[?Yield]
+
+ *FunctionBody*[Yield] **:**
+ *[FunctionStatementList](#FunctionStatementList)*[?Yield]
+
+ *FunctionStatementList*[Yield] **:**
+ *[StatementList](#StatementList)*[?Yield, Return]opt
+
+ *ArrowFunction*[In, Yield] **:**
+ *[ArrowParameters](#ArrowParameters)*[?Yield] [no *[LineTerminator](#LineTerminator)* here] `` => `` *[ConciseBody](#ConciseBody)*[?In]
+
+ *ArrowParameters*[Yield] **:**
+ *[BindingIdentifier](#BindingIdentifier)*[?Yield]
+ *[CoverParenthesizedExpressionAndArrowParameterList](#CoverParenthesizedExpressionAndArrowParameterList)*[?Yield]
+
+ *ConciseBody*[In] **:**
+ [lookahead ≠ `` { ``] *[AssignmentExpression](#AssignmentExpression)*[?In]
+ `` { `` *[FunctionBody](#FunctionBody)* `` } ``
+
+ *MethodDefinition*[Yield] **:**
+ *[PropertyName](#PropertyName)*[?Yield] `` ( `` *[StrictFormalParameters](#StrictFormalParameters)* `` ) `` `` { `` *[FunctionBody](#FunctionBody)* `` } ``
+ *[GeneratorMethod](#GeneratorMethod)*[?Yield]
+ `` get `` *[PropertyName](#PropertyName)*[?Yield] `` ( `` `` ) `` `` { `` *[FunctionBody](#FunctionBody)* `` } ``
+ `` set `` *[PropertyName](#PropertyName)*[?Yield] `` ( `` *[PropertySetParameterList](#PropertySetParameterList)* `` ) `` `` { `` *[FunctionBody](#FunctionBody)* `` } ``
+
+ *PropertySetParameterList* **:**
+ *[FormalParameter](#FormalParameter)*
+
+ *GeneratorMethod*[Yield] **:**
+ `` * `` *[PropertyName](#PropertyName)*[?Yield] `` ( `` *[StrictFormalParameters](#StrictFormalParameters)*[Yield] `` ) `` `` { `` *[GeneratorBody](#GeneratorBody)* `` } ``
+
+ *GeneratorDeclaration*[Yield, Default] **:**
+ `` function `` `` * `` *[BindingIdentifier](#BindingIdentifier)*[?Yield] `` ( `` *[FormalParameters](#FormalParameters)*[Yield] `` ) `` `` { `` *[GeneratorBody](#GeneratorBody)* `` } ``
+ [+Default] `` function `` `` * `` `` ( `` *[FormalParameters](#FormalParameters)*[Yield] `` ) `` `` { `` *[GeneratorBody](#GeneratorBody)* `` } ``
+
+ *GeneratorExpression* **:**
+ `` function `` `` * `` *[BindingIdentifier](#BindingIdentifier)*[Yield]opt `` ( `` *[FormalParameters](#FormalParameters)*[Yield] `` ) `` `` { `` *[GeneratorBody](#GeneratorBody)* `` } ``
+
+ *GeneratorBody* **:**
+ *[FunctionBody](#FunctionBody)*[Yield]
+
+ *YieldExpression*[In] **:**
+ `` yield ``
+ `` yield `` [no *[LineTerminator](#LineTerminator)* here] *[AssignmentExpression](#AssignmentExpression)*[?In, Yield]
+ `` yield `` [no *[LineTerminator](#LineTerminator)* here] `` * `` *[AssignmentExpression](#AssignmentExpression)*[?In, Yield]
+
+ *ClassDeclaration*[Yield, Default] **:**
+ `` class `` *[BindingIdentifier](#BindingIdentifier)*[?Yield] *[ClassTail](#ClassTail)*[?Yield]
+ [+Default] `` class `` *[ClassTail](#ClassTail)*[?Yield]
+
+ *ClassExpression*[Yield] **:**
+ `` class `` *[BindingIdentifier](#BindingIdentifier)*[?Yield]opt *[ClassTail](#ClassTail)*[?Yield]
+
+ *ClassTail*[Yield] **:**
+ *[ClassHeritage](#ClassHeritage)*[?Yield]opt `` { `` *[ClassBody](#ClassBody)*[?Yield]opt `` } ``
+
+ *ClassHeritage*[Yield] **:**
+ `` extends `` *[LeftHandSideExpression](#LeftHandSideExpression)*[?Yield]
+
+ *ClassBody*[Yield] **:**
+ *[ClassElementList](#ClassElementList)*[?Yield]
+
+ *ClassElementList*[Yield] **:**
+ *[ClassElement](#ClassElement)*[?Yield]
+ *[ClassElementList](#ClassElementList)*[?Yield] *[ClassElement](#ClassElement)*[?Yield]
+
+ *ClassElement*[Yield] **:**
+ *[MethodDefinition](#MethodDefinition)*[?Yield]
+ `` static `` *[MethodDefinition](#MethodDefinition)*[?Yield]
+ `` ; ``
+
+ *Script* **:**
+ *[ScriptBody](#ScriptBody)*opt
+
+ *ScriptBody* **:**
+ *[StatementList](#StatementList)*
+
+ *Module* **:**
+ *[ModuleBody](#ModuleBody)*opt
+
+ *ModuleBody* **:**
+ *[ModuleItemList](#ModuleItemList)*
+
+ *ModuleItemList* **:**
+ *[ModuleItem](#ModuleItem)*
+ *[ModuleItemList](#ModuleItemList)* *[ModuleItem](#ModuleItem)*
+
+ *ModuleItem* **:**
+ *[ImportDeclaration](#ImportDeclaration)*
+ *[ExportDeclaration](#ExportDeclaration)*
+ *[StatementListItem](#StatementListItem)*
+
+ *ImportDeclaration* **:**
+ `` import `` *[ImportClause](#ImportClause)* *[FromClause](#FromClause)* `` ; ``
+ `` import `` *[ModuleSpecifier](#ModuleSpecifier)* `` ; ``
+
+ *ImportClause* **:**
+ *[ImportedDefaultBinding](#ImportedDefaultBinding)*
+ *[NameSpaceImport](#NameSpaceImport)*
+ *[NamedImports](#NamedImports)*
+ *[ImportedDefaultBinding](#ImportedDefaultBinding)* `` , `` *[NameSpaceImport](#NameSpaceImport)*
+ *[ImportedDefaultBinding](#ImportedDefaultBinding)* `` , `` *[NamedImports](#NamedImports)*
+
+ *ImportedDefaultBinding* **:**
+ *[ImportedBinding](#ImportedBinding)*
+
+ *NameSpaceImport* **:**
+ `` * `` `` as `` *[ImportedBinding](#ImportedBinding)*
+
+ *NamedImports* **:**
+ `` { `` `` } ``
+ `` { `` *[ImportsList](#ImportsList)* `` } ``
+ `` { `` *[ImportsList](#ImportsList)* `` , `` `` } ``
+
+ *FromClause* **:**
+ `` from `` *[ModuleSpecifier](#ModuleSpecifier)*
+
+ *ImportsList* **:**
+ *[ImportSpecifier](#ImportSpecifier)*
+ *[ImportsList](#ImportsList)* `` , `` *[ImportSpecifier](#ImportSpecifier)*
+
+ *ImportSpecifier* **:**
+ *[ImportedBinding](#ImportedBinding)*
+ *[IdentifierName](#IdentifierName)* `` as `` *[ImportedBinding](#ImportedBinding)*
+
+ *ModuleSpecifier* **:**
+ *[StringLiteral](#StringLiteral)*
+
+ *ImportedBinding* **:**
+ *[BindingIdentifier](#BindingIdentifier)*
+
+ *ExportDeclaration* **:**
+ `` export `` `` * `` *[FromClause](#FromClause)* `` ; ``
+ `` export `` *[ExportClause](#ExportClause)* *[FromClause](#FromClause)* `` ; ``
+ `` export `` *[ExportClause](#ExportClause)* `` ; ``
+ `` export `` *[VariableStatement](#VariableStatement)*
+ `` export `` *[Declaration](#Declaration)*
+ `` export `` `` default `` *[HoistableDeclaration](#HoistableDeclaration)*[Default]
+ `` export `` `` default `` *[ClassDeclaration](#ClassDeclaration)*[Default]
+ `` export `` `` default `` [lookahead ∉ { `` function ``, `` class `` }] *[AssignmentExpression](#AssignmentExpression)*[In] `` ; ``
+
+ *ExportClause* **:**
+ `` { `` `` } ``
+ `` { `` *[ExportsList](#ExportsList)* `` } ``
+ `` { `` *[ExportsList](#ExportsList)* `` , `` `` } ``
+
+ *ExportsList* **:**
+ *[ExportSpecifier](#ExportSpecifier)*
+ *[ExportsList](#ExportsList)* `` , `` *[ExportSpecifier](#ExportSpecifier)*
+
+ *ExportSpecifier* **:**
+ *[IdentifierName](#IdentifierName)*
+ *[IdentifierName](#IdentifierName)* `` as `` *[IdentifierName](#IdentifierName)*
+
\ No newline at end of file
diff --git a/tests/baselines/reference/es6.grammar.nodes b/tests/baselines/reference/es6.grammar.nodes
new file mode 100644
index 0000000..59322a8
--- /dev/null
+++ b/tests/baselines/reference/es6.grammar.nodes
@@ -0,0 +1,7939 @@
+/// es6.grammar:
+(1,1)SyntaxKind[SourceFile](filename = "es6.grammar")
+ (1,1)SyntaxKind[Define]
+ (5,1)SyntaxKind[Production]
+ (5,1)SyntaxKind[Identifier](text = "SourceCharacter")
+ (6,1)SyntaxKind[RightHandSideList]
+ (6,1)SyntaxKind[IndentToken]
+ (6,2)SyntaxKind[RightHandSide]
+ (6,2)SyntaxKind[SymbolSpan]
+ (6,2)SyntaxKind[Prose]
+ (6,2)SyntaxKind[GreaterThanToken]
+ (6,4)SyntaxKind[ProseFull](text = "any Unicode code point")
+ (7,1)SyntaxKind[DedentToken]
+ (8,1)SyntaxKind[Production]
+ (8,1)SyntaxKind[Identifier](text = "InputElementDiv")
+ (9,1)SyntaxKind[RightHandSideList]
+ (9,1)SyntaxKind[IndentToken]
+ (9,2)SyntaxKind[RightHandSide]
+ (9,2)SyntaxKind[SymbolSpan]
+ (9,2)SyntaxKind[Nonterminal]
+ (9,2)SyntaxKind[Identifier](text = "WhiteSpace")
+ (10,2)SyntaxKind[RightHandSide]
+ (10,2)SyntaxKind[SymbolSpan]
+ (10,2)SyntaxKind[Nonterminal]
+ (10,2)SyntaxKind[Identifier](text = "LineTerminator")
+ (11,2)SyntaxKind[RightHandSide]
+ (11,2)SyntaxKind[SymbolSpan]
+ (11,2)SyntaxKind[Nonterminal]
+ (11,2)SyntaxKind[Identifier](text = "Comment")
+ (12,2)SyntaxKind[RightHandSide]
+ (12,2)SyntaxKind[SymbolSpan]
+ (12,2)SyntaxKind[Nonterminal]
+ (12,2)SyntaxKind[Identifier](text = "CommonToken")
+ (13,2)SyntaxKind[RightHandSide]
+ (13,2)SyntaxKind[SymbolSpan]
+ (13,2)SyntaxKind[Nonterminal]
+ (13,2)SyntaxKind[Identifier](text = "DivPunctuator")
+ (14,2)SyntaxKind[RightHandSide]
+ (14,2)SyntaxKind[SymbolSpan]
+ (14,2)SyntaxKind[Nonterminal]
+ (14,2)SyntaxKind[Identifier](text = "RightBracePunctuator")
+ (15,1)SyntaxKind[DedentToken]
+ (16,1)SyntaxKind[Production]
+ (16,1)SyntaxKind[Identifier](text = "InputElementRegExp")
+ (17,1)SyntaxKind[RightHandSideList]
+ (17,1)SyntaxKind[IndentToken]
+ (17,2)SyntaxKind[RightHandSide]
+ (17,2)SyntaxKind[SymbolSpan]
+ (17,2)SyntaxKind[Nonterminal]
+ (17,2)SyntaxKind[Identifier](text = "WhiteSpace")
+ (18,2)SyntaxKind[RightHandSide]
+ (18,2)SyntaxKind[SymbolSpan]
+ (18,2)SyntaxKind[Nonterminal]
+ (18,2)SyntaxKind[Identifier](text = "LineTerminator")
+ (19,2)SyntaxKind[RightHandSide]
+ (19,2)SyntaxKind[SymbolSpan]
+ (19,2)SyntaxKind[Nonterminal]
+ (19,2)SyntaxKind[Identifier](text = "Comment")
+ (20,2)SyntaxKind[RightHandSide]
+ (20,2)SyntaxKind[SymbolSpan]
+ (20,2)SyntaxKind[Nonterminal]
+ (20,2)SyntaxKind[Identifier](text = "CommonToken")
+ (21,2)SyntaxKind[RightHandSide]
+ (21,2)SyntaxKind[SymbolSpan]
+ (21,2)SyntaxKind[Nonterminal]
+ (21,2)SyntaxKind[Identifier](text = "RightBracePunctuator")
+ (22,2)SyntaxKind[RightHandSide]
+ (22,2)SyntaxKind[SymbolSpan]
+ (22,2)SyntaxKind[Nonterminal]
+ (22,2)SyntaxKind[Identifier](text = "RegularExpressionLiteral")
+ (23,1)SyntaxKind[DedentToken]
+ (24,1)SyntaxKind[Production]
+ (24,1)SyntaxKind[Identifier](text = "InputElementRegExpOrTemplateTail")
+ (25,1)SyntaxKind[RightHandSideList]
+ (25,1)SyntaxKind[IndentToken]
+ (25,2)SyntaxKind[RightHandSide]
+ (25,2)SyntaxKind[SymbolSpan]
+ (25,2)SyntaxKind[Nonterminal]
+ (25,2)SyntaxKind[Identifier](text = "WhiteSpace")
+ (26,2)SyntaxKind[RightHandSide]
+ (26,2)SyntaxKind[SymbolSpan]
+ (26,2)SyntaxKind[Nonterminal]
+ (26,2)SyntaxKind[Identifier](text = "LineTerminator")
+ (27,2)SyntaxKind[RightHandSide]
+ (27,2)SyntaxKind[SymbolSpan]
+ (27,2)SyntaxKind[Nonterminal]
+ (27,2)SyntaxKind[Identifier](text = "Comment")
+ (28,2)SyntaxKind[RightHandSide]
+ (28,2)SyntaxKind[SymbolSpan]
+ (28,2)SyntaxKind[Nonterminal]
+ (28,2)SyntaxKind[Identifier](text = "CommonToken")
+ (29,2)SyntaxKind[RightHandSide]
+ (29,2)SyntaxKind[SymbolSpan]
+ (29,2)SyntaxKind[Nonterminal]
+ (29,2)SyntaxKind[Identifier](text = "RegularExpressionLiteral")
+ (30,2)SyntaxKind[RightHandSide]
+ (30,2)SyntaxKind[SymbolSpan]
+ (30,2)SyntaxKind[Nonterminal]
+ (30,2)SyntaxKind[Identifier](text = "TemplateSubstitutionTail")
+ (31,1)SyntaxKind[DedentToken]
+ (32,1)SyntaxKind[Production]
+ (32,1)SyntaxKind[Identifier](text = "InputElementTemplateTail")
+ (33,1)SyntaxKind[RightHandSideList]
+ (33,1)SyntaxKind[IndentToken]
+ (33,2)SyntaxKind[RightHandSide]
+ (33,2)SyntaxKind[SymbolSpan]
+ (33,2)SyntaxKind[Nonterminal]
+ (33,2)SyntaxKind[Identifier](text = "WhiteSpace")
+ (34,2)SyntaxKind[RightHandSide]
+ (34,2)SyntaxKind[SymbolSpan]
+ (34,2)SyntaxKind[Nonterminal]
+ (34,2)SyntaxKind[Identifier](text = "LineTerminator")
+ (35,2)SyntaxKind[RightHandSide]
+ (35,2)SyntaxKind[SymbolSpan]
+ (35,2)SyntaxKind[Nonterminal]
+ (35,2)SyntaxKind[Identifier](text = "Comment")
+ (36,2)SyntaxKind[RightHandSide]
+ (36,2)SyntaxKind[SymbolSpan]
+ (36,2)SyntaxKind[Nonterminal]
+ (36,2)SyntaxKind[Identifier](text = "CommonToken")
+ (37,2)SyntaxKind[RightHandSide]
+ (37,2)SyntaxKind[SymbolSpan]
+ (37,2)SyntaxKind[Nonterminal]
+ (37,2)SyntaxKind[Identifier](text = "DivPunctuator")
+ (38,2)SyntaxKind[RightHandSide]
+ (38,2)SyntaxKind[SymbolSpan]
+ (38,2)SyntaxKind[Nonterminal]
+ (38,2)SyntaxKind[Identifier](text = "TemplateSubstitutionTail")
+ (39,1)SyntaxKind[DedentToken]
+ (40,1)SyntaxKind[Production]
+ (40,1)SyntaxKind[Identifier](text = "WhiteSpace")
+ (41,1)SyntaxKind[RightHandSideList]
+ (41,1)SyntaxKind[IndentToken]
+ (41,2)SyntaxKind[RightHandSide]
+ (41,2)SyntaxKind[SymbolSpan]
+ (41,2)SyntaxKind[UnicodeCharacterLiteral](text = )
+ (42,2)SyntaxKind[RightHandSide]
+ (42,2)SyntaxKind[SymbolSpan]
+ (42,2)SyntaxKind[UnicodeCharacterLiteral](text = )
+ (43,2)SyntaxKind[RightHandSide]
+ (43,2)SyntaxKind[SymbolSpan]
+ (43,2)SyntaxKind[UnicodeCharacterLiteral](text = )
+ (44,2)SyntaxKind[RightHandSide]
+ (44,2)SyntaxKind[SymbolSpan]
+ (44,2)SyntaxKind[UnicodeCharacterLiteral](text = )
+ (45,2)SyntaxKind[RightHandSide]
+ (45,2)SyntaxKind[SymbolSpan]
+ (45,2)SyntaxKind[UnicodeCharacterLiteral](text = )
+ (46,2)SyntaxKind[RightHandSide]
+ (46,2)SyntaxKind[SymbolSpan]
+ (46,2)SyntaxKind[UnicodeCharacterLiteral](text = )
+ (47,2)SyntaxKind[RightHandSide]
+ (47,2)SyntaxKind[SymbolSpan]
+ (47,2)SyntaxKind[UnicodeCharacterLiteral](text = )
+ (48,1)SyntaxKind[DedentToken]
+ (49,1)SyntaxKind[Production]
+ (49,1)SyntaxKind[Identifier](text = "LineTerminator")
+ (50,1)SyntaxKind[RightHandSideList]
+ (50,1)SyntaxKind[IndentToken]
+ (50,2)SyntaxKind[RightHandSide]
+ (50,2)SyntaxKind[SymbolSpan]
+ (50,2)SyntaxKind[UnicodeCharacterLiteral](text = )
+ (51,2)SyntaxKind[RightHandSide]
+ (51,2)SyntaxKind[SymbolSpan]
+ (51,2)SyntaxKind[UnicodeCharacterLiteral](text = )
+ (52,2)SyntaxKind[RightHandSide]
+ (52,2)SyntaxKind[SymbolSpan]
+ (52,2)SyntaxKind[UnicodeCharacterLiteral](text = )
+ (53,2)SyntaxKind[RightHandSide]
+ (53,2)SyntaxKind[SymbolSpan]
+ (53,2)SyntaxKind[UnicodeCharacterLiteral](text = )
+ (54,1)SyntaxKind[DedentToken]
+ (55,1)SyntaxKind[Production]
+ (55,1)SyntaxKind[Identifier](text = "LineTerminatorSequence")
+ (56,1)SyntaxKind[RightHandSideList]
+ (56,1)SyntaxKind[IndentToken]
+ (56,2)SyntaxKind[RightHandSide]
+ (56,2)SyntaxKind[SymbolSpan]
+ (56,2)SyntaxKind[UnicodeCharacterLiteral](text = )
+ (57,2)SyntaxKind[RightHandSide]
+ (57,2)SyntaxKind[SymbolSpan]
+ (57,2)SyntaxKind[UnicodeCharacterLiteral](text = )
+ (57,7)SyntaxKind[SymbolSpan]
+ (57,7)SyntaxKind[LookaheadAssertion]
+ (57,7)SyntaxKind[OpenBracketToken]
+ (57,8)SyntaxKind[LookaheadKeyword]
+ (57,18)SyntaxKind[ExclamationEqualsToken]
+ (57,21)SyntaxKind[SymbolSpan]
+ (57,21)SyntaxKind[UnicodeCharacterLiteral](text = )
+ (57,25)SyntaxKind[CloseBracketToken]
+ (58,2)SyntaxKind[RightHandSide]
+ (58,2)SyntaxKind[SymbolSpan]
+ (58,2)SyntaxKind[UnicodeCharacterLiteral](text = )
+ (59,2)SyntaxKind[RightHandSide]
+ (59,2)SyntaxKind[SymbolSpan]
+ (59,2)SyntaxKind[UnicodeCharacterLiteral](text = )
+ (60,2)SyntaxKind[RightHandSide]
+ (60,2)SyntaxKind[SymbolSpan]
+ (60,2)SyntaxKind[UnicodeCharacterLiteral](text = )
+ (60,7)SyntaxKind[SymbolSpan]
+ (60,7)SyntaxKind[UnicodeCharacterLiteral](text = )
+ (61,1)SyntaxKind[DedentToken]
+ (62,1)SyntaxKind[Production]
+ (62,1)SyntaxKind[Identifier](text = "Comment")
+ (63,1)SyntaxKind[RightHandSideList]
+ (63,1)SyntaxKind[IndentToken]
+ (63,2)SyntaxKind[RightHandSide]
+ (63,2)SyntaxKind[SymbolSpan]
+ (63,2)SyntaxKind[Nonterminal]
+ (63,2)SyntaxKind[Identifier](text = "MultiLineComment")
+ (64,2)SyntaxKind[RightHandSide]
+ (64,2)SyntaxKind[SymbolSpan]
+ (64,2)SyntaxKind[Nonterminal]
+ (64,2)SyntaxKind[Identifier](text = "SingleLineComment")
+ (65,1)SyntaxKind[DedentToken]
+ (66,1)SyntaxKind[Production]
+ (66,1)SyntaxKind[Identifier](text = "MultiLineComment")
+ (67,1)SyntaxKind[RightHandSideList]
+ (67,1)SyntaxKind[IndentToken]
+ (67,2)SyntaxKind[RightHandSide]
+ (67,2)SyntaxKind[SymbolSpan]
+ (67,2)SyntaxKind[Terminal](text = "/*")
+ (67,7)SyntaxKind[SymbolSpan]
+ (67,7)SyntaxKind[Nonterminal]?
+ (67,7)SyntaxKind[Identifier](text = "MultiLineCommentChars")
+ (67,28)SyntaxKind[QuestionToken]
+ (67,30)SyntaxKind[SymbolSpan]
+ (67,30)SyntaxKind[Terminal](text = "*/")
+ (68,1)SyntaxKind[DedentToken]
+ (69,1)SyntaxKind[Production]
+ (69,1)SyntaxKind[Identifier](text = "MultiLineCommentChars")
+ (70,1)SyntaxKind[RightHandSideList]
+ (70,1)SyntaxKind[IndentToken]
+ (70,2)SyntaxKind[RightHandSide]
+ (70,2)SyntaxKind[SymbolSpan]
+ (70,2)SyntaxKind[Nonterminal]
+ (70,2)SyntaxKind[Identifier](text = "MultiLineNotAsteriskChar")
+ (70,27)SyntaxKind[SymbolSpan]
+ (70,27)SyntaxKind[Nonterminal]?
+ (70,27)SyntaxKind[Identifier](text = "MultiLineCommentChars")
+ (70,48)SyntaxKind[QuestionToken]
+ (71,2)SyntaxKind[RightHandSide]
+ (71,2)SyntaxKind[SymbolSpan]
+ (71,2)SyntaxKind[Terminal](text = "*")
+ (71,6)SyntaxKind[SymbolSpan]
+ (71,6)SyntaxKind[Nonterminal]?
+ (71,6)SyntaxKind[Identifier](text = "PostAsteriskCommentChars")
+ (71,30)SyntaxKind[QuestionToken]
+ (72,1)SyntaxKind[DedentToken]
+ (73,1)SyntaxKind[Production]
+ (73,1)SyntaxKind[Identifier](text = "PostAsteriskCommentChars")
+ (74,1)SyntaxKind[RightHandSideList]
+ (74,1)SyntaxKind[IndentToken]
+ (74,2)SyntaxKind[RightHandSide]
+ (74,2)SyntaxKind[SymbolSpan]
+ (74,2)SyntaxKind[Nonterminal]
+ (74,2)SyntaxKind[Identifier](text = "MultiLineNotForwardSlashOrAsteriskChar")
+ (74,41)SyntaxKind[SymbolSpan]
+ (74,41)SyntaxKind[Nonterminal]?
+ (74,41)SyntaxKind[Identifier](text = "MultiLineCommentChars")
+ (74,62)SyntaxKind[QuestionToken]
+ (75,2)SyntaxKind[RightHandSide]
+ (75,2)SyntaxKind[SymbolSpan]
+ (75,2)SyntaxKind[Terminal](text = "*")
+ (75,6)SyntaxKind[SymbolSpan]
+ (75,6)SyntaxKind[Nonterminal]?
+ (75,6)SyntaxKind[Identifier](text = "PostAsteriskCommentChars")
+ (75,30)SyntaxKind[QuestionToken]
+ (76,1)SyntaxKind[DedentToken]
+ (77,1)SyntaxKind[Production]
+ (77,1)SyntaxKind[Identifier](text = "MultiLineNotAsteriskChar")
+ (78,1)SyntaxKind[RightHandSideList]
+ (78,1)SyntaxKind[IndentToken]
+ (78,2)SyntaxKind[RightHandSide]
+ (78,2)SyntaxKind[SymbolSpan]
+ (78,2)SyntaxKind[ButNotSymbol]
+ (78,2)SyntaxKind[Nonterminal]
+ (78,2)SyntaxKind[Identifier](text = "SourceCharacter")
+ (78,18)SyntaxKind[ButKeyword]
+ (78,22)SyntaxKind[NotKeyword]
+ (78,26)SyntaxKind[Terminal](text = "*")
+ (79,1)SyntaxKind[DedentToken]
+ (80,1)SyntaxKind[Production]
+ (80,1)SyntaxKind[Identifier](text = "MultiLineNotForwardSlashOrAsteriskChar")
+ (81,1)SyntaxKind[RightHandSideList]
+ (81,1)SyntaxKind[IndentToken]
+ (81,2)SyntaxKind[RightHandSide]
+ (81,2)SyntaxKind[SymbolSpan]
+ (81,2)SyntaxKind[ButNotSymbol]
+ (81,2)SyntaxKind[Nonterminal]
+ (81,2)SyntaxKind[Identifier](text = "SourceCharacter")
+ (81,18)SyntaxKind[ButKeyword]
+ (81,22)SyntaxKind[NotKeyword]
+ (81,26)SyntaxKind[OneOfSymbol]
+ (81,33)SyntaxKind[Terminal](text = "/")
+ (81,40)SyntaxKind[Terminal](text = "*")
+ (82,1)SyntaxKind[DedentToken]
+ (83,1)SyntaxKind[Production]
+ (83,1)SyntaxKind[Identifier](text = "SingleLineComment")
+ (84,1)SyntaxKind[RightHandSideList]
+ (84,1)SyntaxKind[IndentToken]
+ (84,2)SyntaxKind[RightHandSide]
+ (84,2)SyntaxKind[SymbolSpan]
+ (84,2)SyntaxKind[Terminal](text = "//")
+ (84,7)SyntaxKind[SymbolSpan]
+ (84,7)SyntaxKind[Nonterminal]?
+ (84,7)SyntaxKind[Identifier](text = "SingleLineCommentChars")
+ (84,29)SyntaxKind[QuestionToken]
+ (85,1)SyntaxKind[DedentToken]
+ (86,1)SyntaxKind[Production]
+ (86,1)SyntaxKind[Identifier](text = "SingleLineCommentChars")
+ (87,1)SyntaxKind[RightHandSideList]
+ (87,1)SyntaxKind[IndentToken]
+ (87,2)SyntaxKind[RightHandSide]
+ (87,2)SyntaxKind[SymbolSpan]
+ (87,2)SyntaxKind[Nonterminal]
+ (87,2)SyntaxKind[Identifier](text = "SingleLineCommentChar")
+ (87,24)SyntaxKind[SymbolSpan]
+ (87,24)SyntaxKind[Nonterminal]?
+ (87,24)SyntaxKind[Identifier](text = "SingleLineCommentChars")
+ (87,46)SyntaxKind[QuestionToken]
+ (88,1)SyntaxKind[DedentToken]
+ (89,1)SyntaxKind[Production]
+ (89,1)SyntaxKind[Identifier](text = "SingleLineCommentChar")
+ (90,1)SyntaxKind[RightHandSideList]
+ (90,1)SyntaxKind[IndentToken]
+ (90,2)SyntaxKind[RightHandSide]
+ (90,2)SyntaxKind[SymbolSpan]
+ (90,2)SyntaxKind[ButNotSymbol]
+ (90,2)SyntaxKind[Nonterminal]
+ (90,2)SyntaxKind[Identifier](text = "SourceCharacter")
+ (90,18)SyntaxKind[ButKeyword]
+ (90,22)SyntaxKind[NotKeyword]
+ (90,26)SyntaxKind[Nonterminal]
+ (90,26)SyntaxKind[Identifier](text = "LineTerminator")
+ (91,1)SyntaxKind[DedentToken]
+ (92,1)SyntaxKind[Production]
+ (92,1)SyntaxKind[Identifier](text = "CommonToken")
+ (93,1)SyntaxKind[RightHandSideList]
+ (93,1)SyntaxKind[IndentToken]
+ (93,2)SyntaxKind[RightHandSide]
+ (93,2)SyntaxKind[SymbolSpan]
+ (93,2)SyntaxKind[Nonterminal]
+ (93,2)SyntaxKind[Identifier](text = "IdentifierName")
+ (94,2)SyntaxKind[RightHandSide]
+ (94,2)SyntaxKind[SymbolSpan]
+ (94,2)SyntaxKind[Nonterminal]
+ (94,2)SyntaxKind[Identifier](text = "Punctuator")
+ (95,2)SyntaxKind[RightHandSide]
+ (95,2)SyntaxKind[SymbolSpan]
+ (95,2)SyntaxKind[Nonterminal]
+ (95,2)SyntaxKind[Identifier](text = "NumericLiteral")
+ (96,2)SyntaxKind[RightHandSide]
+ (96,2)SyntaxKind[SymbolSpan]
+ (96,2)SyntaxKind[Nonterminal]
+ (96,2)SyntaxKind[Identifier](text = "StringLiteral")
+ (97,2)SyntaxKind[RightHandSide]
+ (97,2)SyntaxKind[SymbolSpan]
+ (97,2)SyntaxKind[Nonterminal]
+ (97,2)SyntaxKind[Identifier](text = "Template")
+ (98,1)SyntaxKind[DedentToken]
+ (99,1)SyntaxKind[Production]
+ (99,1)SyntaxKind[Identifier](text = "IdentifierName")
+ (100,1)SyntaxKind[RightHandSideList]
+ (100,1)SyntaxKind[IndentToken]
+ (100,2)SyntaxKind[RightHandSide]
+ (100,2)SyntaxKind[SymbolSpan]
+ (100,2)SyntaxKind[Nonterminal]
+ (100,2)SyntaxKind[Identifier](text = "IdentifierStart")
+ (101,2)SyntaxKind[RightHandSide]
+ (101,2)SyntaxKind[SymbolSpan]
+ (101,2)SyntaxKind[Nonterminal]
+ (101,2)SyntaxKind[Identifier](text = "IdentifierName")
+ (101,17)SyntaxKind[SymbolSpan]
+ (101,17)SyntaxKind[Nonterminal]
+ (101,17)SyntaxKind[Identifier](text = "IdentifierPart")
+ (102,1)SyntaxKind[DedentToken]
+ (103,1)SyntaxKind[Production]
+ (103,1)SyntaxKind[Identifier](text = "IdentifierStart")
+ (104,1)SyntaxKind[RightHandSideList]
+ (104,1)SyntaxKind[IndentToken]
+ (104,2)SyntaxKind[RightHandSide]
+ (104,2)SyntaxKind[SymbolSpan]
+ (104,2)SyntaxKind[Nonterminal]
+ (104,2)SyntaxKind[Identifier](text = "UnicodeIDStart")
+ (105,2)SyntaxKind[RightHandSide]
+ (105,2)SyntaxKind[SymbolSpan]
+ (105,2)SyntaxKind[Terminal](text = "$")
+ (106,2)SyntaxKind[RightHandSide]
+ (106,2)SyntaxKind[SymbolSpan]
+ (106,2)SyntaxKind[Terminal](text = "_")
+ (107,2)SyntaxKind[RightHandSide]
+ (107,2)SyntaxKind[SymbolSpan]
+ (107,2)SyntaxKind[Terminal](text = "\")
+ (107,6)SyntaxKind[SymbolSpan]
+ (107,6)SyntaxKind[Nonterminal]
+ (107,6)SyntaxKind[Identifier](text = "UnicodeEscapeSequence")
+ (108,1)SyntaxKind[DedentToken]
+ (109,1)SyntaxKind[Production]
+ (109,1)SyntaxKind[Identifier](text = "IdentifierPart")
+ (110,1)SyntaxKind[RightHandSideList]
+ (110,1)SyntaxKind[IndentToken]
+ (110,2)SyntaxKind[RightHandSide]
+ (110,2)SyntaxKind[SymbolSpan]
+ (110,2)SyntaxKind[Nonterminal]
+ (110,2)SyntaxKind[Identifier](text = "UnicodeIDContinue")
+ (111,2)SyntaxKind[RightHandSide]
+ (111,2)SyntaxKind[SymbolSpan]
+ (111,2)SyntaxKind[Terminal](text = "$")
+ (112,2)SyntaxKind[RightHandSide]
+ (112,2)SyntaxKind[SymbolSpan]
+ (112,2)SyntaxKind[Terminal](text = "_")
+ (113,2)SyntaxKind[RightHandSide]
+ (113,2)SyntaxKind[SymbolSpan]
+ (113,2)SyntaxKind[Terminal](text = "\")
+ (113,6)SyntaxKind[SymbolSpan]
+ (113,6)SyntaxKind[Nonterminal]
+ (113,6)SyntaxKind[Identifier](text = "UnicodeEscapeSequence")
+ (114,2)SyntaxKind[RightHandSide]
+ (114,2)SyntaxKind[SymbolSpan]
+ (114,2)SyntaxKind[UnicodeCharacterLiteral](text = )
+ (115,2)SyntaxKind[RightHandSide]
+ (115,2)SyntaxKind[SymbolSpan]
+ (115,2)SyntaxKind[UnicodeCharacterLiteral](text = )
+ (116,1)SyntaxKind[DedentToken]
+ (117,1)SyntaxKind[Production]
+ (117,1)SyntaxKind[Identifier](text = "UnicodeIDStart")
+ (118,1)SyntaxKind[RightHandSideList]
+ (118,1)SyntaxKind[IndentToken]
+ (118,2)SyntaxKind[RightHandSide]
+ (118,2)SyntaxKind[SymbolSpan]
+ (118,2)SyntaxKind[Prose]
+ (118,2)SyntaxKind[GreaterThanToken]
+ (118,4)SyntaxKind[ProseFull](text = "any Unicode code point with the Unicode property "ID_Start" or "Other_ID_Start"")
+ (119,1)SyntaxKind[DedentToken]
+ (120,1)SyntaxKind[Production]
+ (120,1)SyntaxKind[Identifier](text = "UnicodeIDContinue")
+ (121,1)SyntaxKind[RightHandSideList]
+ (121,1)SyntaxKind[IndentToken]
+ (121,2)SyntaxKind[RightHandSide]
+ (121,2)SyntaxKind[SymbolSpan]
+ (121,2)SyntaxKind[Prose]
+ (121,2)SyntaxKind[GreaterThanToken]
+ (121,4)SyntaxKind[ProseFull](text = "any Unicode code point with the Unicode property "ID_Continue" or "Other_ID_Continue", or "Other_ID_Start"")
+ (122,1)SyntaxKind[DedentToken]
+ (123,1)SyntaxKind[Production]
+ (123,1)SyntaxKind[Identifier](text = "ReservedWord")
+ (124,1)SyntaxKind[RightHandSideList]
+ (124,1)SyntaxKind[IndentToken]
+ (124,2)SyntaxKind[RightHandSide]
+ (124,2)SyntaxKind[SymbolSpan]
+ (124,2)SyntaxKind[Nonterminal]
+ (124,2)SyntaxKind[Identifier](text = "Keyword")
+ (125,2)SyntaxKind[RightHandSide]
+ (125,2)SyntaxKind[SymbolSpan]
+ (125,2)SyntaxKind[Nonterminal]
+ (125,2)SyntaxKind[Identifier](text = "FutureReservedWord")
+ (126,2)SyntaxKind[RightHandSide]
+ (126,2)SyntaxKind[SymbolSpan]
+ (126,2)SyntaxKind[Nonterminal]
+ (126,2)SyntaxKind[Identifier](text = "NullLiteral")
+ (127,2)SyntaxKind[RightHandSide]
+ (127,2)SyntaxKind[SymbolSpan]
+ (127,2)SyntaxKind[Nonterminal]
+ (127,2)SyntaxKind[Identifier](text = "BooleanLiteral")
+ (128,1)SyntaxKind[DedentToken]
+ (129,1)SyntaxKind[Production]
+ (129,1)SyntaxKind[Identifier](text = "Keyword")
+ (129,12)SyntaxKind[OneOfList]
+ (129,12)SyntaxKind[OneKeyword]
+ (129,16)SyntaxKind[OfKeyword]
+ (130,1)SyntaxKind[IndentToken]
+ (130,2)SyntaxKind[Terminal](text = "break")
+ (130,11)SyntaxKind[Terminal](text = "do")
+ (130,17)SyntaxKind[Terminal](text = "in")
+ (130,24)SyntaxKind[Terminal](text = "typeof")
+ (131,2)SyntaxKind[Terminal](text = "case")
+ (131,10)SyntaxKind[Terminal](text = "else")
+ (131,18)SyntaxKind[Terminal](text = "instanceof")
+ (131,31)SyntaxKind[Terminal](text = "var")
+ (132,2)SyntaxKind[Terminal](text = "catch")
+ (132,11)SyntaxKind[Terminal](text = "export")
+ (132,20)SyntaxKind[Terminal](text = "new")
+ (132,28)SyntaxKind[Terminal](text = "void")
+ (133,2)SyntaxKind[Terminal](text = "class")
+ (133,11)SyntaxKind[Terminal](text = "extends")
+ (133,21)SyntaxKind[Terminal](text = "return")
+ (133,31)SyntaxKind[Terminal](text = "while")
+ (134,2)SyntaxKind[Terminal](text = "const")
+ (134,11)SyntaxKind[Terminal](text = "finally")
+ (134,21)SyntaxKind[Terminal](text = "super")
+ (134,31)SyntaxKind[Terminal](text = "with")
+ (135,2)SyntaxKind[Terminal](text = "continue")
+ (135,13)SyntaxKind[Terminal](text = "for")
+ (135,20)SyntaxKind[Terminal](text = "switch")
+ (135,30)SyntaxKind[Terminal](text = "yield")
+ (136,2)SyntaxKind[Terminal](text = "debugger")
+ (136,13)SyntaxKind[Terminal](text = "function")
+ (136,24)SyntaxKind[Terminal](text = "this")
+ (137,2)SyntaxKind[Terminal](text = "default")
+ (137,12)SyntaxKind[Terminal](text = "if")
+ (137,18)SyntaxKind[Terminal](text = "throw")
+ (138,2)SyntaxKind[Terminal](text = "delete")
+ (138,11)SyntaxKind[Terminal](text = "import")
+ (138,20)SyntaxKind[Terminal](text = "try")
+ (139,1)SyntaxKind[DedentToken]
+ (140,1)SyntaxKind[Production]
+ (140,1)SyntaxKind[Identifier](text = "FutureReservedWord")
+ (140,23)SyntaxKind[OneOfList]
+ (140,23)SyntaxKind[OneKeyword]
+ (140,27)SyntaxKind[OfKeyword]
+ (141,1)SyntaxKind[IndentToken]
+ (141,2)SyntaxKind[Terminal](text = "enum")
+ (143,2)SyntaxKind[Terminal](text = "await")
+ (145,2)SyntaxKind[Terminal](text = "implements")
+ (145,15)SyntaxKind[Terminal](text = "package")
+ (145,25)SyntaxKind[Terminal](text = "protected")
+ (146,2)SyntaxKind[Terminal](text = "interface")
+ (146,15)SyntaxKind[Terminal](text = "private")
+ (146,25)SyntaxKind[Terminal](text = "public")
+ (147,1)SyntaxKind[DedentToken]
+ (148,1)SyntaxKind[Production]
+ (148,1)SyntaxKind[Identifier](text = "Punctuator")
+ (148,15)SyntaxKind[OneOfList]
+ (148,15)SyntaxKind[OneKeyword]
+ (148,19)SyntaxKind[OfKeyword]
+ (149,1)SyntaxKind[IndentToken]
+ (149,2)SyntaxKind[Terminal](text = "{")
+ (149,7)SyntaxKind[Terminal](text = "}")
+ (149,12)SyntaxKind[Terminal](text = "(")
+ (149,17)SyntaxKind[Terminal](text = ")")
+ (149,22)SyntaxKind[Terminal](text = "[")
+ (149,27)SyntaxKind[Terminal](text = "]")
+ (150,2)SyntaxKind[Terminal](text = ".")
+ (150,7)SyntaxKind[Terminal](text = ";")
+ (150,12)SyntaxKind[Terminal](text = ",")
+ (150,17)SyntaxKind[Terminal](text = "<")
+ (150,22)SyntaxKind[Terminal](text = ">")
+ (150,27)SyntaxKind[Terminal](text = "<=")
+ (151,2)SyntaxKind[Terminal](text = ">=")
+ (151,7)SyntaxKind[Terminal](text = "==")
+ (151,12)SyntaxKind[Terminal](text = "!=")
+ (151,17)SyntaxKind[Terminal](text = "===")
+ (151,23)SyntaxKind[Terminal](text = "!==")
+ (152,2)SyntaxKind[Terminal](text = "+")
+ (152,7)SyntaxKind[Terminal](text = "-")
+ (152,12)SyntaxKind[Terminal](text = "*")
+ (152,17)SyntaxKind[Terminal](text = "%")
+ (152,22)SyntaxKind[Terminal](text = "++")
+ (152,27)SyntaxKind[Terminal](text = "--")
+ (153,2)SyntaxKind[Terminal](text = "<<")
+ (153,7)SyntaxKind[Terminal](text = ">>")
+ (153,12)SyntaxKind[Terminal](text = ">>>")
+ (153,18)SyntaxKind[Terminal](text = "&")
+ (153,23)SyntaxKind[Terminal](text = "|")
+ (153,28)SyntaxKind[Terminal](text = "^")
+ (154,2)SyntaxKind[Terminal](text = "!")
+ (154,7)SyntaxKind[Terminal](text = "~")
+ (154,12)SyntaxKind[Terminal](text = "&&")
+ (154,17)SyntaxKind[Terminal](text = "||")
+ (154,22)SyntaxKind[Terminal](text = "?")
+ (154,27)SyntaxKind[Terminal](text = " ::")
+ (155,2)SyntaxKind[Terminal](text = "=")
+ (155,7)SyntaxKind[Terminal](text = "+=")
+ (155,12)SyntaxKind[Terminal](text = "-=")
+ (155,17)SyntaxKind[Terminal](text = "*=")
+ (155,22)SyntaxKind[Terminal](text = "%=")
+ (155,27)SyntaxKind[Terminal](text = "<<=")
+ (156,2)SyntaxKind[Terminal](text = ">>=")
+ (156,8)SyntaxKind[Terminal](text = ">>>=")
+ (156,15)SyntaxKind[Terminal](text = "&=")
+ (156,20)SyntaxKind[Terminal](text = "|=")
+ (156,25)SyntaxKind[Terminal](text = "^=")
+ (156,30)SyntaxKind[Terminal](text = "=>")
+ (157,1)SyntaxKind[DedentToken]
+ (158,1)SyntaxKind[Production]
+ (158,1)SyntaxKind[Identifier](text = "DivPunctuator")
+ (158,18)SyntaxKind[OneOfList]
+ (158,18)SyntaxKind[OneKeyword]
+ (158,22)SyntaxKind[OfKeyword]
+ (159,1)SyntaxKind[IndentToken]
+ (159,2)SyntaxKind[Terminal](text = "/")
+ (159,7)SyntaxKind[Terminal](text = "/=")
+ (160,1)SyntaxKind[DedentToken]
+ (161,1)SyntaxKind[Production]
+ (161,1)SyntaxKind[Identifier](text = "RightBracePunctuator")
+ (161,25)SyntaxKind[OneOfList]
+ (161,25)SyntaxKind[OneKeyword]
+ (161,29)SyntaxKind[OfKeyword]
+ (162,1)SyntaxKind[IndentToken]
+ (162,2)SyntaxKind[Terminal](text = ")")
+ (163,1)SyntaxKind[DedentToken]
+ (164,1)SyntaxKind[Production]
+ (164,1)SyntaxKind[Identifier](text = "NullLiteral")
+ (165,1)SyntaxKind[RightHandSideList]
+ (165,1)SyntaxKind[IndentToken]
+ (165,2)SyntaxKind[RightHandSide]
+ (165,2)SyntaxKind[SymbolSpan]
+ (165,2)SyntaxKind[Terminal](text = "null")
+ (166,1)SyntaxKind[DedentToken]
+ (167,1)SyntaxKind[Production]
+ (167,1)SyntaxKind[Identifier](text = "BooleanLiteral")
+ (168,1)SyntaxKind[RightHandSideList]
+ (168,1)SyntaxKind[IndentToken]
+ (168,2)SyntaxKind[RightHandSide]
+ (168,2)SyntaxKind[SymbolSpan]
+ (168,2)SyntaxKind[Terminal](text = "true")
+ (169,2)SyntaxKind[RightHandSide]
+ (169,2)SyntaxKind[SymbolSpan]
+ (169,2)SyntaxKind[Terminal](text = "false")
+ (170,1)SyntaxKind[DedentToken]
+ (171,1)SyntaxKind[Production]
+ (171,1)SyntaxKind[Identifier](text = "NumericLiteral")
+ (172,1)SyntaxKind[RightHandSideList]
+ (172,1)SyntaxKind[IndentToken]
+ (172,2)SyntaxKind[RightHandSide]
+ (172,2)SyntaxKind[SymbolSpan]
+ (172,2)SyntaxKind[Nonterminal]
+ (172,2)SyntaxKind[Identifier](text = "DecimalLiteral")
+ (173,2)SyntaxKind[RightHandSide]
+ (173,2)SyntaxKind[SymbolSpan]
+ (173,2)SyntaxKind[Nonterminal]
+ (173,2)SyntaxKind[Identifier](text = "BinaryIntegerLiteral")
+ (174,2)SyntaxKind[RightHandSide]
+ (174,2)SyntaxKind[SymbolSpan]
+ (174,2)SyntaxKind[Nonterminal]
+ (174,2)SyntaxKind[Identifier](text = "OctalIntegerLiteral")
+ (175,2)SyntaxKind[RightHandSide]
+ (175,2)SyntaxKind[SymbolSpan]
+ (175,2)SyntaxKind[Nonterminal]
+ (175,2)SyntaxKind[Identifier](text = "HexIntegerLiteral")
+ (176,1)SyntaxKind[DedentToken]
+ (177,1)SyntaxKind[Production]
+ (177,1)SyntaxKind[Identifier](text = "DecimalLiteral")
+ (178,1)SyntaxKind[RightHandSideList]
+ (178,1)SyntaxKind[IndentToken]
+ (178,2)SyntaxKind[RightHandSide]
+ (178,2)SyntaxKind[SymbolSpan]
+ (178,2)SyntaxKind[Nonterminal]
+ (178,2)SyntaxKind[Identifier](text = "DecimalIntegerLiteral")
+ (178,24)SyntaxKind[SymbolSpan]
+ (178,24)SyntaxKind[Terminal](text = ".")
+ (178,28)SyntaxKind[SymbolSpan]
+ (178,28)SyntaxKind[Nonterminal]?
+ (178,28)SyntaxKind[Identifier](text = "DecimalDigits")
+ (178,41)SyntaxKind[QuestionToken]
+ (178,43)SyntaxKind[SymbolSpan]
+ (178,43)SyntaxKind[Nonterminal]?
+ (178,43)SyntaxKind[Identifier](text = "ExponentPart")
+ (178,55)SyntaxKind[QuestionToken]
+ (179,2)SyntaxKind[RightHandSide]
+ (179,2)SyntaxKind[SymbolSpan]
+ (179,2)SyntaxKind[Terminal](text = ".")
+ (179,6)SyntaxKind[SymbolSpan]
+ (179,6)SyntaxKind[Nonterminal]
+ (179,6)SyntaxKind[Identifier](text = "DecimalDigits")
+ (179,20)SyntaxKind[SymbolSpan]
+ (179,20)SyntaxKind[Nonterminal]?
+ (179,20)SyntaxKind[Identifier](text = "ExponentPart")
+ (179,32)SyntaxKind[QuestionToken]
+ (180,2)SyntaxKind[RightHandSide]
+ (180,2)SyntaxKind[SymbolSpan]
+ (180,2)SyntaxKind[Nonterminal]
+ (180,2)SyntaxKind[Identifier](text = "DecimalIntegerLiteral")
+ (180,24)SyntaxKind[SymbolSpan]
+ (180,24)SyntaxKind[Nonterminal]?
+ (180,24)SyntaxKind[Identifier](text = "ExponentPart")
+ (180,36)SyntaxKind[QuestionToken]
+ (181,1)SyntaxKind[DedentToken]
+ (182,1)SyntaxKind[Production]
+ (182,1)SyntaxKind[Identifier](text = "DecimalIntegerLiteral")
+ (183,1)SyntaxKind[RightHandSideList]
+ (183,1)SyntaxKind[IndentToken]
+ (183,2)SyntaxKind[RightHandSide]
+ (183,2)SyntaxKind[SymbolSpan]
+ (183,2)SyntaxKind[Terminal](text = "0")
+ (184,2)SyntaxKind[RightHandSide]
+ (184,2)SyntaxKind[SymbolSpan]
+ (184,2)SyntaxKind[Nonterminal]
+ (184,2)SyntaxKind[Identifier](text = "NonZeroDigit")
+ (184,15)SyntaxKind[SymbolSpan]
+ (184,15)SyntaxKind[Nonterminal]?
+ (184,15)SyntaxKind[Identifier](text = "DecimalDigits")
+ (184,28)SyntaxKind[QuestionToken]
+ (185,1)SyntaxKind[DedentToken]
+ (186,1)SyntaxKind[Production]
+ (186,1)SyntaxKind[Identifier](text = "DecimalDigits")
+ (187,1)SyntaxKind[RightHandSideList]
+ (187,1)SyntaxKind[IndentToken]
+ (187,2)SyntaxKind[RightHandSide]
+ (187,2)SyntaxKind[SymbolSpan]
+ (187,2)SyntaxKind[Nonterminal]
+ (187,2)SyntaxKind[Identifier](text = "DecimalDigit")
+ (188,2)SyntaxKind[RightHandSide]
+ (188,2)SyntaxKind[SymbolSpan]
+ (188,2)SyntaxKind[Nonterminal]
+ (188,2)SyntaxKind[Identifier](text = "DecimalDigits")
+ (188,16)SyntaxKind[SymbolSpan]
+ (188,16)SyntaxKind[Nonterminal]
+ (188,16)SyntaxKind[Identifier](text = "DecimalDigit")
+ (189,1)SyntaxKind[DedentToken]
+ (190,1)SyntaxKind[Production]
+ (190,1)SyntaxKind[Identifier](text = "DecimalDigit")
+ (190,17)SyntaxKind[OneOfList]
+ (190,17)SyntaxKind[OneKeyword]
+ (190,21)SyntaxKind[OfKeyword]
+ (191,1)SyntaxKind[IndentToken]
+ (191,2)SyntaxKind[Terminal](text = "0")
+ (191,6)SyntaxKind[Terminal](text = "1")
+ (191,10)SyntaxKind[Terminal](text = "2")
+ (191,14)SyntaxKind[Terminal](text = "3")
+ (191,18)SyntaxKind[Terminal](text = "4")
+ (191,22)SyntaxKind[Terminal](text = "5")
+ (191,26)SyntaxKind[Terminal](text = "6")
+ (191,30)SyntaxKind[Terminal](text = "7")
+ (191,34)SyntaxKind[Terminal](text = "8")
+ (191,38)SyntaxKind[Terminal](text = "9")
+ (192,1)SyntaxKind[DedentToken]
+ (193,1)SyntaxKind[Production]
+ (193,1)SyntaxKind[Identifier](text = "NonZeroDigit")
+ (193,17)SyntaxKind[OneOfList]
+ (193,17)SyntaxKind[OneKeyword]
+ (193,21)SyntaxKind[OfKeyword]
+ (194,1)SyntaxKind[IndentToken]
+ (194,2)SyntaxKind[Terminal](text = "1")
+ (194,6)SyntaxKind[Terminal](text = "2")
+ (194,10)SyntaxKind[Terminal](text = "3")
+ (194,14)SyntaxKind[Terminal](text = "4")
+ (194,18)SyntaxKind[Terminal](text = "5")
+ (194,22)SyntaxKind[Terminal](text = "6")
+ (194,26)SyntaxKind[Terminal](text = "7")
+ (194,30)SyntaxKind[Terminal](text = "8")
+ (194,34)SyntaxKind[Terminal](text = "9")
+ (195,1)SyntaxKind[DedentToken]
+ (196,1)SyntaxKind[Production]
+ (196,1)SyntaxKind[Identifier](text = "ExponentPart")
+ (197,1)SyntaxKind[RightHandSideList]
+ (197,1)SyntaxKind[IndentToken]
+ (197,2)SyntaxKind[RightHandSide]
+ (197,2)SyntaxKind[SymbolSpan]
+ (197,2)SyntaxKind[Nonterminal]
+ (197,2)SyntaxKind[Identifier](text = "ExponentIndicator")
+ (197,20)SyntaxKind[SymbolSpan]
+ (197,20)SyntaxKind[Nonterminal]
+ (197,20)SyntaxKind[Identifier](text = "SignedInteger")
+ (198,1)SyntaxKind[DedentToken]
+ (199,1)SyntaxKind[Production]
+ (199,1)SyntaxKind[Identifier](text = "ExponentIndicator")
+ (199,22)SyntaxKind[OneOfList]
+ (199,22)SyntaxKind[OneKeyword]
+ (199,26)SyntaxKind[OfKeyword]
+ (200,1)SyntaxKind[IndentToken]
+ (200,2)SyntaxKind[Terminal](text = "e")
+ (200,6)SyntaxKind[Terminal](text = "E")
+ (201,1)SyntaxKind[DedentToken]
+ (202,1)SyntaxKind[Production]
+ (202,1)SyntaxKind[Identifier](text = "SignedInteger")
+ (203,1)SyntaxKind[RightHandSideList]
+ (203,1)SyntaxKind[IndentToken]
+ (203,2)SyntaxKind[RightHandSide]
+ (203,2)SyntaxKind[SymbolSpan]
+ (203,2)SyntaxKind[Nonterminal]
+ (203,2)SyntaxKind[Identifier](text = "DecimalDigits")
+ (204,2)SyntaxKind[RightHandSide]
+ (204,2)SyntaxKind[SymbolSpan]
+ (204,2)SyntaxKind[Terminal](text = "+")
+ (204,6)SyntaxKind[SymbolSpan]
+ (204,6)SyntaxKind[Nonterminal]
+ (204,6)SyntaxKind[Identifier](text = "DecimalDigits")
+ (205,2)SyntaxKind[RightHandSide]
+ (205,2)SyntaxKind[SymbolSpan]
+ (205,2)SyntaxKind[Terminal](text = "-")
+ (205,6)SyntaxKind[SymbolSpan]
+ (205,6)SyntaxKind[Nonterminal]
+ (205,6)SyntaxKind[Identifier](text = "DecimalDigits")
+ (206,1)SyntaxKind[DedentToken]
+ (207,1)SyntaxKind[Production]
+ (207,1)SyntaxKind[Identifier](text = "BinaryIntegerLiteral")
+ (208,1)SyntaxKind[RightHandSideList]
+ (208,1)SyntaxKind[IndentToken]
+ (208,2)SyntaxKind[RightHandSide]
+ (208,2)SyntaxKind[SymbolSpan]
+ (208,2)SyntaxKind[Terminal](text = "0b")
+ (208,7)SyntaxKind[SymbolSpan]
+ (208,7)SyntaxKind[Nonterminal]
+ (208,7)SyntaxKind[Identifier](text = "BinaryDigits")
+ (209,2)SyntaxKind[RightHandSide]
+ (209,2)SyntaxKind[SymbolSpan]
+ (209,2)SyntaxKind[Terminal](text = "0B")
+ (209,7)SyntaxKind[SymbolSpan]
+ (209,7)SyntaxKind[Nonterminal]
+ (209,7)SyntaxKind[Identifier](text = "BinaryDigits")
+ (210,1)SyntaxKind[DedentToken]
+ (211,1)SyntaxKind[Production]
+ (211,1)SyntaxKind[Identifier](text = "BinaryDigits")
+ (212,1)SyntaxKind[RightHandSideList]
+ (212,1)SyntaxKind[IndentToken]
+ (212,2)SyntaxKind[RightHandSide]
+ (212,2)SyntaxKind[SymbolSpan]
+ (212,2)SyntaxKind[Nonterminal]
+ (212,2)SyntaxKind[Identifier](text = "BinaryDigit")
+ (213,2)SyntaxKind[RightHandSide]
+ (213,2)SyntaxKind[SymbolSpan]
+ (213,2)SyntaxKind[Nonterminal]
+ (213,2)SyntaxKind[Identifier](text = "BinaryDigits")
+ (213,15)SyntaxKind[SymbolSpan]
+ (213,15)SyntaxKind[Nonterminal]
+ (213,15)SyntaxKind[Identifier](text = "BinaryDigit")
+ (214,1)SyntaxKind[DedentToken]
+ (215,1)SyntaxKind[Production]
+ (215,1)SyntaxKind[Identifier](text = "BinaryDigit")
+ (215,16)SyntaxKind[OneOfList]
+ (215,16)SyntaxKind[OneKeyword]
+ (215,20)SyntaxKind[OfKeyword]
+ (216,1)SyntaxKind[IndentToken]
+ (216,2)SyntaxKind[Terminal](text = "0")
+ (216,6)SyntaxKind[Terminal](text = "1")
+ (217,1)SyntaxKind[DedentToken]
+ (218,1)SyntaxKind[Production]
+ (218,1)SyntaxKind[Identifier](text = "OctalIntegerLiteral")
+ (219,1)SyntaxKind[RightHandSideList]
+ (219,1)SyntaxKind[IndentToken]
+ (219,2)SyntaxKind[RightHandSide]
+ (219,2)SyntaxKind[SymbolSpan]
+ (219,2)SyntaxKind[Terminal](text = "0o")
+ (219,7)SyntaxKind[SymbolSpan]
+ (219,7)SyntaxKind[Nonterminal]
+ (219,7)SyntaxKind[Identifier](text = "OctalDigits")
+ (220,2)SyntaxKind[RightHandSide]
+ (220,2)SyntaxKind[SymbolSpan]
+ (220,2)SyntaxKind[Terminal](text = "0O")
+ (220,7)SyntaxKind[SymbolSpan]
+ (220,7)SyntaxKind[Nonterminal]
+ (220,7)SyntaxKind[Identifier](text = "OctalDigits")
+ (221,1)SyntaxKind[DedentToken]
+ (222,1)SyntaxKind[Production]
+ (222,1)SyntaxKind[Identifier](text = "OctalDigits")
+ (223,1)SyntaxKind[RightHandSideList]
+ (223,1)SyntaxKind[IndentToken]
+ (223,2)SyntaxKind[RightHandSide]
+ (223,2)SyntaxKind[SymbolSpan]
+ (223,2)SyntaxKind[Nonterminal]
+ (223,2)SyntaxKind[Identifier](text = "OctalDigit")
+ (224,2)SyntaxKind[RightHandSide]
+ (224,2)SyntaxKind[SymbolSpan]
+ (224,2)SyntaxKind[Nonterminal]
+ (224,2)SyntaxKind[Identifier](text = "OctalDigits")
+ (224,14)SyntaxKind[SymbolSpan]
+ (224,14)SyntaxKind[Nonterminal]
+ (224,14)SyntaxKind[Identifier](text = "OctalDigit")
+ (225,1)SyntaxKind[DedentToken]
+ (226,1)SyntaxKind[Production]
+ (226,1)SyntaxKind[Identifier](text = "OctalDigit")
+ (226,15)SyntaxKind[OneOfList]
+ (226,15)SyntaxKind[OneKeyword]
+ (226,19)SyntaxKind[OfKeyword]
+ (227,1)SyntaxKind[IndentToken]
+ (227,2)SyntaxKind[Terminal](text = "0")
+ (227,6)SyntaxKind[Terminal](text = "1")
+ (227,10)SyntaxKind[Terminal](text = "2")
+ (227,14)SyntaxKind[Terminal](text = "3")
+ (227,18)SyntaxKind[Terminal](text = "4")
+ (227,22)SyntaxKind[Terminal](text = "5")
+ (227,26)SyntaxKind[Terminal](text = "6")
+ (227,30)SyntaxKind[Terminal](text = "7")
+ (228,1)SyntaxKind[DedentToken]
+ (229,1)SyntaxKind[Production]
+ (229,1)SyntaxKind[Identifier](text = "HexIntegerLiteral")
+ (230,1)SyntaxKind[RightHandSideList]
+ (230,1)SyntaxKind[IndentToken]
+ (230,2)SyntaxKind[RightHandSide]
+ (230,2)SyntaxKind[SymbolSpan]
+ (230,2)SyntaxKind[Terminal](text = "0x")
+ (230,7)SyntaxKind[SymbolSpan]
+ (230,7)SyntaxKind[Nonterminal]
+ (230,7)SyntaxKind[Identifier](text = "HexDigits")
+ (231,2)SyntaxKind[RightHandSide]
+ (231,2)SyntaxKind[SymbolSpan]
+ (231,2)SyntaxKind[Terminal](text = "0X")
+ (231,7)SyntaxKind[SymbolSpan]
+ (231,7)SyntaxKind[Nonterminal]
+ (231,7)SyntaxKind[Identifier](text = "HexDigits")
+ (232,1)SyntaxKind[DedentToken]
+ (233,1)SyntaxKind[Production]
+ (233,1)SyntaxKind[Identifier](text = "HexDigits")
+ (234,1)SyntaxKind[RightHandSideList]
+ (234,1)SyntaxKind[IndentToken]
+ (234,2)SyntaxKind[RightHandSide]
+ (234,2)SyntaxKind[SymbolSpan]
+ (234,2)SyntaxKind[Nonterminal]
+ (234,2)SyntaxKind[Identifier](text = "HexDigit")
+ (235,2)SyntaxKind[RightHandSide]
+ (235,2)SyntaxKind[SymbolSpan]
+ (235,2)SyntaxKind[Nonterminal]
+ (235,2)SyntaxKind[Identifier](text = "HexDigits")
+ (235,12)SyntaxKind[SymbolSpan]
+ (235,12)SyntaxKind[Nonterminal]
+ (235,12)SyntaxKind[Identifier](text = "HexDigit")
+ (236,1)SyntaxKind[DedentToken]
+ (237,1)SyntaxKind[Production]
+ (237,1)SyntaxKind[Identifier](text = "HexDigit")
+ (237,13)SyntaxKind[OneOfList]
+ (237,13)SyntaxKind[OneKeyword]
+ (237,17)SyntaxKind[OfKeyword]
+ (238,1)SyntaxKind[IndentToken]
+ (238,2)SyntaxKind[Terminal](text = "0")
+ (238,6)SyntaxKind[Terminal](text = "1")
+ (238,10)SyntaxKind[Terminal](text = "2")
+ (238,14)SyntaxKind[Terminal](text = "3")
+ (238,18)SyntaxKind[Terminal](text = "4")
+ (238,22)SyntaxKind[Terminal](text = "5")
+ (238,26)SyntaxKind[Terminal](text = "6")
+ (238,30)SyntaxKind[Terminal](text = "7")
+ (238,34)SyntaxKind[Terminal](text = "8")
+ (238,38)SyntaxKind[Terminal](text = "9")
+ (238,42)SyntaxKind[Terminal](text = "a")
+ (238,46)SyntaxKind[Terminal](text = "b")
+ (238,50)SyntaxKind[Terminal](text = "c")
+ (238,54)SyntaxKind[Terminal](text = "d")
+ (238,58)SyntaxKind[Terminal](text = "e")
+ (238,62)SyntaxKind[Terminal](text = "f")
+ (238,66)SyntaxKind[Terminal](text = "A")
+ (238,70)SyntaxKind[Terminal](text = "B")
+ (238,74)SyntaxKind[Terminal](text = "C")
+ (238,78)SyntaxKind[Terminal](text = "D")
+ (238,82)SyntaxKind[Terminal](text = "E")
+ (238,86)SyntaxKind[Terminal](text = "F")
+ (239,1)SyntaxKind[DedentToken]
+ (240,1)SyntaxKind[Production]
+ (240,1)SyntaxKind[Identifier](text = "StringLiteral")
+ (241,1)SyntaxKind[RightHandSideList]
+ (241,1)SyntaxKind[IndentToken]
+ (241,2)SyntaxKind[RightHandSide]
+ (241,2)SyntaxKind[SymbolSpan]
+ (241,2)SyntaxKind[Terminal](text = """)
+ (241,6)SyntaxKind[SymbolSpan]
+ (241,6)SyntaxKind[Nonterminal]?
+ (241,6)SyntaxKind[Identifier](text = "DoubleStringCharacters")
+ (241,28)SyntaxKind[QuestionToken]
+ (241,30)SyntaxKind[SymbolSpan]
+ (241,30)SyntaxKind[Terminal](text = """)
+ (242,2)SyntaxKind[RightHandSide]
+ (242,2)SyntaxKind[SymbolSpan]
+ (242,2)SyntaxKind[Terminal](text = "'")
+ (242,6)SyntaxKind[SymbolSpan]
+ (242,6)SyntaxKind[Nonterminal]?
+ (242,6)SyntaxKind[Identifier](text = "SingleStringCharacters")
+ (242,28)SyntaxKind[QuestionToken]
+ (242,30)SyntaxKind[SymbolSpan]
+ (242,30)SyntaxKind[Terminal](text = "'")
+ (243,1)SyntaxKind[DedentToken]
+ (244,1)SyntaxKind[Production]
+ (244,1)SyntaxKind[Identifier](text = "DoubleStringCharacters")
+ (245,1)SyntaxKind[RightHandSideList]
+ (245,1)SyntaxKind[IndentToken]
+ (245,2)SyntaxKind[RightHandSide]
+ (245,2)SyntaxKind[SymbolSpan]
+ (245,2)SyntaxKind[Nonterminal]
+ (245,2)SyntaxKind[Identifier](text = "DoubleStringCharacter")
+ (245,24)SyntaxKind[SymbolSpan]
+ (245,24)SyntaxKind[Nonterminal]?
+ (245,24)SyntaxKind[Identifier](text = "DoubleStringCharacters")
+ (245,46)SyntaxKind[QuestionToken]
+ (246,1)SyntaxKind[DedentToken]
+ (247,1)SyntaxKind[Production]
+ (247,1)SyntaxKind[Identifier](text = "SingleStringCharacters")
+ (248,1)SyntaxKind[RightHandSideList]
+ (248,1)SyntaxKind[IndentToken]
+ (248,2)SyntaxKind[RightHandSide]
+ (248,2)SyntaxKind[SymbolSpan]
+ (248,2)SyntaxKind[Nonterminal]
+ (248,2)SyntaxKind[Identifier](text = "SingleStringCharacter")
+ (248,24)SyntaxKind[SymbolSpan]
+ (248,24)SyntaxKind[Nonterminal]?
+ (248,24)SyntaxKind[Identifier](text = "SingleStringCharacters")
+ (248,46)SyntaxKind[QuestionToken]
+ (249,1)SyntaxKind[DedentToken]
+ (250,1)SyntaxKind[Production]
+ (250,1)SyntaxKind[Identifier](text = "DoubleStringCharacter")
+ (251,1)SyntaxKind[RightHandSideList]
+ (251,1)SyntaxKind[IndentToken]
+ (251,2)SyntaxKind[RightHandSide]
+ (251,2)SyntaxKind[SymbolSpan]
+ (251,2)SyntaxKind[ButNotSymbol]
+ (251,2)SyntaxKind[Nonterminal]
+ (251,2)SyntaxKind[Identifier](text = "SourceCharacter")
+ (251,18)SyntaxKind[ButKeyword]
+ (251,22)SyntaxKind[NotKeyword]
+ (251,26)SyntaxKind[OneOfSymbol]
+ (251,33)SyntaxKind[Terminal](text = """)
+ (251,40)SyntaxKind[Terminal](text = "\")
+ (251,47)SyntaxKind[Nonterminal]
+ (251,47)SyntaxKind[Identifier](text = "LineTerminator")
+ (252,2)SyntaxKind[RightHandSide]
+ (252,2)SyntaxKind[SymbolSpan]
+ (252,2)SyntaxKind[Terminal](text = "\")
+ (252,6)SyntaxKind[SymbolSpan]
+ (252,6)SyntaxKind[Nonterminal]
+ (252,6)SyntaxKind[Identifier](text = "EscapeSequence")
+ (253,2)SyntaxKind[RightHandSide]
+ (253,2)SyntaxKind[SymbolSpan]
+ (253,2)SyntaxKind[Nonterminal]
+ (253,2)SyntaxKind[Identifier](text = "LineContinuation")
+ (254,1)SyntaxKind[DedentToken]
+ (255,1)SyntaxKind[Production]
+ (255,1)SyntaxKind[Identifier](text = "SingleStringCharacter")
+ (256,1)SyntaxKind[RightHandSideList]
+ (256,1)SyntaxKind[IndentToken]
+ (256,2)SyntaxKind[RightHandSide]
+ (256,2)SyntaxKind[SymbolSpan]
+ (256,2)SyntaxKind[ButNotSymbol]
+ (256,2)SyntaxKind[Nonterminal]
+ (256,2)SyntaxKind[Identifier](text = "SourceCharacter")
+ (256,18)SyntaxKind[ButKeyword]
+ (256,22)SyntaxKind[NotKeyword]
+ (256,26)SyntaxKind[OneOfSymbol]
+ (256,33)SyntaxKind[Terminal](text = "'")
+ (256,40)SyntaxKind[Terminal](text = "\")
+ (256,47)SyntaxKind[Nonterminal]
+ (256,47)SyntaxKind[Identifier](text = "LineTerminator")
+ (257,2)SyntaxKind[RightHandSide]
+ (257,2)SyntaxKind[SymbolSpan]
+ (257,2)SyntaxKind[Terminal](text = "\")
+ (257,6)SyntaxKind[SymbolSpan]
+ (257,6)SyntaxKind[Nonterminal]
+ (257,6)SyntaxKind[Identifier](text = "EscapeSequence")
+ (258,2)SyntaxKind[RightHandSide]
+ (258,2)SyntaxKind[SymbolSpan]
+ (258,2)SyntaxKind[Nonterminal]
+ (258,2)SyntaxKind[Identifier](text = "LineContinuation")
+ (259,1)SyntaxKind[DedentToken]
+ (260,1)SyntaxKind[Production]
+ (260,1)SyntaxKind[Identifier](text = "LineContinuation")
+ (261,1)SyntaxKind[RightHandSideList]
+ (261,1)SyntaxKind[IndentToken]
+ (261,2)SyntaxKind[RightHandSide]
+ (261,2)SyntaxKind[SymbolSpan]
+ (261,2)SyntaxKind[Terminal](text = "\")
+ (261,6)SyntaxKind[SymbolSpan]
+ (261,6)SyntaxKind[Nonterminal]
+ (261,6)SyntaxKind[Identifier](text = "LineTerminatorSequence")
+ (262,1)SyntaxKind[DedentToken]
+ (263,1)SyntaxKind[Production]
+ (263,1)SyntaxKind[Identifier](text = "EscapeSequence")
+ (264,1)SyntaxKind[RightHandSideList]
+ (264,1)SyntaxKind[IndentToken]
+ (264,2)SyntaxKind[RightHandSide]
+ (264,2)SyntaxKind[SymbolSpan]
+ (264,2)SyntaxKind[Nonterminal]
+ (264,2)SyntaxKind[Identifier](text = "CharacterEscapeSequence")
+ (265,2)SyntaxKind[RightHandSide]
+ (265,2)SyntaxKind[SymbolSpan]
+ (265,2)SyntaxKind[Terminal](text = "0")
+ (265,6)SyntaxKind[SymbolSpan]
+ (265,6)SyntaxKind[LookaheadAssertion]
+ (265,6)SyntaxKind[OpenBracketToken]
+ (265,7)SyntaxKind[LookaheadKeyword]
+ (265,17)SyntaxKind[ExclamationEqualsToken]
+ (265,20)SyntaxKind[SymbolSpan]
+ (265,20)SyntaxKind[Nonterminal]
+ (265,20)SyntaxKind[Identifier](text = "DecimalDigit")
+ (265,32)SyntaxKind[CloseBracketToken]
+ (266,2)SyntaxKind[RightHandSide]
+ (266,2)SyntaxKind[SymbolSpan]
+ (266,2)SyntaxKind[Nonterminal]
+ (266,2)SyntaxKind[Identifier](text = "HexEscapeSequence")
+ (267,2)SyntaxKind[RightHandSide]
+ (267,2)SyntaxKind[SymbolSpan]
+ (267,2)SyntaxKind[Nonterminal]
+ (267,2)SyntaxKind[Identifier](text = "UnicodeEscapeSequence")
+ (268,1)SyntaxKind[DedentToken]
+ (269,1)SyntaxKind[Production]
+ (269,1)SyntaxKind[Identifier](text = "CharacterEscapeSequence")
+ (270,1)SyntaxKind[RightHandSideList]
+ (270,1)SyntaxKind[IndentToken]
+ (270,2)SyntaxKind[RightHandSide]
+ (270,2)SyntaxKind[SymbolSpan]
+ (270,2)SyntaxKind[Nonterminal]
+ (270,2)SyntaxKind[Identifier](text = "SingleEscapeCharacter")
+ (271,2)SyntaxKind[RightHandSide]
+ (271,2)SyntaxKind[SymbolSpan]
+ (271,2)SyntaxKind[Nonterminal]
+ (271,2)SyntaxKind[Identifier](text = "NonEscapeCharacter")
+ (272,1)SyntaxKind[DedentToken]
+ (273,1)SyntaxKind[Production]
+ (273,1)SyntaxKind[Identifier](text = "SingleEscapeCharacter")
+ (273,26)SyntaxKind[OneOfList]
+ (273,26)SyntaxKind[OneKeyword]
+ (273,30)SyntaxKind[OfKeyword]
+ (274,1)SyntaxKind[IndentToken]
+ (274,2)SyntaxKind[Terminal](text = "'")
+ (274,6)SyntaxKind[Terminal](text = """)
+ (274,10)SyntaxKind[Terminal](text = "\")
+ (274,14)SyntaxKind[Terminal](text = "b")
+ (274,18)SyntaxKind[Terminal](text = "f")
+ (274,22)SyntaxKind[Terminal](text = "n")
+ (274,26)SyntaxKind[Terminal](text = "r")
+ (274,30)SyntaxKind[Terminal](text = "t")
+ (274,34)SyntaxKind[Terminal](text = "v")
+ (275,1)SyntaxKind[DedentToken]
+ (276,1)SyntaxKind[Production]
+ (276,1)SyntaxKind[Identifier](text = "NonEscapeCharacter")
+ (277,1)SyntaxKind[RightHandSideList]
+ (277,1)SyntaxKind[IndentToken]
+ (277,2)SyntaxKind[RightHandSide]
+ (277,2)SyntaxKind[SymbolSpan]
+ (277,2)SyntaxKind[ButNotSymbol]
+ (277,2)SyntaxKind[Nonterminal]
+ (277,2)SyntaxKind[Identifier](text = "SourceCharacter")
+ (277,18)SyntaxKind[ButKeyword]
+ (277,22)SyntaxKind[NotKeyword]
+ (277,26)SyntaxKind[OneOfSymbol]
+ (277,33)SyntaxKind[Nonterminal]
+ (277,33)SyntaxKind[Identifier](text = "EscapeCharacter")
+ (277,52)SyntaxKind[Nonterminal]
+ (277,52)SyntaxKind[Identifier](text = "LineTerminator")
+ (278,1)SyntaxKind[DedentToken]
+ (279,1)SyntaxKind[Production]
+ (279,1)SyntaxKind[Identifier](text = "EscapeCharacter")
+ (280,1)SyntaxKind[RightHandSideList]
+ (280,1)SyntaxKind[IndentToken]
+ (280,2)SyntaxKind[RightHandSide]
+ (280,2)SyntaxKind[SymbolSpan]
+ (280,2)SyntaxKind[Nonterminal]
+ (280,2)SyntaxKind[Identifier](text = "SingleEscapeCharacter")
+ (281,2)SyntaxKind[RightHandSide]
+ (281,2)SyntaxKind[SymbolSpan]
+ (281,2)SyntaxKind[Nonterminal]
+ (281,2)SyntaxKind[Identifier](text = "DecimalDigit")
+ (282,2)SyntaxKind[RightHandSide]
+ (282,2)SyntaxKind[SymbolSpan]
+ (282,2)SyntaxKind[Terminal](text = "x")
+ (283,2)SyntaxKind[RightHandSide]
+ (283,2)SyntaxKind[SymbolSpan]
+ (283,2)SyntaxKind[Terminal](text = "u")
+ (284,1)SyntaxKind[DedentToken]
+ (285,1)SyntaxKind[Production]
+ (285,1)SyntaxKind[Identifier](text = "HexEscapeSequence")
+ (286,1)SyntaxKind[RightHandSideList]
+ (286,1)SyntaxKind[IndentToken]
+ (286,2)SyntaxKind[RightHandSide]
+ (286,2)SyntaxKind[SymbolSpan]
+ (286,2)SyntaxKind[Terminal](text = "x")
+ (286,6)SyntaxKind[SymbolSpan]
+ (286,6)SyntaxKind[Nonterminal]
+ (286,6)SyntaxKind[Identifier](text = "HexDigit")
+ (286,15)SyntaxKind[SymbolSpan]
+ (286,15)SyntaxKind[Nonterminal]
+ (286,15)SyntaxKind[Identifier](text = "HexDigit")
+ (287,1)SyntaxKind[DedentToken]
+ (288,1)SyntaxKind[Production]
+ (288,1)SyntaxKind[Identifier](text = "UnicodeEscapeSequence")
+ (289,1)SyntaxKind[RightHandSideList]
+ (289,1)SyntaxKind[IndentToken]
+ (289,2)SyntaxKind[RightHandSide]
+ (289,2)SyntaxKind[SymbolSpan]
+ (289,2)SyntaxKind[Terminal](text = "u")
+ (289,6)SyntaxKind[SymbolSpan]
+ (289,6)SyntaxKind[Nonterminal]
+ (289,6)SyntaxKind[Identifier](text = "Hex4Digits")
+ (290,2)SyntaxKind[RightHandSide]
+ (290,2)SyntaxKind[SymbolSpan]
+ (290,2)SyntaxKind[Terminal](text = "u{")
+ (290,7)SyntaxKind[SymbolSpan]
+ (290,7)SyntaxKind[Nonterminal]
+ (290,7)SyntaxKind[Identifier](text = "HexDigits")
+ (290,17)SyntaxKind[SymbolSpan]
+ (290,17)SyntaxKind[Terminal](text = "}")
+ (291,1)SyntaxKind[DedentToken]
+ (292,1)SyntaxKind[Production]
+ (292,1)SyntaxKind[Identifier](text = "Hex4Digits")
+ (293,1)SyntaxKind[RightHandSideList]
+ (293,1)SyntaxKind[IndentToken]
+ (293,2)SyntaxKind[RightHandSide]
+ (293,2)SyntaxKind[SymbolSpan]
+ (293,2)SyntaxKind[Nonterminal]
+ (293,2)SyntaxKind[Identifier](text = "HexDigit")
+ (293,11)SyntaxKind[SymbolSpan]
+ (293,11)SyntaxKind[Nonterminal]
+ (293,11)SyntaxKind[Identifier](text = "HexDigit")
+ (293,20)SyntaxKind[SymbolSpan]
+ (293,20)SyntaxKind[Nonterminal]
+ (293,20)SyntaxKind[Identifier](text = "HexDigit")
+ (293,29)SyntaxKind[SymbolSpan]
+ (293,29)SyntaxKind[Nonterminal]
+ (293,29)SyntaxKind[Identifier](text = "HexDigit")
+ (294,1)SyntaxKind[DedentToken]
+ (295,1)SyntaxKind[Production]
+ (295,1)SyntaxKind[Identifier](text = "RegularExpressionLiteral")
+ (296,1)SyntaxKind[RightHandSideList]
+ (296,1)SyntaxKind[IndentToken]
+ (296,2)SyntaxKind[RightHandSide]
+ (296,2)SyntaxKind[SymbolSpan]
+ (296,2)SyntaxKind[Terminal](text = "/")
+ (296,6)SyntaxKind[SymbolSpan]
+ (296,6)SyntaxKind[Nonterminal]
+ (296,6)SyntaxKind[Identifier](text = "RegularExpressionBody")
+ (296,28)SyntaxKind[SymbolSpan]
+ (296,28)SyntaxKind[Terminal](text = "/")
+ (296,32)SyntaxKind[SymbolSpan]
+ (296,32)SyntaxKind[Nonterminal]
+ (296,32)SyntaxKind[Identifier](text = "RegularExpressionFlags")
+ (297,1)SyntaxKind[DedentToken]
+ (298,1)SyntaxKind[Production]
+ (298,1)SyntaxKind[Identifier](text = "RegularExpressionBody")
+ (299,1)SyntaxKind[RightHandSideList]
+ (299,1)SyntaxKind[IndentToken]
+ (299,2)SyntaxKind[RightHandSide]
+ (299,2)SyntaxKind[SymbolSpan]
+ (299,2)SyntaxKind[Nonterminal]
+ (299,2)SyntaxKind[Identifier](text = "RegularExpressionFirstChar")
+ (299,29)SyntaxKind[SymbolSpan]
+ (299,29)SyntaxKind[Nonterminal]
+ (299,29)SyntaxKind[Identifier](text = "RegularExpressionChars")
+ (300,1)SyntaxKind[DedentToken]
+ (301,1)SyntaxKind[Production]
+ (301,1)SyntaxKind[Identifier](text = "RegularExpressionChars")
+ (302,1)SyntaxKind[RightHandSideList]
+ (302,1)SyntaxKind[IndentToken]
+ (302,2)SyntaxKind[RightHandSide]
+ (302,2)SyntaxKind[SymbolSpan]
+ (302,2)SyntaxKind[EmptyAssertion]
+ (302,2)SyntaxKind[OpenBracketToken]
+ (302,3)SyntaxKind[EmptyKeyword]
+ (302,8)SyntaxKind[CloseBracketToken]
+ (303,2)SyntaxKind[RightHandSide]
+ (303,2)SyntaxKind[SymbolSpan]
+ (303,2)SyntaxKind[Nonterminal]
+ (303,2)SyntaxKind[Identifier](text = "RegularExpressionChars")
+ (303,25)SyntaxKind[SymbolSpan]
+ (303,25)SyntaxKind[Nonterminal]
+ (303,25)SyntaxKind[Identifier](text = "RegularExpressionChar")
+ (304,1)SyntaxKind[DedentToken]
+ (305,1)SyntaxKind[Production]
+ (305,1)SyntaxKind[Identifier](text = "RegularExpressionFirstChar")
+ (306,1)SyntaxKind[RightHandSideList]
+ (306,1)SyntaxKind[IndentToken]
+ (306,2)SyntaxKind[RightHandSide]
+ (306,2)SyntaxKind[SymbolSpan]
+ (306,2)SyntaxKind[ButNotSymbol]
+ (306,2)SyntaxKind[Nonterminal]
+ (306,2)SyntaxKind[Identifier](text = "RegularExpressionNonTerminator")
+ (306,33)SyntaxKind[ButKeyword]
+ (306,37)SyntaxKind[NotKeyword]
+ (306,41)SyntaxKind[OneOfSymbol]
+ (306,48)SyntaxKind[Terminal](text = "*")
+ (306,55)SyntaxKind[Terminal](text = "\")
+ (306,62)SyntaxKind[Terminal](text = "/")
+ (306,69)SyntaxKind[Terminal](text = "[")
+ (307,2)SyntaxKind[RightHandSide]
+ (307,2)SyntaxKind[SymbolSpan]
+ (307,2)SyntaxKind[Nonterminal]
+ (307,2)SyntaxKind[Identifier](text = "RegularExpressionBackslashSequence")
+ (308,2)SyntaxKind[RightHandSide]
+ (308,2)SyntaxKind[SymbolSpan]
+ (308,2)SyntaxKind[Nonterminal]
+ (308,2)SyntaxKind[Identifier](text = "RegularExpressionClass")
+ (309,1)SyntaxKind[DedentToken]
+ (310,1)SyntaxKind[Production]
+ (310,1)SyntaxKind[Identifier](text = "RegularExpressionChar")
+ (311,1)SyntaxKind[RightHandSideList]
+ (311,1)SyntaxKind[IndentToken]
+ (311,2)SyntaxKind[RightHandSide]
+ (311,2)SyntaxKind[SymbolSpan]
+ (311,2)SyntaxKind[ButNotSymbol]
+ (311,2)SyntaxKind[Nonterminal]
+ (311,2)SyntaxKind[Identifier](text = "RegularExpressionNonTerminator")
+ (311,33)SyntaxKind[ButKeyword]
+ (311,37)SyntaxKind[NotKeyword]
+ (311,41)SyntaxKind[OneOfSymbol]
+ (311,48)SyntaxKind[Terminal](text = "\")
+ (311,55)SyntaxKind[Terminal](text = "/")
+ (311,62)SyntaxKind[Terminal](text = "[")
+ (312,2)SyntaxKind[RightHandSide]
+ (312,2)SyntaxKind[SymbolSpan]
+ (312,2)SyntaxKind[Nonterminal]
+ (312,2)SyntaxKind[Identifier](text = "RegularExpressionBackslashSequence")
+ (313,2)SyntaxKind[RightHandSide]
+ (313,2)SyntaxKind[SymbolSpan]
+ (313,2)SyntaxKind[Nonterminal]
+ (313,2)SyntaxKind[Identifier](text = "RegularExpressionClass")
+ (314,1)SyntaxKind[DedentToken]
+ (315,1)SyntaxKind[Production]
+ (315,1)SyntaxKind[Identifier](text = "RegularExpressionBackslashSequence")
+ (316,1)SyntaxKind[RightHandSideList]
+ (316,1)SyntaxKind[IndentToken]
+ (316,2)SyntaxKind[RightHandSide]
+ (316,2)SyntaxKind[SymbolSpan]
+ (316,2)SyntaxKind[Terminal](text = "\")
+ (316,6)SyntaxKind[SymbolSpan]
+ (316,6)SyntaxKind[Nonterminal]
+ (316,6)SyntaxKind[Identifier](text = "RegularExpressionNonTerminator")
+ (317,1)SyntaxKind[DedentToken]
+ (318,1)SyntaxKind[Production]
+ (318,1)SyntaxKind[Identifier](text = "RegularExpressionNonTerminator")
+ (319,1)SyntaxKind[RightHandSideList]
+ (319,1)SyntaxKind[IndentToken]
+ (319,2)SyntaxKind[RightHandSide]
+ (319,2)SyntaxKind[SymbolSpan]
+ (319,2)SyntaxKind[ButNotSymbol]
+ (319,2)SyntaxKind[Nonterminal]
+ (319,2)SyntaxKind[Identifier](text = "SourceCharacter")
+ (319,18)SyntaxKind[ButKeyword]
+ (319,22)SyntaxKind[NotKeyword]
+ (319,26)SyntaxKind[Nonterminal]
+ (319,26)SyntaxKind[Identifier](text = "LineTerminator")
+ (320,1)SyntaxKind[DedentToken]
+ (321,1)SyntaxKind[Production]
+ (321,1)SyntaxKind[Identifier](text = "RegularExpressionClass")
+ (322,1)SyntaxKind[RightHandSideList]
+ (322,1)SyntaxKind[IndentToken]
+ (322,2)SyntaxKind[RightHandSide]
+ (322,2)SyntaxKind[SymbolSpan]
+ (322,2)SyntaxKind[Terminal](text = "[")
+ (322,6)SyntaxKind[SymbolSpan]
+ (322,6)SyntaxKind[Nonterminal]
+ (322,6)SyntaxKind[Identifier](text = "RegularExpressionClassChars")
+ (322,34)SyntaxKind[SymbolSpan]
+ (322,34)SyntaxKind[Terminal](text = "]")
+ (323,1)SyntaxKind[DedentToken]
+ (324,1)SyntaxKind[Production]
+ (324,1)SyntaxKind[Identifier](text = "RegularExpressionClassChars")
+ (325,1)SyntaxKind[RightHandSideList]
+ (325,1)SyntaxKind[IndentToken]
+ (325,2)SyntaxKind[RightHandSide]
+ (325,2)SyntaxKind[SymbolSpan]
+ (325,2)SyntaxKind[EmptyAssertion]
+ (325,2)SyntaxKind[OpenBracketToken]
+ (325,3)SyntaxKind[EmptyKeyword]
+ (325,8)SyntaxKind[CloseBracketToken]
+ (326,2)SyntaxKind[RightHandSide]
+ (326,2)SyntaxKind[SymbolSpan]
+ (326,2)SyntaxKind[Nonterminal]
+ (326,2)SyntaxKind[Identifier](text = "RegularExpressionClassChars")
+ (326,30)SyntaxKind[SymbolSpan]
+ (326,30)SyntaxKind[Nonterminal]
+ (326,30)SyntaxKind[Identifier](text = "RegularExpressionClassChar")
+ (327,1)SyntaxKind[DedentToken]
+ (328,1)SyntaxKind[Production]
+ (328,1)SyntaxKind[Identifier](text = "RegularExpressionClassChar")
+ (329,1)SyntaxKind[RightHandSideList]
+ (329,1)SyntaxKind[IndentToken]
+ (329,2)SyntaxKind[RightHandSide]
+ (329,2)SyntaxKind[SymbolSpan]
+ (329,2)SyntaxKind[ButNotSymbol]
+ (329,2)SyntaxKind[Nonterminal]
+ (329,2)SyntaxKind[Identifier](text = "RegularExpressionNonTerminator")
+ (329,33)SyntaxKind[ButKeyword]
+ (329,37)SyntaxKind[NotKeyword]
+ (329,41)SyntaxKind[OneOfSymbol]
+ (329,48)SyntaxKind[Terminal](text = "]")
+ (329,55)SyntaxKind[Terminal](text = "\")
+ (330,2)SyntaxKind[RightHandSide]
+ (330,2)SyntaxKind[SymbolSpan]
+ (330,2)SyntaxKind[Nonterminal]
+ (330,2)SyntaxKind[Identifier](text = "RegularExpressionBackslashSequence")
+ (331,1)SyntaxKind[DedentToken]
+ (332,1)SyntaxKind[Production]
+ (332,1)SyntaxKind[Identifier](text = "RegularExpressionFlags")
+ (333,1)SyntaxKind[RightHandSideList]
+ (333,1)SyntaxKind[IndentToken]
+ (333,2)SyntaxKind[RightHandSide]
+ (333,2)SyntaxKind[SymbolSpan]
+ (333,2)SyntaxKind[EmptyAssertion]
+ (333,2)SyntaxKind[OpenBracketToken]
+ (333,3)SyntaxKind[EmptyKeyword]
+ (333,8)SyntaxKind[CloseBracketToken]
+ (334,2)SyntaxKind[RightHandSide]
+ (334,2)SyntaxKind[SymbolSpan]
+ (334,2)SyntaxKind[Nonterminal]
+ (334,2)SyntaxKind[Identifier](text = "RegularExpressionFlags")
+ (334,25)SyntaxKind[SymbolSpan]
+ (334,25)SyntaxKind[Nonterminal]
+ (334,25)SyntaxKind[Identifier](text = "IdentifierPart")
+ (335,1)SyntaxKind[DedentToken]
+ (336,1)SyntaxKind[Production]
+ (336,1)SyntaxKind[Identifier](text = "Template")
+ (337,1)SyntaxKind[RightHandSideList]
+ (337,1)SyntaxKind[IndentToken]
+ (337,2)SyntaxKind[RightHandSide]
+ (337,2)SyntaxKind[SymbolSpan]
+ (337,2)SyntaxKind[Nonterminal]
+ (337,2)SyntaxKind[Identifier](text = "NoSubstitutionTemplate")
+ (338,2)SyntaxKind[RightHandSide]
+ (338,2)SyntaxKind[SymbolSpan]
+ (338,2)SyntaxKind[Nonterminal]
+ (338,2)SyntaxKind[Identifier](text = "TemplateHead")
+ (339,1)SyntaxKind[DedentToken]
+ (340,1)SyntaxKind[Production]
+ (340,1)SyntaxKind[Identifier](text = "NoSubstitutionTemplate")
+ (341,1)SyntaxKind[RightHandSideList]
+ (341,1)SyntaxKind[IndentToken]
+ (341,2)SyntaxKind[RightHandSide]
+ (341,2)SyntaxKind[SymbolSpan]
+ (341,2)SyntaxKind[Terminal](text = "`")
+ (341,6)SyntaxKind[SymbolSpan]
+ (341,6)SyntaxKind[Nonterminal]?
+ (341,6)SyntaxKind[Identifier](text = "TemplateCharacters")
+ (341,24)SyntaxKind[QuestionToken]
+ (341,26)SyntaxKind[SymbolSpan]
+ (341,26)SyntaxKind[Terminal](text = "`")
+ (342,1)SyntaxKind[DedentToken]
+ (343,1)SyntaxKind[Production]
+ (343,1)SyntaxKind[Identifier](text = "TemplateHead")
+ (344,1)SyntaxKind[RightHandSideList]
+ (344,1)SyntaxKind[IndentToken]
+ (344,2)SyntaxKind[RightHandSide]
+ (344,2)SyntaxKind[SymbolSpan]
+ (344,2)SyntaxKind[Terminal](text = "`")
+ (344,6)SyntaxKind[SymbolSpan]
+ (344,6)SyntaxKind[Nonterminal]?
+ (344,6)SyntaxKind[Identifier](text = "TemplateCharacters")
+ (344,24)SyntaxKind[QuestionToken]
+ (344,26)SyntaxKind[SymbolSpan]
+ (344,26)SyntaxKind[Terminal](text = "${")
+ (345,1)SyntaxKind[DedentToken]
+ (346,1)SyntaxKind[Production]
+ (346,1)SyntaxKind[Identifier](text = "TemplateSubstitutionTail")
+ (347,1)SyntaxKind[RightHandSideList]
+ (347,1)SyntaxKind[IndentToken]
+ (347,2)SyntaxKind[RightHandSide]
+ (347,2)SyntaxKind[SymbolSpan]
+ (347,2)SyntaxKind[Nonterminal]
+ (347,2)SyntaxKind[Identifier](text = "TemplateMiddle")
+ (348,2)SyntaxKind[RightHandSide]
+ (348,2)SyntaxKind[SymbolSpan]
+ (348,2)SyntaxKind[Nonterminal]
+ (348,2)SyntaxKind[Identifier](text = "TemplateTail")
+ (349,1)SyntaxKind[DedentToken]
+ (350,1)SyntaxKind[Production]
+ (350,1)SyntaxKind[Identifier](text = "TemplateMiddle")
+ (351,1)SyntaxKind[RightHandSideList]
+ (351,1)SyntaxKind[IndentToken]
+ (351,2)SyntaxKind[RightHandSide]
+ (351,2)SyntaxKind[SymbolSpan]
+ (351,2)SyntaxKind[Terminal](text = "}")
+ (351,6)SyntaxKind[SymbolSpan]
+ (351,6)SyntaxKind[Nonterminal]?
+ (351,6)SyntaxKind[Identifier](text = "TemplateCharacters")
+ (351,24)SyntaxKind[QuestionToken]
+ (351,26)SyntaxKind[SymbolSpan]
+ (351,26)SyntaxKind[Terminal](text = "${")
+ (352,1)SyntaxKind[DedentToken]
+ (353,1)SyntaxKind[Production]
+ (353,1)SyntaxKind[Identifier](text = "TemplateTail")
+ (354,1)SyntaxKind[RightHandSideList]
+ (354,1)SyntaxKind[IndentToken]
+ (354,2)SyntaxKind[RightHandSide]
+ (354,2)SyntaxKind[SymbolSpan]
+ (354,2)SyntaxKind[Terminal](text = "}")
+ (354,6)SyntaxKind[SymbolSpan]
+ (354,6)SyntaxKind[Nonterminal]?
+ (354,6)SyntaxKind[Identifier](text = "TemplateCharacters")
+ (354,24)SyntaxKind[QuestionToken]
+ (354,26)SyntaxKind[SymbolSpan]
+ (354,26)SyntaxKind[Terminal](text = "`")
+ (355,1)SyntaxKind[DedentToken]
+ (356,1)SyntaxKind[Production]
+ (356,1)SyntaxKind[Identifier](text = "TemplateCharacters")
+ (357,1)SyntaxKind[RightHandSideList]
+ (357,1)SyntaxKind[IndentToken]
+ (357,2)SyntaxKind[RightHandSide]
+ (357,2)SyntaxKind[SymbolSpan]
+ (357,2)SyntaxKind[Nonterminal]
+ (357,2)SyntaxKind[Identifier](text = "TemplateCharacter")
+ (357,20)SyntaxKind[SymbolSpan]
+ (357,20)SyntaxKind[Nonterminal]?
+ (357,20)SyntaxKind[Identifier](text = "TemplateCharacters")
+ (357,38)SyntaxKind[QuestionToken]
+ (358,1)SyntaxKind[DedentToken]
+ (359,1)SyntaxKind[Production]
+ (359,1)SyntaxKind[Identifier](text = "TemplateCharacter")
+ (360,1)SyntaxKind[RightHandSideList]
+ (360,1)SyntaxKind[IndentToken]
+ (360,2)SyntaxKind[RightHandSide]
+ (360,2)SyntaxKind[SymbolSpan]
+ (360,2)SyntaxKind[Terminal](text = "$")
+ (360,6)SyntaxKind[SymbolSpan]
+ (360,6)SyntaxKind[LookaheadAssertion]
+ (360,6)SyntaxKind[OpenBracketToken]
+ (360,7)SyntaxKind[LookaheadKeyword]
+ (360,17)SyntaxKind[ExclamationEqualsToken]
+ (360,20)SyntaxKind[SymbolSpan]
+ (360,20)SyntaxKind[Terminal](text = "{")
+ (360,24)SyntaxKind[CloseBracketToken]
+ (361,2)SyntaxKind[RightHandSide]
+ (361,2)SyntaxKind[SymbolSpan]
+ (361,2)SyntaxKind[Terminal](text = "\")
+ (361,6)SyntaxKind[SymbolSpan]
+ (361,6)SyntaxKind[Nonterminal]
+ (361,6)SyntaxKind[Identifier](text = "EscapeSequence")
+ (362,2)SyntaxKind[RightHandSide]
+ (362,2)SyntaxKind[SymbolSpan]
+ (362,2)SyntaxKind[Nonterminal]
+ (362,2)SyntaxKind[Identifier](text = "LineContinuation")
+ (363,2)SyntaxKind[RightHandSide]
+ (363,2)SyntaxKind[SymbolSpan]
+ (363,2)SyntaxKind[Nonterminal]
+ (363,2)SyntaxKind[Identifier](text = "LineTerminatorSequence")
+ (364,2)SyntaxKind[RightHandSide]
+ (364,2)SyntaxKind[SymbolSpan]
+ (364,2)SyntaxKind[ButNotSymbol]
+ (364,2)SyntaxKind[Nonterminal]
+ (364,2)SyntaxKind[Identifier](text = "SourceCharacter")
+ (364,18)SyntaxKind[ButKeyword]
+ (364,22)SyntaxKind[NotKeyword]
+ (364,26)SyntaxKind[OneOfSymbol]
+ (364,33)SyntaxKind[Terminal](text = "`")
+ (364,40)SyntaxKind[Terminal](text = "\")
+ (364,47)SyntaxKind[Terminal](text = "$")
+ (364,54)SyntaxKind[Nonterminal]
+ (364,54)SyntaxKind[Identifier](text = "LineTerminator")
+ (365,1)SyntaxKind[DedentToken]
+ (367,1)SyntaxKind[Production]
+ (367,1)SyntaxKind[Identifier](text = "IdentifierReference")
+ (367,20)SyntaxKind[ParameterList]
+ (367,20)SyntaxKind[OpenBracketToken]
+ (367,21)SyntaxKind[Parameter]
+ (367,21)SyntaxKind[Identifier](text = "Yield")
+ (367,26)SyntaxKind[CloseBracketToken]
+ (368,1)SyntaxKind[RightHandSideList]
+ (368,1)SyntaxKind[IndentToken]
+ (368,2)SyntaxKind[RightHandSide]
+ (368,2)SyntaxKind[SymbolSpan]
+ (368,2)SyntaxKind[Nonterminal]
+ (368,2)SyntaxKind[Identifier](text = "Identifier")
+ (369,2)SyntaxKind[RightHandSide]
+ (369,2)SyntaxKind[SymbolSpan]
+ (369,2)SyntaxKind[ParameterValueAssertion]
+ (369,2)SyntaxKind[OpenBracketToken]
+ (369,3)SyntaxKind[TildeToken]
+ (369,4)SyntaxKind[Identifier](text = "Yield")
+ (369,9)SyntaxKind[CloseBracketToken]
+ (369,11)SyntaxKind[SymbolSpan]
+ (369,11)SyntaxKind[Terminal](text = "yield")
+ (370,1)SyntaxKind[DedentToken]
+ (371,1)SyntaxKind[Production]
+ (371,1)SyntaxKind[Identifier](text = "BindingIdentifier")
+ (371,18)SyntaxKind[ParameterList]
+ (371,18)SyntaxKind[OpenBracketToken]
+ (371,19)SyntaxKind[Parameter]
+ (371,19)SyntaxKind[Identifier](text = "Yield")
+ (371,24)SyntaxKind[CloseBracketToken]
+ (372,1)SyntaxKind[RightHandSideList]
+ (372,1)SyntaxKind[IndentToken]
+ (372,2)SyntaxKind[RightHandSide]
+ (372,2)SyntaxKind[SymbolSpan]
+ (372,2)SyntaxKind[Nonterminal]
+ (372,2)SyntaxKind[Identifier](text = "Identifier")
+ (373,2)SyntaxKind[RightHandSide]
+ (373,2)SyntaxKind[SymbolSpan]
+ (373,2)SyntaxKind[ParameterValueAssertion]
+ (373,2)SyntaxKind[OpenBracketToken]
+ (373,3)SyntaxKind[TildeToken]
+ (373,4)SyntaxKind[Identifier](text = "Yield")
+ (373,9)SyntaxKind[CloseBracketToken]
+ (373,11)SyntaxKind[SymbolSpan]
+ (373,11)SyntaxKind[Terminal](text = "yield")
+ (374,1)SyntaxKind[DedentToken]
+ (375,1)SyntaxKind[Production]
+ (375,1)SyntaxKind[Identifier](text = "LabelIdentifier")
+ (375,16)SyntaxKind[ParameterList]
+ (375,16)SyntaxKind[OpenBracketToken]
+ (375,17)SyntaxKind[Parameter]
+ (375,17)SyntaxKind[Identifier](text = "Yield")
+ (375,22)SyntaxKind[CloseBracketToken]
+ (376,1)SyntaxKind[RightHandSideList]
+ (376,1)SyntaxKind[IndentToken]
+ (376,2)SyntaxKind[RightHandSide]
+ (376,2)SyntaxKind[SymbolSpan]
+ (376,2)SyntaxKind[Nonterminal]
+ (376,2)SyntaxKind[Identifier](text = "Identifier")
+ (377,2)SyntaxKind[RightHandSide]
+ (377,2)SyntaxKind[SymbolSpan]
+ (377,2)SyntaxKind[ParameterValueAssertion]
+ (377,2)SyntaxKind[OpenBracketToken]
+ (377,3)SyntaxKind[TildeToken]
+ (377,4)SyntaxKind[Identifier](text = "Yield")
+ (377,9)SyntaxKind[CloseBracketToken]
+ (377,11)SyntaxKind[SymbolSpan]
+ (377,11)SyntaxKind[Terminal](text = "yield")
+ (378,1)SyntaxKind[DedentToken]
+ (379,1)SyntaxKind[Production]
+ (379,1)SyntaxKind[Identifier](text = "Identifier")
+ (380,1)SyntaxKind[RightHandSideList]
+ (380,1)SyntaxKind[IndentToken]
+ (380,2)SyntaxKind[RightHandSide]
+ (380,2)SyntaxKind[SymbolSpan]
+ (380,2)SyntaxKind[ButNotSymbol]
+ (380,2)SyntaxKind[Nonterminal]
+ (380,2)SyntaxKind[Identifier](text = "IdentifierName")
+ (380,17)SyntaxKind[ButKeyword]
+ (380,21)SyntaxKind[NotKeyword]
+ (380,25)SyntaxKind[Nonterminal]
+ (380,25)SyntaxKind[Identifier](text = "ReservedWord")
+ (381,1)SyntaxKind[DedentToken]
+ (382,1)SyntaxKind[Production]
+ (382,1)SyntaxKind[Identifier](text = "PrimaryExpression")
+ (382,18)SyntaxKind[ParameterList]
+ (382,18)SyntaxKind[OpenBracketToken]
+ (382,19)SyntaxKind[Parameter]
+ (382,19)SyntaxKind[Identifier](text = "Yield")
+ (382,24)SyntaxKind[CloseBracketToken]
+ (383,1)SyntaxKind[RightHandSideList]
+ (383,1)SyntaxKind[IndentToken]
+ (383,2)SyntaxKind[RightHandSide]
+ (383,2)SyntaxKind[SymbolSpan]
+ (383,2)SyntaxKind[Terminal](text = "this")
+ (384,2)SyntaxKind[RightHandSide]
+ (384,2)SyntaxKind[SymbolSpan]
+ (384,2)SyntaxKind[Nonterminal]
+ (384,2)SyntaxKind[Identifier](text = "IdentifierReference")
+ (384,21)SyntaxKind[ArgumentList]
+ (384,21)SyntaxKind[OpenBracketToken]
+ (384,22)SyntaxKind[Argument]?
+ (384,22)SyntaxKind[QuestionToken]
+ (384,23)SyntaxKind[Identifier](text = "Yield")
+ (384,28)SyntaxKind[CloseBracketToken]
+ (385,2)SyntaxKind[RightHandSide]
+ (385,2)SyntaxKind[SymbolSpan]
+ (385,2)SyntaxKind[Nonterminal]
+ (385,2)SyntaxKind[Identifier](text = "Literal")
+ (386,2)SyntaxKind[RightHandSide]
+ (386,2)SyntaxKind[SymbolSpan]
+ (386,2)SyntaxKind[Nonterminal]
+ (386,2)SyntaxKind[Identifier](text = "ArrayLiteral")
+ (386,14)SyntaxKind[ArgumentList]
+ (386,14)SyntaxKind[OpenBracketToken]
+ (386,15)SyntaxKind[Argument]?
+ (386,15)SyntaxKind[QuestionToken]
+ (386,16)SyntaxKind[Identifier](text = "Yield")
+ (386,21)SyntaxKind[CloseBracketToken]
+ (387,2)SyntaxKind[RightHandSide]
+ (387,2)SyntaxKind[SymbolSpan]
+ (387,2)SyntaxKind[Nonterminal]
+ (387,2)SyntaxKind[Identifier](text = "ObjectLiteral")
+ (387,15)SyntaxKind[ArgumentList]
+ (387,15)SyntaxKind[OpenBracketToken]
+ (387,16)SyntaxKind[Argument]?
+ (387,16)SyntaxKind[QuestionToken]
+ (387,17)SyntaxKind[Identifier](text = "Yield")
+ (387,22)SyntaxKind[CloseBracketToken]
+ (388,2)SyntaxKind[RightHandSide]
+ (388,2)SyntaxKind[SymbolSpan]
+ (388,2)SyntaxKind[Nonterminal]
+ (388,2)SyntaxKind[Identifier](text = "FunctionExpression")
+ (389,2)SyntaxKind[RightHandSide]
+ (389,2)SyntaxKind[SymbolSpan]
+ (389,2)SyntaxKind[Nonterminal]
+ (389,2)SyntaxKind[Identifier](text = "ClassExpression")
+ (389,17)SyntaxKind[ArgumentList]
+ (389,17)SyntaxKind[OpenBracketToken]
+ (389,18)SyntaxKind[Argument]?
+ (389,18)SyntaxKind[QuestionToken]
+ (389,19)SyntaxKind[Identifier](text = "Yield")
+ (389,24)SyntaxKind[CloseBracketToken]
+ (390,2)SyntaxKind[RightHandSide]
+ (390,2)SyntaxKind[SymbolSpan]
+ (390,2)SyntaxKind[Nonterminal]
+ (390,2)SyntaxKind[Identifier](text = "GeneratorExpression")
+ (391,2)SyntaxKind[RightHandSide]
+ (391,2)SyntaxKind[SymbolSpan]
+ (391,2)SyntaxKind[Nonterminal]
+ (391,2)SyntaxKind[Identifier](text = "RegularExpressionLiteral")
+ (392,2)SyntaxKind[RightHandSide]
+ (392,2)SyntaxKind[SymbolSpan]
+ (392,2)SyntaxKind[Nonterminal]
+ (392,2)SyntaxKind[Identifier](text = "TemplateLiteral")
+ (392,17)SyntaxKind[ArgumentList]
+ (392,17)SyntaxKind[OpenBracketToken]
+ (392,18)SyntaxKind[Argument]?
+ (392,18)SyntaxKind[QuestionToken]
+ (392,19)SyntaxKind[Identifier](text = "Yield")
+ (392,24)SyntaxKind[CloseBracketToken]
+ (393,2)SyntaxKind[RightHandSide]
+ (393,2)SyntaxKind[SymbolSpan]
+ (393,2)SyntaxKind[Nonterminal]
+ (393,2)SyntaxKind[Identifier](text = "CoverParenthesizedExpressionAndArrowParameterList")
+ (393,51)SyntaxKind[ArgumentList]
+ (393,51)SyntaxKind[OpenBracketToken]
+ (393,52)SyntaxKind[Argument]?
+ (393,52)SyntaxKind[QuestionToken]
+ (393,53)SyntaxKind[Identifier](text = "Yield")
+ (393,58)SyntaxKind[CloseBracketToken]
+ (394,1)SyntaxKind[DedentToken]
+ (395,1)SyntaxKind[Production]
+ (395,1)SyntaxKind[Identifier](text = "CoverParenthesizedExpressionAndArrowParameterList")
+ (395,50)SyntaxKind[ParameterList]
+ (395,50)SyntaxKind[OpenBracketToken]
+ (395,51)SyntaxKind[Parameter]
+ (395,51)SyntaxKind[Identifier](text = "Yield")
+ (395,56)SyntaxKind[CloseBracketToken]
+ (396,1)SyntaxKind[RightHandSideList]
+ (396,1)SyntaxKind[IndentToken]
+ (396,2)SyntaxKind[RightHandSide]
+ (396,2)SyntaxKind[SymbolSpan]
+ (396,2)SyntaxKind[Terminal](text = "(")
+ (396,6)SyntaxKind[SymbolSpan]
+ (396,6)SyntaxKind[Nonterminal]
+ (396,6)SyntaxKind[Identifier](text = "Expression")
+ (396,16)SyntaxKind[ArgumentList]
+ (396,16)SyntaxKind[OpenBracketToken]
+ (396,17)SyntaxKind[Argument]+
+ (396,17)SyntaxKind[PlusToken]
+ (396,18)SyntaxKind[Identifier](text = "In")
+ (396,22)SyntaxKind[Argument]?
+ (396,22)SyntaxKind[QuestionToken]
+ (396,23)SyntaxKind[Identifier](text = "Yield")
+ (396,28)SyntaxKind[CloseBracketToken]
+ (396,30)SyntaxKind[SymbolSpan]
+ (396,30)SyntaxKind[Terminal](text = ")")
+ (397,2)SyntaxKind[RightHandSide]
+ (397,2)SyntaxKind[SymbolSpan]
+ (397,2)SyntaxKind[Terminal](text = "(")
+ (397,6)SyntaxKind[SymbolSpan]
+ (397,6)SyntaxKind[Terminal](text = ")")
+ (398,2)SyntaxKind[RightHandSide]
+ (398,2)SyntaxKind[SymbolSpan]
+ (398,2)SyntaxKind[Terminal](text = "(")
+ (398,6)SyntaxKind[SymbolSpan]
+ (398,6)SyntaxKind[Terminal](text = "...")
+ (398,12)SyntaxKind[SymbolSpan]
+ (398,12)SyntaxKind[Nonterminal]
+ (398,12)SyntaxKind[Identifier](text = "BindingIdentifier")
+ (398,29)SyntaxKind[ArgumentList]
+ (398,29)SyntaxKind[OpenBracketToken]
+ (398,30)SyntaxKind[Argument]?
+ (398,30)SyntaxKind[QuestionToken]
+ (398,31)SyntaxKind[Identifier](text = "Yield")
+ (398,36)SyntaxKind[CloseBracketToken]
+ (398,38)SyntaxKind[SymbolSpan]
+ (398,38)SyntaxKind[Terminal](text = ")")
+ (399,2)SyntaxKind[RightHandSide]
+ (399,2)SyntaxKind[SymbolSpan]
+ (399,2)SyntaxKind[Terminal](text = "(")
+ (399,6)SyntaxKind[SymbolSpan]
+ (399,6)SyntaxKind[Nonterminal]
+ (399,6)SyntaxKind[Identifier](text = "Expression")
+ (399,16)SyntaxKind[ArgumentList]
+ (399,16)SyntaxKind[OpenBracketToken]
+ (399,17)SyntaxKind[Argument]+
+ (399,17)SyntaxKind[PlusToken]
+ (399,18)SyntaxKind[Identifier](text = "In")
+ (399,22)SyntaxKind[Argument]?
+ (399,22)SyntaxKind[QuestionToken]
+ (399,23)SyntaxKind[Identifier](text = "Yield")
+ (399,28)SyntaxKind[CloseBracketToken]
+ (399,30)SyntaxKind[SymbolSpan]
+ (399,30)SyntaxKind[Terminal](text = ",")
+ (399,34)SyntaxKind[SymbolSpan]
+ (399,34)SyntaxKind[Terminal](text = "...")
+ (399,40)SyntaxKind[SymbolSpan]
+ (399,40)SyntaxKind[Nonterminal]
+ (399,40)SyntaxKind[Identifier](text = "BindingIdentifier")
+ (399,57)SyntaxKind[ArgumentList]
+ (399,57)SyntaxKind[OpenBracketToken]
+ (399,58)SyntaxKind[Argument]?
+ (399,58)SyntaxKind[QuestionToken]
+ (399,59)SyntaxKind[Identifier](text = "Yield")
+ (399,64)SyntaxKind[CloseBracketToken]
+ (399,66)SyntaxKind[SymbolSpan]
+ (399,66)SyntaxKind[Terminal](text = ")")
+ (400,1)SyntaxKind[DedentToken]
+ (401,1)SyntaxKind[Production]
+ (401,1)SyntaxKind[Identifier](text = "Literal")
+ (402,1)SyntaxKind[RightHandSideList]
+ (402,1)SyntaxKind[IndentToken]
+ (402,2)SyntaxKind[RightHandSide]
+ (402,2)SyntaxKind[SymbolSpan]
+ (402,2)SyntaxKind[Nonterminal]
+ (402,2)SyntaxKind[Identifier](text = "NullLiteral")
+ (403,2)SyntaxKind[RightHandSide]
+ (403,2)SyntaxKind[SymbolSpan]
+ (403,2)SyntaxKind[Nonterminal]
+ (403,2)SyntaxKind[Identifier](text = "BooleanLiteral")
+ (404,2)SyntaxKind[RightHandSide]
+ (404,2)SyntaxKind[SymbolSpan]
+ (404,2)SyntaxKind[Nonterminal]
+ (404,2)SyntaxKind[Identifier](text = "NumericLiteral")
+ (405,2)SyntaxKind[RightHandSide]
+ (405,2)SyntaxKind[SymbolSpan]
+ (405,2)SyntaxKind[Nonterminal]
+ (405,2)SyntaxKind[Identifier](text = "StringLiteral")
+ (406,1)SyntaxKind[DedentToken]
+ (407,1)SyntaxKind[Production]
+ (407,1)SyntaxKind[Identifier](text = "ArrayLiteral")
+ (407,13)SyntaxKind[ParameterList]
+ (407,13)SyntaxKind[OpenBracketToken]
+ (407,14)SyntaxKind[Parameter]
+ (407,14)SyntaxKind[Identifier](text = "Yield")
+ (407,19)SyntaxKind[CloseBracketToken]
+ (408,1)SyntaxKind[RightHandSideList]
+ (408,1)SyntaxKind[IndentToken]
+ (408,2)SyntaxKind[RightHandSide]
+ (408,2)SyntaxKind[SymbolSpan]
+ (408,2)SyntaxKind[Terminal](text = "[")
+ (408,6)SyntaxKind[SymbolSpan]
+ (408,6)SyntaxKind[Nonterminal]?
+ (408,6)SyntaxKind[Identifier](text = "Elision")
+ (408,13)SyntaxKind[QuestionToken]
+ (408,15)SyntaxKind[SymbolSpan]
+ (408,15)SyntaxKind[Terminal](text = "]")
+ (409,2)SyntaxKind[RightHandSide]
+ (409,2)SyntaxKind[SymbolSpan]
+ (409,2)SyntaxKind[Terminal](text = "[")
+ (409,6)SyntaxKind[SymbolSpan]
+ (409,6)SyntaxKind[Nonterminal]
+ (409,6)SyntaxKind[Identifier](text = "ElementList")
+ (409,17)SyntaxKind[ArgumentList]
+ (409,17)SyntaxKind[OpenBracketToken]
+ (409,18)SyntaxKind[Argument]?
+ (409,18)SyntaxKind[QuestionToken]
+ (409,19)SyntaxKind[Identifier](text = "Yield")
+ (409,24)SyntaxKind[CloseBracketToken]
+ (409,26)SyntaxKind[SymbolSpan]
+ (409,26)SyntaxKind[Terminal](text = "]")
+ (410,2)SyntaxKind[RightHandSide]
+ (410,2)SyntaxKind[SymbolSpan]
+ (410,2)SyntaxKind[Terminal](text = "[")
+ (410,6)SyntaxKind[SymbolSpan]
+ (410,6)SyntaxKind[Nonterminal]
+ (410,6)SyntaxKind[Identifier](text = "ElementList")
+ (410,17)SyntaxKind[ArgumentList]
+ (410,17)SyntaxKind[OpenBracketToken]
+ (410,18)SyntaxKind[Argument]?
+ (410,18)SyntaxKind[QuestionToken]
+ (410,19)SyntaxKind[Identifier](text = "Yield")
+ (410,24)SyntaxKind[CloseBracketToken]
+ (410,26)SyntaxKind[SymbolSpan]
+ (410,26)SyntaxKind[Terminal](text = ",")
+ (410,30)SyntaxKind[SymbolSpan]
+ (410,30)SyntaxKind[Nonterminal]?
+ (410,30)SyntaxKind[Identifier](text = "Elision")
+ (410,37)SyntaxKind[QuestionToken]
+ (410,39)SyntaxKind[SymbolSpan]
+ (410,39)SyntaxKind[Terminal](text = "]")
+ (411,1)SyntaxKind[DedentToken]
+ (412,1)SyntaxKind[Production]
+ (412,1)SyntaxKind[Identifier](text = "ElementList")
+ (412,12)SyntaxKind[ParameterList]
+ (412,12)SyntaxKind[OpenBracketToken]
+ (412,13)SyntaxKind[Parameter]
+ (412,13)SyntaxKind[Identifier](text = "Yield")
+ (412,18)SyntaxKind[CloseBracketToken]
+ (413,1)SyntaxKind[RightHandSideList]
+ (413,1)SyntaxKind[IndentToken]
+ (413,2)SyntaxKind[RightHandSide]
+ (413,2)SyntaxKind[SymbolSpan]
+ (413,2)SyntaxKind[Nonterminal]?
+ (413,2)SyntaxKind[Identifier](text = "Elision")
+ (413,9)SyntaxKind[QuestionToken]
+ (413,11)SyntaxKind[SymbolSpan]
+ (413,11)SyntaxKind[Nonterminal]
+ (413,11)SyntaxKind[Identifier](text = "AssignmentExpression")
+ (413,31)SyntaxKind[ArgumentList]
+ (413,31)SyntaxKind[OpenBracketToken]
+ (413,32)SyntaxKind[Argument]
+ (413,32)SyntaxKind[Identifier](text = "In")
+ (413,36)SyntaxKind[Argument]?
+ (413,36)SyntaxKind[QuestionToken]
+ (413,37)SyntaxKind[Identifier](text = "Yield")
+ (413,42)SyntaxKind[CloseBracketToken]
+ (414,2)SyntaxKind[RightHandSide]
+ (414,2)SyntaxKind[SymbolSpan]
+ (414,2)SyntaxKind[Nonterminal]?
+ (414,2)SyntaxKind[Identifier](text = "Elision")
+ (414,9)SyntaxKind[QuestionToken]
+ (414,11)SyntaxKind[SymbolSpan]
+ (414,11)SyntaxKind[Nonterminal]
+ (414,11)SyntaxKind[Identifier](text = "SpreadElement")
+ (414,24)SyntaxKind[ArgumentList]
+ (414,24)SyntaxKind[OpenBracketToken]
+ (414,25)SyntaxKind[Argument]?
+ (414,25)SyntaxKind[QuestionToken]
+ (414,26)SyntaxKind[Identifier](text = "Yield")
+ (414,31)SyntaxKind[CloseBracketToken]
+ (415,2)SyntaxKind[RightHandSide]
+ (415,2)SyntaxKind[SymbolSpan]
+ (415,2)SyntaxKind[Nonterminal]
+ (415,2)SyntaxKind[Identifier](text = "ElementList")
+ (415,13)SyntaxKind[ArgumentList]
+ (415,13)SyntaxKind[OpenBracketToken]
+ (415,14)SyntaxKind[Argument]?
+ (415,14)SyntaxKind[QuestionToken]
+ (415,15)SyntaxKind[Identifier](text = "Yield")
+ (415,20)SyntaxKind[CloseBracketToken]
+ (415,22)SyntaxKind[SymbolSpan]
+ (415,22)SyntaxKind[Terminal](text = ",")
+ (415,26)SyntaxKind[SymbolSpan]
+ (415,26)SyntaxKind[Nonterminal]?
+ (415,26)SyntaxKind[Identifier](text = "Elision")
+ (415,33)SyntaxKind[QuestionToken]
+ (415,35)SyntaxKind[SymbolSpan]
+ (415,35)SyntaxKind[Nonterminal]
+ (415,35)SyntaxKind[Identifier](text = "AssignmentExpression")
+ (415,55)SyntaxKind[ArgumentList]
+ (415,55)SyntaxKind[OpenBracketToken]
+ (415,56)SyntaxKind[Argument]
+ (415,56)SyntaxKind[Identifier](text = "In")
+ (415,60)SyntaxKind[Argument]?
+ (415,60)SyntaxKind[QuestionToken]
+ (415,61)SyntaxKind[Identifier](text = "Yield")
+ (415,66)SyntaxKind[CloseBracketToken]
+ (416,2)SyntaxKind[RightHandSide]
+ (416,2)SyntaxKind[SymbolSpan]
+ (416,2)SyntaxKind[Nonterminal]
+ (416,2)SyntaxKind[Identifier](text = "ElementList")
+ (416,13)SyntaxKind[ArgumentList]
+ (416,13)SyntaxKind[OpenBracketToken]
+ (416,14)SyntaxKind[Argument]?
+ (416,14)SyntaxKind[QuestionToken]
+ (416,15)SyntaxKind[Identifier](text = "Yield")
+ (416,20)SyntaxKind[CloseBracketToken]
+ (416,22)SyntaxKind[SymbolSpan]
+ (416,22)SyntaxKind[Terminal](text = ",")
+ (416,26)SyntaxKind[SymbolSpan]
+ (416,26)SyntaxKind[Nonterminal]?
+ (416,26)SyntaxKind[Identifier](text = "Elision")
+ (416,33)SyntaxKind[QuestionToken]
+ (416,35)SyntaxKind[SymbolSpan]
+ (416,35)SyntaxKind[Nonterminal]
+ (416,35)SyntaxKind[Identifier](text = "SpreadElement")
+ (416,48)SyntaxKind[ArgumentList]
+ (416,48)SyntaxKind[OpenBracketToken]
+ (416,49)SyntaxKind[Argument]?
+ (416,49)SyntaxKind[QuestionToken]
+ (416,50)SyntaxKind[Identifier](text = "Yield")
+ (416,55)SyntaxKind[CloseBracketToken]
+ (417,1)SyntaxKind[DedentToken]
+ (418,1)SyntaxKind[Production]
+ (418,1)SyntaxKind[Identifier](text = "Elision")
+ (419,1)SyntaxKind[RightHandSideList]
+ (419,1)SyntaxKind[IndentToken]
+ (419,2)SyntaxKind[RightHandSide]
+ (419,2)SyntaxKind[SymbolSpan]
+ (419,2)SyntaxKind[Terminal](text = ",")
+ (420,2)SyntaxKind[RightHandSide]
+ (420,2)SyntaxKind[SymbolSpan]
+ (420,2)SyntaxKind[Nonterminal]
+ (420,2)SyntaxKind[Identifier](text = "Elision")
+ (420,10)SyntaxKind[SymbolSpan]
+ (420,10)SyntaxKind[Terminal](text = ",")
+ (421,1)SyntaxKind[DedentToken]
+ (422,1)SyntaxKind[Production]
+ (422,1)SyntaxKind[Identifier](text = "SpreadElement")
+ (422,14)SyntaxKind[ParameterList]
+ (422,14)SyntaxKind[OpenBracketToken]
+ (422,15)SyntaxKind[Parameter]
+ (422,15)SyntaxKind[Identifier](text = "Yield")
+ (422,20)SyntaxKind[CloseBracketToken]
+ (423,1)SyntaxKind[RightHandSideList]
+ (423,1)SyntaxKind[IndentToken]
+ (423,2)SyntaxKind[RightHandSide]
+ (423,2)SyntaxKind[SymbolSpan]
+ (423,2)SyntaxKind[Terminal](text = "...")
+ (423,8)SyntaxKind[SymbolSpan]
+ (423,8)SyntaxKind[Nonterminal]
+ (423,8)SyntaxKind[Identifier](text = "AssignmentExpression")
+ (423,28)SyntaxKind[ArgumentList]
+ (423,28)SyntaxKind[OpenBracketToken]
+ (423,29)SyntaxKind[Argument]
+ (423,29)SyntaxKind[Identifier](text = "In")
+ (423,33)SyntaxKind[Argument]?
+ (423,33)SyntaxKind[QuestionToken]
+ (423,34)SyntaxKind[Identifier](text = "Yield")
+ (423,39)SyntaxKind[CloseBracketToken]
+ (424,1)SyntaxKind[DedentToken]
+ (425,1)SyntaxKind[Production]
+ (425,1)SyntaxKind[Identifier](text = "ObjectLiteral")
+ (425,14)SyntaxKind[ParameterList]
+ (425,14)SyntaxKind[OpenBracketToken]
+ (425,15)SyntaxKind[Parameter]
+ (425,15)SyntaxKind[Identifier](text = "Yield")
+ (425,20)SyntaxKind[CloseBracketToken]
+ (426,1)SyntaxKind[RightHandSideList]
+ (426,1)SyntaxKind[IndentToken]
+ (426,2)SyntaxKind[RightHandSide]
+ (426,2)SyntaxKind[SymbolSpan]
+ (426,2)SyntaxKind[Terminal](text = "{")
+ (426,6)SyntaxKind[SymbolSpan]
+ (426,6)SyntaxKind[Terminal](text = "}")
+ (427,2)SyntaxKind[RightHandSide]
+ (427,2)SyntaxKind[SymbolSpan]
+ (427,2)SyntaxKind[Terminal](text = "{")
+ (427,6)SyntaxKind[SymbolSpan]
+ (427,6)SyntaxKind[Nonterminal]
+ (427,6)SyntaxKind[Identifier](text = "PropertyDefinitionList")
+ (427,28)SyntaxKind[ArgumentList]
+ (427,28)SyntaxKind[OpenBracketToken]
+ (427,29)SyntaxKind[Argument]?
+ (427,29)SyntaxKind[QuestionToken]
+ (427,30)SyntaxKind[Identifier](text = "Yield")
+ (427,35)SyntaxKind[CloseBracketToken]
+ (427,37)SyntaxKind[SymbolSpan]
+ (427,37)SyntaxKind[Terminal](text = "}")
+ (428,2)SyntaxKind[RightHandSide]
+ (428,2)SyntaxKind[SymbolSpan]
+ (428,2)SyntaxKind[Terminal](text = "{")
+ (428,6)SyntaxKind[SymbolSpan]
+ (428,6)SyntaxKind[Nonterminal]
+ (428,6)SyntaxKind[Identifier](text = "PropertyDefinitionList")
+ (428,28)SyntaxKind[ArgumentList]
+ (428,28)SyntaxKind[OpenBracketToken]
+ (428,29)SyntaxKind[Argument]?
+ (428,29)SyntaxKind[QuestionToken]
+ (428,30)SyntaxKind[Identifier](text = "Yield")
+ (428,35)SyntaxKind[CloseBracketToken]
+ (428,37)SyntaxKind[SymbolSpan]
+ (428,37)SyntaxKind[Terminal](text = ",")
+ (428,41)SyntaxKind[SymbolSpan]
+ (428,41)SyntaxKind[Terminal](text = "}")
+ (429,1)SyntaxKind[DedentToken]
+ (430,1)SyntaxKind[Production]
+ (430,1)SyntaxKind[Identifier](text = "PropertyDefinitionList")
+ (430,23)SyntaxKind[ParameterList]
+ (430,23)SyntaxKind[OpenBracketToken]
+ (430,24)SyntaxKind[Parameter]
+ (430,24)SyntaxKind[Identifier](text = "Yield")
+ (430,29)SyntaxKind[CloseBracketToken]
+ (431,1)SyntaxKind[RightHandSideList]
+ (431,1)SyntaxKind[IndentToken]
+ (431,2)SyntaxKind[RightHandSide]
+ (431,2)SyntaxKind[SymbolSpan]
+ (431,2)SyntaxKind[Nonterminal]
+ (431,2)SyntaxKind[Identifier](text = "PropertyDefinition")
+ (431,20)SyntaxKind[ArgumentList]
+ (431,20)SyntaxKind[OpenBracketToken]
+ (431,21)SyntaxKind[Argument]?
+ (431,21)SyntaxKind[QuestionToken]
+ (431,22)SyntaxKind[Identifier](text = "Yield")
+ (431,27)SyntaxKind[CloseBracketToken]
+ (432,2)SyntaxKind[RightHandSide]
+ (432,2)SyntaxKind[SymbolSpan]
+ (432,2)SyntaxKind[Nonterminal]
+ (432,2)SyntaxKind[Identifier](text = "PropertyDefinitionList")
+ (432,24)SyntaxKind[ArgumentList]
+ (432,24)SyntaxKind[OpenBracketToken]
+ (432,25)SyntaxKind[Argument]?
+ (432,25)SyntaxKind[QuestionToken]
+ (432,26)SyntaxKind[Identifier](text = "Yield")
+ (432,31)SyntaxKind[CloseBracketToken]
+ (432,33)SyntaxKind[SymbolSpan]
+ (432,33)SyntaxKind[Terminal](text = ",")
+ (432,37)SyntaxKind[SymbolSpan]
+ (432,37)SyntaxKind[Nonterminal]
+ (432,37)SyntaxKind[Identifier](text = "PropertyDefinition")
+ (432,55)SyntaxKind[ArgumentList]
+ (432,55)SyntaxKind[OpenBracketToken]
+ (432,56)SyntaxKind[Argument]?
+ (432,56)SyntaxKind[QuestionToken]
+ (432,57)SyntaxKind[Identifier](text = "Yield")
+ (432,62)SyntaxKind[CloseBracketToken]
+ (433,1)SyntaxKind[DedentToken]
+ (434,1)SyntaxKind[Production]
+ (434,1)SyntaxKind[Identifier](text = "PropertyDefinition")
+ (434,19)SyntaxKind[ParameterList]
+ (434,19)SyntaxKind[OpenBracketToken]
+ (434,20)SyntaxKind[Parameter]
+ (434,20)SyntaxKind[Identifier](text = "Yield")
+ (434,25)SyntaxKind[CloseBracketToken]
+ (435,1)SyntaxKind[RightHandSideList]
+ (435,1)SyntaxKind[IndentToken]
+ (435,2)SyntaxKind[RightHandSide]
+ (435,2)SyntaxKind[SymbolSpan]
+ (435,2)SyntaxKind[Nonterminal]
+ (435,2)SyntaxKind[Identifier](text = "IdentifierReference")
+ (435,21)SyntaxKind[ArgumentList]
+ (435,21)SyntaxKind[OpenBracketToken]
+ (435,22)SyntaxKind[Argument]?
+ (435,22)SyntaxKind[QuestionToken]
+ (435,23)SyntaxKind[Identifier](text = "Yield")
+ (435,28)SyntaxKind[CloseBracketToken]
+ (436,2)SyntaxKind[RightHandSide]
+ (436,2)SyntaxKind[SymbolSpan]
+ (436,2)SyntaxKind[Nonterminal]
+ (436,2)SyntaxKind[Identifier](text = "CoverInitializedName")
+ (436,22)SyntaxKind[ArgumentList]
+ (436,22)SyntaxKind[OpenBracketToken]
+ (436,23)SyntaxKind[Argument]?
+ (436,23)SyntaxKind[QuestionToken]
+ (436,24)SyntaxKind[Identifier](text = "Yield")
+ (436,29)SyntaxKind[CloseBracketToken]
+ (437,2)SyntaxKind[RightHandSide]
+ (437,2)SyntaxKind[SymbolSpan]
+ (437,2)SyntaxKind[Nonterminal]
+ (437,2)SyntaxKind[Identifier](text = "PropertyName")
+ (437,14)SyntaxKind[ArgumentList]
+ (437,14)SyntaxKind[OpenBracketToken]
+ (437,15)SyntaxKind[Argument]?
+ (437,15)SyntaxKind[QuestionToken]
+ (437,16)SyntaxKind[Identifier](text = "Yield")
+ (437,21)SyntaxKind[CloseBracketToken]
+ (437,23)SyntaxKind[SymbolSpan]
+ (437,23)SyntaxKind[Terminal](text = ":")
+ (437,27)SyntaxKind[SymbolSpan]
+ (437,27)SyntaxKind[Nonterminal]
+ (437,27)SyntaxKind[Identifier](text = "AssignmentExpression")
+ (437,47)SyntaxKind[ArgumentList]
+ (437,47)SyntaxKind[OpenBracketToken]
+ (437,48)SyntaxKind[Argument]
+ (437,48)SyntaxKind[Identifier](text = "In")
+ (437,52)SyntaxKind[Argument]?
+ (437,52)SyntaxKind[QuestionToken]
+ (437,53)SyntaxKind[Identifier](text = "Yield")
+ (437,58)SyntaxKind[CloseBracketToken]
+ (438,2)SyntaxKind[RightHandSide]
+ (438,2)SyntaxKind[SymbolSpan]
+ (438,2)SyntaxKind[Nonterminal]
+ (438,2)SyntaxKind[Identifier](text = "MethodDefinition")
+ (438,18)SyntaxKind[ArgumentList]
+ (438,18)SyntaxKind[OpenBracketToken]
+ (438,19)SyntaxKind[Argument]?
+ (438,19)SyntaxKind[QuestionToken]
+ (438,20)SyntaxKind[Identifier](text = "Yield")
+ (438,25)SyntaxKind[CloseBracketToken]
+ (439,1)SyntaxKind[DedentToken]
+ (440,1)SyntaxKind[Production]
+ (440,1)SyntaxKind[Identifier](text = "PropertyName")
+ (440,13)SyntaxKind[ParameterList]
+ (440,13)SyntaxKind[OpenBracketToken]
+ (440,14)SyntaxKind[Parameter]
+ (440,14)SyntaxKind[Identifier](text = "Yield")
+ (440,19)SyntaxKind[CloseBracketToken]
+ (441,1)SyntaxKind[RightHandSideList]
+ (441,1)SyntaxKind[IndentToken]
+ (441,2)SyntaxKind[RightHandSide]
+ (441,2)SyntaxKind[SymbolSpan]
+ (441,2)SyntaxKind[Nonterminal]
+ (441,2)SyntaxKind[Identifier](text = "LiteralPropertyName")
+ (442,2)SyntaxKind[RightHandSide]
+ (442,2)SyntaxKind[SymbolSpan]
+ (442,2)SyntaxKind[Nonterminal]
+ (442,2)SyntaxKind[Identifier](text = "ComputedPropertyName")
+ (442,22)SyntaxKind[ArgumentList]
+ (442,22)SyntaxKind[OpenBracketToken]
+ (442,23)SyntaxKind[Argument]?
+ (442,23)SyntaxKind[QuestionToken]
+ (442,24)SyntaxKind[Identifier](text = "Yield")
+ (442,29)SyntaxKind[CloseBracketToken]
+ (443,1)SyntaxKind[DedentToken]
+ (444,1)SyntaxKind[Production]
+ (444,1)SyntaxKind[Identifier](text = "LiteralPropertyName")
+ (445,1)SyntaxKind[RightHandSideList]
+ (445,1)SyntaxKind[IndentToken]
+ (445,2)SyntaxKind[RightHandSide]
+ (445,2)SyntaxKind[SymbolSpan]
+ (445,2)SyntaxKind[Nonterminal]
+ (445,2)SyntaxKind[Identifier](text = "IdentifierName")
+ (446,2)SyntaxKind[RightHandSide]
+ (446,2)SyntaxKind[SymbolSpan]
+ (446,2)SyntaxKind[Nonterminal]
+ (446,2)SyntaxKind[Identifier](text = "StringLiteral")
+ (447,2)SyntaxKind[RightHandSide]
+ (447,2)SyntaxKind[SymbolSpan]
+ (447,2)SyntaxKind[Nonterminal]
+ (447,2)SyntaxKind[Identifier](text = "NumericLiteral")
+ (448,1)SyntaxKind[DedentToken]
+ (449,1)SyntaxKind[Production]
+ (449,1)SyntaxKind[Identifier](text = "ComputedPropertyName")
+ (449,21)SyntaxKind[ParameterList]
+ (449,21)SyntaxKind[OpenBracketToken]
+ (449,22)SyntaxKind[Parameter]
+ (449,22)SyntaxKind[Identifier](text = "Yield")
+ (449,27)SyntaxKind[CloseBracketToken]
+ (450,1)SyntaxKind[RightHandSideList]
+ (450,1)SyntaxKind[IndentToken]
+ (450,2)SyntaxKind[RightHandSide]
+ (450,2)SyntaxKind[SymbolSpan]
+ (450,2)SyntaxKind[Terminal](text = "[")
+ (450,6)SyntaxKind[SymbolSpan]
+ (450,6)SyntaxKind[Nonterminal]
+ (450,6)SyntaxKind[Identifier](text = "AssignmentExpression")
+ (450,26)SyntaxKind[ArgumentList]
+ (450,26)SyntaxKind[OpenBracketToken]
+ (450,27)SyntaxKind[Argument]
+ (450,27)SyntaxKind[Identifier](text = "In")
+ (450,31)SyntaxKind[Argument]?
+ (450,31)SyntaxKind[QuestionToken]
+ (450,32)SyntaxKind[Identifier](text = "Yield")
+ (450,37)SyntaxKind[CloseBracketToken]
+ (450,40)SyntaxKind[SymbolSpan]
+ (450,40)SyntaxKind[Terminal](text = "]")
+ (451,1)SyntaxKind[DedentToken]
+ (452,1)SyntaxKind[Production]
+ (452,1)SyntaxKind[Identifier](text = "CoverInitializedName")
+ (452,21)SyntaxKind[ParameterList]
+ (452,21)SyntaxKind[OpenBracketToken]
+ (452,22)SyntaxKind[Parameter]
+ (452,22)SyntaxKind[Identifier](text = "Yield")
+ (452,27)SyntaxKind[CloseBracketToken]
+ (453,1)SyntaxKind[RightHandSideList]
+ (453,1)SyntaxKind[IndentToken]
+ (453,2)SyntaxKind[RightHandSide]
+ (453,2)SyntaxKind[SymbolSpan]
+ (453,2)SyntaxKind[Nonterminal]
+ (453,2)SyntaxKind[Identifier](text = "IdentifierReference")
+ (453,21)SyntaxKind[ArgumentList]
+ (453,21)SyntaxKind[OpenBracketToken]
+ (453,22)SyntaxKind[Argument]?
+ (453,22)SyntaxKind[QuestionToken]
+ (453,23)SyntaxKind[Identifier](text = "Yield")
+ (453,28)SyntaxKind[CloseBracketToken]
+ (453,30)SyntaxKind[SymbolSpan]
+ (453,30)SyntaxKind[Nonterminal]
+ (453,30)SyntaxKind[Identifier](text = "Initializer")
+ (453,41)SyntaxKind[ArgumentList]
+ (453,41)SyntaxKind[OpenBracketToken]
+ (453,42)SyntaxKind[Argument]
+ (453,42)SyntaxKind[Identifier](text = "In")
+ (453,46)SyntaxKind[Argument]?
+ (453,46)SyntaxKind[QuestionToken]
+ (453,47)SyntaxKind[Identifier](text = "Yield")
+ (453,52)SyntaxKind[CloseBracketToken]
+ (454,1)SyntaxKind[DedentToken]
+ (455,1)SyntaxKind[Production]
+ (455,1)SyntaxKind[Identifier](text = "Initializer")
+ (455,12)SyntaxKind[ParameterList]
+ (455,12)SyntaxKind[OpenBracketToken]
+ (455,13)SyntaxKind[Parameter]
+ (455,13)SyntaxKind[Identifier](text = "In")
+ (455,17)SyntaxKind[Parameter]
+ (455,17)SyntaxKind[Identifier](text = "Yield")
+ (455,22)SyntaxKind[CloseBracketToken]
+ (456,1)SyntaxKind[RightHandSideList]
+ (456,1)SyntaxKind[IndentToken]
+ (456,2)SyntaxKind[RightHandSide]
+ (456,2)SyntaxKind[SymbolSpan]
+ (456,2)SyntaxKind[Terminal](text = "=")
+ (456,6)SyntaxKind[SymbolSpan]
+ (456,6)SyntaxKind[Nonterminal]
+ (456,6)SyntaxKind[Identifier](text = "AssignmentExpression")
+ (456,26)SyntaxKind[ArgumentList]
+ (456,26)SyntaxKind[OpenBracketToken]
+ (456,27)SyntaxKind[Argument]?
+ (456,27)SyntaxKind[QuestionToken]
+ (456,28)SyntaxKind[Identifier](text = "In")
+ (456,32)SyntaxKind[Argument]?
+ (456,32)SyntaxKind[QuestionToken]
+ (456,33)SyntaxKind[Identifier](text = "Yield")
+ (456,38)SyntaxKind[CloseBracketToken]
+ (457,1)SyntaxKind[DedentToken]
+ (458,1)SyntaxKind[Production]
+ (458,1)SyntaxKind[Identifier](text = "TemplateLiteral")
+ (458,16)SyntaxKind[ParameterList]
+ (458,16)SyntaxKind[OpenBracketToken]
+ (458,17)SyntaxKind[Parameter]
+ (458,17)SyntaxKind[Identifier](text = "Yield")
+ (458,22)SyntaxKind[CloseBracketToken]
+ (459,1)SyntaxKind[RightHandSideList]
+ (459,1)SyntaxKind[IndentToken]
+ (459,2)SyntaxKind[RightHandSide]
+ (459,2)SyntaxKind[SymbolSpan]
+ (459,2)SyntaxKind[Nonterminal]
+ (459,2)SyntaxKind[Identifier](text = "NoSubstitutionTemplate")
+ (460,2)SyntaxKind[RightHandSide]
+ (460,2)SyntaxKind[SymbolSpan]
+ (460,2)SyntaxKind[Nonterminal]
+ (460,2)SyntaxKind[Identifier](text = "TemplateHead")
+ (460,15)SyntaxKind[SymbolSpan]
+ (460,15)SyntaxKind[Nonterminal]
+ (460,15)SyntaxKind[Identifier](text = "Expression")
+ (460,25)SyntaxKind[ArgumentList]
+ (460,25)SyntaxKind[OpenBracketToken]
+ (460,26)SyntaxKind[Argument]
+ (460,26)SyntaxKind[Identifier](text = "In")
+ (460,30)SyntaxKind[Argument]?
+ (460,30)SyntaxKind[QuestionToken]
+ (460,31)SyntaxKind[Identifier](text = "Yield")
+ (460,36)SyntaxKind[CloseBracketToken]
+ (460,38)SyntaxKind[SymbolSpan]
+ (460,38)SyntaxKind[Nonterminal]
+ (460,38)SyntaxKind[Identifier](text = "TemplateSpans")
+ (460,51)SyntaxKind[ArgumentList]
+ (460,51)SyntaxKind[OpenBracketToken]
+ (460,52)SyntaxKind[Argument]?
+ (460,52)SyntaxKind[QuestionToken]
+ (460,53)SyntaxKind[Identifier](text = "Yield")
+ (460,58)SyntaxKind[CloseBracketToken]
+ (461,1)SyntaxKind[DedentToken]
+ (462,1)SyntaxKind[Production]
+ (462,1)SyntaxKind[Identifier](text = "TemplateSpans")
+ (462,14)SyntaxKind[ParameterList]
+ (462,14)SyntaxKind[OpenBracketToken]
+ (462,15)SyntaxKind[Parameter]
+ (462,15)SyntaxKind[Identifier](text = "Yield")
+ (462,20)SyntaxKind[CloseBracketToken]
+ (463,1)SyntaxKind[RightHandSideList]
+ (463,1)SyntaxKind[IndentToken]
+ (463,2)SyntaxKind[RightHandSide]
+ (463,2)SyntaxKind[SymbolSpan]
+ (463,2)SyntaxKind[Nonterminal]
+ (463,2)SyntaxKind[Identifier](text = "TemplateTail")
+ (464,2)SyntaxKind[RightHandSide]
+ (464,2)SyntaxKind[SymbolSpan]
+ (464,2)SyntaxKind[Nonterminal]
+ (464,2)SyntaxKind[Identifier](text = "TemplateMiddleList")
+ (464,20)SyntaxKind[ArgumentList]
+ (464,20)SyntaxKind[OpenBracketToken]
+ (464,21)SyntaxKind[Argument]?
+ (464,21)SyntaxKind[QuestionToken]
+ (464,22)SyntaxKind[Identifier](text = "Yield")
+ (464,27)SyntaxKind[CloseBracketToken]
+ (464,29)SyntaxKind[SymbolSpan]
+ (464,29)SyntaxKind[Nonterminal]
+ (464,29)SyntaxKind[Identifier](text = "TemplateTail")
+ (465,1)SyntaxKind[DedentToken]
+ (466,1)SyntaxKind[Production]
+ (466,1)SyntaxKind[Identifier](text = "TemplateMiddleList")
+ (466,19)SyntaxKind[ParameterList]
+ (466,19)SyntaxKind[OpenBracketToken]
+ (466,20)SyntaxKind[Parameter]
+ (466,20)SyntaxKind[Identifier](text = "Yield")
+ (466,25)SyntaxKind[CloseBracketToken]
+ (467,1)SyntaxKind[RightHandSideList]
+ (467,1)SyntaxKind[IndentToken]
+ (467,2)SyntaxKind[RightHandSide]
+ (467,2)SyntaxKind[SymbolSpan]
+ (467,2)SyntaxKind[Nonterminal]
+ (467,2)SyntaxKind[Identifier](text = "TemplateMiddle")
+ (467,18)SyntaxKind[SymbolSpan]
+ (467,18)SyntaxKind[Nonterminal]
+ (467,18)SyntaxKind[Identifier](text = "Expression")
+ (467,28)SyntaxKind[ArgumentList]
+ (467,28)SyntaxKind[OpenBracketToken]
+ (467,29)SyntaxKind[Argument]
+ (467,29)SyntaxKind[Identifier](text = "In")
+ (467,33)SyntaxKind[Argument]?
+ (467,33)SyntaxKind[QuestionToken]
+ (467,34)SyntaxKind[Identifier](text = "Yield")
+ (467,39)SyntaxKind[CloseBracketToken]
+ (468,2)SyntaxKind[RightHandSide]
+ (468,2)SyntaxKind[SymbolSpan]
+ (468,2)SyntaxKind[Nonterminal]
+ (468,2)SyntaxKind[Identifier](text = "TemplateMiddleList")
+ (468,20)SyntaxKind[ArgumentList]
+ (468,20)SyntaxKind[OpenBracketToken]
+ (468,21)SyntaxKind[Argument]?
+ (468,21)SyntaxKind[QuestionToken]
+ (468,22)SyntaxKind[Identifier](text = "Yield")
+ (468,27)SyntaxKind[CloseBracketToken]
+ (468,30)SyntaxKind[SymbolSpan]
+ (468,30)SyntaxKind[Nonterminal]
+ (468,30)SyntaxKind[Identifier](text = "TemplateMiddle")
+ (468,46)SyntaxKind[SymbolSpan]
+ (468,46)SyntaxKind[Nonterminal]
+ (468,46)SyntaxKind[Identifier](text = "Expression")
+ (468,56)SyntaxKind[ArgumentList]
+ (468,56)SyntaxKind[OpenBracketToken]
+ (468,57)SyntaxKind[Argument]
+ (468,57)SyntaxKind[Identifier](text = "In")
+ (468,61)SyntaxKind[Argument]?
+ (468,61)SyntaxKind[QuestionToken]
+ (468,62)SyntaxKind[Identifier](text = "Yield")
+ (468,67)SyntaxKind[CloseBracketToken]
+ (469,1)SyntaxKind[DedentToken]
+ (470,1)SyntaxKind[Production]
+ (470,1)SyntaxKind[Identifier](text = "MemberExpression")
+ (470,17)SyntaxKind[ParameterList]
+ (470,17)SyntaxKind[OpenBracketToken]
+ (470,18)SyntaxKind[Parameter]
+ (470,18)SyntaxKind[Identifier](text = "Yield")
+ (470,23)SyntaxKind[CloseBracketToken]
+ (471,1)SyntaxKind[RightHandSideList]
+ (471,1)SyntaxKind[IndentToken]
+ (471,2)SyntaxKind[RightHandSide]
+ (471,2)SyntaxKind[SymbolSpan]
+ (471,2)SyntaxKind[Nonterminal]
+ (471,2)SyntaxKind[Identifier](text = "PrimaryExpression")
+ (471,19)SyntaxKind[ArgumentList]
+ (471,19)SyntaxKind[OpenBracketToken]
+ (471,20)SyntaxKind[Argument]?
+ (471,20)SyntaxKind[QuestionToken]
+ (471,21)SyntaxKind[Identifier](text = "Yield")
+ (471,26)SyntaxKind[CloseBracketToken]
+ (472,2)SyntaxKind[RightHandSide]
+ (472,2)SyntaxKind[SymbolSpan]
+ (472,2)SyntaxKind[Nonterminal]
+ (472,2)SyntaxKind[Identifier](text = "MemberExpression")
+ (472,18)SyntaxKind[ArgumentList]
+ (472,18)SyntaxKind[OpenBracketToken]
+ (472,19)SyntaxKind[Argument]?
+ (472,19)SyntaxKind[QuestionToken]
+ (472,20)SyntaxKind[Identifier](text = "Yield")
+ (472,25)SyntaxKind[CloseBracketToken]
+ (472,27)SyntaxKind[SymbolSpan]
+ (472,27)SyntaxKind[Terminal](text = "[")
+ (472,31)SyntaxKind[SymbolSpan]
+ (472,31)SyntaxKind[Nonterminal]
+ (472,31)SyntaxKind[Identifier](text = "Expression")
+ (472,41)SyntaxKind[ArgumentList]
+ (472,41)SyntaxKind[OpenBracketToken]
+ (472,42)SyntaxKind[Argument]
+ (472,42)SyntaxKind[Identifier](text = "In")
+ (472,46)SyntaxKind[Argument]?
+ (472,46)SyntaxKind[QuestionToken]
+ (472,47)SyntaxKind[Identifier](text = "Yield")
+ (472,52)SyntaxKind[CloseBracketToken]
+ (472,54)SyntaxKind[SymbolSpan]
+ (472,54)SyntaxKind[Terminal](text = "]")
+ (473,2)SyntaxKind[RightHandSide]
+ (473,2)SyntaxKind[SymbolSpan]
+ (473,2)SyntaxKind[Nonterminal]
+ (473,2)SyntaxKind[Identifier](text = "MemberExpression")
+ (473,18)SyntaxKind[ArgumentList]
+ (473,18)SyntaxKind[OpenBracketToken]
+ (473,19)SyntaxKind[Argument]?
+ (473,19)SyntaxKind[QuestionToken]
+ (473,20)SyntaxKind[Identifier](text = "Yield")
+ (473,25)SyntaxKind[CloseBracketToken]
+ (473,27)SyntaxKind[SymbolSpan]
+ (473,27)SyntaxKind[Terminal](text = ".")
+ (473,31)SyntaxKind[SymbolSpan]
+ (473,31)SyntaxKind[Nonterminal]
+ (473,31)SyntaxKind[Identifier](text = "IdentifierName")
+ (474,2)SyntaxKind[RightHandSide]
+ (474,2)SyntaxKind[SymbolSpan]
+ (474,2)SyntaxKind[Nonterminal]
+ (474,2)SyntaxKind[Identifier](text = "MemberExpression")
+ (474,18)SyntaxKind[ArgumentList]
+ (474,18)SyntaxKind[OpenBracketToken]
+ (474,19)SyntaxKind[Argument]?
+ (474,19)SyntaxKind[QuestionToken]
+ (474,20)SyntaxKind[Identifier](text = "Yield")
+ (474,25)SyntaxKind[CloseBracketToken]
+ (474,27)SyntaxKind[SymbolSpan]
+ (474,27)SyntaxKind[Nonterminal]
+ (474,27)SyntaxKind[Identifier](text = "TemplateLiteral")
+ (474,42)SyntaxKind[ArgumentList]
+ (474,42)SyntaxKind[OpenBracketToken]
+ (474,43)SyntaxKind[Argument]?
+ (474,43)SyntaxKind[QuestionToken]
+ (474,44)SyntaxKind[Identifier](text = "Yield")
+ (474,49)SyntaxKind[CloseBracketToken]
+ (475,2)SyntaxKind[RightHandSide]
+ (475,2)SyntaxKind[SymbolSpan]
+ (475,2)SyntaxKind[Nonterminal]
+ (475,2)SyntaxKind[Identifier](text = "SuperProperty")
+ (475,15)SyntaxKind[ArgumentList]
+ (475,15)SyntaxKind[OpenBracketToken]
+ (475,16)SyntaxKind[Argument]?
+ (475,16)SyntaxKind[QuestionToken]
+ (475,17)SyntaxKind[Identifier](text = "Yield")
+ (475,22)SyntaxKind[CloseBracketToken]
+ (476,2)SyntaxKind[RightHandSide]
+ (476,2)SyntaxKind[SymbolSpan]
+ (476,2)SyntaxKind[Nonterminal]
+ (476,2)SyntaxKind[Identifier](text = "MetaProperty")
+ (477,2)SyntaxKind[RightHandSide]
+ (477,2)SyntaxKind[SymbolSpan]
+ (477,2)SyntaxKind[Terminal](text = "new")
+ (477,8)SyntaxKind[SymbolSpan]
+ (477,8)SyntaxKind[Nonterminal]
+ (477,8)SyntaxKind[Identifier](text = "MemberExpression")
+ (477,24)SyntaxKind[ArgumentList]
+ (477,24)SyntaxKind[OpenBracketToken]
+ (477,25)SyntaxKind[Argument]?
+ (477,25)SyntaxKind[QuestionToken]
+ (477,26)SyntaxKind[Identifier](text = "Yield")
+ (477,31)SyntaxKind[CloseBracketToken]
+ (477,33)SyntaxKind[SymbolSpan]
+ (477,33)SyntaxKind[Nonterminal]
+ (477,33)SyntaxKind[Identifier](text = "Arguments")
+ (477,42)SyntaxKind[ArgumentList]
+ (477,42)SyntaxKind[OpenBracketToken]
+ (477,43)SyntaxKind[Argument]?
+ (477,43)SyntaxKind[QuestionToken]
+ (477,44)SyntaxKind[Identifier](text = "Yield")
+ (477,49)SyntaxKind[CloseBracketToken]
+ (478,1)SyntaxKind[DedentToken]
+ (479,1)SyntaxKind[Production]
+ (479,1)SyntaxKind[Identifier](text = "SuperProperty")
+ (479,14)SyntaxKind[ParameterList]
+ (479,14)SyntaxKind[OpenBracketToken]
+ (479,15)SyntaxKind[Parameter]
+ (479,15)SyntaxKind[Identifier](text = "Yield")
+ (479,20)SyntaxKind[CloseBracketToken]
+ (480,1)SyntaxKind[RightHandSideList]
+ (480,1)SyntaxKind[IndentToken]
+ (480,2)SyntaxKind[RightHandSide]
+ (480,2)SyntaxKind[SymbolSpan]
+ (480,2)SyntaxKind[Terminal](text = "super")
+ (480,10)SyntaxKind[SymbolSpan]
+ (480,10)SyntaxKind[Terminal](text = "[")
+ (480,14)SyntaxKind[SymbolSpan]
+ (480,14)SyntaxKind[Nonterminal]
+ (480,14)SyntaxKind[Identifier](text = "Expression")
+ (480,24)SyntaxKind[ArgumentList]
+ (480,24)SyntaxKind[OpenBracketToken]
+ (480,25)SyntaxKind[Argument]
+ (480,25)SyntaxKind[Identifier](text = "In")
+ (480,29)SyntaxKind[Argument]?
+ (480,29)SyntaxKind[QuestionToken]
+ (480,30)SyntaxKind[Identifier](text = "Yield")
+ (480,35)SyntaxKind[CloseBracketToken]
+ (480,37)SyntaxKind[SymbolSpan]
+ (480,37)SyntaxKind[Terminal](text = "]")
+ (481,2)SyntaxKind[RightHandSide]
+ (481,2)SyntaxKind[SymbolSpan]
+ (481,2)SyntaxKind[Terminal](text = "super")
+ (481,10)SyntaxKind[SymbolSpan]
+ (481,10)SyntaxKind[Terminal](text = ".")
+ (481,14)SyntaxKind[SymbolSpan]
+ (481,14)SyntaxKind[Nonterminal]
+ (481,14)SyntaxKind[Identifier](text = "IdentifierName")
+ (482,1)SyntaxKind[DedentToken]
+ (483,1)SyntaxKind[Production]
+ (483,1)SyntaxKind[Identifier](text = "MetaProperty")
+ (484,1)SyntaxKind[RightHandSideList]
+ (484,1)SyntaxKind[IndentToken]
+ (484,2)SyntaxKind[RightHandSide]
+ (484,2)SyntaxKind[SymbolSpan]
+ (484,2)SyntaxKind[Nonterminal]
+ (484,2)SyntaxKind[Identifier](text = "NewTarget")
+ (485,1)SyntaxKind[DedentToken]
+ (486,1)SyntaxKind[Production]
+ (486,1)SyntaxKind[Identifier](text = "NewTarget")
+ (487,1)SyntaxKind[RightHandSideList]
+ (487,1)SyntaxKind[IndentToken]
+ (487,2)SyntaxKind[RightHandSide]
+ (487,2)SyntaxKind[SymbolSpan]
+ (487,2)SyntaxKind[Terminal](text = "new")
+ (487,8)SyntaxKind[SymbolSpan]
+ (487,8)SyntaxKind[Terminal](text = ".")
+ (487,12)SyntaxKind[SymbolSpan]
+ (487,12)SyntaxKind[Terminal](text = "target")
+ (488,1)SyntaxKind[DedentToken]
+ (489,1)SyntaxKind[Production]
+ (489,1)SyntaxKind[Identifier](text = "NewExpression")
+ (489,14)SyntaxKind[ParameterList]
+ (489,14)SyntaxKind[OpenBracketToken]
+ (489,15)SyntaxKind[Parameter]
+ (489,15)SyntaxKind[Identifier](text = "Yield")
+ (489,20)SyntaxKind[CloseBracketToken]
+ (490,1)SyntaxKind[RightHandSideList]
+ (490,1)SyntaxKind[IndentToken]
+ (490,2)SyntaxKind[RightHandSide]
+ (490,2)SyntaxKind[SymbolSpan]
+ (490,2)SyntaxKind[Nonterminal]
+ (490,2)SyntaxKind[Identifier](text = "MemberExpression")
+ (490,18)SyntaxKind[ArgumentList]
+ (490,18)SyntaxKind[OpenBracketToken]
+ (490,19)SyntaxKind[Argument]?
+ (490,19)SyntaxKind[QuestionToken]
+ (490,20)SyntaxKind[Identifier](text = "Yield")
+ (490,25)SyntaxKind[CloseBracketToken]
+ (491,2)SyntaxKind[RightHandSide]
+ (491,2)SyntaxKind[SymbolSpan]
+ (491,2)SyntaxKind[Terminal](text = "new")
+ (491,8)SyntaxKind[SymbolSpan]
+ (491,8)SyntaxKind[Nonterminal]
+ (491,8)SyntaxKind[Identifier](text = "NewExpression")
+ (491,21)SyntaxKind[ArgumentList]
+ (491,21)SyntaxKind[OpenBracketToken]
+ (491,22)SyntaxKind[Argument]?
+ (491,22)SyntaxKind[QuestionToken]
+ (491,23)SyntaxKind[Identifier](text = "Yield")
+ (491,28)SyntaxKind[CloseBracketToken]
+ (492,1)SyntaxKind[DedentToken]
+ (493,1)SyntaxKind[Production]
+ (493,1)SyntaxKind[Identifier](text = "CallExpression")
+ (493,15)SyntaxKind[ParameterList]
+ (493,15)SyntaxKind[OpenBracketToken]
+ (493,16)SyntaxKind[Parameter]
+ (493,16)SyntaxKind[Identifier](text = "Yield")
+ (493,21)SyntaxKind[CloseBracketToken]
+ (494,1)SyntaxKind[RightHandSideList]
+ (494,1)SyntaxKind[IndentToken]
+ (494,2)SyntaxKind[RightHandSide]
+ (494,2)SyntaxKind[SymbolSpan]
+ (494,2)SyntaxKind[Nonterminal]
+ (494,2)SyntaxKind[Identifier](text = "MemberExpression")
+ (494,18)SyntaxKind[ArgumentList]
+ (494,18)SyntaxKind[OpenBracketToken]
+ (494,19)SyntaxKind[Argument]?
+ (494,19)SyntaxKind[QuestionToken]
+ (494,20)SyntaxKind[Identifier](text = "Yield")
+ (494,25)SyntaxKind[CloseBracketToken]
+ (494,27)SyntaxKind[SymbolSpan]
+ (494,27)SyntaxKind[Nonterminal]
+ (494,27)SyntaxKind[Identifier](text = "Arguments")
+ (494,36)SyntaxKind[ArgumentList]
+ (494,36)SyntaxKind[OpenBracketToken]
+ (494,37)SyntaxKind[Argument]?
+ (494,37)SyntaxKind[QuestionToken]
+ (494,38)SyntaxKind[Identifier](text = "Yield")
+ (494,43)SyntaxKind[CloseBracketToken]
+ (495,2)SyntaxKind[RightHandSide]
+ (495,2)SyntaxKind[SymbolSpan]
+ (495,2)SyntaxKind[Nonterminal]
+ (495,2)SyntaxKind[Identifier](text = "SuperCall")
+ (495,11)SyntaxKind[ArgumentList]
+ (495,11)SyntaxKind[OpenBracketToken]
+ (495,12)SyntaxKind[Argument]?
+ (495,12)SyntaxKind[QuestionToken]
+ (495,13)SyntaxKind[Identifier](text = "Yield")
+ (495,18)SyntaxKind[CloseBracketToken]
+ (496,2)SyntaxKind[RightHandSide]
+ (496,2)SyntaxKind[SymbolSpan]
+ (496,2)SyntaxKind[Nonterminal]
+ (496,2)SyntaxKind[Identifier](text = "CallExpression")
+ (496,16)SyntaxKind[ArgumentList]
+ (496,16)SyntaxKind[OpenBracketToken]
+ (496,17)SyntaxKind[Argument]?
+ (496,17)SyntaxKind[QuestionToken]
+ (496,18)SyntaxKind[Identifier](text = "Yield")
+ (496,23)SyntaxKind[CloseBracketToken]
+ (496,25)SyntaxKind[SymbolSpan]
+ (496,25)SyntaxKind[Nonterminal]
+ (496,25)SyntaxKind[Identifier](text = "Arguments")
+ (496,34)SyntaxKind[ArgumentList]
+ (496,34)SyntaxKind[OpenBracketToken]
+ (496,35)SyntaxKind[Argument]?
+ (496,35)SyntaxKind[QuestionToken]
+ (496,36)SyntaxKind[Identifier](text = "Yield")
+ (496,41)SyntaxKind[CloseBracketToken]
+ (497,2)SyntaxKind[RightHandSide]
+ (497,2)SyntaxKind[SymbolSpan]
+ (497,2)SyntaxKind[Nonterminal]
+ (497,2)SyntaxKind[Identifier](text = "CallExpression")
+ (497,16)SyntaxKind[ArgumentList]
+ (497,16)SyntaxKind[OpenBracketToken]
+ (497,17)SyntaxKind[Argument]?
+ (497,17)SyntaxKind[QuestionToken]
+ (497,18)SyntaxKind[Identifier](text = "Yield")
+ (497,23)SyntaxKind[CloseBracketToken]
+ (497,25)SyntaxKind[SymbolSpan]
+ (497,25)SyntaxKind[Terminal](text = "[")
+ (497,29)SyntaxKind[SymbolSpan]
+ (497,29)SyntaxKind[Nonterminal]
+ (497,29)SyntaxKind[Identifier](text = "Expression")
+ (497,39)SyntaxKind[ArgumentList]
+ (497,39)SyntaxKind[OpenBracketToken]
+ (497,40)SyntaxKind[Argument]
+ (497,40)SyntaxKind[Identifier](text = "In")
+ (497,44)SyntaxKind[Argument]?
+ (497,44)SyntaxKind[QuestionToken]
+ (497,45)SyntaxKind[Identifier](text = "Yield")
+ (497,50)SyntaxKind[CloseBracketToken]
+ (497,52)SyntaxKind[SymbolSpan]
+ (497,52)SyntaxKind[Terminal](text = "]")
+ (498,2)SyntaxKind[RightHandSide]
+ (498,2)SyntaxKind[SymbolSpan]
+ (498,2)SyntaxKind[Nonterminal]
+ (498,2)SyntaxKind[Identifier](text = "CallExpression")
+ (498,16)SyntaxKind[ArgumentList]
+ (498,16)SyntaxKind[OpenBracketToken]
+ (498,17)SyntaxKind[Argument]?
+ (498,17)SyntaxKind[QuestionToken]
+ (498,18)SyntaxKind[Identifier](text = "Yield")
+ (498,23)SyntaxKind[CloseBracketToken]
+ (498,25)SyntaxKind[SymbolSpan]
+ (498,25)SyntaxKind[Terminal](text = ".")
+ (498,29)SyntaxKind[SymbolSpan]
+ (498,29)SyntaxKind[Nonterminal]
+ (498,29)SyntaxKind[Identifier](text = "IdentifierName")
+ (499,2)SyntaxKind[RightHandSide]
+ (499,2)SyntaxKind[SymbolSpan]
+ (499,2)SyntaxKind[Nonterminal]
+ (499,2)SyntaxKind[Identifier](text = "CallExpression")
+ (499,16)SyntaxKind[ArgumentList]
+ (499,16)SyntaxKind[OpenBracketToken]
+ (499,17)SyntaxKind[Argument]?
+ (499,17)SyntaxKind[QuestionToken]
+ (499,18)SyntaxKind[Identifier](text = "Yield")
+ (499,23)SyntaxKind[CloseBracketToken]
+ (499,25)SyntaxKind[SymbolSpan]
+ (499,25)SyntaxKind[Nonterminal]
+ (499,25)SyntaxKind[Identifier](text = "TemplateLiteral")
+ (499,40)SyntaxKind[ArgumentList]
+ (499,40)SyntaxKind[OpenBracketToken]
+ (499,41)SyntaxKind[Argument]?
+ (499,41)SyntaxKind[QuestionToken]
+ (499,42)SyntaxKind[Identifier](text = "Yield")
+ (499,47)SyntaxKind[CloseBracketToken]
+ (500,1)SyntaxKind[DedentToken]
+ (501,1)SyntaxKind[Production]
+ (501,1)SyntaxKind[Identifier](text = "SuperCall")
+ (501,10)SyntaxKind[ParameterList]
+ (501,10)SyntaxKind[OpenBracketToken]
+ (501,11)SyntaxKind[Parameter]
+ (501,11)SyntaxKind[Identifier](text = "Yield")
+ (501,16)SyntaxKind[CloseBracketToken]
+ (502,1)SyntaxKind[RightHandSideList]
+ (502,1)SyntaxKind[IndentToken]
+ (502,2)SyntaxKind[RightHandSide]
+ (502,2)SyntaxKind[SymbolSpan]
+ (502,2)SyntaxKind[Terminal](text = "super")
+ (502,10)SyntaxKind[SymbolSpan]
+ (502,10)SyntaxKind[Nonterminal]
+ (502,10)SyntaxKind[Identifier](text = "Arguments")
+ (502,19)SyntaxKind[ArgumentList]
+ (502,19)SyntaxKind[OpenBracketToken]
+ (502,20)SyntaxKind[Argument]?
+ (502,20)SyntaxKind[QuestionToken]
+ (502,21)SyntaxKind[Identifier](text = "Yield")
+ (502,26)SyntaxKind[CloseBracketToken]
+ (503,1)SyntaxKind[DedentToken]
+ (504,1)SyntaxKind[Production]
+ (504,1)SyntaxKind[Identifier](text = "Arguments")
+ (504,10)SyntaxKind[ParameterList]
+ (504,10)SyntaxKind[OpenBracketToken]
+ (504,11)SyntaxKind[Parameter]
+ (504,11)SyntaxKind[Identifier](text = "Yield")
+ (504,16)SyntaxKind[CloseBracketToken]
+ (505,1)SyntaxKind[RightHandSideList]
+ (505,1)SyntaxKind[IndentToken]
+ (505,2)SyntaxKind[RightHandSide]
+ (505,2)SyntaxKind[SymbolSpan]
+ (505,2)SyntaxKind[Terminal](text = "(")
+ (505,6)SyntaxKind[SymbolSpan]
+ (505,6)SyntaxKind[Terminal](text = ")")
+ (506,2)SyntaxKind[RightHandSide]
+ (506,2)SyntaxKind[SymbolSpan]
+ (506,2)SyntaxKind[Terminal](text = "(")
+ (506,6)SyntaxKind[SymbolSpan]
+ (506,6)SyntaxKind[Nonterminal]
+ (506,6)SyntaxKind[Identifier](text = "ArgumentList")
+ (506,18)SyntaxKind[ArgumentList]
+ (506,18)SyntaxKind[OpenBracketToken]
+ (506,19)SyntaxKind[Argument]?
+ (506,19)SyntaxKind[QuestionToken]
+ (506,20)SyntaxKind[Identifier](text = "Yield")
+ (506,25)SyntaxKind[CloseBracketToken]
+ (506,28)SyntaxKind[SymbolSpan]
+ (506,28)SyntaxKind[Terminal](text = ")")
+ (507,1)SyntaxKind[DedentToken]
+ (508,1)SyntaxKind[Production]
+ (508,1)SyntaxKind[Identifier](text = "ArgumentList")
+ (508,13)SyntaxKind[ParameterList]
+ (508,13)SyntaxKind[OpenBracketToken]
+ (508,14)SyntaxKind[Parameter]
+ (508,14)SyntaxKind[Identifier](text = "Yield")
+ (508,19)SyntaxKind[CloseBracketToken]
+ (509,1)SyntaxKind[RightHandSideList]
+ (509,1)SyntaxKind[IndentToken]
+ (509,2)SyntaxKind[RightHandSide]
+ (509,2)SyntaxKind[SymbolSpan]
+ (509,2)SyntaxKind[Nonterminal]
+ (509,2)SyntaxKind[Identifier](text = "AssignmentExpression")
+ (509,22)SyntaxKind[ArgumentList]
+ (509,22)SyntaxKind[OpenBracketToken]
+ (509,23)SyntaxKind[Argument]
+ (509,23)SyntaxKind[Identifier](text = "In")
+ (509,27)SyntaxKind[Argument]?
+ (509,27)SyntaxKind[QuestionToken]
+ (509,28)SyntaxKind[Identifier](text = "Yield")
+ (509,33)SyntaxKind[CloseBracketToken]
+ (510,2)SyntaxKind[RightHandSide]
+ (510,2)SyntaxKind[SymbolSpan]
+ (510,2)SyntaxKind[Terminal](text = "...")
+ (510,8)SyntaxKind[SymbolSpan]
+ (510,8)SyntaxKind[Nonterminal]
+ (510,8)SyntaxKind[Identifier](text = "AssignmentExpression")
+ (510,28)SyntaxKind[ArgumentList]
+ (510,28)SyntaxKind[OpenBracketToken]
+ (510,29)SyntaxKind[Argument]
+ (510,29)SyntaxKind[Identifier](text = "In")
+ (510,33)SyntaxKind[Argument]?
+ (510,33)SyntaxKind[QuestionToken]
+ (510,34)SyntaxKind[Identifier](text = "Yield")
+ (510,39)SyntaxKind[CloseBracketToken]
+ (511,2)SyntaxKind[RightHandSide]
+ (511,2)SyntaxKind[SymbolSpan]
+ (511,2)SyntaxKind[Nonterminal]
+ (511,2)SyntaxKind[Identifier](text = "ArgumentList")
+ (511,14)SyntaxKind[ArgumentList]
+ (511,14)SyntaxKind[OpenBracketToken]
+ (511,15)SyntaxKind[Argument]?
+ (511,15)SyntaxKind[QuestionToken]
+ (511,16)SyntaxKind[Identifier](text = "Yield")
+ (511,21)SyntaxKind[CloseBracketToken]
+ (511,23)SyntaxKind[SymbolSpan]
+ (511,23)SyntaxKind[Terminal](text = ",")
+ (511,27)SyntaxKind[SymbolSpan]
+ (511,27)SyntaxKind[Nonterminal]
+ (511,27)SyntaxKind[Identifier](text = "AssignmentExpression")
+ (511,47)SyntaxKind[ArgumentList]
+ (511,47)SyntaxKind[OpenBracketToken]
+ (511,48)SyntaxKind[Argument]
+ (511,48)SyntaxKind[Identifier](text = "In")
+ (511,52)SyntaxKind[Argument]?
+ (511,52)SyntaxKind[QuestionToken]
+ (511,53)SyntaxKind[Identifier](text = "Yield")
+ (511,58)SyntaxKind[CloseBracketToken]
+ (512,2)SyntaxKind[RightHandSide]
+ (512,2)SyntaxKind[SymbolSpan]
+ (512,2)SyntaxKind[Nonterminal]
+ (512,2)SyntaxKind[Identifier](text = "ArgumentList")
+ (512,14)SyntaxKind[ArgumentList]
+ (512,14)SyntaxKind[OpenBracketToken]
+ (512,15)SyntaxKind[Argument]?
+ (512,15)SyntaxKind[QuestionToken]
+ (512,16)SyntaxKind[Identifier](text = "Yield")
+ (512,21)SyntaxKind[CloseBracketToken]
+ (512,23)SyntaxKind[SymbolSpan]
+ (512,23)SyntaxKind[Terminal](text = ",")
+ (512,27)SyntaxKind[SymbolSpan]
+ (512,27)SyntaxKind[Terminal](text = "...")
+ (512,33)SyntaxKind[SymbolSpan]
+ (512,33)SyntaxKind[Nonterminal]
+ (512,33)SyntaxKind[Identifier](text = "AssignmentExpression")
+ (512,53)SyntaxKind[ArgumentList]
+ (512,53)SyntaxKind[OpenBracketToken]
+ (512,54)SyntaxKind[Argument]
+ (512,54)SyntaxKind[Identifier](text = "In")
+ (512,58)SyntaxKind[Argument]?
+ (512,58)SyntaxKind[QuestionToken]
+ (512,59)SyntaxKind[Identifier](text = "Yield")
+ (512,64)SyntaxKind[CloseBracketToken]
+ (513,1)SyntaxKind[DedentToken]
+ (514,1)SyntaxKind[Production]
+ (514,1)SyntaxKind[Identifier](text = "LeftHandSideExpression")
+ (514,23)SyntaxKind[ParameterList]
+ (514,23)SyntaxKind[OpenBracketToken]
+ (514,24)SyntaxKind[Parameter]
+ (514,24)SyntaxKind[Identifier](text = "Yield")
+ (514,29)SyntaxKind[CloseBracketToken]
+ (515,1)SyntaxKind[RightHandSideList]
+ (515,1)SyntaxKind[IndentToken]
+ (515,2)SyntaxKind[RightHandSide]
+ (515,2)SyntaxKind[SymbolSpan]
+ (515,2)SyntaxKind[Nonterminal]
+ (515,2)SyntaxKind[Identifier](text = "NewExpression")
+ (515,15)SyntaxKind[ArgumentList]
+ (515,15)SyntaxKind[OpenBracketToken]
+ (515,16)SyntaxKind[Argument]?
+ (515,16)SyntaxKind[QuestionToken]
+ (515,17)SyntaxKind[Identifier](text = "Yield")
+ (515,22)SyntaxKind[CloseBracketToken]
+ (516,2)SyntaxKind[RightHandSide]
+ (516,2)SyntaxKind[SymbolSpan]
+ (516,2)SyntaxKind[Nonterminal]
+ (516,2)SyntaxKind[Identifier](text = "CallExpression")
+ (516,16)SyntaxKind[ArgumentList]
+ (516,16)SyntaxKind[OpenBracketToken]
+ (516,17)SyntaxKind[Argument]?
+ (516,17)SyntaxKind[QuestionToken]
+ (516,18)SyntaxKind[Identifier](text = "Yield")
+ (516,23)SyntaxKind[CloseBracketToken]
+ (517,1)SyntaxKind[DedentToken]
+ (518,1)SyntaxKind[Production]
+ (518,1)SyntaxKind[Identifier](text = "PostfixExpression")
+ (518,18)SyntaxKind[ParameterList]
+ (518,18)SyntaxKind[OpenBracketToken]
+ (518,19)SyntaxKind[Parameter]
+ (518,19)SyntaxKind[Identifier](text = "Yield")
+ (518,24)SyntaxKind[CloseBracketToken]
+ (519,1)SyntaxKind[RightHandSideList]
+ (519,1)SyntaxKind[IndentToken]
+ (519,2)SyntaxKind[RightHandSide]
+ (519,2)SyntaxKind[SymbolSpan]
+ (519,2)SyntaxKind[Nonterminal]
+ (519,2)SyntaxKind[Identifier](text = "LeftHandSideExpression")
+ (519,24)SyntaxKind[ArgumentList]
+ (519,24)SyntaxKind[OpenBracketToken]
+ (519,25)SyntaxKind[Argument]?
+ (519,25)SyntaxKind[QuestionToken]
+ (519,26)SyntaxKind[Identifier](text = "Yield")
+ (519,31)SyntaxKind[CloseBracketToken]
+ (520,2)SyntaxKind[RightHandSide]
+ (520,2)SyntaxKind[SymbolSpan]
+ (520,2)SyntaxKind[Nonterminal]
+ (520,2)SyntaxKind[Identifier](text = "LeftHandSideExpression")
+ (520,24)SyntaxKind[ArgumentList]
+ (520,24)SyntaxKind[OpenBracketToken]
+ (520,25)SyntaxKind[Argument]?
+ (520,25)SyntaxKind[QuestionToken]
+ (520,26)SyntaxKind[Identifier](text = "Yield")
+ (520,31)SyntaxKind[CloseBracketToken]
+ (520,33)SyntaxKind[SymbolSpan]
+ (520,33)SyntaxKind[NoSymbolHereAssertion]
+ (520,33)SyntaxKind[OpenBracketToken]
+ (520,34)SyntaxKind[NoKeyword]
+ (520,37)SyntaxKind[Nonterminal]
+ (520,37)SyntaxKind[Identifier](text = "LineTerminator")
+ (520,52)SyntaxKind[HereKeyword]
+ (520,56)SyntaxKind[CloseBracketToken]
+ (520,58)SyntaxKind[SymbolSpan]
+ (520,58)SyntaxKind[Terminal](text = "++")
+ (521,2)SyntaxKind[RightHandSide]
+ (521,2)SyntaxKind[SymbolSpan]
+ (521,2)SyntaxKind[Nonterminal]
+ (521,2)SyntaxKind[Identifier](text = "LeftHandSideExpression")
+ (521,24)SyntaxKind[ArgumentList]
+ (521,24)SyntaxKind[OpenBracketToken]
+ (521,25)SyntaxKind[Argument]?
+ (521,25)SyntaxKind[QuestionToken]
+ (521,26)SyntaxKind[Identifier](text = "Yield")
+ (521,31)SyntaxKind[CloseBracketToken]
+ (521,33)SyntaxKind[SymbolSpan]
+ (521,33)SyntaxKind[NoSymbolHereAssertion]
+ (521,33)SyntaxKind[OpenBracketToken]
+ (521,34)SyntaxKind[NoKeyword]
+ (521,37)SyntaxKind[Nonterminal]
+ (521,37)SyntaxKind[Identifier](text = "LineTerminator")
+ (521,52)SyntaxKind[HereKeyword]
+ (521,56)SyntaxKind[CloseBracketToken]
+ (521,58)SyntaxKind[SymbolSpan]
+ (521,58)SyntaxKind[Terminal](text = "--")
+ (522,1)SyntaxKind[DedentToken]
+ (523,1)SyntaxKind[Production]
+ (523,1)SyntaxKind[Identifier](text = "UnaryExpression")
+ (523,16)SyntaxKind[ParameterList]
+ (523,16)SyntaxKind[OpenBracketToken]
+ (523,17)SyntaxKind[Parameter]
+ (523,17)SyntaxKind[Identifier](text = "Yield")
+ (523,22)SyntaxKind[CloseBracketToken]
+ (524,1)SyntaxKind[RightHandSideList]
+ (524,1)SyntaxKind[IndentToken]
+ (524,2)SyntaxKind[RightHandSide]
+ (524,2)SyntaxKind[SymbolSpan]
+ (524,2)SyntaxKind[Nonterminal]
+ (524,2)SyntaxKind[Identifier](text = "PostfixExpression")
+ (524,19)SyntaxKind[ArgumentList]
+ (524,19)SyntaxKind[OpenBracketToken]
+ (524,20)SyntaxKind[Argument]?
+ (524,20)SyntaxKind[QuestionToken]
+ (524,21)SyntaxKind[Identifier](text = "Yield")
+ (524,26)SyntaxKind[CloseBracketToken]
+ (525,2)SyntaxKind[RightHandSide]
+ (525,2)SyntaxKind[SymbolSpan]
+ (525,2)SyntaxKind[Terminal](text = "delete")
+ (525,11)SyntaxKind[SymbolSpan]
+ (525,11)SyntaxKind[Nonterminal]
+ (525,11)SyntaxKind[Identifier](text = "UnaryExpression")
+ (525,26)SyntaxKind[ArgumentList]
+ (525,26)SyntaxKind[OpenBracketToken]
+ (525,27)SyntaxKind[Argument]?
+ (525,27)SyntaxKind[QuestionToken]
+ (525,28)SyntaxKind[Identifier](text = "Yield")
+ (525,33)SyntaxKind[CloseBracketToken]
+ (526,2)SyntaxKind[RightHandSide]
+ (526,2)SyntaxKind[SymbolSpan]
+ (526,2)SyntaxKind[Terminal](text = "void")
+ (526,9)SyntaxKind[SymbolSpan]
+ (526,9)SyntaxKind[Nonterminal]
+ (526,9)SyntaxKind[Identifier](text = "UnaryExpression")
+ (526,24)SyntaxKind[ArgumentList]
+ (526,24)SyntaxKind[OpenBracketToken]
+ (526,25)SyntaxKind[Argument]?
+ (526,25)SyntaxKind[QuestionToken]
+ (526,26)SyntaxKind[Identifier](text = "Yield")
+ (526,31)SyntaxKind[CloseBracketToken]
+ (527,2)SyntaxKind[RightHandSide]
+ (527,2)SyntaxKind[SymbolSpan]
+ (527,2)SyntaxKind[Terminal](text = "typeof")
+ (527,11)SyntaxKind[SymbolSpan]
+ (527,11)SyntaxKind[Nonterminal]
+ (527,11)SyntaxKind[Identifier](text = "UnaryExpression")
+ (527,26)SyntaxKind[ArgumentList]
+ (527,26)SyntaxKind[OpenBracketToken]
+ (527,27)SyntaxKind[Argument]?
+ (527,27)SyntaxKind[QuestionToken]
+ (527,28)SyntaxKind[Identifier](text = "Yield")
+ (527,33)SyntaxKind[CloseBracketToken]
+ (528,2)SyntaxKind[RightHandSide]
+ (528,2)SyntaxKind[SymbolSpan]
+ (528,2)SyntaxKind[Terminal](text = "++")
+ (528,7)SyntaxKind[SymbolSpan]
+ (528,7)SyntaxKind[Nonterminal]
+ (528,7)SyntaxKind[Identifier](text = "UnaryExpression")
+ (528,22)SyntaxKind[ArgumentList]
+ (528,22)SyntaxKind[OpenBracketToken]
+ (528,23)SyntaxKind[Argument]?
+ (528,23)SyntaxKind[QuestionToken]
+ (528,24)SyntaxKind[Identifier](text = "Yield")
+ (528,29)SyntaxKind[CloseBracketToken]
+ (529,2)SyntaxKind[RightHandSide]
+ (529,2)SyntaxKind[SymbolSpan]
+ (529,2)SyntaxKind[Terminal](text = "--")
+ (529,7)SyntaxKind[SymbolSpan]
+ (529,7)SyntaxKind[Nonterminal]
+ (529,7)SyntaxKind[Identifier](text = "UnaryExpression")
+ (529,22)SyntaxKind[ArgumentList]
+ (529,22)SyntaxKind[OpenBracketToken]
+ (529,23)SyntaxKind[Argument]?
+ (529,23)SyntaxKind[QuestionToken]
+ (529,24)SyntaxKind[Identifier](text = "Yield")
+ (529,29)SyntaxKind[CloseBracketToken]
+ (530,2)SyntaxKind[RightHandSide]
+ (530,2)SyntaxKind[SymbolSpan]
+ (530,2)SyntaxKind[Terminal](text = "+")
+ (530,6)SyntaxKind[SymbolSpan]
+ (530,6)SyntaxKind[Nonterminal]
+ (530,6)SyntaxKind[Identifier](text = "UnaryExpression")
+ (530,21)SyntaxKind[ArgumentList]
+ (530,21)SyntaxKind[OpenBracketToken]
+ (530,22)SyntaxKind[Argument]?
+ (530,22)SyntaxKind[QuestionToken]
+ (530,23)SyntaxKind[Identifier](text = "Yield")
+ (530,28)SyntaxKind[CloseBracketToken]
+ (531,2)SyntaxKind[RightHandSide]
+ (531,2)SyntaxKind[SymbolSpan]
+ (531,2)SyntaxKind[Terminal](text = "-")
+ (531,6)SyntaxKind[SymbolSpan]
+ (531,6)SyntaxKind[Nonterminal]
+ (531,6)SyntaxKind[Identifier](text = "UnaryExpression")
+ (531,21)SyntaxKind[ArgumentList]
+ (531,21)SyntaxKind[OpenBracketToken]
+ (531,22)SyntaxKind[Argument]?
+ (531,22)SyntaxKind[QuestionToken]
+ (531,23)SyntaxKind[Identifier](text = "Yield")
+ (531,28)SyntaxKind[CloseBracketToken]
+ (532,2)SyntaxKind[RightHandSide]
+ (532,2)SyntaxKind[SymbolSpan]
+ (532,2)SyntaxKind[Terminal](text = "~")
+ (532,6)SyntaxKind[SymbolSpan]
+ (532,6)SyntaxKind[Nonterminal]
+ (532,6)SyntaxKind[Identifier](text = "UnaryExpression")
+ (532,21)SyntaxKind[ArgumentList]
+ (532,21)SyntaxKind[OpenBracketToken]
+ (532,22)SyntaxKind[Argument]?
+ (532,22)SyntaxKind[QuestionToken]
+ (532,23)SyntaxKind[Identifier](text = "Yield")
+ (532,28)SyntaxKind[CloseBracketToken]
+ (533,2)SyntaxKind[RightHandSide]
+ (533,2)SyntaxKind[SymbolSpan]
+ (533,2)SyntaxKind[Terminal](text = "!")
+ (533,6)SyntaxKind[SymbolSpan]
+ (533,6)SyntaxKind[Nonterminal]
+ (533,6)SyntaxKind[Identifier](text = "UnaryExpression")
+ (533,21)SyntaxKind[ArgumentList]
+ (533,21)SyntaxKind[OpenBracketToken]
+ (533,22)SyntaxKind[Argument]?
+ (533,22)SyntaxKind[QuestionToken]
+ (533,23)SyntaxKind[Identifier](text = "Yield")
+ (533,28)SyntaxKind[CloseBracketToken]
+ (534,1)SyntaxKind[DedentToken]
+ (535,1)SyntaxKind[Production]
+ (535,1)SyntaxKind[Identifier](text = "MultiplicativeExpression")
+ (535,25)SyntaxKind[ParameterList]
+ (535,25)SyntaxKind[OpenBracketToken]
+ (535,26)SyntaxKind[Parameter]
+ (535,26)SyntaxKind[Identifier](text = "Yield")
+ (535,31)SyntaxKind[CloseBracketToken]
+ (536,1)SyntaxKind[RightHandSideList]
+ (536,1)SyntaxKind[IndentToken]
+ (536,2)SyntaxKind[RightHandSide]
+ (536,2)SyntaxKind[SymbolSpan]
+ (536,2)SyntaxKind[Nonterminal]
+ (536,2)SyntaxKind[Identifier](text = "UnaryExpression")
+ (536,17)SyntaxKind[ArgumentList]
+ (536,17)SyntaxKind[OpenBracketToken]
+ (536,18)SyntaxKind[Argument]?
+ (536,18)SyntaxKind[QuestionToken]
+ (536,19)SyntaxKind[Identifier](text = "Yield")
+ (536,24)SyntaxKind[CloseBracketToken]
+ (537,2)SyntaxKind[RightHandSide]
+ (537,2)SyntaxKind[SymbolSpan]
+ (537,2)SyntaxKind[Nonterminal]
+ (537,2)SyntaxKind[Identifier](text = "MultiplicativeExpression")
+ (537,26)SyntaxKind[ArgumentList]
+ (537,26)SyntaxKind[OpenBracketToken]
+ (537,27)SyntaxKind[Argument]?
+ (537,27)SyntaxKind[QuestionToken]
+ (537,28)SyntaxKind[Identifier](text = "Yield")
+ (537,33)SyntaxKind[CloseBracketToken]
+ (537,35)SyntaxKind[SymbolSpan]
+ (537,35)SyntaxKind[Nonterminal]
+ (537,35)SyntaxKind[Identifier](text = "MultiplicativeOperator")
+ (537,58)SyntaxKind[SymbolSpan]
+ (537,58)SyntaxKind[Nonterminal]
+ (537,58)SyntaxKind[Identifier](text = "UnaryExpression")
+ (537,73)SyntaxKind[ArgumentList]
+ (537,73)SyntaxKind[OpenBracketToken]
+ (537,74)SyntaxKind[Argument]?
+ (537,74)SyntaxKind[QuestionToken]
+ (537,75)SyntaxKind[Identifier](text = "Yield")
+ (537,80)SyntaxKind[CloseBracketToken]
+ (538,1)SyntaxKind[DedentToken]
+ (539,1)SyntaxKind[Production]
+ (539,1)SyntaxKind[Identifier](text = "MultiplicativeOperator")
+ (539,26)SyntaxKind[OneOfList]
+ (539,26)SyntaxKind[OneKeyword]
+ (539,30)SyntaxKind[OfKeyword]
+ (540,1)SyntaxKind[IndentToken]
+ (540,2)SyntaxKind[Terminal](text = "*")
+ (540,6)SyntaxKind[Terminal](text = "/")
+ (540,10)SyntaxKind[Terminal](text = "%")
+ (541,1)SyntaxKind[DedentToken]
+ (542,1)SyntaxKind[Production]
+ (542,1)SyntaxKind[Identifier](text = "AdditiveExpression")
+ (542,19)SyntaxKind[ParameterList]
+ (542,19)SyntaxKind[OpenBracketToken]
+ (542,20)SyntaxKind[Parameter]
+ (542,20)SyntaxKind[Identifier](text = "Yield")
+ (542,25)SyntaxKind[CloseBracketToken]
+ (543,1)SyntaxKind[RightHandSideList]
+ (543,1)SyntaxKind[IndentToken]
+ (543,2)SyntaxKind[RightHandSide]
+ (543,2)SyntaxKind[SymbolSpan]
+ (543,2)SyntaxKind[Nonterminal]
+ (543,2)SyntaxKind[Identifier](text = "MultiplicativeExpression")
+ (543,26)SyntaxKind[ArgumentList]
+ (543,26)SyntaxKind[OpenBracketToken]
+ (543,27)SyntaxKind[Argument]?
+ (543,27)SyntaxKind[QuestionToken]
+ (543,28)SyntaxKind[Identifier](text = "Yield")
+ (543,33)SyntaxKind[CloseBracketToken]
+ (544,2)SyntaxKind[RightHandSide]
+ (544,2)SyntaxKind[SymbolSpan]
+ (544,2)SyntaxKind[Nonterminal]
+ (544,2)SyntaxKind[Identifier](text = "AdditiveExpression")
+ (544,20)SyntaxKind[ArgumentList]
+ (544,20)SyntaxKind[OpenBracketToken]
+ (544,21)SyntaxKind[Argument]?
+ (544,21)SyntaxKind[QuestionToken]
+ (544,22)SyntaxKind[Identifier](text = "Yield")
+ (544,27)SyntaxKind[CloseBracketToken]
+ (544,29)SyntaxKind[SymbolSpan]
+ (544,29)SyntaxKind[Terminal](text = "+")
+ (544,33)SyntaxKind[SymbolSpan]
+ (544,33)SyntaxKind[Nonterminal]
+ (544,33)SyntaxKind[Identifier](text = "MultiplicativeExpression")
+ (544,57)SyntaxKind[ArgumentList]
+ (544,57)SyntaxKind[OpenBracketToken]
+ (544,58)SyntaxKind[Argument]?
+ (544,58)SyntaxKind[QuestionToken]
+ (544,59)SyntaxKind[Identifier](text = "Yield")
+ (544,64)SyntaxKind[CloseBracketToken]
+ (545,2)SyntaxKind[RightHandSide]
+ (545,2)SyntaxKind[SymbolSpan]
+ (545,2)SyntaxKind[Nonterminal]
+ (545,2)SyntaxKind[Identifier](text = "AdditiveExpression")
+ (545,20)SyntaxKind[ArgumentList]
+ (545,20)SyntaxKind[OpenBracketToken]
+ (545,21)SyntaxKind[Argument]?
+ (545,21)SyntaxKind[QuestionToken]
+ (545,22)SyntaxKind[Identifier](text = "Yield")
+ (545,27)SyntaxKind[CloseBracketToken]
+ (545,29)SyntaxKind[SymbolSpan]
+ (545,29)SyntaxKind[Terminal](text = "-")
+ (545,33)SyntaxKind[SymbolSpan]
+ (545,33)SyntaxKind[Nonterminal]
+ (545,33)SyntaxKind[Identifier](text = "MultiplicativeExpression")
+ (545,57)SyntaxKind[ArgumentList]
+ (545,57)SyntaxKind[OpenBracketToken]
+ (545,58)SyntaxKind[Argument]?
+ (545,58)SyntaxKind[QuestionToken]
+ (545,59)SyntaxKind[Identifier](text = "Yield")
+ (545,64)SyntaxKind[CloseBracketToken]
+ (546,1)SyntaxKind[DedentToken]
+ (547,1)SyntaxKind[Production]
+ (547,1)SyntaxKind[Identifier](text = "ShiftExpression")
+ (547,16)SyntaxKind[ParameterList]
+ (547,16)SyntaxKind[OpenBracketToken]
+ (547,17)SyntaxKind[Parameter]
+ (547,17)SyntaxKind[Identifier](text = "Yield")
+ (547,22)SyntaxKind[CloseBracketToken]
+ (548,1)SyntaxKind[RightHandSideList]
+ (548,1)SyntaxKind[IndentToken]
+ (548,2)SyntaxKind[RightHandSide]
+ (548,2)SyntaxKind[SymbolSpan]
+ (548,2)SyntaxKind[Nonterminal]
+ (548,2)SyntaxKind[Identifier](text = "AdditiveExpression")
+ (548,20)SyntaxKind[ArgumentList]
+ (548,20)SyntaxKind[OpenBracketToken]
+ (548,21)SyntaxKind[Argument]?
+ (548,21)SyntaxKind[QuestionToken]
+ (548,22)SyntaxKind[Identifier](text = "Yield")
+ (548,27)SyntaxKind[CloseBracketToken]
+ (549,2)SyntaxKind[RightHandSide]
+ (549,2)SyntaxKind[SymbolSpan]
+ (549,2)SyntaxKind[Nonterminal]
+ (549,2)SyntaxKind[Identifier](text = "ShiftExpression")
+ (549,17)SyntaxKind[ArgumentList]
+ (549,17)SyntaxKind[OpenBracketToken]
+ (549,18)SyntaxKind[Argument]?
+ (549,18)SyntaxKind[QuestionToken]
+ (549,19)SyntaxKind[Identifier](text = "Yield")
+ (549,24)SyntaxKind[CloseBracketToken]
+ (549,26)SyntaxKind[SymbolSpan]
+ (549,26)SyntaxKind[Terminal](text = "<<")
+ (549,31)SyntaxKind[SymbolSpan]
+ (549,31)SyntaxKind[Nonterminal]
+ (549,31)SyntaxKind[Identifier](text = "AdditiveExpression")
+ (549,49)SyntaxKind[ArgumentList]
+ (549,49)SyntaxKind[OpenBracketToken]
+ (549,50)SyntaxKind[Argument]?
+ (549,50)SyntaxKind[QuestionToken]
+ (549,51)SyntaxKind[Identifier](text = "Yield")
+ (549,56)SyntaxKind[CloseBracketToken]
+ (550,2)SyntaxKind[RightHandSide]
+ (550,2)SyntaxKind[SymbolSpan]
+ (550,2)SyntaxKind[Nonterminal]
+ (550,2)SyntaxKind[Identifier](text = "ShiftExpression")
+ (550,17)SyntaxKind[ArgumentList]
+ (550,17)SyntaxKind[OpenBracketToken]
+ (550,18)SyntaxKind[Argument]?
+ (550,18)SyntaxKind[QuestionToken]
+ (550,19)SyntaxKind[Identifier](text = "Yield")
+ (550,24)SyntaxKind[CloseBracketToken]
+ (550,26)SyntaxKind[SymbolSpan]
+ (550,26)SyntaxKind[Terminal](text = ">>")
+ (550,31)SyntaxKind[SymbolSpan]
+ (550,31)SyntaxKind[Nonterminal]
+ (550,31)SyntaxKind[Identifier](text = "AdditiveExpression")
+ (550,49)SyntaxKind[ArgumentList]
+ (550,49)SyntaxKind[OpenBracketToken]
+ (550,50)SyntaxKind[Argument]?
+ (550,50)SyntaxKind[QuestionToken]
+ (550,51)SyntaxKind[Identifier](text = "Yield")
+ (550,56)SyntaxKind[CloseBracketToken]
+ (551,2)SyntaxKind[RightHandSide]
+ (551,2)SyntaxKind[SymbolSpan]
+ (551,2)SyntaxKind[Nonterminal]
+ (551,2)SyntaxKind[Identifier](text = "ShiftExpression")
+ (551,17)SyntaxKind[ArgumentList]
+ (551,17)SyntaxKind[OpenBracketToken]
+ (551,18)SyntaxKind[Argument]?
+ (551,18)SyntaxKind[QuestionToken]
+ (551,19)SyntaxKind[Identifier](text = "Yield")
+ (551,24)SyntaxKind[CloseBracketToken]
+ (551,26)SyntaxKind[SymbolSpan]
+ (551,26)SyntaxKind[Terminal](text = ">>>")
+ (551,32)SyntaxKind[SymbolSpan]
+ (551,32)SyntaxKind[Nonterminal]
+ (551,32)SyntaxKind[Identifier](text = "AdditiveExpression")
+ (551,50)SyntaxKind[ArgumentList]
+ (551,50)SyntaxKind[OpenBracketToken]
+ (551,51)SyntaxKind[Argument]?
+ (551,51)SyntaxKind[QuestionToken]
+ (551,52)SyntaxKind[Identifier](text = "Yield")
+ (551,57)SyntaxKind[CloseBracketToken]
+ (552,1)SyntaxKind[DedentToken]
+ (553,1)SyntaxKind[Production]
+ (553,1)SyntaxKind[Identifier](text = "RelationalExpression")
+ (553,21)SyntaxKind[ParameterList]
+ (553,21)SyntaxKind[OpenBracketToken]
+ (553,22)SyntaxKind[Parameter]
+ (553,22)SyntaxKind[Identifier](text = "In")
+ (553,26)SyntaxKind[Parameter]
+ (553,26)SyntaxKind[Identifier](text = "Yield")
+ (553,31)SyntaxKind[CloseBracketToken]
+ (554,1)SyntaxKind[RightHandSideList]
+ (554,1)SyntaxKind[IndentToken]
+ (554,2)SyntaxKind[RightHandSide]
+ (554,2)SyntaxKind[SymbolSpan]
+ (554,2)SyntaxKind[Nonterminal]
+ (554,2)SyntaxKind[Identifier](text = "ShiftExpression")
+ (554,17)SyntaxKind[ArgumentList]
+ (554,17)SyntaxKind[OpenBracketToken]
+ (554,18)SyntaxKind[Argument]?
+ (554,18)SyntaxKind[QuestionToken]
+ (554,19)SyntaxKind[Identifier](text = "Yield")
+ (554,24)SyntaxKind[CloseBracketToken]
+ (555,2)SyntaxKind[RightHandSide]
+ (555,2)SyntaxKind[SymbolSpan]
+ (555,2)SyntaxKind[Nonterminal]
+ (555,2)SyntaxKind[Identifier](text = "RelationalExpression")
+ (555,22)SyntaxKind[ArgumentList]
+ (555,22)SyntaxKind[OpenBracketToken]
+ (555,23)SyntaxKind[Argument]?
+ (555,23)SyntaxKind[QuestionToken]
+ (555,24)SyntaxKind[Identifier](text = "In")
+ (555,28)SyntaxKind[Argument]?
+ (555,28)SyntaxKind[QuestionToken]
+ (555,29)SyntaxKind[Identifier](text = "Yield")
+ (555,34)SyntaxKind[CloseBracketToken]
+ (555,36)SyntaxKind[SymbolSpan]
+ (555,36)SyntaxKind[Terminal](text = "<")
+ (555,40)SyntaxKind[SymbolSpan]
+ (555,40)SyntaxKind[Nonterminal]
+ (555,40)SyntaxKind[Identifier](text = "ShiftExpression")
+ (555,55)SyntaxKind[ArgumentList]
+ (555,55)SyntaxKind[OpenBracketToken]
+ (555,56)SyntaxKind[Argument]?
+ (555,56)SyntaxKind[QuestionToken]
+ (555,57)SyntaxKind[Identifier](text = "Yield")
+ (555,62)SyntaxKind[CloseBracketToken]
+ (556,2)SyntaxKind[RightHandSide]
+ (556,2)SyntaxKind[SymbolSpan]
+ (556,2)SyntaxKind[Nonterminal]
+ (556,2)SyntaxKind[Identifier](text = "RelationalExpression")
+ (556,22)SyntaxKind[ArgumentList]
+ (556,22)SyntaxKind[OpenBracketToken]
+ (556,23)SyntaxKind[Argument]?
+ (556,23)SyntaxKind[QuestionToken]
+ (556,24)SyntaxKind[Identifier](text = "In")
+ (556,28)SyntaxKind[Argument]?
+ (556,28)SyntaxKind[QuestionToken]
+ (556,29)SyntaxKind[Identifier](text = "Yield")
+ (556,34)SyntaxKind[CloseBracketToken]
+ (556,36)SyntaxKind[SymbolSpan]
+ (556,36)SyntaxKind[Terminal](text = ">")
+ (556,40)SyntaxKind[SymbolSpan]
+ (556,40)SyntaxKind[Nonterminal]
+ (556,40)SyntaxKind[Identifier](text = "ShiftExpression")
+ (556,55)SyntaxKind[ArgumentList]
+ (556,55)SyntaxKind[OpenBracketToken]
+ (556,56)SyntaxKind[Argument]?
+ (556,56)SyntaxKind[QuestionToken]
+ (556,57)SyntaxKind[Identifier](text = "Yield")
+ (556,62)SyntaxKind[CloseBracketToken]
+ (557,2)SyntaxKind[RightHandSide]
+ (557,2)SyntaxKind[SymbolSpan]
+ (557,2)SyntaxKind[Nonterminal]
+ (557,2)SyntaxKind[Identifier](text = "RelationalExpression")
+ (557,22)SyntaxKind[ArgumentList]
+ (557,22)SyntaxKind[OpenBracketToken]
+ (557,23)SyntaxKind[Argument]?
+ (557,23)SyntaxKind[QuestionToken]
+ (557,24)SyntaxKind[Identifier](text = "In")
+ (557,28)SyntaxKind[Argument]?
+ (557,28)SyntaxKind[QuestionToken]
+ (557,29)SyntaxKind[Identifier](text = "Yield")
+ (557,34)SyntaxKind[CloseBracketToken]
+ (557,36)SyntaxKind[SymbolSpan]
+ (557,36)SyntaxKind[Terminal](text = "<=")
+ (557,41)SyntaxKind[SymbolSpan]
+ (557,41)SyntaxKind[Nonterminal]
+ (557,41)SyntaxKind[Identifier](text = "ShiftExpression")
+ (557,56)SyntaxKind[ArgumentList]
+ (557,56)SyntaxKind[OpenBracketToken]
+ (557,57)SyntaxKind[Argument]?
+ (557,57)SyntaxKind[QuestionToken]
+ (557,58)SyntaxKind[Identifier](text = "Yield")
+ (557,63)SyntaxKind[CloseBracketToken]
+ (558,2)SyntaxKind[RightHandSide]
+ (558,2)SyntaxKind[SymbolSpan]
+ (558,2)SyntaxKind[Nonterminal]
+ (558,2)SyntaxKind[Identifier](text = "RelationalExpression")
+ (558,22)SyntaxKind[ArgumentList]
+ (558,22)SyntaxKind[OpenBracketToken]
+ (558,23)SyntaxKind[Argument]?
+ (558,23)SyntaxKind[QuestionToken]
+ (558,24)SyntaxKind[Identifier](text = "In")
+ (558,28)SyntaxKind[Argument]?
+ (558,28)SyntaxKind[QuestionToken]
+ (558,29)SyntaxKind[Identifier](text = "Yield")
+ (558,34)SyntaxKind[CloseBracketToken]
+ (558,36)SyntaxKind[SymbolSpan]
+ (558,36)SyntaxKind[Terminal](text = ">=")
+ (558,41)SyntaxKind[SymbolSpan]
+ (558,41)SyntaxKind[Nonterminal]
+ (558,41)SyntaxKind[Identifier](text = "ShiftExpression")
+ (558,56)SyntaxKind[ArgumentList]
+ (558,56)SyntaxKind[OpenBracketToken]
+ (558,57)SyntaxKind[Argument]?
+ (558,57)SyntaxKind[QuestionToken]
+ (558,58)SyntaxKind[Identifier](text = "Yield")
+ (558,63)SyntaxKind[CloseBracketToken]
+ (559,2)SyntaxKind[RightHandSide]
+ (559,2)SyntaxKind[SymbolSpan]
+ (559,2)SyntaxKind[Nonterminal]
+ (559,2)SyntaxKind[Identifier](text = "RelationalExpression")
+ (559,22)SyntaxKind[ArgumentList]
+ (559,22)SyntaxKind[OpenBracketToken]
+ (559,23)SyntaxKind[Argument]?
+ (559,23)SyntaxKind[QuestionToken]
+ (559,24)SyntaxKind[Identifier](text = "In")
+ (559,28)SyntaxKind[Argument]?
+ (559,28)SyntaxKind[QuestionToken]
+ (559,29)SyntaxKind[Identifier](text = "Yield")
+ (559,34)SyntaxKind[CloseBracketToken]
+ (559,36)SyntaxKind[SymbolSpan]
+ (559,36)SyntaxKind[Terminal](text = "instanceof")
+ (559,49)SyntaxKind[SymbolSpan]
+ (559,49)SyntaxKind[Nonterminal]
+ (559,49)SyntaxKind[Identifier](text = "ShiftExpression")
+ (559,64)SyntaxKind[ArgumentList]
+ (559,64)SyntaxKind[OpenBracketToken]
+ (559,65)SyntaxKind[Argument]?
+ (559,65)SyntaxKind[QuestionToken]
+ (559,66)SyntaxKind[Identifier](text = "Yield")
+ (559,71)SyntaxKind[CloseBracketToken]
+ (560,2)SyntaxKind[RightHandSide]
+ (560,2)SyntaxKind[SymbolSpan]
+ (560,2)SyntaxKind[ParameterValueAssertion]
+ (560,2)SyntaxKind[OpenBracketToken]
+ (560,3)SyntaxKind[PlusToken]
+ (560,4)SyntaxKind[Identifier](text = "In")
+ (560,6)SyntaxKind[CloseBracketToken]
+ (560,8)SyntaxKind[SymbolSpan]
+ (560,8)SyntaxKind[Nonterminal]
+ (560,8)SyntaxKind[Identifier](text = "RelationalExpression")
+ (560,28)SyntaxKind[ArgumentList]
+ (560,28)SyntaxKind[OpenBracketToken]
+ (560,29)SyntaxKind[Argument]
+ (560,29)SyntaxKind[Identifier](text = "In")
+ (560,33)SyntaxKind[Argument]?
+ (560,33)SyntaxKind[QuestionToken]
+ (560,34)SyntaxKind[Identifier](text = "Yield")
+ (560,39)SyntaxKind[CloseBracketToken]
+ (560,41)SyntaxKind[SymbolSpan]
+ (560,41)SyntaxKind[Terminal](text = "in")
+ (560,46)SyntaxKind[SymbolSpan]
+ (560,46)SyntaxKind[Nonterminal]
+ (560,46)SyntaxKind[Identifier](text = "ShiftExpression")
+ (560,61)SyntaxKind[ArgumentList]
+ (560,61)SyntaxKind[OpenBracketToken]
+ (560,62)SyntaxKind[Argument]?
+ (560,62)SyntaxKind[QuestionToken]
+ (560,63)SyntaxKind[Identifier](text = "Yield")
+ (560,68)SyntaxKind[CloseBracketToken]
+ (561,1)SyntaxKind[DedentToken]
+ (562,1)SyntaxKind[Production]
+ (562,1)SyntaxKind[Identifier](text = "EqualityExpression")
+ (562,19)SyntaxKind[ParameterList]
+ (562,19)SyntaxKind[OpenBracketToken]
+ (562,20)SyntaxKind[Parameter]
+ (562,20)SyntaxKind[Identifier](text = "In")
+ (562,24)SyntaxKind[Parameter]
+ (562,24)SyntaxKind[Identifier](text = "Yield")
+ (562,29)SyntaxKind[CloseBracketToken]
+ (563,1)SyntaxKind[RightHandSideList]
+ (563,1)SyntaxKind[IndentToken]
+ (563,2)SyntaxKind[RightHandSide]
+ (563,2)SyntaxKind[SymbolSpan]
+ (563,2)SyntaxKind[Nonterminal]
+ (563,2)SyntaxKind[Identifier](text = "RelationalExpression")
+ (563,22)SyntaxKind[ArgumentList]
+ (563,22)SyntaxKind[OpenBracketToken]
+ (563,23)SyntaxKind[Argument]?
+ (563,23)SyntaxKind[QuestionToken]
+ (563,24)SyntaxKind[Identifier](text = "In")
+ (563,28)SyntaxKind[Argument]?
+ (563,28)SyntaxKind[QuestionToken]
+ (563,29)SyntaxKind[Identifier](text = "Yield")
+ (563,34)SyntaxKind[CloseBracketToken]
+ (564,2)SyntaxKind[RightHandSide]
+ (564,2)SyntaxKind[SymbolSpan]
+ (564,2)SyntaxKind[Nonterminal]
+ (564,2)SyntaxKind[Identifier](text = "EqualityExpression")
+ (564,20)SyntaxKind[ArgumentList]
+ (564,20)SyntaxKind[OpenBracketToken]
+ (564,21)SyntaxKind[Argument]?
+ (564,21)SyntaxKind[QuestionToken]
+ (564,22)SyntaxKind[Identifier](text = "In")
+ (564,26)SyntaxKind[Argument]?
+ (564,26)SyntaxKind[QuestionToken]
+ (564,27)SyntaxKind[Identifier](text = "Yield")
+ (564,32)SyntaxKind[CloseBracketToken]
+ (564,34)SyntaxKind[SymbolSpan]
+ (564,34)SyntaxKind[Terminal](text = "==")
+ (564,39)SyntaxKind[SymbolSpan]
+ (564,39)SyntaxKind[Nonterminal]
+ (564,39)SyntaxKind[Identifier](text = "RelationalExpression")
+ (564,59)SyntaxKind[ArgumentList]
+ (564,59)SyntaxKind[OpenBracketToken]
+ (564,60)SyntaxKind[Argument]?
+ (564,60)SyntaxKind[QuestionToken]
+ (564,61)SyntaxKind[Identifier](text = "In")
+ (564,65)SyntaxKind[Argument]?
+ (564,65)SyntaxKind[QuestionToken]
+ (564,66)SyntaxKind[Identifier](text = "Yield")
+ (564,71)SyntaxKind[CloseBracketToken]
+ (565,2)SyntaxKind[RightHandSide]
+ (565,2)SyntaxKind[SymbolSpan]
+ (565,2)SyntaxKind[Nonterminal]
+ (565,2)SyntaxKind[Identifier](text = "EqualityExpression")
+ (565,20)SyntaxKind[ArgumentList]
+ (565,20)SyntaxKind[OpenBracketToken]
+ (565,21)SyntaxKind[Argument]?
+ (565,21)SyntaxKind[QuestionToken]
+ (565,22)SyntaxKind[Identifier](text = "In")
+ (565,26)SyntaxKind[Argument]?
+ (565,26)SyntaxKind[QuestionToken]
+ (565,27)SyntaxKind[Identifier](text = "Yield")
+ (565,32)SyntaxKind[CloseBracketToken]
+ (565,34)SyntaxKind[SymbolSpan]
+ (565,34)SyntaxKind[Terminal](text = "!=")
+ (565,39)SyntaxKind[SymbolSpan]
+ (565,39)SyntaxKind[Nonterminal]
+ (565,39)SyntaxKind[Identifier](text = "RelationalExpression")
+ (565,59)SyntaxKind[ArgumentList]
+ (565,59)SyntaxKind[OpenBracketToken]
+ (565,60)SyntaxKind[Argument]?
+ (565,60)SyntaxKind[QuestionToken]
+ (565,61)SyntaxKind[Identifier](text = "In")
+ (565,65)SyntaxKind[Argument]?
+ (565,65)SyntaxKind[QuestionToken]
+ (565,66)SyntaxKind[Identifier](text = "Yield")
+ (565,71)SyntaxKind[CloseBracketToken]
+ (566,2)SyntaxKind[RightHandSide]
+ (566,2)SyntaxKind[SymbolSpan]
+ (566,2)SyntaxKind[Nonterminal]
+ (566,2)SyntaxKind[Identifier](text = "EqualityExpression")
+ (566,20)SyntaxKind[ArgumentList]
+ (566,20)SyntaxKind[OpenBracketToken]
+ (566,21)SyntaxKind[Argument]?
+ (566,21)SyntaxKind[QuestionToken]
+ (566,22)SyntaxKind[Identifier](text = "In")
+ (566,26)SyntaxKind[Argument]?
+ (566,26)SyntaxKind[QuestionToken]
+ (566,27)SyntaxKind[Identifier](text = "Yield")
+ (566,32)SyntaxKind[CloseBracketToken]
+ (566,34)SyntaxKind[SymbolSpan]
+ (566,34)SyntaxKind[Terminal](text = "===")
+ (566,40)SyntaxKind[SymbolSpan]
+ (566,40)SyntaxKind[Nonterminal]
+ (566,40)SyntaxKind[Identifier](text = "RelationalExpression")
+ (566,60)SyntaxKind[ArgumentList]
+ (566,60)SyntaxKind[OpenBracketToken]
+ (566,61)SyntaxKind[Argument]?
+ (566,61)SyntaxKind[QuestionToken]
+ (566,62)SyntaxKind[Identifier](text = "In")
+ (566,66)SyntaxKind[Argument]?
+ (566,66)SyntaxKind[QuestionToken]
+ (566,67)SyntaxKind[Identifier](text = "Yield")
+ (566,72)SyntaxKind[CloseBracketToken]
+ (567,2)SyntaxKind[RightHandSide]
+ (567,2)SyntaxKind[SymbolSpan]
+ (567,2)SyntaxKind[Nonterminal]
+ (567,2)SyntaxKind[Identifier](text = "EqualityExpression")
+ (567,20)SyntaxKind[ArgumentList]
+ (567,20)SyntaxKind[OpenBracketToken]
+ (567,21)SyntaxKind[Argument]?
+ (567,21)SyntaxKind[QuestionToken]
+ (567,22)SyntaxKind[Identifier](text = "In")
+ (567,26)SyntaxKind[Argument]?
+ (567,26)SyntaxKind[QuestionToken]
+ (567,27)SyntaxKind[Identifier](text = "Yield")
+ (567,32)SyntaxKind[CloseBracketToken]
+ (567,34)SyntaxKind[SymbolSpan]
+ (567,34)SyntaxKind[Terminal](text = "!==")
+ (567,40)SyntaxKind[SymbolSpan]
+ (567,40)SyntaxKind[Nonterminal]
+ (567,40)SyntaxKind[Identifier](text = "RelationalExpression")
+ (567,60)SyntaxKind[ArgumentList]
+ (567,60)SyntaxKind[OpenBracketToken]
+ (567,61)SyntaxKind[Argument]?
+ (567,61)SyntaxKind[QuestionToken]
+ (567,62)SyntaxKind[Identifier](text = "In")
+ (567,66)SyntaxKind[Argument]?
+ (567,66)SyntaxKind[QuestionToken]
+ (567,67)SyntaxKind[Identifier](text = "Yield")
+ (567,72)SyntaxKind[CloseBracketToken]
+ (568,1)SyntaxKind[DedentToken]
+ (569,1)SyntaxKind[Production]
+ (569,1)SyntaxKind[Identifier](text = "BitwiseANDExpression")
+ (569,21)SyntaxKind[ParameterList]
+ (569,21)SyntaxKind[OpenBracketToken]
+ (569,22)SyntaxKind[Parameter]
+ (569,22)SyntaxKind[Identifier](text = "In")
+ (569,26)SyntaxKind[Parameter]
+ (569,26)SyntaxKind[Identifier](text = "Yield")
+ (569,31)SyntaxKind[CloseBracketToken]
+ (570,1)SyntaxKind[RightHandSideList]
+ (570,1)SyntaxKind[IndentToken]
+ (570,2)SyntaxKind[RightHandSide]
+ (570,2)SyntaxKind[SymbolSpan]
+ (570,2)SyntaxKind[Nonterminal]
+ (570,2)SyntaxKind[Identifier](text = "EqualityExpression")
+ (570,20)SyntaxKind[ArgumentList]
+ (570,20)SyntaxKind[OpenBracketToken]
+ (570,21)SyntaxKind[Argument]?
+ (570,21)SyntaxKind[QuestionToken]
+ (570,22)SyntaxKind[Identifier](text = "In")
+ (570,26)SyntaxKind[Argument]?
+ (570,26)SyntaxKind[QuestionToken]
+ (570,27)SyntaxKind[Identifier](text = "Yield")
+ (570,32)SyntaxKind[CloseBracketToken]
+ (571,2)SyntaxKind[RightHandSide]
+ (571,2)SyntaxKind[SymbolSpan]
+ (571,2)SyntaxKind[Nonterminal]
+ (571,2)SyntaxKind[Identifier](text = "BitwiseANDExpression")
+ (571,22)SyntaxKind[ArgumentList]
+ (571,22)SyntaxKind[OpenBracketToken]
+ (571,23)SyntaxKind[Argument]?
+ (571,23)SyntaxKind[QuestionToken]
+ (571,24)SyntaxKind[Identifier](text = "In")
+ (571,28)SyntaxKind[Argument]?
+ (571,28)SyntaxKind[QuestionToken]
+ (571,29)SyntaxKind[Identifier](text = "Yield")
+ (571,34)SyntaxKind[CloseBracketToken]
+ (571,36)SyntaxKind[SymbolSpan]
+ (571,36)SyntaxKind[Terminal](text = "&")
+ (571,40)SyntaxKind[SymbolSpan]
+ (571,40)SyntaxKind[Nonterminal]
+ (571,40)SyntaxKind[Identifier](text = "EqualityExpression")
+ (571,58)SyntaxKind[ArgumentList]
+ (571,58)SyntaxKind[OpenBracketToken]
+ (571,59)SyntaxKind[Argument]?
+ (571,59)SyntaxKind[QuestionToken]
+ (571,60)SyntaxKind[Identifier](text = "In")
+ (571,64)SyntaxKind[Argument]?
+ (571,64)SyntaxKind[QuestionToken]
+ (571,65)SyntaxKind[Identifier](text = "Yield")
+ (571,70)SyntaxKind[CloseBracketToken]
+ (572,1)SyntaxKind[DedentToken]
+ (573,1)SyntaxKind[Production]
+ (573,1)SyntaxKind[Identifier](text = "BitwiseXORExpression")
+ (573,21)SyntaxKind[ParameterList]
+ (573,21)SyntaxKind[OpenBracketToken]
+ (573,22)SyntaxKind[Parameter]
+ (573,22)SyntaxKind[Identifier](text = "In")
+ (573,26)SyntaxKind[Parameter]
+ (573,26)SyntaxKind[Identifier](text = "Yield")
+ (573,31)SyntaxKind[CloseBracketToken]
+ (574,1)SyntaxKind[RightHandSideList]
+ (574,1)SyntaxKind[IndentToken]
+ (574,2)SyntaxKind[RightHandSide]
+ (574,2)SyntaxKind[SymbolSpan]
+ (574,2)SyntaxKind[Nonterminal]
+ (574,2)SyntaxKind[Identifier](text = "BitwiseANDExpression")
+ (574,22)SyntaxKind[ArgumentList]
+ (574,22)SyntaxKind[OpenBracketToken]
+ (574,23)SyntaxKind[Argument]?
+ (574,23)SyntaxKind[QuestionToken]
+ (574,24)SyntaxKind[Identifier](text = "In")
+ (574,28)SyntaxKind[Argument]?
+ (574,28)SyntaxKind[QuestionToken]
+ (574,29)SyntaxKind[Identifier](text = "Yield")
+ (574,34)SyntaxKind[CloseBracketToken]
+ (575,2)SyntaxKind[RightHandSide]
+ (575,2)SyntaxKind[SymbolSpan]
+ (575,2)SyntaxKind[Nonterminal]
+ (575,2)SyntaxKind[Identifier](text = "BitwiseXORExpression")
+ (575,22)SyntaxKind[ArgumentList]
+ (575,22)SyntaxKind[OpenBracketToken]
+ (575,23)SyntaxKind[Argument]?
+ (575,23)SyntaxKind[QuestionToken]
+ (575,24)SyntaxKind[Identifier](text = "In")
+ (575,28)SyntaxKind[Argument]?
+ (575,28)SyntaxKind[QuestionToken]
+ (575,29)SyntaxKind[Identifier](text = "Yield")
+ (575,34)SyntaxKind[CloseBracketToken]
+ (575,36)SyntaxKind[SymbolSpan]
+ (575,36)SyntaxKind[Terminal](text = "^")
+ (575,40)SyntaxKind[SymbolSpan]
+ (575,40)SyntaxKind[Nonterminal]
+ (575,40)SyntaxKind[Identifier](text = "BitwiseANDExpression")
+ (575,60)SyntaxKind[ArgumentList]
+ (575,60)SyntaxKind[OpenBracketToken]
+ (575,61)SyntaxKind[Argument]?
+ (575,61)SyntaxKind[QuestionToken]
+ (575,62)SyntaxKind[Identifier](text = "In")
+ (575,66)SyntaxKind[Argument]?
+ (575,66)SyntaxKind[QuestionToken]
+ (575,67)SyntaxKind[Identifier](text = "Yield")
+ (575,72)SyntaxKind[CloseBracketToken]
+ (576,1)SyntaxKind[DedentToken]
+ (577,1)SyntaxKind[Production]
+ (577,1)SyntaxKind[Identifier](text = "BitwiseORExpression")
+ (577,20)SyntaxKind[ParameterList]
+ (577,20)SyntaxKind[OpenBracketToken]
+ (577,21)SyntaxKind[Parameter]
+ (577,21)SyntaxKind[Identifier](text = "In")
+ (577,25)SyntaxKind[Parameter]
+ (577,25)SyntaxKind[Identifier](text = "Yield")
+ (577,30)SyntaxKind[CloseBracketToken]
+ (578,1)SyntaxKind[RightHandSideList]
+ (578,1)SyntaxKind[IndentToken]
+ (578,2)SyntaxKind[RightHandSide]
+ (578,2)SyntaxKind[SymbolSpan]
+ (578,2)SyntaxKind[Nonterminal]
+ (578,2)SyntaxKind[Identifier](text = "BitwiseXORExpression")
+ (578,22)SyntaxKind[ArgumentList]
+ (578,22)SyntaxKind[OpenBracketToken]
+ (578,23)SyntaxKind[Argument]?
+ (578,23)SyntaxKind[QuestionToken]
+ (578,24)SyntaxKind[Identifier](text = "In")
+ (578,28)SyntaxKind[Argument]?
+ (578,28)SyntaxKind[QuestionToken]
+ (578,29)SyntaxKind[Identifier](text = "Yield")
+ (578,34)SyntaxKind[CloseBracketToken]
+ (579,2)SyntaxKind[RightHandSide]
+ (579,2)SyntaxKind[SymbolSpan]
+ (579,2)SyntaxKind[Nonterminal]
+ (579,2)SyntaxKind[Identifier](text = "BitwiseORExpression")
+ (579,21)SyntaxKind[ArgumentList]
+ (579,21)SyntaxKind[OpenBracketToken]
+ (579,22)SyntaxKind[Argument]?
+ (579,22)SyntaxKind[QuestionToken]
+ (579,23)SyntaxKind[Identifier](text = "In")
+ (579,27)SyntaxKind[Argument]?
+ (579,27)SyntaxKind[QuestionToken]
+ (579,28)SyntaxKind[Identifier](text = "Yield")
+ (579,33)SyntaxKind[CloseBracketToken]
+ (579,35)SyntaxKind[SymbolSpan]
+ (579,35)SyntaxKind[Terminal](text = "|")
+ (579,39)SyntaxKind[SymbolSpan]
+ (579,39)SyntaxKind[Nonterminal]
+ (579,39)SyntaxKind[Identifier](text = "BitwiseXORExpression")
+ (579,59)SyntaxKind[ArgumentList]
+ (579,59)SyntaxKind[OpenBracketToken]
+ (579,60)SyntaxKind[Argument]?
+ (579,60)SyntaxKind[QuestionToken]
+ (579,61)SyntaxKind[Identifier](text = "In")
+ (579,65)SyntaxKind[Argument]?
+ (579,65)SyntaxKind[QuestionToken]
+ (579,66)SyntaxKind[Identifier](text = "Yield")
+ (579,71)SyntaxKind[CloseBracketToken]
+ (580,1)SyntaxKind[DedentToken]
+ (581,1)SyntaxKind[Production]
+ (581,1)SyntaxKind[Identifier](text = "LogicalANDExpression")
+ (581,21)SyntaxKind[ParameterList]
+ (581,21)SyntaxKind[OpenBracketToken]
+ (581,22)SyntaxKind[Parameter]
+ (581,22)SyntaxKind[Identifier](text = "In")
+ (581,26)SyntaxKind[Parameter]
+ (581,26)SyntaxKind[Identifier](text = "Yield")
+ (581,31)SyntaxKind[CloseBracketToken]
+ (582,1)SyntaxKind[RightHandSideList]
+ (582,1)SyntaxKind[IndentToken]
+ (582,2)SyntaxKind[RightHandSide]
+ (582,2)SyntaxKind[SymbolSpan]
+ (582,2)SyntaxKind[Nonterminal]
+ (582,2)SyntaxKind[Identifier](text = "BitwiseORExpression")
+ (582,21)SyntaxKind[ArgumentList]
+ (582,21)SyntaxKind[OpenBracketToken]
+ (582,22)SyntaxKind[Argument]?
+ (582,22)SyntaxKind[QuestionToken]
+ (582,23)SyntaxKind[Identifier](text = "In")
+ (582,27)SyntaxKind[Argument]?
+ (582,27)SyntaxKind[QuestionToken]
+ (582,28)SyntaxKind[Identifier](text = "Yield")
+ (582,33)SyntaxKind[CloseBracketToken]
+ (583,2)SyntaxKind[RightHandSide]
+ (583,2)SyntaxKind[SymbolSpan]
+ (583,2)SyntaxKind[Nonterminal]
+ (583,2)SyntaxKind[Identifier](text = "LogicalANDExpression")
+ (583,22)SyntaxKind[ArgumentList]
+ (583,22)SyntaxKind[OpenBracketToken]
+ (583,23)SyntaxKind[Argument]?
+ (583,23)SyntaxKind[QuestionToken]
+ (583,24)SyntaxKind[Identifier](text = "In")
+ (583,28)SyntaxKind[Argument]?
+ (583,28)SyntaxKind[QuestionToken]
+ (583,29)SyntaxKind[Identifier](text = "Yield")
+ (583,34)SyntaxKind[CloseBracketToken]
+ (583,36)SyntaxKind[SymbolSpan]
+ (583,36)SyntaxKind[Terminal](text = "&&")
+ (583,41)SyntaxKind[SymbolSpan]
+ (583,41)SyntaxKind[Nonterminal]
+ (583,41)SyntaxKind[Identifier](text = "BitwiseORExpression")
+ (583,60)SyntaxKind[ArgumentList]
+ (583,60)SyntaxKind[OpenBracketToken]
+ (583,61)SyntaxKind[Argument]?
+ (583,61)SyntaxKind[QuestionToken]
+ (583,62)SyntaxKind[Identifier](text = "In")
+ (583,66)SyntaxKind[Argument]?
+ (583,66)SyntaxKind[QuestionToken]
+ (583,67)SyntaxKind[Identifier](text = "Yield")
+ (583,72)SyntaxKind[CloseBracketToken]
+ (584,1)SyntaxKind[DedentToken]
+ (585,1)SyntaxKind[Production]
+ (585,1)SyntaxKind[Identifier](text = "LogicalORExpression")
+ (585,20)SyntaxKind[ParameterList]
+ (585,20)SyntaxKind[OpenBracketToken]
+ (585,21)SyntaxKind[Parameter]
+ (585,21)SyntaxKind[Identifier](text = "In")
+ (585,25)SyntaxKind[Parameter]
+ (585,25)SyntaxKind[Identifier](text = "Yield")
+ (585,30)SyntaxKind[CloseBracketToken]
+ (586,1)SyntaxKind[RightHandSideList]
+ (586,1)SyntaxKind[IndentToken]
+ (586,2)SyntaxKind[RightHandSide]
+ (586,2)SyntaxKind[SymbolSpan]
+ (586,2)SyntaxKind[Nonterminal]
+ (586,2)SyntaxKind[Identifier](text = "LogicalANDExpression")
+ (586,22)SyntaxKind[ArgumentList]
+ (586,22)SyntaxKind[OpenBracketToken]
+ (586,23)SyntaxKind[Argument]?
+ (586,23)SyntaxKind[QuestionToken]
+ (586,24)SyntaxKind[Identifier](text = "In")
+ (586,28)SyntaxKind[Argument]?
+ (586,28)SyntaxKind[QuestionToken]
+ (586,29)SyntaxKind[Identifier](text = "Yield")
+ (586,34)SyntaxKind[CloseBracketToken]
+ (587,2)SyntaxKind[RightHandSide]
+ (587,2)SyntaxKind[SymbolSpan]
+ (587,2)SyntaxKind[Nonterminal]
+ (587,2)SyntaxKind[Identifier](text = "LogicalORExpression")
+ (587,21)SyntaxKind[ArgumentList]
+ (587,21)SyntaxKind[OpenBracketToken]
+ (587,22)SyntaxKind[Argument]?
+ (587,22)SyntaxKind[QuestionToken]
+ (587,23)SyntaxKind[Identifier](text = "In")
+ (587,27)SyntaxKind[Argument]?
+ (587,27)SyntaxKind[QuestionToken]
+ (587,28)SyntaxKind[Identifier](text = "Yield")
+ (587,33)SyntaxKind[CloseBracketToken]
+ (587,35)SyntaxKind[SymbolSpan]
+ (587,35)SyntaxKind[Terminal](text = "||")
+ (587,40)SyntaxKind[SymbolSpan]
+ (587,40)SyntaxKind[Nonterminal]
+ (587,40)SyntaxKind[Identifier](text = "LogicalANDExpression")
+ (587,60)SyntaxKind[ArgumentList]
+ (587,60)SyntaxKind[OpenBracketToken]
+ (587,61)SyntaxKind[Argument]?
+ (587,61)SyntaxKind[QuestionToken]
+ (587,62)SyntaxKind[Identifier](text = "In")
+ (587,66)SyntaxKind[Argument]?
+ (587,66)SyntaxKind[QuestionToken]
+ (587,67)SyntaxKind[Identifier](text = "Yield")
+ (587,72)SyntaxKind[CloseBracketToken]
+ (588,1)SyntaxKind[DedentToken]
+ (589,1)SyntaxKind[Production]
+ (589,1)SyntaxKind[Identifier](text = "ConditionalExpression")
+ (589,22)SyntaxKind[ParameterList]
+ (589,22)SyntaxKind[OpenBracketToken]
+ (589,23)SyntaxKind[Parameter]
+ (589,23)SyntaxKind[Identifier](text = "In")
+ (589,27)SyntaxKind[Parameter]
+ (589,27)SyntaxKind[Identifier](text = "Yield")
+ (589,32)SyntaxKind[CloseBracketToken]
+ (590,1)SyntaxKind[RightHandSideList]
+ (590,1)SyntaxKind[IndentToken]
+ (590,2)SyntaxKind[RightHandSide]
+ (590,2)SyntaxKind[SymbolSpan]
+ (590,2)SyntaxKind[Nonterminal]
+ (590,2)SyntaxKind[Identifier](text = "LogicalORExpression")
+ (590,21)SyntaxKind[ArgumentList]
+ (590,21)SyntaxKind[OpenBracketToken]
+ (590,22)SyntaxKind[Argument]?
+ (590,22)SyntaxKind[QuestionToken]
+ (590,23)SyntaxKind[Identifier](text = "In")
+ (590,27)SyntaxKind[Argument]?
+ (590,27)SyntaxKind[QuestionToken]
+ (590,28)SyntaxKind[Identifier](text = "Yield")
+ (590,33)SyntaxKind[CloseBracketToken]
+ (591,2)SyntaxKind[RightHandSide]
+ (591,2)SyntaxKind[SymbolSpan]
+ (591,2)SyntaxKind[Nonterminal]
+ (591,2)SyntaxKind[Identifier](text = "LogicalORExpression")
+ (591,21)SyntaxKind[ArgumentList]
+ (591,21)SyntaxKind[OpenBracketToken]
+ (591,22)SyntaxKind[Argument]?
+ (591,22)SyntaxKind[QuestionToken]
+ (591,23)SyntaxKind[Identifier](text = "In")
+ (591,27)SyntaxKind[Argument]?
+ (591,27)SyntaxKind[QuestionToken]
+ (591,28)SyntaxKind[Identifier](text = "Yield")
+ (591,33)SyntaxKind[CloseBracketToken]
+ (591,35)SyntaxKind[SymbolSpan]
+ (591,35)SyntaxKind[Terminal](text = "?")
+ (591,39)SyntaxKind[SymbolSpan]
+ (591,39)SyntaxKind[Nonterminal]
+ (591,39)SyntaxKind[Identifier](text = "AssignmentExpression")
+ (591,59)SyntaxKind[ArgumentList]
+ (591,59)SyntaxKind[OpenBracketToken]
+ (591,60)SyntaxKind[Argument]
+ (591,60)SyntaxKind[Identifier](text = "In")
+ (591,64)SyntaxKind[Argument]?
+ (591,64)SyntaxKind[QuestionToken]
+ (591,65)SyntaxKind[Identifier](text = "Yield")
+ (591,70)SyntaxKind[CloseBracketToken]
+ (591,72)SyntaxKind[SymbolSpan]
+ (591,72)SyntaxKind[Terminal](text = ":")
+ (591,76)SyntaxKind[SymbolSpan]
+ (591,76)SyntaxKind[Nonterminal]
+ (591,76)SyntaxKind[Identifier](text = "AssignmentExpression")
+ (591,96)SyntaxKind[ArgumentList]
+ (591,96)SyntaxKind[OpenBracketToken]
+ (591,97)SyntaxKind[Argument]?
+ (591,97)SyntaxKind[QuestionToken]
+ (591,98)SyntaxKind[Identifier](text = "In")
+ (591,102)SyntaxKind[Argument]?
+ (591,102)SyntaxKind[QuestionToken]
+ (591,103)SyntaxKind[Identifier](text = "Yield")
+ (591,108)SyntaxKind[CloseBracketToken]
+ (592,1)SyntaxKind[DedentToken]
+ (593,1)SyntaxKind[Production]
+ (593,1)SyntaxKind[Identifier](text = "AssignmentExpression")
+ (593,21)SyntaxKind[ParameterList]
+ (593,21)SyntaxKind[OpenBracketToken]
+ (593,22)SyntaxKind[Parameter]
+ (593,22)SyntaxKind[Identifier](text = "In")
+ (593,26)SyntaxKind[Parameter]
+ (593,26)SyntaxKind[Identifier](text = "Yield")
+ (593,31)SyntaxKind[CloseBracketToken]
+ (594,1)SyntaxKind[RightHandSideList]
+ (594,1)SyntaxKind[IndentToken]
+ (594,2)SyntaxKind[RightHandSide]
+ (594,2)SyntaxKind[SymbolSpan]
+ (594,2)SyntaxKind[Nonterminal]
+ (594,2)SyntaxKind[Identifier](text = "ConditionalExpression")
+ (594,23)SyntaxKind[ArgumentList]
+ (594,23)SyntaxKind[OpenBracketToken]
+ (594,24)SyntaxKind[Argument]?
+ (594,24)SyntaxKind[QuestionToken]
+ (594,25)SyntaxKind[Identifier](text = "In")
+ (594,29)SyntaxKind[Argument]?
+ (594,29)SyntaxKind[QuestionToken]
+ (594,30)SyntaxKind[Identifier](text = "Yield")
+ (594,35)SyntaxKind[CloseBracketToken]
+ (595,2)SyntaxKind[RightHandSide]
+ (595,2)SyntaxKind[SymbolSpan]
+ (595,2)SyntaxKind[ParameterValueAssertion]
+ (595,2)SyntaxKind[OpenBracketToken]
+ (595,3)SyntaxKind[PlusToken]
+ (595,4)SyntaxKind[Identifier](text = "Yield")
+ (595,9)SyntaxKind[CloseBracketToken]
+ (595,11)SyntaxKind[SymbolSpan]
+ (595,11)SyntaxKind[Nonterminal]
+ (595,11)SyntaxKind[Identifier](text = "YieldExpression")
+ (595,26)SyntaxKind[ArgumentList]
+ (595,26)SyntaxKind[OpenBracketToken]
+ (595,27)SyntaxKind[Argument]?
+ (595,27)SyntaxKind[QuestionToken]
+ (595,28)SyntaxKind[Identifier](text = "In")
+ (595,30)SyntaxKind[CloseBracketToken]
+ (596,2)SyntaxKind[RightHandSide]
+ (596,2)SyntaxKind[SymbolSpan]
+ (596,2)SyntaxKind[Nonterminal]
+ (596,2)SyntaxKind[Identifier](text = "ArrowFunction")
+ (596,15)SyntaxKind[ArgumentList]
+ (596,15)SyntaxKind[OpenBracketToken]
+ (596,16)SyntaxKind[Argument]?
+ (596,16)SyntaxKind[QuestionToken]
+ (596,17)SyntaxKind[Identifier](text = "In")
+ (596,21)SyntaxKind[Argument]?
+ (596,21)SyntaxKind[QuestionToken]
+ (596,22)SyntaxKind[Identifier](text = "Yield")
+ (596,27)SyntaxKind[CloseBracketToken]
+ (597,2)SyntaxKind[RightHandSide]
+ (597,2)SyntaxKind[SymbolSpan]
+ (597,2)SyntaxKind[Nonterminal]
+ (597,2)SyntaxKind[Identifier](text = "LeftHandSideExpression")
+ (597,24)SyntaxKind[ArgumentList]
+ (597,24)SyntaxKind[OpenBracketToken]
+ (597,25)SyntaxKind[Argument]?
+ (597,25)SyntaxKind[QuestionToken]
+ (597,26)SyntaxKind[Identifier](text = "Yield")
+ (597,31)SyntaxKind[CloseBracketToken]
+ (597,33)SyntaxKind[SymbolSpan]
+ (597,33)SyntaxKind[Terminal](text = "=")
+ (597,37)SyntaxKind[SymbolSpan]
+ (597,37)SyntaxKind[Nonterminal]
+ (597,37)SyntaxKind[Identifier](text = "AssignmentExpression")
+ (597,57)SyntaxKind[ArgumentList]
+ (597,57)SyntaxKind[OpenBracketToken]
+ (597,58)SyntaxKind[Argument]?
+ (597,58)SyntaxKind[QuestionToken]
+ (597,59)SyntaxKind[Identifier](text = "In")
+ (597,63)SyntaxKind[Argument]?
+ (597,63)SyntaxKind[QuestionToken]
+ (597,64)SyntaxKind[Identifier](text = "Yield")
+ (597,69)SyntaxKind[CloseBracketToken]
+ (598,2)SyntaxKind[RightHandSide]
+ (598,2)SyntaxKind[SymbolSpan]
+ (598,2)SyntaxKind[Nonterminal]
+ (598,2)SyntaxKind[Identifier](text = "LeftHandSideExpression")
+ (598,24)SyntaxKind[ArgumentList]
+ (598,24)SyntaxKind[OpenBracketToken]
+ (598,25)SyntaxKind[Argument]?
+ (598,25)SyntaxKind[QuestionToken]
+ (598,26)SyntaxKind[Identifier](text = "Yield")
+ (598,31)SyntaxKind[CloseBracketToken]
+ (598,33)SyntaxKind[SymbolSpan]
+ (598,33)SyntaxKind[Nonterminal]
+ (598,33)SyntaxKind[Identifier](text = "AssignmentOperator")
+ (598,52)SyntaxKind[SymbolSpan]
+ (598,52)SyntaxKind[Nonterminal]
+ (598,52)SyntaxKind[Identifier](text = "AssignmentExpression")
+ (598,72)SyntaxKind[ArgumentList]
+ (598,72)SyntaxKind[OpenBracketToken]
+ (598,73)SyntaxKind[Argument]?
+ (598,73)SyntaxKind[QuestionToken]
+ (598,74)SyntaxKind[Identifier](text = "In")
+ (598,78)SyntaxKind[Argument]?
+ (598,78)SyntaxKind[QuestionToken]
+ (598,79)SyntaxKind[Identifier](text = "Yield")
+ (598,84)SyntaxKind[CloseBracketToken]
+ (599,1)SyntaxKind[DedentToken]
+ (600,1)SyntaxKind[Production]
+ (600,1)SyntaxKind[Identifier](text = "AssignmentOperator")
+ (600,22)SyntaxKind[OneOfList]
+ (600,22)SyntaxKind[OneKeyword]
+ (600,26)SyntaxKind[OfKeyword]
+ (601,1)SyntaxKind[IndentToken]
+ (601,2)SyntaxKind[Terminal](text = "*=")
+ (601,7)SyntaxKind[Terminal](text = "/=")
+ (601,12)SyntaxKind[Terminal](text = "%=")
+ (601,17)SyntaxKind[Terminal](text = "+=")
+ (601,22)SyntaxKind[Terminal](text = "-=")
+ (601,27)SyntaxKind[Terminal](text = "<<=")
+ (601,33)SyntaxKind[Terminal](text = ">>=")
+ (601,39)SyntaxKind[Terminal](text = ">>>=")
+ (601,46)SyntaxKind[Terminal](text = "&=")
+ (601,51)SyntaxKind[Terminal](text = "^=")
+ (601,56)SyntaxKind[Terminal](text = "|=")
+ (602,1)SyntaxKind[DedentToken]
+ (603,1)SyntaxKind[Production]
+ (603,1)SyntaxKind[Identifier](text = "Expression")
+ (603,11)SyntaxKind[ParameterList]
+ (603,11)SyntaxKind[OpenBracketToken]
+ (603,12)SyntaxKind[Parameter]
+ (603,12)SyntaxKind[Identifier](text = "In")
+ (603,16)SyntaxKind[Parameter]
+ (603,16)SyntaxKind[Identifier](text = "Yield")
+ (603,21)SyntaxKind[CloseBracketToken]
+ (604,1)SyntaxKind[RightHandSideList]
+ (604,1)SyntaxKind[IndentToken]
+ (604,2)SyntaxKind[RightHandSide]
+ (604,2)SyntaxKind[SymbolSpan]
+ (604,2)SyntaxKind[Nonterminal]
+ (604,2)SyntaxKind[Identifier](text = "AssignmentExpression")
+ (604,22)SyntaxKind[ArgumentList]
+ (604,22)SyntaxKind[OpenBracketToken]
+ (604,23)SyntaxKind[Argument]?
+ (604,23)SyntaxKind[QuestionToken]
+ (604,24)SyntaxKind[Identifier](text = "In")
+ (604,28)SyntaxKind[Argument]?
+ (604,28)SyntaxKind[QuestionToken]
+ (604,29)SyntaxKind[Identifier](text = "Yield")
+ (604,34)SyntaxKind[CloseBracketToken]
+ (605,2)SyntaxKind[RightHandSide]
+ (605,2)SyntaxKind[SymbolSpan]
+ (605,2)SyntaxKind[Nonterminal]
+ (605,2)SyntaxKind[Identifier](text = "Expression")
+ (605,12)SyntaxKind[ArgumentList]
+ (605,12)SyntaxKind[OpenBracketToken]
+ (605,13)SyntaxKind[Argument]?
+ (605,13)SyntaxKind[QuestionToken]
+ (605,14)SyntaxKind[Identifier](text = "In")
+ (605,18)SyntaxKind[Argument]?
+ (605,18)SyntaxKind[QuestionToken]
+ (605,19)SyntaxKind[Identifier](text = "Yield")
+ (605,24)SyntaxKind[CloseBracketToken]
+ (605,26)SyntaxKind[SymbolSpan]
+ (605,26)SyntaxKind[Terminal](text = ",")
+ (605,30)SyntaxKind[SymbolSpan]
+ (605,30)SyntaxKind[Nonterminal]
+ (605,30)SyntaxKind[Identifier](text = "AssignmentExpression")
+ (605,50)SyntaxKind[ArgumentList]
+ (605,50)SyntaxKind[OpenBracketToken]
+ (605,51)SyntaxKind[Argument]?
+ (605,51)SyntaxKind[QuestionToken]
+ (605,52)SyntaxKind[Identifier](text = "In")
+ (605,56)SyntaxKind[Argument]?
+ (605,56)SyntaxKind[QuestionToken]
+ (605,57)SyntaxKind[Identifier](text = "Yield")
+ (605,62)SyntaxKind[CloseBracketToken]
+ (606,1)SyntaxKind[DedentToken]
+ (609,1)SyntaxKind[Production]
+ (609,1)SyntaxKind[Identifier](text = "Statement")
+ (609,10)SyntaxKind[ParameterList]
+ (609,10)SyntaxKind[OpenBracketToken]
+ (609,11)SyntaxKind[Parameter]
+ (609,11)SyntaxKind[Identifier](text = "Yield")
+ (609,18)SyntaxKind[Parameter]
+ (609,18)SyntaxKind[Identifier](text = "Return")
+ (609,24)SyntaxKind[CloseBracketToken]
+ (610,1)SyntaxKind[RightHandSideList]
+ (610,1)SyntaxKind[IndentToken]
+ (610,2)SyntaxKind[RightHandSide]
+ (610,2)SyntaxKind[SymbolSpan]
+ (610,2)SyntaxKind[Nonterminal]
+ (610,2)SyntaxKind[Identifier](text = "BlockStatement")
+ (610,16)SyntaxKind[ArgumentList]
+ (610,16)SyntaxKind[OpenBracketToken]
+ (610,17)SyntaxKind[Argument]?
+ (610,17)SyntaxKind[QuestionToken]
+ (610,18)SyntaxKind[Identifier](text = "Yield")
+ (610,25)SyntaxKind[Argument]?
+ (610,25)SyntaxKind[QuestionToken]
+ (610,26)SyntaxKind[Identifier](text = "Return")
+ (610,32)SyntaxKind[CloseBracketToken]
+ (611,2)SyntaxKind[RightHandSide]
+ (611,2)SyntaxKind[SymbolSpan]
+ (611,2)SyntaxKind[Nonterminal]
+ (611,2)SyntaxKind[Identifier](text = "VariableStatement")
+ (611,19)SyntaxKind[ArgumentList]
+ (611,19)SyntaxKind[OpenBracketToken]
+ (611,20)SyntaxKind[Argument]?
+ (611,20)SyntaxKind[QuestionToken]
+ (611,21)SyntaxKind[Identifier](text = "Yield")
+ (611,26)SyntaxKind[CloseBracketToken]
+ (612,2)SyntaxKind[RightHandSide]
+ (612,2)SyntaxKind[SymbolSpan]
+ (612,2)SyntaxKind[Nonterminal]
+ (612,2)SyntaxKind[Identifier](text = "EmptyStatement")
+ (613,2)SyntaxKind[RightHandSide]
+ (613,2)SyntaxKind[SymbolSpan]
+ (613,2)SyntaxKind[Nonterminal]
+ (613,2)SyntaxKind[Identifier](text = "ExpressionStatement")
+ (613,21)SyntaxKind[ArgumentList]
+ (613,21)SyntaxKind[OpenBracketToken]
+ (613,22)SyntaxKind[Argument]?
+ (613,22)SyntaxKind[QuestionToken]
+ (613,23)SyntaxKind[Identifier](text = "Yield")
+ (613,28)SyntaxKind[CloseBracketToken]
+ (614,2)SyntaxKind[RightHandSide]
+ (614,2)SyntaxKind[SymbolSpan]
+ (614,2)SyntaxKind[Nonterminal]
+ (614,2)SyntaxKind[Identifier](text = "IfStatement")
+ (614,13)SyntaxKind[ArgumentList]
+ (614,13)SyntaxKind[OpenBracketToken]
+ (614,14)SyntaxKind[Argument]?
+ (614,14)SyntaxKind[QuestionToken]
+ (614,15)SyntaxKind[Identifier](text = "Yield")
+ (614,22)SyntaxKind[Argument]?
+ (614,22)SyntaxKind[QuestionToken]
+ (614,23)SyntaxKind[Identifier](text = "Return")
+ (614,29)SyntaxKind[CloseBracketToken]
+ (615,2)SyntaxKind[RightHandSide]
+ (615,2)SyntaxKind[SymbolSpan]
+ (615,2)SyntaxKind[Nonterminal]
+ (615,2)SyntaxKind[Identifier](text = "BreakableStatement")
+ (615,20)SyntaxKind[ArgumentList]
+ (615,20)SyntaxKind[OpenBracketToken]
+ (615,21)SyntaxKind[Argument]?
+ (615,21)SyntaxKind[QuestionToken]
+ (615,22)SyntaxKind[Identifier](text = "Yield")
+ (615,29)SyntaxKind[Argument]?
+ (615,29)SyntaxKind[QuestionToken]
+ (615,30)SyntaxKind[Identifier](text = "Return")
+ (615,36)SyntaxKind[CloseBracketToken]
+ (616,2)SyntaxKind[RightHandSide]
+ (616,2)SyntaxKind[SymbolSpan]
+ (616,2)SyntaxKind[Nonterminal]
+ (616,2)SyntaxKind[Identifier](text = "ContinueStatement")
+ (616,19)SyntaxKind[ArgumentList]
+ (616,19)SyntaxKind[OpenBracketToken]
+ (616,20)SyntaxKind[Argument]?
+ (616,20)SyntaxKind[QuestionToken]
+ (616,21)SyntaxKind[Identifier](text = "Yield")
+ (616,26)SyntaxKind[CloseBracketToken]
+ (617,2)SyntaxKind[RightHandSide]
+ (617,2)SyntaxKind[SymbolSpan]
+ (617,2)SyntaxKind[Nonterminal]
+ (617,2)SyntaxKind[Identifier](text = "BreakStatement")
+ (617,16)SyntaxKind[ArgumentList]
+ (617,16)SyntaxKind[OpenBracketToken]
+ (617,17)SyntaxKind[Argument]?
+ (617,17)SyntaxKind[QuestionToken]
+ (617,18)SyntaxKind[Identifier](text = "Yield")
+ (617,23)SyntaxKind[CloseBracketToken]
+ (618,2)SyntaxKind[RightHandSide]
+ (618,2)SyntaxKind[SymbolSpan]
+ (618,2)SyntaxKind[ParameterValueAssertion]
+ (618,2)SyntaxKind[OpenBracketToken]
+ (618,3)SyntaxKind[PlusToken]
+ (618,4)SyntaxKind[Identifier](text = "Return")
+ (618,10)SyntaxKind[CloseBracketToken]
+ (618,12)SyntaxKind[SymbolSpan]
+ (618,12)SyntaxKind[Nonterminal]
+ (618,12)SyntaxKind[Identifier](text = "ReturnStatement")
+ (618,27)SyntaxKind[ArgumentList]
+ (618,27)SyntaxKind[OpenBracketToken]
+ (618,28)SyntaxKind[Argument]?
+ (618,28)SyntaxKind[QuestionToken]
+ (618,29)SyntaxKind[Identifier](text = "Yield")
+ (618,34)SyntaxKind[CloseBracketToken]
+ (619,2)SyntaxKind[RightHandSide]
+ (619,2)SyntaxKind[SymbolSpan]
+ (619,2)SyntaxKind[Nonterminal]
+ (619,2)SyntaxKind[Identifier](text = "WithStatement")
+ (619,15)SyntaxKind[ArgumentList]
+ (619,15)SyntaxKind[OpenBracketToken]
+ (619,16)SyntaxKind[Argument]?
+ (619,16)SyntaxKind[QuestionToken]
+ (619,17)SyntaxKind[Identifier](text = "Yield")
+ (619,24)SyntaxKind[Argument]?
+ (619,24)SyntaxKind[QuestionToken]
+ (619,25)SyntaxKind[Identifier](text = "Return")
+ (619,31)SyntaxKind[CloseBracketToken]
+ (620,2)SyntaxKind[RightHandSide]
+ (620,2)SyntaxKind[SymbolSpan]
+ (620,2)SyntaxKind[Nonterminal]
+ (620,2)SyntaxKind[Identifier](text = "LabelledStatement")
+ (620,19)SyntaxKind[ArgumentList]
+ (620,19)SyntaxKind[OpenBracketToken]
+ (620,20)SyntaxKind[Argument]?
+ (620,20)SyntaxKind[QuestionToken]
+ (620,21)SyntaxKind[Identifier](text = "Yield")
+ (620,28)SyntaxKind[Argument]?
+ (620,28)SyntaxKind[QuestionToken]
+ (620,29)SyntaxKind[Identifier](text = "Return")
+ (620,35)SyntaxKind[CloseBracketToken]
+ (621,2)SyntaxKind[RightHandSide]
+ (621,2)SyntaxKind[SymbolSpan]
+ (621,2)SyntaxKind[Nonterminal]
+ (621,2)SyntaxKind[Identifier](text = "ThrowStatement")
+ (621,16)SyntaxKind[ArgumentList]
+ (621,16)SyntaxKind[OpenBracketToken]
+ (621,17)SyntaxKind[Argument]?
+ (621,17)SyntaxKind[QuestionToken]
+ (621,18)SyntaxKind[Identifier](text = "Yield")
+ (621,23)SyntaxKind[CloseBracketToken]
+ (622,2)SyntaxKind[RightHandSide]
+ (622,2)SyntaxKind[SymbolSpan]
+ (622,2)SyntaxKind[Nonterminal]
+ (622,2)SyntaxKind[Identifier](text = "TryStatement")
+ (622,14)SyntaxKind[ArgumentList]
+ (622,14)SyntaxKind[OpenBracketToken]
+ (622,15)SyntaxKind[Argument]?
+ (622,15)SyntaxKind[QuestionToken]
+ (622,16)SyntaxKind[Identifier](text = "Yield")
+ (622,23)SyntaxKind[Argument]?
+ (622,23)SyntaxKind[QuestionToken]
+ (622,24)SyntaxKind[Identifier](text = "Return")
+ (622,30)SyntaxKind[CloseBracketToken]
+ (623,2)SyntaxKind[RightHandSide]
+ (623,2)SyntaxKind[SymbolSpan]
+ (623,2)SyntaxKind[Nonterminal]
+ (623,2)SyntaxKind[Identifier](text = "DebuggerStatement")
+ (624,1)SyntaxKind[DedentToken]
+ (625,1)SyntaxKind[Production]
+ (625,1)SyntaxKind[Identifier](text = "Declaration")
+ (625,12)SyntaxKind[ParameterList]
+ (625,12)SyntaxKind[OpenBracketToken]
+ (625,13)SyntaxKind[Parameter]
+ (625,13)SyntaxKind[Identifier](text = "Yield")
+ (625,18)SyntaxKind[CloseBracketToken]
+ (626,1)SyntaxKind[RightHandSideList]
+ (626,1)SyntaxKind[IndentToken]
+ (626,2)SyntaxKind[RightHandSide]
+ (626,2)SyntaxKind[SymbolSpan]
+ (626,2)SyntaxKind[Nonterminal]
+ (626,2)SyntaxKind[Identifier](text = "HoistableDeclaration")
+ (626,22)SyntaxKind[ArgumentList]
+ (626,22)SyntaxKind[OpenBracketToken]
+ (626,23)SyntaxKind[Argument]?
+ (626,23)SyntaxKind[QuestionToken]
+ (626,24)SyntaxKind[Identifier](text = "Yield")
+ (626,29)SyntaxKind[CloseBracketToken]
+ (627,2)SyntaxKind[RightHandSide]
+ (627,2)SyntaxKind[SymbolSpan]
+ (627,2)SyntaxKind[Nonterminal]
+ (627,2)SyntaxKind[Identifier](text = "ClassDeclaration")
+ (627,18)SyntaxKind[ArgumentList]
+ (627,18)SyntaxKind[OpenBracketToken]
+ (627,19)SyntaxKind[Argument]?
+ (627,19)SyntaxKind[QuestionToken]
+ (627,20)SyntaxKind[Identifier](text = "Yield")
+ (627,25)SyntaxKind[CloseBracketToken]
+ (628,2)SyntaxKind[RightHandSide]
+ (628,2)SyntaxKind[SymbolSpan]
+ (628,2)SyntaxKind[Nonterminal]
+ (628,2)SyntaxKind[Identifier](text = "LexicalDeclaration")
+ (628,20)SyntaxKind[ArgumentList]
+ (628,20)SyntaxKind[OpenBracketToken]
+ (628,21)SyntaxKind[Argument]
+ (628,21)SyntaxKind[Identifier](text = "In")
+ (628,25)SyntaxKind[Argument]?
+ (628,25)SyntaxKind[QuestionToken]
+ (628,26)SyntaxKind[Identifier](text = "Yield")
+ (628,31)SyntaxKind[CloseBracketToken]
+ (629,1)SyntaxKind[DedentToken]
+ (630,1)SyntaxKind[Production]
+ (630,1)SyntaxKind[Identifier](text = "HoistableDeclaration")
+ (630,21)SyntaxKind[ParameterList]
+ (630,21)SyntaxKind[OpenBracketToken]
+ (630,22)SyntaxKind[Parameter]
+ (630,22)SyntaxKind[Identifier](text = "Yield")
+ (630,29)SyntaxKind[Parameter]
+ (630,29)SyntaxKind[Identifier](text = "Default")
+ (630,36)SyntaxKind[CloseBracketToken]
+ (631,1)SyntaxKind[RightHandSideList]
+ (631,1)SyntaxKind[IndentToken]
+ (631,2)SyntaxKind[RightHandSide]
+ (631,2)SyntaxKind[SymbolSpan]
+ (631,2)SyntaxKind[Nonterminal]
+ (631,2)SyntaxKind[Identifier](text = "FunctionDeclaration")
+ (631,21)SyntaxKind[ArgumentList]
+ (631,21)SyntaxKind[OpenBracketToken]
+ (631,22)SyntaxKind[Argument]?
+ (631,22)SyntaxKind[QuestionToken]
+ (631,23)SyntaxKind[Identifier](text = "Yield")
+ (631,30)SyntaxKind[Argument]?
+ (631,30)SyntaxKind[QuestionToken]
+ (631,31)SyntaxKind[Identifier](text = "Default")
+ (631,38)SyntaxKind[CloseBracketToken]
+ (632,2)SyntaxKind[RightHandSide]
+ (632,2)SyntaxKind[SymbolSpan]
+ (632,2)SyntaxKind[Nonterminal]
+ (632,2)SyntaxKind[Identifier](text = "GeneratorDeclaration")
+ (632,22)SyntaxKind[ArgumentList]
+ (632,22)SyntaxKind[OpenBracketToken]
+ (632,23)SyntaxKind[Argument]?
+ (632,23)SyntaxKind[QuestionToken]
+ (632,24)SyntaxKind[Identifier](text = "Yield")
+ (632,31)SyntaxKind[Argument]?
+ (632,31)SyntaxKind[QuestionToken]
+ (632,32)SyntaxKind[Identifier](text = "Default")
+ (632,39)SyntaxKind[CloseBracketToken]
+ (633,1)SyntaxKind[DedentToken]
+ (634,1)SyntaxKind[Production]
+ (634,1)SyntaxKind[Identifier](text = "BreakableStatement")
+ (634,19)SyntaxKind[ParameterList]
+ (634,19)SyntaxKind[OpenBracketToken]
+ (634,20)SyntaxKind[Parameter]
+ (634,20)SyntaxKind[Identifier](text = "Yield")
+ (634,27)SyntaxKind[Parameter]
+ (634,27)SyntaxKind[Identifier](text = "Return")
+ (634,33)SyntaxKind[CloseBracketToken]
+ (635,1)SyntaxKind[RightHandSideList]
+ (635,1)SyntaxKind[IndentToken]
+ (635,2)SyntaxKind[RightHandSide]
+ (635,2)SyntaxKind[SymbolSpan]
+ (635,2)SyntaxKind[Nonterminal]
+ (635,2)SyntaxKind[Identifier](text = "IterationStatement")
+ (635,20)SyntaxKind[ArgumentList]
+ (635,20)SyntaxKind[OpenBracketToken]
+ (635,21)SyntaxKind[Argument]?
+ (635,21)SyntaxKind[QuestionToken]
+ (635,22)SyntaxKind[Identifier](text = "Yield")
+ (635,29)SyntaxKind[Argument]?
+ (635,29)SyntaxKind[QuestionToken]
+ (635,30)SyntaxKind[Identifier](text = "Return")
+ (635,36)SyntaxKind[CloseBracketToken]
+ (636,2)SyntaxKind[RightHandSide]
+ (636,2)SyntaxKind[SymbolSpan]
+ (636,2)SyntaxKind[Nonterminal]
+ (636,2)SyntaxKind[Identifier](text = "SwitchStatement")
+ (636,17)SyntaxKind[ArgumentList]
+ (636,17)SyntaxKind[OpenBracketToken]
+ (636,18)SyntaxKind[Argument]?
+ (636,18)SyntaxKind[QuestionToken]
+ (636,19)SyntaxKind[Identifier](text = "Yield")
+ (636,26)SyntaxKind[Argument]?
+ (636,26)SyntaxKind[QuestionToken]
+ (636,27)SyntaxKind[Identifier](text = "Return")
+ (636,33)SyntaxKind[CloseBracketToken]
+ (637,1)SyntaxKind[DedentToken]
+ (638,1)SyntaxKind[Production]
+ (638,1)SyntaxKind[Identifier](text = "BlockStatement")
+ (638,15)SyntaxKind[ParameterList]
+ (638,15)SyntaxKind[OpenBracketToken]
+ (638,16)SyntaxKind[Parameter]
+ (638,16)SyntaxKind[Identifier](text = "Yield")
+ (638,23)SyntaxKind[Parameter]
+ (638,23)SyntaxKind[Identifier](text = "Return")
+ (638,29)SyntaxKind[CloseBracketToken]
+ (639,1)SyntaxKind[RightHandSideList]
+ (639,1)SyntaxKind[IndentToken]
+ (639,2)SyntaxKind[RightHandSide]
+ (639,2)SyntaxKind[SymbolSpan]
+ (639,2)SyntaxKind[Nonterminal]
+ (639,2)SyntaxKind[Identifier](text = "Block")
+ (639,7)SyntaxKind[ArgumentList]
+ (639,7)SyntaxKind[OpenBracketToken]
+ (639,8)SyntaxKind[Argument]?
+ (639,8)SyntaxKind[QuestionToken]
+ (639,9)SyntaxKind[Identifier](text = "Yield")
+ (639,16)SyntaxKind[Argument]?
+ (639,16)SyntaxKind[QuestionToken]
+ (639,17)SyntaxKind[Identifier](text = "Return")
+ (639,23)SyntaxKind[CloseBracketToken]
+ (640,1)SyntaxKind[DedentToken]
+ (641,1)SyntaxKind[Production]
+ (641,1)SyntaxKind[Identifier](text = "Block")
+ (641,6)SyntaxKind[ParameterList]
+ (641,6)SyntaxKind[OpenBracketToken]
+ (641,7)SyntaxKind[Parameter]
+ (641,7)SyntaxKind[Identifier](text = "Yield")
+ (641,14)SyntaxKind[Parameter]
+ (641,14)SyntaxKind[Identifier](text = "Return")
+ (641,20)SyntaxKind[CloseBracketToken]
+ (642,1)SyntaxKind[RightHandSideList]
+ (642,1)SyntaxKind[IndentToken]
+ (642,2)SyntaxKind[RightHandSide]
+ (642,2)SyntaxKind[SymbolSpan]
+ (642,2)SyntaxKind[Terminal](text = "{")
+ (642,6)SyntaxKind[SymbolSpan]
+ (642,6)SyntaxKind[Nonterminal]?
+ (642,6)SyntaxKind[Identifier](text = "StatementList")
+ (642,19)SyntaxKind[ArgumentList]
+ (642,19)SyntaxKind[OpenBracketToken]
+ (642,20)SyntaxKind[Argument]?
+ (642,20)SyntaxKind[QuestionToken]
+ (642,21)SyntaxKind[Identifier](text = "Yield")
+ (642,28)SyntaxKind[Argument]?
+ (642,28)SyntaxKind[QuestionToken]
+ (642,29)SyntaxKind[Identifier](text = "Return")
+ (642,35)SyntaxKind[CloseBracketToken]
+ (642,36)SyntaxKind[QuestionToken]
+ (642,38)SyntaxKind[SymbolSpan]
+ (642,38)SyntaxKind[Terminal](text = "}")
+ (643,1)SyntaxKind[DedentToken]
+ (644,1)SyntaxKind[Production]
+ (644,1)SyntaxKind[Identifier](text = "StatementList")
+ (644,14)SyntaxKind[ParameterList]
+ (644,14)SyntaxKind[OpenBracketToken]
+ (644,15)SyntaxKind[Parameter]
+ (644,15)SyntaxKind[Identifier](text = "Yield")
+ (644,22)SyntaxKind[Parameter]
+ (644,22)SyntaxKind[Identifier](text = "Return")
+ (644,28)SyntaxKind[CloseBracketToken]
+ (645,1)SyntaxKind[RightHandSideList]
+ (645,1)SyntaxKind[IndentToken]
+ (645,2)SyntaxKind[RightHandSide]
+ (645,2)SyntaxKind[SymbolSpan]
+ (645,2)SyntaxKind[Nonterminal]
+ (645,2)SyntaxKind[Identifier](text = "StatementListItem")
+ (645,19)SyntaxKind[ArgumentList]
+ (645,19)SyntaxKind[OpenBracketToken]
+ (645,20)SyntaxKind[Argument]?
+ (645,20)SyntaxKind[QuestionToken]
+ (645,21)SyntaxKind[Identifier](text = "Yield")
+ (645,28)SyntaxKind[Argument]?
+ (645,28)SyntaxKind[QuestionToken]
+ (645,29)SyntaxKind[Identifier](text = "Return")
+ (645,35)SyntaxKind[CloseBracketToken]
+ (646,2)SyntaxKind[RightHandSide]
+ (646,2)SyntaxKind[SymbolSpan]
+ (646,2)SyntaxKind[Nonterminal]
+ (646,2)SyntaxKind[Identifier](text = "StatementList")
+ (646,15)SyntaxKind[ArgumentList]
+ (646,15)SyntaxKind[OpenBracketToken]
+ (646,16)SyntaxKind[Argument]?
+ (646,16)SyntaxKind[QuestionToken]
+ (646,17)SyntaxKind[Identifier](text = "Yield")
+ (646,24)SyntaxKind[Argument]?
+ (646,24)SyntaxKind[QuestionToken]
+ (646,25)SyntaxKind[Identifier](text = "Return")
+ (646,31)SyntaxKind[CloseBracketToken]
+ (646,33)SyntaxKind[SymbolSpan]
+ (646,33)SyntaxKind[Nonterminal]
+ (646,33)SyntaxKind[Identifier](text = "StatementListItem")
+ (646,50)SyntaxKind[ArgumentList]
+ (646,50)SyntaxKind[OpenBracketToken]
+ (646,51)SyntaxKind[Argument]?
+ (646,51)SyntaxKind[QuestionToken]
+ (646,52)SyntaxKind[Identifier](text = "Yield")
+ (646,59)SyntaxKind[Argument]?
+ (646,59)SyntaxKind[QuestionToken]
+ (646,60)SyntaxKind[Identifier](text = "Return")
+ (646,66)SyntaxKind[CloseBracketToken]
+ (647,1)SyntaxKind[DedentToken]
+ (648,1)SyntaxKind[Production]
+ (648,1)SyntaxKind[Identifier](text = "StatementListItem")
+ (648,18)SyntaxKind[ParameterList]
+ (648,18)SyntaxKind[OpenBracketToken]
+ (648,19)SyntaxKind[Parameter]
+ (648,19)SyntaxKind[Identifier](text = "Yield")
+ (648,26)SyntaxKind[Parameter]
+ (648,26)SyntaxKind[Identifier](text = "Return")
+ (648,32)SyntaxKind[CloseBracketToken]
+ (649,1)SyntaxKind[RightHandSideList]
+ (649,1)SyntaxKind[IndentToken]
+ (649,2)SyntaxKind[RightHandSide]
+ (649,2)SyntaxKind[SymbolSpan]
+ (649,2)SyntaxKind[Nonterminal]
+ (649,2)SyntaxKind[Identifier](text = "Statement")
+ (649,11)SyntaxKind[ArgumentList]
+ (649,11)SyntaxKind[OpenBracketToken]
+ (649,12)SyntaxKind[Argument]?
+ (649,12)SyntaxKind[QuestionToken]
+ (649,13)SyntaxKind[Identifier](text = "Yield")
+ (649,20)SyntaxKind[Argument]?
+ (649,20)SyntaxKind[QuestionToken]
+ (649,21)SyntaxKind[Identifier](text = "Return")
+ (649,27)SyntaxKind[CloseBracketToken]
+ (650,2)SyntaxKind[RightHandSide]
+ (650,2)SyntaxKind[SymbolSpan]
+ (650,2)SyntaxKind[Nonterminal]
+ (650,2)SyntaxKind[Identifier](text = "Declaration")
+ (650,13)SyntaxKind[ArgumentList]
+ (650,13)SyntaxKind[OpenBracketToken]
+ (650,14)SyntaxKind[Argument]?
+ (650,14)SyntaxKind[QuestionToken]
+ (650,15)SyntaxKind[Identifier](text = "Yield")
+ (650,20)SyntaxKind[CloseBracketToken]
+ (651,1)SyntaxKind[DedentToken]
+ (652,1)SyntaxKind[Production]
+ (652,1)SyntaxKind[Identifier](text = "LexicalDeclaration")
+ (652,19)SyntaxKind[ParameterList]
+ (652,19)SyntaxKind[OpenBracketToken]
+ (652,20)SyntaxKind[Parameter]
+ (652,20)SyntaxKind[Identifier](text = "In")
+ (652,24)SyntaxKind[Parameter]
+ (652,24)SyntaxKind[Identifier](text = "Yield")
+ (652,29)SyntaxKind[CloseBracketToken]
+ (653,1)SyntaxKind[RightHandSideList]
+ (653,1)SyntaxKind[IndentToken]
+ (653,2)SyntaxKind[RightHandSide]
+ (653,2)SyntaxKind[SymbolSpan]
+ (653,2)SyntaxKind[Nonterminal]
+ (653,2)SyntaxKind[Identifier](text = "LetOrConst")
+ (653,13)SyntaxKind[SymbolSpan]
+ (653,13)SyntaxKind[Nonterminal]
+ (653,13)SyntaxKind[Identifier](text = "BindingList")
+ (653,24)SyntaxKind[ArgumentList]
+ (653,24)SyntaxKind[OpenBracketToken]
+ (653,25)SyntaxKind[Argument]?
+ (653,25)SyntaxKind[QuestionToken]
+ (653,26)SyntaxKind[Identifier](text = "In")
+ (653,30)SyntaxKind[Argument]?
+ (653,30)SyntaxKind[QuestionToken]
+ (653,31)SyntaxKind[Identifier](text = "Yield")
+ (653,36)SyntaxKind[CloseBracketToken]
+ (653,38)SyntaxKind[SymbolSpan]
+ (653,38)SyntaxKind[Terminal](text = ";")
+ (654,1)SyntaxKind[DedentToken]
+ (655,1)SyntaxKind[Production]
+ (655,1)SyntaxKind[Identifier](text = "LetOrConst")
+ (656,1)SyntaxKind[RightHandSideList]
+ (656,1)SyntaxKind[IndentToken]
+ (656,2)SyntaxKind[RightHandSide]
+ (656,2)SyntaxKind[SymbolSpan]
+ (656,2)SyntaxKind[Terminal](text = "let")
+ (657,2)SyntaxKind[RightHandSide]
+ (657,2)SyntaxKind[SymbolSpan]
+ (657,2)SyntaxKind[Terminal](text = "const")
+ (658,1)SyntaxKind[DedentToken]
+ (659,1)SyntaxKind[Production]
+ (659,1)SyntaxKind[Identifier](text = "BindingList")
+ (659,12)SyntaxKind[ParameterList]
+ (659,12)SyntaxKind[OpenBracketToken]
+ (659,13)SyntaxKind[Parameter]
+ (659,13)SyntaxKind[Identifier](text = "In")
+ (659,17)SyntaxKind[Parameter]
+ (659,17)SyntaxKind[Identifier](text = "Yield")
+ (659,22)SyntaxKind[CloseBracketToken]
+ (660,1)SyntaxKind[RightHandSideList]
+ (660,1)SyntaxKind[IndentToken]
+ (660,2)SyntaxKind[RightHandSide]
+ (660,2)SyntaxKind[SymbolSpan]
+ (660,2)SyntaxKind[Nonterminal]
+ (660,2)SyntaxKind[Identifier](text = "LexicalBinding")
+ (660,16)SyntaxKind[ArgumentList]
+ (660,16)SyntaxKind[OpenBracketToken]
+ (660,17)SyntaxKind[Argument]?
+ (660,17)SyntaxKind[QuestionToken]
+ (660,18)SyntaxKind[Identifier](text = "In")
+ (660,22)SyntaxKind[Argument]?
+ (660,22)SyntaxKind[QuestionToken]
+ (660,23)SyntaxKind[Identifier](text = "Yield")
+ (660,28)SyntaxKind[CloseBracketToken]
+ (661,2)SyntaxKind[RightHandSide]
+ (661,2)SyntaxKind[SymbolSpan]
+ (661,2)SyntaxKind[Nonterminal]
+ (661,2)SyntaxKind[Identifier](text = "BindingList")
+ (661,13)SyntaxKind[ArgumentList]
+ (661,13)SyntaxKind[OpenBracketToken]
+ (661,14)SyntaxKind[Argument]?
+ (661,14)SyntaxKind[QuestionToken]
+ (661,15)SyntaxKind[Identifier](text = "In")
+ (661,19)SyntaxKind[Argument]?
+ (661,19)SyntaxKind[QuestionToken]
+ (661,20)SyntaxKind[Identifier](text = "Yield")
+ (661,25)SyntaxKind[CloseBracketToken]
+ (661,27)SyntaxKind[SymbolSpan]
+ (661,27)SyntaxKind[Terminal](text = ",")
+ (661,31)SyntaxKind[SymbolSpan]
+ (661,31)SyntaxKind[Nonterminal]
+ (661,31)SyntaxKind[Identifier](text = "LexicalBinding")
+ (661,45)SyntaxKind[ArgumentList]
+ (661,45)SyntaxKind[OpenBracketToken]
+ (661,46)SyntaxKind[Argument]?
+ (661,46)SyntaxKind[QuestionToken]
+ (661,47)SyntaxKind[Identifier](text = "In")
+ (661,51)SyntaxKind[Argument]?
+ (661,51)SyntaxKind[QuestionToken]
+ (661,52)SyntaxKind[Identifier](text = "Yield")
+ (661,57)SyntaxKind[CloseBracketToken]
+ (662,1)SyntaxKind[DedentToken]
+ (663,1)SyntaxKind[Production]
+ (663,1)SyntaxKind[Identifier](text = "LexicalBinding")
+ (663,15)SyntaxKind[ParameterList]
+ (663,15)SyntaxKind[OpenBracketToken]
+ (663,16)SyntaxKind[Parameter]
+ (663,16)SyntaxKind[Identifier](text = "In")
+ (663,20)SyntaxKind[Parameter]
+ (663,20)SyntaxKind[Identifier](text = "Yield")
+ (663,25)SyntaxKind[CloseBracketToken]
+ (664,1)SyntaxKind[RightHandSideList]
+ (664,1)SyntaxKind[IndentToken]
+ (664,2)SyntaxKind[RightHandSide]
+ (664,2)SyntaxKind[SymbolSpan]
+ (664,2)SyntaxKind[Nonterminal]
+ (664,2)SyntaxKind[Identifier](text = "BindingIdentifier")
+ (664,19)SyntaxKind[ArgumentList]
+ (664,19)SyntaxKind[OpenBracketToken]
+ (664,20)SyntaxKind[Argument]?
+ (664,20)SyntaxKind[QuestionToken]
+ (664,21)SyntaxKind[Identifier](text = "Yield")
+ (664,26)SyntaxKind[CloseBracketToken]
+ (664,28)SyntaxKind[SymbolSpan]
+ (664,28)SyntaxKind[Nonterminal]?
+ (664,28)SyntaxKind[Identifier](text = "Initializer")
+ (664,39)SyntaxKind[ArgumentList]
+ (664,39)SyntaxKind[OpenBracketToken]
+ (664,40)SyntaxKind[Argument]?
+ (664,40)SyntaxKind[QuestionToken]
+ (664,41)SyntaxKind[Identifier](text = "In")
+ (664,45)SyntaxKind[Argument]?
+ (664,45)SyntaxKind[QuestionToken]
+ (664,46)SyntaxKind[Identifier](text = "Yield")
+ (664,51)SyntaxKind[CloseBracketToken]
+ (664,52)SyntaxKind[QuestionToken]
+ (665,2)SyntaxKind[RightHandSide]
+ (665,2)SyntaxKind[SymbolSpan]
+ (665,2)SyntaxKind[Nonterminal]
+ (665,2)SyntaxKind[Identifier](text = "BindingPattern")
+ (665,16)SyntaxKind[ArgumentList]
+ (665,16)SyntaxKind[OpenBracketToken]
+ (665,17)SyntaxKind[Argument]?
+ (665,17)SyntaxKind[QuestionToken]
+ (665,18)SyntaxKind[Identifier](text = "Yield")
+ (665,23)SyntaxKind[CloseBracketToken]
+ (665,25)SyntaxKind[SymbolSpan]
+ (665,25)SyntaxKind[Nonterminal]
+ (665,25)SyntaxKind[Identifier](text = "Initializer")
+ (665,36)SyntaxKind[ArgumentList]
+ (665,36)SyntaxKind[OpenBracketToken]
+ (665,37)SyntaxKind[Argument]?
+ (665,37)SyntaxKind[QuestionToken]
+ (665,38)SyntaxKind[Identifier](text = "In")
+ (665,42)SyntaxKind[Argument]?
+ (665,42)SyntaxKind[QuestionToken]
+ (665,43)SyntaxKind[Identifier](text = "Yield")
+ (665,48)SyntaxKind[CloseBracketToken]
+ (666,1)SyntaxKind[DedentToken]
+ (667,1)SyntaxKind[Production]
+ (667,1)SyntaxKind[Identifier](text = "VariableStatement")
+ (667,18)SyntaxKind[ParameterList]
+ (667,18)SyntaxKind[OpenBracketToken]
+ (667,19)SyntaxKind[Parameter]
+ (667,19)SyntaxKind[Identifier](text = "Yield")
+ (667,24)SyntaxKind[CloseBracketToken]
+ (668,1)SyntaxKind[RightHandSideList]
+ (668,1)SyntaxKind[IndentToken]
+ (668,2)SyntaxKind[RightHandSide]
+ (668,2)SyntaxKind[SymbolSpan]
+ (668,2)SyntaxKind[Terminal](text = "var")
+ (668,8)SyntaxKind[SymbolSpan]
+ (668,8)SyntaxKind[Nonterminal]
+ (668,8)SyntaxKind[Identifier](text = "VariableDeclarationList")
+ (668,31)SyntaxKind[ArgumentList]
+ (668,31)SyntaxKind[OpenBracketToken]
+ (668,32)SyntaxKind[Argument]
+ (668,32)SyntaxKind[Identifier](text = "In")
+ (668,36)SyntaxKind[Argument]?
+ (668,36)SyntaxKind[QuestionToken]
+ (668,37)SyntaxKind[Identifier](text = "Yield")
+ (668,42)SyntaxKind[CloseBracketToken]
+ (668,44)SyntaxKind[SymbolSpan]
+ (668,44)SyntaxKind[Terminal](text = ";")
+ (669,1)SyntaxKind[DedentToken]
+ (670,1)SyntaxKind[Production]
+ (670,1)SyntaxKind[Identifier](text = "VariableDeclarationList")
+ (670,24)SyntaxKind[ParameterList]
+ (670,24)SyntaxKind[OpenBracketToken]
+ (670,25)SyntaxKind[Parameter]
+ (670,25)SyntaxKind[Identifier](text = "In")
+ (670,29)SyntaxKind[Parameter]
+ (670,29)SyntaxKind[Identifier](text = "Yield")
+ (670,34)SyntaxKind[CloseBracketToken]
+ (671,1)SyntaxKind[RightHandSideList]
+ (671,1)SyntaxKind[IndentToken]
+ (671,2)SyntaxKind[RightHandSide]
+ (671,2)SyntaxKind[SymbolSpan]
+ (671,2)SyntaxKind[Nonterminal]
+ (671,2)SyntaxKind[Identifier](text = "VariableDeclaration")
+ (671,21)SyntaxKind[ArgumentList]
+ (671,21)SyntaxKind[OpenBracketToken]
+ (671,22)SyntaxKind[Argument]?
+ (671,22)SyntaxKind[QuestionToken]
+ (671,23)SyntaxKind[Identifier](text = "In")
+ (671,27)SyntaxKind[Argument]?
+ (671,27)SyntaxKind[QuestionToken]
+ (671,28)SyntaxKind[Identifier](text = "Yield")
+ (671,33)SyntaxKind[CloseBracketToken]
+ (672,2)SyntaxKind[RightHandSide]
+ (672,2)SyntaxKind[SymbolSpan]
+ (672,2)SyntaxKind[Nonterminal]
+ (672,2)SyntaxKind[Identifier](text = "VariableDeclarationList")
+ (672,25)SyntaxKind[ArgumentList]
+ (672,25)SyntaxKind[OpenBracketToken]
+ (672,26)SyntaxKind[Argument]?
+ (672,26)SyntaxKind[QuestionToken]
+ (672,27)SyntaxKind[Identifier](text = "In")
+ (672,31)SyntaxKind[Argument]?
+ (672,31)SyntaxKind[QuestionToken]
+ (672,32)SyntaxKind[Identifier](text = "Yield")
+ (672,37)SyntaxKind[CloseBracketToken]
+ (672,39)SyntaxKind[SymbolSpan]
+ (672,39)SyntaxKind[Terminal](text = ",")
+ (672,43)SyntaxKind[SymbolSpan]
+ (672,43)SyntaxKind[Nonterminal]
+ (672,43)SyntaxKind[Identifier](text = "VariableDeclaration")
+ (672,62)SyntaxKind[ArgumentList]
+ (672,62)SyntaxKind[OpenBracketToken]
+ (672,63)SyntaxKind[Argument]?
+ (672,63)SyntaxKind[QuestionToken]
+ (672,64)SyntaxKind[Identifier](text = "In")
+ (672,68)SyntaxKind[Argument]?
+ (672,68)SyntaxKind[QuestionToken]
+ (672,69)SyntaxKind[Identifier](text = "Yield")
+ (672,74)SyntaxKind[CloseBracketToken]
+ (673,1)SyntaxKind[DedentToken]
+ (674,1)SyntaxKind[Production]
+ (674,1)SyntaxKind[Identifier](text = "VariableDeclaration")
+ (674,20)SyntaxKind[ParameterList]
+ (674,20)SyntaxKind[OpenBracketToken]
+ (674,21)SyntaxKind[Parameter]
+ (674,21)SyntaxKind[Identifier](text = "In")
+ (674,25)SyntaxKind[Parameter]
+ (674,25)SyntaxKind[Identifier](text = "Yield")
+ (674,30)SyntaxKind[CloseBracketToken]
+ (675,1)SyntaxKind[RightHandSideList]
+ (675,1)SyntaxKind[IndentToken]
+ (675,2)SyntaxKind[RightHandSide]
+ (675,2)SyntaxKind[SymbolSpan]
+ (675,2)SyntaxKind[Nonterminal]
+ (675,2)SyntaxKind[Identifier](text = "BindingIdentifier")
+ (675,19)SyntaxKind[ArgumentList]
+ (675,19)SyntaxKind[OpenBracketToken]
+ (675,20)SyntaxKind[Argument]?
+ (675,20)SyntaxKind[QuestionToken]
+ (675,21)SyntaxKind[Identifier](text = "Yield")
+ (675,26)SyntaxKind[CloseBracketToken]
+ (675,28)SyntaxKind[SymbolSpan]
+ (675,28)SyntaxKind[Nonterminal]?
+ (675,28)SyntaxKind[Identifier](text = "Initializer")
+ (675,39)SyntaxKind[ArgumentList]
+ (675,39)SyntaxKind[OpenBracketToken]
+ (675,40)SyntaxKind[Argument]?
+ (675,40)SyntaxKind[QuestionToken]
+ (675,41)SyntaxKind[Identifier](text = "In")
+ (675,45)SyntaxKind[Argument]?
+ (675,45)SyntaxKind[QuestionToken]
+ (675,46)SyntaxKind[Identifier](text = "Yield")
+ (675,51)SyntaxKind[CloseBracketToken]
+ (675,52)SyntaxKind[QuestionToken]
+ (676,2)SyntaxKind[RightHandSide]
+ (676,2)SyntaxKind[SymbolSpan]
+ (676,2)SyntaxKind[Nonterminal]
+ (676,2)SyntaxKind[Identifier](text = "BindingPattern")
+ (676,16)SyntaxKind[ArgumentList]
+ (676,16)SyntaxKind[OpenBracketToken]
+ (676,17)SyntaxKind[Argument]?
+ (676,17)SyntaxKind[QuestionToken]
+ (676,18)SyntaxKind[Identifier](text = "Yield")
+ (676,23)SyntaxKind[CloseBracketToken]
+ (676,25)SyntaxKind[SymbolSpan]
+ (676,25)SyntaxKind[Nonterminal]
+ (676,25)SyntaxKind[Identifier](text = "Initializer")
+ (676,36)SyntaxKind[ArgumentList]
+ (676,36)SyntaxKind[OpenBracketToken]
+ (676,37)SyntaxKind[Argument]?
+ (676,37)SyntaxKind[QuestionToken]
+ (676,38)SyntaxKind[Identifier](text = "In")
+ (676,42)SyntaxKind[Argument]?
+ (676,42)SyntaxKind[QuestionToken]
+ (676,43)SyntaxKind[Identifier](text = "Yield")
+ (676,48)SyntaxKind[CloseBracketToken]
+ (677,1)SyntaxKind[DedentToken]
+ (678,1)SyntaxKind[Production]
+ (678,1)SyntaxKind[Identifier](text = "BindingPattern")
+ (678,15)SyntaxKind[ParameterList]
+ (678,15)SyntaxKind[OpenBracketToken]
+ (678,16)SyntaxKind[Parameter]
+ (678,16)SyntaxKind[Identifier](text = "Yield")
+ (678,21)SyntaxKind[CloseBracketToken]
+ (679,1)SyntaxKind[RightHandSideList]
+ (679,1)SyntaxKind[IndentToken]
+ (679,2)SyntaxKind[RightHandSide]
+ (679,2)SyntaxKind[SymbolSpan]
+ (679,2)SyntaxKind[Nonterminal]
+ (679,2)SyntaxKind[Identifier](text = "ObjectBindingPattern")
+ (679,22)SyntaxKind[ArgumentList]
+ (679,22)SyntaxKind[OpenBracketToken]
+ (679,23)SyntaxKind[Argument]?
+ (679,23)SyntaxKind[QuestionToken]
+ (679,24)SyntaxKind[Identifier](text = "Yield")
+ (679,29)SyntaxKind[CloseBracketToken]
+ (680,2)SyntaxKind[RightHandSide]
+ (680,2)SyntaxKind[SymbolSpan]
+ (680,2)SyntaxKind[Nonterminal]
+ (680,2)SyntaxKind[Identifier](text = "ArrayBindingPattern")
+ (680,21)SyntaxKind[ArgumentList]
+ (680,21)SyntaxKind[OpenBracketToken]
+ (680,22)SyntaxKind[Argument]?
+ (680,22)SyntaxKind[QuestionToken]
+ (680,23)SyntaxKind[Identifier](text = "Yield")
+ (680,28)SyntaxKind[CloseBracketToken]
+ (681,1)SyntaxKind[DedentToken]
+ (682,1)SyntaxKind[Production]
+ (682,1)SyntaxKind[Identifier](text = "ObjectBindingPattern")
+ (682,21)SyntaxKind[ParameterList]
+ (682,21)SyntaxKind[OpenBracketToken]
+ (682,22)SyntaxKind[Parameter]
+ (682,22)SyntaxKind[Identifier](text = "Yield")
+ (682,27)SyntaxKind[CloseBracketToken]
+ (683,1)SyntaxKind[RightHandSideList]
+ (683,1)SyntaxKind[IndentToken]
+ (683,2)SyntaxKind[RightHandSide]
+ (683,2)SyntaxKind[SymbolSpan]
+ (683,2)SyntaxKind[Terminal](text = "{")
+ (683,6)SyntaxKind[SymbolSpan]
+ (683,6)SyntaxKind[Terminal](text = "}")
+ (684,2)SyntaxKind[RightHandSide]
+ (684,2)SyntaxKind[SymbolSpan]
+ (684,2)SyntaxKind[Terminal](text = "{")
+ (684,6)SyntaxKind[SymbolSpan]
+ (684,6)SyntaxKind[Nonterminal]
+ (684,6)SyntaxKind[Identifier](text = "BindingPropertyList")
+ (684,25)SyntaxKind[ArgumentList]
+ (684,25)SyntaxKind[OpenBracketToken]
+ (684,26)SyntaxKind[Argument]?
+ (684,26)SyntaxKind[QuestionToken]
+ (684,27)SyntaxKind[Identifier](text = "Yield")
+ (684,32)SyntaxKind[CloseBracketToken]
+ (684,34)SyntaxKind[SymbolSpan]
+ (684,34)SyntaxKind[Terminal](text = "}")
+ (685,2)SyntaxKind[RightHandSide]
+ (685,2)SyntaxKind[SymbolSpan]
+ (685,2)SyntaxKind[Terminal](text = "{")
+ (685,6)SyntaxKind[SymbolSpan]
+ (685,6)SyntaxKind[Nonterminal]
+ (685,6)SyntaxKind[Identifier](text = "BindingPropertyList")
+ (685,25)SyntaxKind[ArgumentList]
+ (685,25)SyntaxKind[OpenBracketToken]
+ (685,26)SyntaxKind[Argument]?
+ (685,26)SyntaxKind[QuestionToken]
+ (685,27)SyntaxKind[Identifier](text = "Yield")
+ (685,32)SyntaxKind[CloseBracketToken]
+ (685,34)SyntaxKind[SymbolSpan]
+ (685,34)SyntaxKind[Terminal](text = ",")
+ (685,38)SyntaxKind[SymbolSpan]
+ (685,38)SyntaxKind[Terminal](text = "}")
+ (686,1)SyntaxKind[DedentToken]
+ (687,1)SyntaxKind[Production]
+ (687,1)SyntaxKind[Identifier](text = "ArrayBindingPattern")
+ (687,20)SyntaxKind[ParameterList]
+ (687,20)SyntaxKind[OpenBracketToken]
+ (687,21)SyntaxKind[Parameter]
+ (687,21)SyntaxKind[Identifier](text = "Yield")
+ (687,26)SyntaxKind[CloseBracketToken]
+ (688,1)SyntaxKind[RightHandSideList]
+ (688,1)SyntaxKind[IndentToken]
+ (688,2)SyntaxKind[RightHandSide]
+ (688,2)SyntaxKind[SymbolSpan]
+ (688,2)SyntaxKind[Terminal](text = "[")
+ (688,6)SyntaxKind[SymbolSpan]
+ (688,6)SyntaxKind[Nonterminal]?
+ (688,6)SyntaxKind[Identifier](text = "Elision")
+ (688,13)SyntaxKind[QuestionToken]
+ (688,15)SyntaxKind[SymbolSpan]
+ (688,15)SyntaxKind[Nonterminal]?
+ (688,15)SyntaxKind[Identifier](text = "BindingRestElement")
+ (688,33)SyntaxKind[ArgumentList]
+ (688,33)SyntaxKind[OpenBracketToken]
+ (688,34)SyntaxKind[Argument]?
+ (688,34)SyntaxKind[QuestionToken]
+ (688,35)SyntaxKind[Identifier](text = "Yield")
+ (688,40)SyntaxKind[CloseBracketToken]
+ (688,41)SyntaxKind[QuestionToken]
+ (688,43)SyntaxKind[SymbolSpan]
+ (688,43)SyntaxKind[Terminal](text = "]")
+ (689,2)SyntaxKind[RightHandSide]
+ (689,2)SyntaxKind[SymbolSpan]
+ (689,2)SyntaxKind[Terminal](text = "[")
+ (689,6)SyntaxKind[SymbolSpan]
+ (689,6)SyntaxKind[Nonterminal]
+ (689,6)SyntaxKind[Identifier](text = "BindingElementList")
+ (689,24)SyntaxKind[ArgumentList]
+ (689,24)SyntaxKind[OpenBracketToken]
+ (689,25)SyntaxKind[Argument]?
+ (689,25)SyntaxKind[QuestionToken]
+ (689,26)SyntaxKind[Identifier](text = "Yield")
+ (689,31)SyntaxKind[CloseBracketToken]
+ (689,33)SyntaxKind[SymbolSpan]
+ (689,33)SyntaxKind[Terminal](text = "]")
+ (690,2)SyntaxKind[RightHandSide]
+ (690,2)SyntaxKind[SymbolSpan]
+ (690,2)SyntaxKind[Terminal](text = "[")
+ (690,6)SyntaxKind[SymbolSpan]
+ (690,6)SyntaxKind[Nonterminal]
+ (690,6)SyntaxKind[Identifier](text = "BindingElementList")
+ (690,24)SyntaxKind[ArgumentList]
+ (690,24)SyntaxKind[OpenBracketToken]
+ (690,25)SyntaxKind[Argument]?
+ (690,25)SyntaxKind[QuestionToken]
+ (690,26)SyntaxKind[Identifier](text = "Yield")
+ (690,31)SyntaxKind[CloseBracketToken]
+ (690,33)SyntaxKind[SymbolSpan]
+ (690,33)SyntaxKind[Terminal](text = ",")
+ (690,37)SyntaxKind[SymbolSpan]
+ (690,37)SyntaxKind[Nonterminal]?
+ (690,37)SyntaxKind[Identifier](text = "Elision")
+ (690,44)SyntaxKind[QuestionToken]
+ (690,46)SyntaxKind[SymbolSpan]
+ (690,46)SyntaxKind[Nonterminal]?
+ (690,46)SyntaxKind[Identifier](text = "BindingRestElement")
+ (690,64)SyntaxKind[ArgumentList]
+ (690,64)SyntaxKind[OpenBracketToken]
+ (690,65)SyntaxKind[Argument]?
+ (690,65)SyntaxKind[QuestionToken]
+ (690,66)SyntaxKind[Identifier](text = "Yield")
+ (690,71)SyntaxKind[CloseBracketToken]
+ (690,72)SyntaxKind[QuestionToken]
+ (690,74)SyntaxKind[SymbolSpan]
+ (690,74)SyntaxKind[Terminal](text = "]")
+ (691,1)SyntaxKind[DedentToken]
+ (692,1)SyntaxKind[Production]
+ (692,1)SyntaxKind[Identifier](text = "BindingPropertyList")
+ (692,20)SyntaxKind[ParameterList]
+ (692,20)SyntaxKind[OpenBracketToken]
+ (692,21)SyntaxKind[Parameter]
+ (692,21)SyntaxKind[Identifier](text = "Yield")
+ (692,26)SyntaxKind[CloseBracketToken]
+ (693,1)SyntaxKind[RightHandSideList]
+ (693,1)SyntaxKind[IndentToken]
+ (693,2)SyntaxKind[RightHandSide]
+ (693,2)SyntaxKind[SymbolSpan]
+ (693,2)SyntaxKind[Nonterminal]
+ (693,2)SyntaxKind[Identifier](text = "BindingProperty")
+ (693,17)SyntaxKind[ArgumentList]
+ (693,17)SyntaxKind[OpenBracketToken]
+ (693,18)SyntaxKind[Argument]?
+ (693,18)SyntaxKind[QuestionToken]
+ (693,19)SyntaxKind[Identifier](text = "Yield")
+ (693,24)SyntaxKind[CloseBracketToken]
+ (694,2)SyntaxKind[RightHandSide]
+ (694,2)SyntaxKind[SymbolSpan]
+ (694,2)SyntaxKind[Nonterminal]
+ (694,2)SyntaxKind[Identifier](text = "BindingPropertyList")
+ (694,21)SyntaxKind[ArgumentList]
+ (694,21)SyntaxKind[OpenBracketToken]
+ (694,22)SyntaxKind[Argument]?
+ (694,22)SyntaxKind[QuestionToken]
+ (694,23)SyntaxKind[Identifier](text = "Yield")
+ (694,28)SyntaxKind[CloseBracketToken]
+ (694,30)SyntaxKind[SymbolSpan]
+ (694,30)SyntaxKind[Terminal](text = ",")
+ (694,34)SyntaxKind[SymbolSpan]
+ (694,34)SyntaxKind[Nonterminal]
+ (694,34)SyntaxKind[Identifier](text = "BindingProperty")
+ (694,49)SyntaxKind[ArgumentList]
+ (694,49)SyntaxKind[OpenBracketToken]
+ (694,50)SyntaxKind[Argument]?
+ (694,50)SyntaxKind[QuestionToken]
+ (694,51)SyntaxKind[Identifier](text = "Yield")
+ (694,56)SyntaxKind[CloseBracketToken]
+ (695,1)SyntaxKind[DedentToken]
+ (696,1)SyntaxKind[Production]
+ (696,1)SyntaxKind[Identifier](text = "BindingElementList")
+ (696,19)SyntaxKind[ParameterList]
+ (696,19)SyntaxKind[OpenBracketToken]
+ (696,20)SyntaxKind[Parameter]
+ (696,20)SyntaxKind[Identifier](text = "Yield")
+ (696,25)SyntaxKind[CloseBracketToken]
+ (697,1)SyntaxKind[RightHandSideList]
+ (697,1)SyntaxKind[IndentToken]
+ (697,2)SyntaxKind[RightHandSide]
+ (697,2)SyntaxKind[SymbolSpan]
+ (697,2)SyntaxKind[Nonterminal]
+ (697,2)SyntaxKind[Identifier](text = "BindingElisionElement")
+ (697,23)SyntaxKind[ArgumentList]
+ (697,23)SyntaxKind[OpenBracketToken]
+ (697,24)SyntaxKind[Argument]?
+ (697,24)SyntaxKind[QuestionToken]
+ (697,25)SyntaxKind[Identifier](text = "Yield")
+ (697,30)SyntaxKind[CloseBracketToken]
+ (698,2)SyntaxKind[RightHandSide]
+ (698,2)SyntaxKind[SymbolSpan]
+ (698,2)SyntaxKind[Nonterminal]
+ (698,2)SyntaxKind[Identifier](text = "BindingElementList")
+ (698,20)SyntaxKind[ArgumentList]
+ (698,20)SyntaxKind[OpenBracketToken]
+ (698,21)SyntaxKind[Argument]?
+ (698,21)SyntaxKind[QuestionToken]
+ (698,22)SyntaxKind[Identifier](text = "Yield")
+ (698,27)SyntaxKind[CloseBracketToken]
+ (698,29)SyntaxKind[SymbolSpan]
+ (698,29)SyntaxKind[Terminal](text = ",")
+ (698,33)SyntaxKind[SymbolSpan]
+ (698,33)SyntaxKind[Nonterminal]
+ (698,33)SyntaxKind[Identifier](text = "BindingElisionElement")
+ (698,54)SyntaxKind[ArgumentList]
+ (698,54)SyntaxKind[OpenBracketToken]
+ (698,55)SyntaxKind[Argument]?
+ (698,55)SyntaxKind[QuestionToken]
+ (698,56)SyntaxKind[Identifier](text = "Yield")
+ (698,61)SyntaxKind[CloseBracketToken]
+ (699,1)SyntaxKind[DedentToken]
+ (700,1)SyntaxKind[Production]
+ (700,1)SyntaxKind[Identifier](text = "BindingElisionElement")
+ (700,22)SyntaxKind[ParameterList]
+ (700,22)SyntaxKind[OpenBracketToken]
+ (700,23)SyntaxKind[Parameter]
+ (700,23)SyntaxKind[Identifier](text = "Yield")
+ (700,28)SyntaxKind[CloseBracketToken]
+ (701,1)SyntaxKind[RightHandSideList]
+ (701,1)SyntaxKind[IndentToken]
+ (701,2)SyntaxKind[RightHandSide]
+ (701,2)SyntaxKind[SymbolSpan]
+ (701,2)SyntaxKind[Nonterminal]?
+ (701,2)SyntaxKind[Identifier](text = "Elision")
+ (701,9)SyntaxKind[QuestionToken]
+ (701,11)SyntaxKind[SymbolSpan]
+ (701,11)SyntaxKind[Nonterminal]
+ (701,11)SyntaxKind[Identifier](text = "BindingElement")
+ (701,25)SyntaxKind[ArgumentList]
+ (701,25)SyntaxKind[OpenBracketToken]
+ (701,26)SyntaxKind[Argument]?
+ (701,26)SyntaxKind[QuestionToken]
+ (701,27)SyntaxKind[Identifier](text = "Yield")
+ (701,32)SyntaxKind[CloseBracketToken]
+ (702,1)SyntaxKind[DedentToken]
+ (703,1)SyntaxKind[Production]
+ (703,1)SyntaxKind[Identifier](text = "BindingProperty")
+ (703,16)SyntaxKind[ParameterList]
+ (703,16)SyntaxKind[OpenBracketToken]
+ (703,17)SyntaxKind[Parameter]
+ (703,17)SyntaxKind[Identifier](text = "Yield")
+ (703,22)SyntaxKind[CloseBracketToken]
+ (704,1)SyntaxKind[RightHandSideList]
+ (704,1)SyntaxKind[IndentToken]
+ (704,2)SyntaxKind[RightHandSide]
+ (704,2)SyntaxKind[SymbolSpan]
+ (704,2)SyntaxKind[Nonterminal]
+ (704,2)SyntaxKind[Identifier](text = "SingleNameBinding")
+ (704,19)SyntaxKind[ArgumentList]
+ (704,19)SyntaxKind[OpenBracketToken]
+ (704,20)SyntaxKind[Argument]?
+ (704,20)SyntaxKind[QuestionToken]
+ (704,21)SyntaxKind[Identifier](text = "Yield")
+ (704,26)SyntaxKind[CloseBracketToken]
+ (705,2)SyntaxKind[RightHandSide]
+ (705,2)SyntaxKind[SymbolSpan]
+ (705,2)SyntaxKind[Nonterminal]
+ (705,2)SyntaxKind[Identifier](text = "PropertyName")
+ (705,14)SyntaxKind[ArgumentList]
+ (705,14)SyntaxKind[OpenBracketToken]
+ (705,15)SyntaxKind[Argument]?
+ (705,15)SyntaxKind[QuestionToken]
+ (705,16)SyntaxKind[Identifier](text = "Yield")
+ (705,21)SyntaxKind[CloseBracketToken]
+ (705,23)SyntaxKind[SymbolSpan]
+ (705,23)SyntaxKind[Terminal](text = ":")
+ (705,27)SyntaxKind[SymbolSpan]
+ (705,27)SyntaxKind[Nonterminal]
+ (705,27)SyntaxKind[Identifier](text = "BindingElement")
+ (705,41)SyntaxKind[ArgumentList]
+ (705,41)SyntaxKind[OpenBracketToken]
+ (705,42)SyntaxKind[Argument]?
+ (705,42)SyntaxKind[QuestionToken]
+ (705,43)SyntaxKind[Identifier](text = "Yield")
+ (705,48)SyntaxKind[CloseBracketToken]
+ (706,1)SyntaxKind[DedentToken]
+ (707,1)SyntaxKind[Production]
+ (707,1)SyntaxKind[Identifier](text = "BindingElement")
+ (707,15)SyntaxKind[ParameterList]
+ (707,15)SyntaxKind[OpenBracketToken]
+ (707,16)SyntaxKind[Parameter]
+ (707,16)SyntaxKind[Identifier](text = "Yield")
+ (707,21)SyntaxKind[CloseBracketToken]
+ (708,1)SyntaxKind[RightHandSideList]
+ (708,1)SyntaxKind[IndentToken]
+ (708,2)SyntaxKind[RightHandSide]
+ (708,2)SyntaxKind[SymbolSpan]
+ (708,2)SyntaxKind[Nonterminal]
+ (708,2)SyntaxKind[Identifier](text = "SingleNameBinding")
+ (708,19)SyntaxKind[ArgumentList]
+ (708,19)SyntaxKind[OpenBracketToken]
+ (708,20)SyntaxKind[Argument]?
+ (708,20)SyntaxKind[QuestionToken]
+ (708,21)SyntaxKind[Identifier](text = "Yield")
+ (708,26)SyntaxKind[CloseBracketToken]
+ (709,2)SyntaxKind[RightHandSide]
+ (709,2)SyntaxKind[SymbolSpan]
+ (709,2)SyntaxKind[Nonterminal]
+ (709,2)SyntaxKind[Identifier](text = "BindingPattern")
+ (709,16)SyntaxKind[ArgumentList]
+ (709,16)SyntaxKind[OpenBracketToken]
+ (709,17)SyntaxKind[Argument]?
+ (709,17)SyntaxKind[QuestionToken]
+ (709,18)SyntaxKind[Identifier](text = "Yield")
+ (709,23)SyntaxKind[CloseBracketToken]
+ (709,25)SyntaxKind[SymbolSpan]
+ (709,25)SyntaxKind[Nonterminal]?
+ (709,25)SyntaxKind[Identifier](text = "Initializer")
+ (709,36)SyntaxKind[ArgumentList]
+ (709,36)SyntaxKind[OpenBracketToken]
+ (709,37)SyntaxKind[Argument]
+ (709,37)SyntaxKind[Identifier](text = "In")
+ (709,41)SyntaxKind[Argument]?
+ (709,41)SyntaxKind[QuestionToken]
+ (709,42)SyntaxKind[Identifier](text = "Yield")
+ (709,47)SyntaxKind[CloseBracketToken]
+ (709,48)SyntaxKind[QuestionToken]
+ (710,1)SyntaxKind[DedentToken]
+ (711,1)SyntaxKind[Production]
+ (711,1)SyntaxKind[Identifier](text = "SingleNameBinding")
+ (711,18)SyntaxKind[ParameterList]
+ (711,18)SyntaxKind[OpenBracketToken]
+ (711,19)SyntaxKind[Parameter]
+ (711,19)SyntaxKind[Identifier](text = "Yield")
+ (711,24)SyntaxKind[CloseBracketToken]
+ (712,1)SyntaxKind[RightHandSideList]
+ (712,1)SyntaxKind[IndentToken]
+ (712,2)SyntaxKind[RightHandSide]
+ (712,2)SyntaxKind[SymbolSpan]
+ (712,2)SyntaxKind[Nonterminal]
+ (712,2)SyntaxKind[Identifier](text = "BindingIdentifier")
+ (712,19)SyntaxKind[ArgumentList]
+ (712,19)SyntaxKind[OpenBracketToken]
+ (712,20)SyntaxKind[Argument]?
+ (712,20)SyntaxKind[QuestionToken]
+ (712,21)SyntaxKind[Identifier](text = "Yield")
+ (712,26)SyntaxKind[CloseBracketToken]
+ (712,28)SyntaxKind[SymbolSpan]
+ (712,28)SyntaxKind[Nonterminal]?
+ (712,28)SyntaxKind[Identifier](text = "Initializer")
+ (712,39)SyntaxKind[ArgumentList]
+ (712,39)SyntaxKind[OpenBracketToken]
+ (712,40)SyntaxKind[Argument]
+ (712,40)SyntaxKind[Identifier](text = "In")
+ (712,44)SyntaxKind[Argument]?
+ (712,44)SyntaxKind[QuestionToken]
+ (712,45)SyntaxKind[Identifier](text = "Yield")
+ (712,50)SyntaxKind[CloseBracketToken]
+ (712,51)SyntaxKind[QuestionToken]
+ (713,1)SyntaxKind[DedentToken]
+ (714,1)SyntaxKind[Production]
+ (714,1)SyntaxKind[Identifier](text = "BindingRestElement")
+ (714,19)SyntaxKind[ParameterList]
+ (714,19)SyntaxKind[OpenBracketToken]
+ (714,20)SyntaxKind[Parameter]
+ (714,20)SyntaxKind[Identifier](text = "Yield")
+ (714,25)SyntaxKind[CloseBracketToken]
+ (715,1)SyntaxKind[RightHandSideList]
+ (715,1)SyntaxKind[IndentToken]
+ (715,2)SyntaxKind[RightHandSide]
+ (715,2)SyntaxKind[SymbolSpan]
+ (715,2)SyntaxKind[Terminal](text = "...")
+ (715,8)SyntaxKind[SymbolSpan]
+ (715,8)SyntaxKind[Nonterminal]
+ (715,8)SyntaxKind[Identifier](text = "BindingIdentifier")
+ (715,25)SyntaxKind[ArgumentList]
+ (715,25)SyntaxKind[OpenBracketToken]
+ (715,26)SyntaxKind[Argument]?
+ (715,26)SyntaxKind[QuestionToken]
+ (715,27)SyntaxKind[Identifier](text = "Yield")
+ (715,32)SyntaxKind[CloseBracketToken]
+ (716,1)SyntaxKind[DedentToken]
+ (717,1)SyntaxKind[Production]
+ (717,1)SyntaxKind[Identifier](text = "EmptyStatement")
+ (718,1)SyntaxKind[RightHandSideList]
+ (718,1)SyntaxKind[IndentToken]
+ (718,2)SyntaxKind[RightHandSide]
+ (718,2)SyntaxKind[SymbolSpan]
+ (718,2)SyntaxKind[Terminal](text = ";")
+ (719,1)SyntaxKind[DedentToken]
+ (720,1)SyntaxKind[Production]
+ (720,1)SyntaxKind[Identifier](text = "ExpressionStatement")
+ (720,20)SyntaxKind[ParameterList]
+ (720,20)SyntaxKind[OpenBracketToken]
+ (720,21)SyntaxKind[Parameter]
+ (720,21)SyntaxKind[Identifier](text = "Yield")
+ (720,26)SyntaxKind[CloseBracketToken]
+ (721,1)SyntaxKind[RightHandSideList]
+ (721,1)SyntaxKind[IndentToken]
+ (721,2)SyntaxKind[RightHandSide]
+ (721,2)SyntaxKind[SymbolSpan]
+ (721,2)SyntaxKind[LookaheadAssertion]
+ (721,2)SyntaxKind[OpenBracketToken]
+ (721,3)SyntaxKind[LookaheadKeyword]
+ (721,13)SyntaxKind[LessThanExclamationToken]
+ (721,16)SyntaxKind[SymbolSet]
+ (721,16)SyntaxKind[OpenBraceToken]
+ (721,18)SyntaxKind[SymbolSpan]
+ (721,18)SyntaxKind[Terminal](text = "{")
+ (721,23)SyntaxKind[SymbolSpan]
+ (721,23)SyntaxKind[Terminal](text = "function")
+ (721,35)SyntaxKind[SymbolSpan]
+ (721,35)SyntaxKind[Terminal](text = "class")
+ (721,44)SyntaxKind[SymbolSpan]
+ (721,44)SyntaxKind[Terminal](text = "let")
+ (721,50)SyntaxKind[SymbolSpan]
+ (721,50)SyntaxKind[Terminal](text = "[")
+ (721,54)SyntaxKind[CloseBraceToken]
+ (721,55)SyntaxKind[CloseBracketToken]
+ (721,57)SyntaxKind[SymbolSpan]
+ (721,57)SyntaxKind[Nonterminal]
+ (721,57)SyntaxKind[Identifier](text = "Expression")
+ (721,67)SyntaxKind[ArgumentList]
+ (721,67)SyntaxKind[OpenBracketToken]
+ (721,68)SyntaxKind[Argument]
+ (721,68)SyntaxKind[Identifier](text = "In")
+ (721,72)SyntaxKind[Argument]?
+ (721,72)SyntaxKind[QuestionToken]
+ (721,73)SyntaxKind[Identifier](text = "Yield")
+ (721,78)SyntaxKind[CloseBracketToken]
+ (721,80)SyntaxKind[SymbolSpan]
+ (721,80)SyntaxKind[Terminal](text = ";")
+ (722,1)SyntaxKind[DedentToken]
+ (723,1)SyntaxKind[Production]
+ (723,1)SyntaxKind[Identifier](text = "IfStatement")
+ (723,12)SyntaxKind[ParameterList]
+ (723,12)SyntaxKind[OpenBracketToken]
+ (723,13)SyntaxKind[Parameter]
+ (723,13)SyntaxKind[Identifier](text = "Yield")
+ (723,20)SyntaxKind[Parameter]
+ (723,20)SyntaxKind[Identifier](text = "Return")
+ (723,26)SyntaxKind[CloseBracketToken]
+ (724,1)SyntaxKind[RightHandSideList]
+ (724,1)SyntaxKind[IndentToken]
+ (724,2)SyntaxKind[RightHandSide]
+ (724,2)SyntaxKind[SymbolSpan]
+ (724,2)SyntaxKind[Terminal](text = "if")
+ (724,7)SyntaxKind[SymbolSpan]
+ (724,7)SyntaxKind[Terminal](text = "(")
+ (724,11)SyntaxKind[SymbolSpan]
+ (724,11)SyntaxKind[Nonterminal]
+ (724,11)SyntaxKind[Identifier](text = "Expression")
+ (724,21)SyntaxKind[ArgumentList]
+ (724,21)SyntaxKind[OpenBracketToken]
+ (724,22)SyntaxKind[Argument]
+ (724,22)SyntaxKind[Identifier](text = "In")
+ (724,26)SyntaxKind[Argument]?
+ (724,26)SyntaxKind[QuestionToken]
+ (724,27)SyntaxKind[Identifier](text = "Yield")
+ (724,32)SyntaxKind[CloseBracketToken]
+ (724,34)SyntaxKind[SymbolSpan]
+ (724,34)SyntaxKind[Terminal](text = ")")
+ (724,38)SyntaxKind[SymbolSpan]
+ (724,38)SyntaxKind[Nonterminal]
+ (724,38)SyntaxKind[Identifier](text = "Statement")
+ (724,47)SyntaxKind[ArgumentList]
+ (724,47)SyntaxKind[OpenBracketToken]
+ (724,48)SyntaxKind[Argument]?
+ (724,48)SyntaxKind[QuestionToken]
+ (724,49)SyntaxKind[Identifier](text = "Yield")
+ (724,56)SyntaxKind[Argument]?
+ (724,56)SyntaxKind[QuestionToken]
+ (724,57)SyntaxKind[Identifier](text = "Return")
+ (724,63)SyntaxKind[CloseBracketToken]
+ (724,65)SyntaxKind[SymbolSpan]
+ (724,65)SyntaxKind[Terminal](text = "else")
+ (724,72)SyntaxKind[SymbolSpan]
+ (724,72)SyntaxKind[Nonterminal]
+ (724,72)SyntaxKind[Identifier](text = "Statement")
+ (724,81)SyntaxKind[ArgumentList]
+ (724,81)SyntaxKind[OpenBracketToken]
+ (724,82)SyntaxKind[Argument]?
+ (724,82)SyntaxKind[QuestionToken]
+ (724,83)SyntaxKind[Identifier](text = "Yield")
+ (724,90)SyntaxKind[Argument]?
+ (724,90)SyntaxKind[QuestionToken]
+ (724,91)SyntaxKind[Identifier](text = "Return")
+ (724,97)SyntaxKind[CloseBracketToken]
+ (725,2)SyntaxKind[RightHandSide]
+ (725,2)SyntaxKind[SymbolSpan]
+ (725,2)SyntaxKind[Terminal](text = "if")
+ (725,7)SyntaxKind[SymbolSpan]
+ (725,7)SyntaxKind[Terminal](text = "(")
+ (725,11)SyntaxKind[SymbolSpan]
+ (725,11)SyntaxKind[Nonterminal]
+ (725,11)SyntaxKind[Identifier](text = "Expression")
+ (725,21)SyntaxKind[ArgumentList]
+ (725,21)SyntaxKind[OpenBracketToken]
+ (725,22)SyntaxKind[Argument]
+ (725,22)SyntaxKind[Identifier](text = "In")
+ (725,26)SyntaxKind[Argument]?
+ (725,26)SyntaxKind[QuestionToken]
+ (725,27)SyntaxKind[Identifier](text = "Yield")
+ (725,32)SyntaxKind[CloseBracketToken]
+ (725,34)SyntaxKind[SymbolSpan]
+ (725,34)SyntaxKind[Terminal](text = ")")
+ (725,38)SyntaxKind[SymbolSpan]
+ (725,38)SyntaxKind[Nonterminal]
+ (725,38)SyntaxKind[Identifier](text = "Statement")
+ (725,47)SyntaxKind[ArgumentList]
+ (725,47)SyntaxKind[OpenBracketToken]
+ (725,48)SyntaxKind[Argument]?
+ (725,48)SyntaxKind[QuestionToken]
+ (725,49)SyntaxKind[Identifier](text = "Yield")
+ (725,56)SyntaxKind[Argument]?
+ (725,56)SyntaxKind[QuestionToken]
+ (725,57)SyntaxKind[Identifier](text = "Return")
+ (725,63)SyntaxKind[CloseBracketToken]
+ (726,1)SyntaxKind[DedentToken]
+ (727,1)SyntaxKind[Production]
+ (727,1)SyntaxKind[Identifier](text = "IterationStatement")
+ (727,19)SyntaxKind[ParameterList]
+ (727,19)SyntaxKind[OpenBracketToken]
+ (727,20)SyntaxKind[Parameter]
+ (727,20)SyntaxKind[Identifier](text = "Yield")
+ (727,27)SyntaxKind[Parameter]
+ (727,27)SyntaxKind[Identifier](text = "Return")
+ (727,33)SyntaxKind[CloseBracketToken]
+ (728,1)SyntaxKind[RightHandSideList]
+ (728,1)SyntaxKind[IndentToken]
+ (728,2)SyntaxKind[RightHandSide]
+ (728,2)SyntaxKind[SymbolSpan]
+ (728,2)SyntaxKind[Terminal](text = "do")
+ (728,7)SyntaxKind[SymbolSpan]
+ (728,7)SyntaxKind[Nonterminal]
+ (728,7)SyntaxKind[Identifier](text = "Statement")
+ (728,16)SyntaxKind[ArgumentList]
+ (728,16)SyntaxKind[OpenBracketToken]
+ (728,17)SyntaxKind[Argument]?
+ (728,17)SyntaxKind[QuestionToken]
+ (728,18)SyntaxKind[Identifier](text = "Yield")
+ (728,25)SyntaxKind[Argument]?
+ (728,25)SyntaxKind[QuestionToken]
+ (728,26)SyntaxKind[Identifier](text = "Return")
+ (728,32)SyntaxKind[CloseBracketToken]
+ (728,34)SyntaxKind[SymbolSpan]
+ (728,34)SyntaxKind[Terminal](text = "while")
+ (728,42)SyntaxKind[SymbolSpan]
+ (728,42)SyntaxKind[Terminal](text = "(")
+ (728,46)SyntaxKind[SymbolSpan]
+ (728,46)SyntaxKind[Nonterminal]
+ (728,46)SyntaxKind[Identifier](text = "Expression")
+ (728,56)SyntaxKind[ArgumentList]
+ (728,56)SyntaxKind[OpenBracketToken]
+ (728,57)SyntaxKind[Argument]
+ (728,57)SyntaxKind[Identifier](text = "In")
+ (728,61)SyntaxKind[Argument]?
+ (728,61)SyntaxKind[QuestionToken]
+ (728,62)SyntaxKind[Identifier](text = "Yield")
+ (728,67)SyntaxKind[CloseBracketToken]
+ (728,69)SyntaxKind[SymbolSpan]
+ (728,69)SyntaxKind[Terminal](text = ")")
+ (728,73)SyntaxKind[SymbolSpan]
+ (728,73)SyntaxKind[Terminal](text = ";")
+ (729,2)SyntaxKind[RightHandSide]
+ (729,2)SyntaxKind[SymbolSpan]
+ (729,2)SyntaxKind[Terminal](text = "while")
+ (729,10)SyntaxKind[SymbolSpan]
+ (729,10)SyntaxKind[Terminal](text = "(")
+ (729,14)SyntaxKind[SymbolSpan]
+ (729,14)SyntaxKind[Nonterminal]
+ (729,14)SyntaxKind[Identifier](text = "Expression")
+ (729,24)SyntaxKind[ArgumentList]
+ (729,24)SyntaxKind[OpenBracketToken]
+ (729,25)SyntaxKind[Argument]
+ (729,25)SyntaxKind[Identifier](text = "In")
+ (729,29)SyntaxKind[Argument]?
+ (729,29)SyntaxKind[QuestionToken]
+ (729,30)SyntaxKind[Identifier](text = "Yield")
+ (729,35)SyntaxKind[CloseBracketToken]
+ (729,37)SyntaxKind[SymbolSpan]
+ (729,37)SyntaxKind[Terminal](text = ")")
+ (729,41)SyntaxKind[SymbolSpan]
+ (729,41)SyntaxKind[Nonterminal]
+ (729,41)SyntaxKind[Identifier](text = "Statement")
+ (729,50)SyntaxKind[ArgumentList]
+ (729,50)SyntaxKind[OpenBracketToken]
+ (729,51)SyntaxKind[Argument]?
+ (729,51)SyntaxKind[QuestionToken]
+ (729,52)SyntaxKind[Identifier](text = "Yield")
+ (729,59)SyntaxKind[Argument]?
+ (729,59)SyntaxKind[QuestionToken]
+ (729,60)SyntaxKind[Identifier](text = "Return")
+ (729,66)SyntaxKind[CloseBracketToken]
+ (730,2)SyntaxKind[RightHandSide]
+ (730,2)SyntaxKind[SymbolSpan]
+ (730,2)SyntaxKind[Terminal](text = "for")
+ (730,8)SyntaxKind[SymbolSpan]
+ (730,8)SyntaxKind[Terminal](text = "(")
+ (730,12)SyntaxKind[SymbolSpan]
+ (730,12)SyntaxKind[LookaheadAssertion]
+ (730,12)SyntaxKind[OpenBracketToken]
+ (730,13)SyntaxKind[LookaheadKeyword]
+ (730,23)SyntaxKind[LessThanExclamationToken]
+ (730,26)SyntaxKind[SymbolSet]
+ (730,26)SyntaxKind[OpenBraceToken]
+ (730,28)SyntaxKind[SymbolSpan]
+ (730,28)SyntaxKind[Terminal](text = "let")
+ (730,34)SyntaxKind[SymbolSpan]
+ (730,34)SyntaxKind[Terminal](text = "[")
+ (730,38)SyntaxKind[CloseBraceToken]
+ (730,39)SyntaxKind[CloseBracketToken]
+ (730,41)SyntaxKind[SymbolSpan]
+ (730,41)SyntaxKind[Nonterminal]?
+ (730,41)SyntaxKind[Identifier](text = "Expression")
+ (730,51)SyntaxKind[ArgumentList]
+ (730,51)SyntaxKind[OpenBracketToken]
+ (730,52)SyntaxKind[Argument]?
+ (730,52)SyntaxKind[QuestionToken]
+ (730,53)SyntaxKind[Identifier](text = "Yield")
+ (730,58)SyntaxKind[CloseBracketToken]
+ (730,59)SyntaxKind[QuestionToken]
+ (730,61)SyntaxKind[SymbolSpan]
+ (730,61)SyntaxKind[Terminal](text = ";")
+ (730,65)SyntaxKind[SymbolSpan]
+ (730,65)SyntaxKind[Nonterminal]?
+ (730,65)SyntaxKind[Identifier](text = "Expression")
+ (730,75)SyntaxKind[ArgumentList]
+ (730,75)SyntaxKind[OpenBracketToken]
+ (730,76)SyntaxKind[Argument]
+ (730,76)SyntaxKind[Identifier](text = "In")
+ (730,80)SyntaxKind[Argument]?
+ (730,80)SyntaxKind[QuestionToken]
+ (730,81)SyntaxKind[Identifier](text = "Yield")
+ (730,86)SyntaxKind[CloseBracketToken]
+ (730,87)SyntaxKind[QuestionToken]
+ (730,89)SyntaxKind[SymbolSpan]
+ (730,89)SyntaxKind[Terminal](text = ";")
+ (730,93)SyntaxKind[SymbolSpan]
+ (730,93)SyntaxKind[Nonterminal]?
+ (730,93)SyntaxKind[Identifier](text = "Expression")
+ (730,103)SyntaxKind[ArgumentList]
+ (730,103)SyntaxKind[OpenBracketToken]
+ (730,104)SyntaxKind[Argument]
+ (730,104)SyntaxKind[Identifier](text = "In")
+ (730,108)SyntaxKind[Argument]?
+ (730,108)SyntaxKind[QuestionToken]
+ (730,109)SyntaxKind[Identifier](text = "Yield")
+ (730,114)SyntaxKind[CloseBracketToken]
+ (730,115)SyntaxKind[QuestionToken]
+ (730,117)SyntaxKind[SymbolSpan]
+ (730,117)SyntaxKind[Terminal](text = ")")
+ (730,121)SyntaxKind[SymbolSpan]
+ (730,121)SyntaxKind[Nonterminal]
+ (730,121)SyntaxKind[Identifier](text = "Statement")
+ (730,130)SyntaxKind[ArgumentList]
+ (730,130)SyntaxKind[OpenBracketToken]
+ (730,131)SyntaxKind[Argument]?
+ (730,131)SyntaxKind[QuestionToken]
+ (730,132)SyntaxKind[Identifier](text = "Yield")
+ (730,139)SyntaxKind[Argument]?
+ (730,139)SyntaxKind[QuestionToken]
+ (730,140)SyntaxKind[Identifier](text = "Return")
+ (730,146)SyntaxKind[CloseBracketToken]
+ (731,2)SyntaxKind[RightHandSide]
+ (731,2)SyntaxKind[SymbolSpan]
+ (731,2)SyntaxKind[Terminal](text = "for")
+ (731,8)SyntaxKind[SymbolSpan]
+ (731,8)SyntaxKind[Terminal](text = "(")
+ (731,12)SyntaxKind[SymbolSpan]
+ (731,12)SyntaxKind[Terminal](text = "var")
+ (731,18)SyntaxKind[SymbolSpan]
+ (731,18)SyntaxKind[Nonterminal]
+ (731,18)SyntaxKind[Identifier](text = "VariableDeclarationList")
+ (731,41)SyntaxKind[ArgumentList]
+ (731,41)SyntaxKind[OpenBracketToken]
+ (731,42)SyntaxKind[Argument]?
+ (731,42)SyntaxKind[QuestionToken]
+ (731,43)SyntaxKind[Identifier](text = "Yield")
+ (731,48)SyntaxKind[CloseBracketToken]
+ (731,50)SyntaxKind[SymbolSpan]
+ (731,50)SyntaxKind[Terminal](text = ";")
+ (731,54)SyntaxKind[SymbolSpan]
+ (731,54)SyntaxKind[Nonterminal]?
+ (731,54)SyntaxKind[Identifier](text = "Expression")
+ (731,64)SyntaxKind[ArgumentList]
+ (731,64)SyntaxKind[OpenBracketToken]
+ (731,65)SyntaxKind[Argument]
+ (731,65)SyntaxKind[Identifier](text = "In")
+ (731,69)SyntaxKind[Argument]?
+ (731,69)SyntaxKind[QuestionToken]
+ (731,70)SyntaxKind[Identifier](text = "Yield")
+ (731,75)SyntaxKind[CloseBracketToken]
+ (731,76)SyntaxKind[QuestionToken]
+ (731,78)SyntaxKind[SymbolSpan]
+ (731,78)SyntaxKind[Terminal](text = ";")
+ (731,82)SyntaxKind[SymbolSpan]
+ (731,82)SyntaxKind[Nonterminal]?
+ (731,82)SyntaxKind[Identifier](text = "Expression")
+ (731,92)SyntaxKind[ArgumentList]
+ (731,92)SyntaxKind[OpenBracketToken]
+ (731,93)SyntaxKind[Argument]
+ (731,93)SyntaxKind[Identifier](text = "In")
+ (731,97)SyntaxKind[Argument]?
+ (731,97)SyntaxKind[QuestionToken]
+ (731,98)SyntaxKind[Identifier](text = "Yield")
+ (731,103)SyntaxKind[CloseBracketToken]
+ (731,104)SyntaxKind[QuestionToken]
+ (731,106)SyntaxKind[SymbolSpan]
+ (731,106)SyntaxKind[Terminal](text = ")")
+ (731,110)SyntaxKind[SymbolSpan]
+ (731,110)SyntaxKind[Nonterminal]
+ (731,110)SyntaxKind[Identifier](text = "Statement")
+ (731,119)SyntaxKind[ArgumentList]
+ (731,119)SyntaxKind[OpenBracketToken]
+ (731,120)SyntaxKind[Argument]?
+ (731,120)SyntaxKind[QuestionToken]
+ (731,121)SyntaxKind[Identifier](text = "Yield")
+ (731,128)SyntaxKind[Argument]?
+ (731,128)SyntaxKind[QuestionToken]
+ (731,129)SyntaxKind[Identifier](text = "Return")
+ (731,135)SyntaxKind[CloseBracketToken]
+ (732,2)SyntaxKind[RightHandSide]
+ (732,2)SyntaxKind[SymbolSpan]
+ (732,2)SyntaxKind[Terminal](text = "for")
+ (732,8)SyntaxKind[SymbolSpan]
+ (732,8)SyntaxKind[Terminal](text = "(")
+ (732,12)SyntaxKind[SymbolSpan]
+ (732,12)SyntaxKind[Nonterminal]
+ (732,12)SyntaxKind[Identifier](text = "LexicalDeclaration")
+ (732,30)SyntaxKind[ArgumentList]
+ (732,30)SyntaxKind[OpenBracketToken]
+ (732,31)SyntaxKind[Argument]?
+ (732,31)SyntaxKind[QuestionToken]
+ (732,32)SyntaxKind[Identifier](text = "Yield")
+ (732,37)SyntaxKind[CloseBracketToken]
+ (732,39)SyntaxKind[SymbolSpan]
+ (732,39)SyntaxKind[Nonterminal]?
+ (732,39)SyntaxKind[Identifier](text = "Expression")
+ (732,49)SyntaxKind[ArgumentList]
+ (732,49)SyntaxKind[OpenBracketToken]
+ (732,50)SyntaxKind[Argument]
+ (732,50)SyntaxKind[Identifier](text = "In")
+ (732,54)SyntaxKind[Argument]?
+ (732,54)SyntaxKind[QuestionToken]
+ (732,55)SyntaxKind[Identifier](text = "Yield")
+ (732,60)SyntaxKind[CloseBracketToken]
+ (732,61)SyntaxKind[QuestionToken]
+ (732,63)SyntaxKind[SymbolSpan]
+ (732,63)SyntaxKind[Terminal](text = ";")
+ (732,67)SyntaxKind[SymbolSpan]
+ (732,67)SyntaxKind[Nonterminal]?
+ (732,67)SyntaxKind[Identifier](text = "Expression")
+ (732,77)SyntaxKind[ArgumentList]
+ (732,77)SyntaxKind[OpenBracketToken]
+ (732,78)SyntaxKind[Argument]
+ (732,78)SyntaxKind[Identifier](text = "In")
+ (732,82)SyntaxKind[Argument]?
+ (732,82)SyntaxKind[QuestionToken]
+ (732,83)SyntaxKind[Identifier](text = "Yield")
+ (732,88)SyntaxKind[CloseBracketToken]
+ (732,89)SyntaxKind[QuestionToken]
+ (732,91)SyntaxKind[SymbolSpan]
+ (732,91)SyntaxKind[Terminal](text = ")")
+ (732,95)SyntaxKind[SymbolSpan]
+ (732,95)SyntaxKind[Nonterminal]
+ (732,95)SyntaxKind[Identifier](text = "Statement")
+ (732,104)SyntaxKind[ArgumentList]
+ (732,104)SyntaxKind[OpenBracketToken]
+ (732,105)SyntaxKind[Argument]?
+ (732,105)SyntaxKind[QuestionToken]
+ (732,106)SyntaxKind[Identifier](text = "Yield")
+ (732,113)SyntaxKind[Argument]?
+ (732,113)SyntaxKind[QuestionToken]
+ (732,114)SyntaxKind[Identifier](text = "Return")
+ (732,120)SyntaxKind[CloseBracketToken]
+ (733,2)SyntaxKind[RightHandSide]
+ (733,2)SyntaxKind[SymbolSpan]
+ (733,2)SyntaxKind[Terminal](text = "for")
+ (733,8)SyntaxKind[SymbolSpan]
+ (733,8)SyntaxKind[Terminal](text = "(")
+ (733,12)SyntaxKind[SymbolSpan]
+ (733,12)SyntaxKind[LookaheadAssertion]
+ (733,12)SyntaxKind[OpenBracketToken]
+ (733,13)SyntaxKind[LookaheadKeyword]
+ (733,23)SyntaxKind[LessThanExclamationToken]
+ (733,26)SyntaxKind[SymbolSet]
+ (733,26)SyntaxKind[OpenBraceToken]
+ (733,28)SyntaxKind[SymbolSpan]
+ (733,28)SyntaxKind[Terminal](text = "let")
+ (733,34)SyntaxKind[SymbolSpan]
+ (733,34)SyntaxKind[Terminal](text = "[")
+ (733,38)SyntaxKind[CloseBraceToken]
+ (733,39)SyntaxKind[CloseBracketToken]
+ (733,41)SyntaxKind[SymbolSpan]
+ (733,41)SyntaxKind[Nonterminal]
+ (733,41)SyntaxKind[Identifier](text = "LeftHandSideExpression")
+ (733,63)SyntaxKind[ArgumentList]
+ (733,63)SyntaxKind[OpenBracketToken]
+ (733,64)SyntaxKind[Argument]?
+ (733,64)SyntaxKind[QuestionToken]
+ (733,65)SyntaxKind[Identifier](text = "Yield")
+ (733,70)SyntaxKind[CloseBracketToken]
+ (733,72)SyntaxKind[SymbolSpan]
+ (733,72)SyntaxKind[Terminal](text = "in")
+ (733,77)SyntaxKind[SymbolSpan]
+ (733,77)SyntaxKind[Nonterminal]
+ (733,77)SyntaxKind[Identifier](text = "Expression")
+ (733,87)SyntaxKind[ArgumentList]
+ (733,87)SyntaxKind[OpenBracketToken]
+ (733,88)SyntaxKind[Argument]
+ (733,88)SyntaxKind[Identifier](text = "In")
+ (733,92)SyntaxKind[Argument]?
+ (733,92)SyntaxKind[QuestionToken]
+ (733,93)SyntaxKind[Identifier](text = "Yield")
+ (733,98)SyntaxKind[CloseBracketToken]
+ (733,100)SyntaxKind[SymbolSpan]
+ (733,100)SyntaxKind[Terminal](text = ")")
+ (733,104)SyntaxKind[SymbolSpan]
+ (733,104)SyntaxKind[Nonterminal]
+ (733,104)SyntaxKind[Identifier](text = "Statement")
+ (733,113)SyntaxKind[ArgumentList]
+ (733,113)SyntaxKind[OpenBracketToken]
+ (733,114)SyntaxKind[Argument]?
+ (733,114)SyntaxKind[QuestionToken]
+ (733,115)SyntaxKind[Identifier](text = "Yield")
+ (733,122)SyntaxKind[Argument]?
+ (733,122)SyntaxKind[QuestionToken]
+ (733,123)SyntaxKind[Identifier](text = "Return")
+ (733,129)SyntaxKind[CloseBracketToken]
+ (734,2)SyntaxKind[RightHandSide]
+ (734,2)SyntaxKind[SymbolSpan]
+ (734,2)SyntaxKind[Terminal](text = "for")
+ (734,8)SyntaxKind[SymbolSpan]
+ (734,8)SyntaxKind[Terminal](text = "(")
+ (734,12)SyntaxKind[SymbolSpan]
+ (734,12)SyntaxKind[Terminal](text = "var")
+ (734,18)SyntaxKind[SymbolSpan]
+ (734,18)SyntaxKind[Nonterminal]
+ (734,18)SyntaxKind[Identifier](text = "ForBinding")
+ (734,28)SyntaxKind[ArgumentList]
+ (734,28)SyntaxKind[OpenBracketToken]
+ (734,29)SyntaxKind[Argument]?
+ (734,29)SyntaxKind[QuestionToken]
+ (734,30)SyntaxKind[Identifier](text = "Yield")
+ (734,35)SyntaxKind[CloseBracketToken]
+ (734,37)SyntaxKind[SymbolSpan]
+ (734,37)SyntaxKind[Terminal](text = "in")
+ (734,42)SyntaxKind[SymbolSpan]
+ (734,42)SyntaxKind[Nonterminal]
+ (734,42)SyntaxKind[Identifier](text = "Expression")
+ (734,52)SyntaxKind[ArgumentList]
+ (734,52)SyntaxKind[OpenBracketToken]
+ (734,53)SyntaxKind[Argument]
+ (734,53)SyntaxKind[Identifier](text = "In")
+ (734,57)SyntaxKind[Argument]?
+ (734,57)SyntaxKind[QuestionToken]
+ (734,58)SyntaxKind[Identifier](text = "Yield")
+ (734,63)SyntaxKind[CloseBracketToken]
+ (734,65)SyntaxKind[SymbolSpan]
+ (734,65)SyntaxKind[Terminal](text = ")")
+ (734,69)SyntaxKind[SymbolSpan]
+ (734,69)SyntaxKind[Nonterminal]
+ (734,69)SyntaxKind[Identifier](text = "Statement")
+ (734,78)SyntaxKind[ArgumentList]
+ (734,78)SyntaxKind[OpenBracketToken]
+ (734,79)SyntaxKind[Argument]?
+ (734,79)SyntaxKind[QuestionToken]
+ (734,80)SyntaxKind[Identifier](text = "Yield")
+ (734,87)SyntaxKind[Argument]?
+ (734,87)SyntaxKind[QuestionToken]
+ (734,88)SyntaxKind[Identifier](text = "Return")
+ (734,94)SyntaxKind[CloseBracketToken]
+ (735,2)SyntaxKind[RightHandSide]
+ (735,2)SyntaxKind[SymbolSpan]
+ (735,2)SyntaxKind[Terminal](text = "for")
+ (735,8)SyntaxKind[SymbolSpan]
+ (735,8)SyntaxKind[Terminal](text = "(")
+ (735,12)SyntaxKind[SymbolSpan]
+ (735,12)SyntaxKind[Nonterminal]
+ (735,12)SyntaxKind[Identifier](text = "ForDeclaration")
+ (735,26)SyntaxKind[ArgumentList]
+ (735,26)SyntaxKind[OpenBracketToken]
+ (735,27)SyntaxKind[Argument]?
+ (735,27)SyntaxKind[QuestionToken]
+ (735,28)SyntaxKind[Identifier](text = "Yield")
+ (735,33)SyntaxKind[CloseBracketToken]
+ (735,35)SyntaxKind[SymbolSpan]
+ (735,35)SyntaxKind[Terminal](text = "in")
+ (735,40)SyntaxKind[SymbolSpan]
+ (735,40)SyntaxKind[Nonterminal]
+ (735,40)SyntaxKind[Identifier](text = "Expression")
+ (735,50)SyntaxKind[ArgumentList]
+ (735,50)SyntaxKind[OpenBracketToken]
+ (735,51)SyntaxKind[Argument]
+ (735,51)SyntaxKind[Identifier](text = "In")
+ (735,55)SyntaxKind[Argument]?
+ (735,55)SyntaxKind[QuestionToken]
+ (735,56)SyntaxKind[Identifier](text = "Yield")
+ (735,61)SyntaxKind[CloseBracketToken]
+ (735,63)SyntaxKind[SymbolSpan]
+ (735,63)SyntaxKind[Terminal](text = ")")
+ (735,67)SyntaxKind[SymbolSpan]
+ (735,67)SyntaxKind[Nonterminal]
+ (735,67)SyntaxKind[Identifier](text = "Statement")
+ (735,76)SyntaxKind[ArgumentList]
+ (735,76)SyntaxKind[OpenBracketToken]
+ (735,77)SyntaxKind[Argument]?
+ (735,77)SyntaxKind[QuestionToken]
+ (735,78)SyntaxKind[Identifier](text = "Yield")
+ (735,85)SyntaxKind[Argument]?
+ (735,85)SyntaxKind[QuestionToken]
+ (735,86)SyntaxKind[Identifier](text = "Return")
+ (735,92)SyntaxKind[CloseBracketToken]
+ (736,2)SyntaxKind[RightHandSide]
+ (736,2)SyntaxKind[SymbolSpan]
+ (736,2)SyntaxKind[Terminal](text = "for")
+ (736,8)SyntaxKind[SymbolSpan]
+ (736,8)SyntaxKind[Terminal](text = "(")
+ (736,12)SyntaxKind[SymbolSpan]
+ (736,12)SyntaxKind[LookaheadAssertion]
+ (736,12)SyntaxKind[OpenBracketToken]
+ (736,13)SyntaxKind[LookaheadKeyword]
+ (736,23)SyntaxKind[ExclamationEqualsToken]
+ (736,26)SyntaxKind[SymbolSpan]
+ (736,26)SyntaxKind[Terminal](text = "let")
+ (736,31)SyntaxKind[CloseBracketToken]
+ (736,33)SyntaxKind[SymbolSpan]
+ (736,33)SyntaxKind[Nonterminal]
+ (736,33)SyntaxKind[Identifier](text = "LeftHandSideExpression")
+ (736,55)SyntaxKind[ArgumentList]
+ (736,55)SyntaxKind[OpenBracketToken]
+ (736,56)SyntaxKind[Argument]?
+ (736,56)SyntaxKind[QuestionToken]
+ (736,57)SyntaxKind[Identifier](text = "Yield")
+ (736,62)SyntaxKind[CloseBracketToken]
+ (736,64)SyntaxKind[SymbolSpan]
+ (736,64)SyntaxKind[Terminal](text = "of")
+ (736,69)SyntaxKind[SymbolSpan]
+ (736,69)SyntaxKind[Nonterminal]
+ (736,69)SyntaxKind[Identifier](text = "AssignmentExpression")
+ (736,89)SyntaxKind[ArgumentList]
+ (736,89)SyntaxKind[OpenBracketToken]
+ (736,90)SyntaxKind[Argument]
+ (736,90)SyntaxKind[Identifier](text = "In")
+ (736,94)SyntaxKind[Argument]?
+ (736,94)SyntaxKind[QuestionToken]
+ (736,95)SyntaxKind[Identifier](text = "Yield")
+ (736,100)SyntaxKind[CloseBracketToken]
+ (736,102)SyntaxKind[SymbolSpan]
+ (736,102)SyntaxKind[Terminal](text = ")")
+ (736,106)SyntaxKind[SymbolSpan]
+ (736,106)SyntaxKind[Nonterminal]
+ (736,106)SyntaxKind[Identifier](text = "Statement")
+ (736,115)SyntaxKind[ArgumentList]
+ (736,115)SyntaxKind[OpenBracketToken]
+ (736,116)SyntaxKind[Argument]?
+ (736,116)SyntaxKind[QuestionToken]
+ (736,117)SyntaxKind[Identifier](text = "Yield")
+ (736,124)SyntaxKind[Argument]?
+ (736,124)SyntaxKind[QuestionToken]
+ (736,125)SyntaxKind[Identifier](text = "Return")
+ (736,131)SyntaxKind[CloseBracketToken]
+ (737,2)SyntaxKind[RightHandSide]
+ (737,2)SyntaxKind[SymbolSpan]
+ (737,2)SyntaxKind[Terminal](text = "for")
+ (737,8)SyntaxKind[SymbolSpan]
+ (737,8)SyntaxKind[Terminal](text = "(")
+ (737,12)SyntaxKind[SymbolSpan]
+ (737,12)SyntaxKind[Terminal](text = "var")
+ (737,18)SyntaxKind[SymbolSpan]
+ (737,18)SyntaxKind[Nonterminal]
+ (737,18)SyntaxKind[Identifier](text = "ForBinding")
+ (737,28)SyntaxKind[ArgumentList]
+ (737,28)SyntaxKind[OpenBracketToken]
+ (737,29)SyntaxKind[Argument]?
+ (737,29)SyntaxKind[QuestionToken]
+ (737,30)SyntaxKind[Identifier](text = "Yield")
+ (737,35)SyntaxKind[CloseBracketToken]
+ (737,37)SyntaxKind[SymbolSpan]
+ (737,37)SyntaxKind[Terminal](text = "of")
+ (737,42)SyntaxKind[SymbolSpan]
+ (737,42)SyntaxKind[Nonterminal]
+ (737,42)SyntaxKind[Identifier](text = "AssignmentExpression")
+ (737,62)SyntaxKind[ArgumentList]
+ (737,62)SyntaxKind[OpenBracketToken]
+ (737,63)SyntaxKind[Argument]
+ (737,63)SyntaxKind[Identifier](text = "In")
+ (737,67)SyntaxKind[Argument]?
+ (737,67)SyntaxKind[QuestionToken]
+ (737,68)SyntaxKind[Identifier](text = "Yield")
+ (737,73)SyntaxKind[CloseBracketToken]
+ (737,75)SyntaxKind[SymbolSpan]
+ (737,75)SyntaxKind[Terminal](text = ")")
+ (737,79)SyntaxKind[SymbolSpan]
+ (737,79)SyntaxKind[Nonterminal]
+ (737,79)SyntaxKind[Identifier](text = "Statement")
+ (737,88)SyntaxKind[ArgumentList]
+ (737,88)SyntaxKind[OpenBracketToken]
+ (737,89)SyntaxKind[Argument]?
+ (737,89)SyntaxKind[QuestionToken]
+ (737,90)SyntaxKind[Identifier](text = "Yield")
+ (737,97)SyntaxKind[Argument]?
+ (737,97)SyntaxKind[QuestionToken]
+ (737,98)SyntaxKind[Identifier](text = "Return")
+ (737,104)SyntaxKind[CloseBracketToken]
+ (738,2)SyntaxKind[RightHandSide]
+ (738,2)SyntaxKind[SymbolSpan]
+ (738,2)SyntaxKind[Terminal](text = "for")
+ (738,8)SyntaxKind[SymbolSpan]
+ (738,8)SyntaxKind[Terminal](text = "(")
+ (738,12)SyntaxKind[SymbolSpan]
+ (738,12)SyntaxKind[Nonterminal]
+ (738,12)SyntaxKind[Identifier](text = "ForDeclaration")
+ (738,26)SyntaxKind[ArgumentList]
+ (738,26)SyntaxKind[OpenBracketToken]
+ (738,27)SyntaxKind[Argument]?
+ (738,27)SyntaxKind[QuestionToken]
+ (738,28)SyntaxKind[Identifier](text = "Yield")
+ (738,33)SyntaxKind[CloseBracketToken]
+ (738,35)SyntaxKind[SymbolSpan]
+ (738,35)SyntaxKind[Terminal](text = "of")
+ (738,40)SyntaxKind[SymbolSpan]
+ (738,40)SyntaxKind[Nonterminal]
+ (738,40)SyntaxKind[Identifier](text = "AssignmentExpression")
+ (738,60)SyntaxKind[ArgumentList]
+ (738,60)SyntaxKind[OpenBracketToken]
+ (738,61)SyntaxKind[Argument]
+ (738,61)SyntaxKind[Identifier](text = "In")
+ (738,65)SyntaxKind[Argument]?
+ (738,65)SyntaxKind[QuestionToken]
+ (738,66)SyntaxKind[Identifier](text = "Yield")
+ (738,71)SyntaxKind[CloseBracketToken]
+ (738,73)SyntaxKind[SymbolSpan]
+ (738,73)SyntaxKind[Terminal](text = ")")
+ (738,77)SyntaxKind[SymbolSpan]
+ (738,77)SyntaxKind[Nonterminal]
+ (738,77)SyntaxKind[Identifier](text = "Statement")
+ (738,86)SyntaxKind[ArgumentList]
+ (738,86)SyntaxKind[OpenBracketToken]
+ (738,87)SyntaxKind[Argument]?
+ (738,87)SyntaxKind[QuestionToken]
+ (738,88)SyntaxKind[Identifier](text = "Yield")
+ (738,95)SyntaxKind[Argument]?
+ (738,95)SyntaxKind[QuestionToken]
+ (738,96)SyntaxKind[Identifier](text = "Return")
+ (738,102)SyntaxKind[CloseBracketToken]
+ (739,1)SyntaxKind[DedentToken]
+ (740,1)SyntaxKind[Production]
+ (740,1)SyntaxKind[Identifier](text = "ForDeclaration")
+ (740,15)SyntaxKind[ParameterList]
+ (740,15)SyntaxKind[OpenBracketToken]
+ (740,16)SyntaxKind[Parameter]
+ (740,16)SyntaxKind[Identifier](text = "Yield")
+ (740,21)SyntaxKind[CloseBracketToken]
+ (741,1)SyntaxKind[RightHandSideList]
+ (741,1)SyntaxKind[IndentToken]
+ (741,2)SyntaxKind[RightHandSide]
+ (741,2)SyntaxKind[SymbolSpan]
+ (741,2)SyntaxKind[Nonterminal]
+ (741,2)SyntaxKind[Identifier](text = "LetOrConst")
+ (741,13)SyntaxKind[SymbolSpan]
+ (741,13)SyntaxKind[Nonterminal]
+ (741,13)SyntaxKind[Identifier](text = "ForBinding")
+ (741,23)SyntaxKind[ArgumentList]
+ (741,23)SyntaxKind[OpenBracketToken]
+ (741,24)SyntaxKind[Argument]?
+ (741,24)SyntaxKind[QuestionToken]
+ (741,25)SyntaxKind[Identifier](text = "Yield")
+ (741,30)SyntaxKind[CloseBracketToken]
+ (742,1)SyntaxKind[DedentToken]
+ (743,1)SyntaxKind[Production]
+ (743,1)SyntaxKind[Identifier](text = "ForBinding")
+ (743,11)SyntaxKind[ParameterList]
+ (743,11)SyntaxKind[OpenBracketToken]
+ (743,12)SyntaxKind[Parameter]
+ (743,12)SyntaxKind[Identifier](text = "Yield")
+ (743,17)SyntaxKind[CloseBracketToken]
+ (744,1)SyntaxKind[RightHandSideList]
+ (744,1)SyntaxKind[IndentToken]
+ (744,2)SyntaxKind[RightHandSide]
+ (744,2)SyntaxKind[SymbolSpan]
+ (744,2)SyntaxKind[Nonterminal]
+ (744,2)SyntaxKind[Identifier](text = "BindingIdentifier")
+ (744,19)SyntaxKind[ArgumentList]
+ (744,19)SyntaxKind[OpenBracketToken]
+ (744,20)SyntaxKind[Argument]?
+ (744,20)SyntaxKind[QuestionToken]
+ (744,21)SyntaxKind[Identifier](text = "Yield")
+ (744,26)SyntaxKind[CloseBracketToken]
+ (745,2)SyntaxKind[RightHandSide]
+ (745,2)SyntaxKind[SymbolSpan]
+ (745,2)SyntaxKind[Nonterminal]
+ (745,2)SyntaxKind[Identifier](text = "BindingPattern")
+ (745,16)SyntaxKind[ArgumentList]
+ (745,16)SyntaxKind[OpenBracketToken]
+ (745,17)SyntaxKind[Argument]?
+ (745,17)SyntaxKind[QuestionToken]
+ (745,18)SyntaxKind[Identifier](text = "Yield")
+ (745,23)SyntaxKind[CloseBracketToken]
+ (746,1)SyntaxKind[DedentToken]
+ (747,1)SyntaxKind[Production]
+ (747,1)SyntaxKind[Identifier](text = "ContinueStatement")
+ (747,18)SyntaxKind[ParameterList]
+ (747,18)SyntaxKind[OpenBracketToken]
+ (747,19)SyntaxKind[Parameter]
+ (747,19)SyntaxKind[Identifier](text = "Yield")
+ (747,24)SyntaxKind[CloseBracketToken]
+ (748,1)SyntaxKind[RightHandSideList]
+ (748,1)SyntaxKind[IndentToken]
+ (748,2)SyntaxKind[RightHandSide]
+ (748,2)SyntaxKind[SymbolSpan]
+ (748,2)SyntaxKind[Terminal](text = "continue")
+ (748,13)SyntaxKind[SymbolSpan]
+ (748,13)SyntaxKind[Terminal](text = ";")
+ (749,2)SyntaxKind[RightHandSide]
+ (749,2)SyntaxKind[SymbolSpan]
+ (749,2)SyntaxKind[Terminal](text = "continue")
+ (749,13)SyntaxKind[SymbolSpan]
+ (749,13)SyntaxKind[NoSymbolHereAssertion]
+ (749,13)SyntaxKind[OpenBracketToken]
+ (749,14)SyntaxKind[NoKeyword]
+ (749,17)SyntaxKind[Nonterminal]
+ (749,17)SyntaxKind[Identifier](text = "LineTerminator")
+ (749,32)SyntaxKind[HereKeyword]
+ (749,36)SyntaxKind[CloseBracketToken]
+ (749,38)SyntaxKind[SymbolSpan]
+ (749,38)SyntaxKind[Nonterminal]
+ (749,38)SyntaxKind[Identifier](text = "LabelIdentifier")
+ (749,53)SyntaxKind[ArgumentList]
+ (749,53)SyntaxKind[OpenBracketToken]
+ (749,54)SyntaxKind[Argument]?
+ (749,54)SyntaxKind[QuestionToken]
+ (749,55)SyntaxKind[Identifier](text = "Yield")
+ (749,60)SyntaxKind[CloseBracketToken]
+ (749,62)SyntaxKind[SymbolSpan]
+ (749,62)SyntaxKind[Terminal](text = ";")
+ (750,1)SyntaxKind[DedentToken]
+ (751,1)SyntaxKind[Production]
+ (751,1)SyntaxKind[Identifier](text = "BreakStatement")
+ (751,15)SyntaxKind[ParameterList]
+ (751,15)SyntaxKind[OpenBracketToken]
+ (751,16)SyntaxKind[Parameter]
+ (751,16)SyntaxKind[Identifier](text = "Yield")
+ (751,21)SyntaxKind[CloseBracketToken]
+ (752,1)SyntaxKind[RightHandSideList]
+ (752,1)SyntaxKind[IndentToken]
+ (752,2)SyntaxKind[RightHandSide]
+ (752,2)SyntaxKind[SymbolSpan]
+ (752,2)SyntaxKind[Terminal](text = "break")
+ (752,10)SyntaxKind[SymbolSpan]
+ (752,10)SyntaxKind[Terminal](text = ";")
+ (753,2)SyntaxKind[RightHandSide]
+ (753,2)SyntaxKind[SymbolSpan]
+ (753,2)SyntaxKind[Terminal](text = "break")
+ (753,10)SyntaxKind[SymbolSpan]
+ (753,10)SyntaxKind[NoSymbolHereAssertion]
+ (753,10)SyntaxKind[OpenBracketToken]
+ (753,11)SyntaxKind[NoKeyword]
+ (753,14)SyntaxKind[Nonterminal]
+ (753,14)SyntaxKind[Identifier](text = "LineTerminator")
+ (753,29)SyntaxKind[HereKeyword]
+ (753,33)SyntaxKind[CloseBracketToken]
+ (753,35)SyntaxKind[SymbolSpan]
+ (753,35)SyntaxKind[Nonterminal]
+ (753,35)SyntaxKind[Identifier](text = "LabelIdentifier")
+ (753,50)SyntaxKind[ArgumentList]
+ (753,50)SyntaxKind[OpenBracketToken]
+ (753,51)SyntaxKind[Argument]?
+ (753,51)SyntaxKind[QuestionToken]
+ (753,52)SyntaxKind[Identifier](text = "Yield")
+ (753,57)SyntaxKind[CloseBracketToken]
+ (753,59)SyntaxKind[SymbolSpan]
+ (753,59)SyntaxKind[Terminal](text = ";")
+ (754,1)SyntaxKind[DedentToken]
+ (755,1)SyntaxKind[Production]
+ (755,1)SyntaxKind[Identifier](text = "ReturnStatement")
+ (755,16)SyntaxKind[ParameterList]
+ (755,16)SyntaxKind[OpenBracketToken]
+ (755,17)SyntaxKind[Parameter]
+ (755,17)SyntaxKind[Identifier](text = "Yield")
+ (755,22)SyntaxKind[CloseBracketToken]
+ (756,1)SyntaxKind[RightHandSideList]
+ (756,1)SyntaxKind[IndentToken]
+ (756,2)SyntaxKind[RightHandSide]
+ (756,2)SyntaxKind[SymbolSpan]
+ (756,2)SyntaxKind[Terminal](text = "return")
+ (756,11)SyntaxKind[SymbolSpan]
+ (756,11)SyntaxKind[Terminal](text = ";")
+ (757,2)SyntaxKind[RightHandSide]
+ (757,2)SyntaxKind[SymbolSpan]
+ (757,2)SyntaxKind[Terminal](text = "return")
+ (757,11)SyntaxKind[SymbolSpan]
+ (757,11)SyntaxKind[NoSymbolHereAssertion]
+ (757,11)SyntaxKind[OpenBracketToken]
+ (757,12)SyntaxKind[NoKeyword]
+ (757,15)SyntaxKind[Nonterminal]
+ (757,15)SyntaxKind[Identifier](text = "LineTerminator")
+ (757,30)SyntaxKind[HereKeyword]
+ (757,34)SyntaxKind[CloseBracketToken]
+ (757,36)SyntaxKind[SymbolSpan]
+ (757,36)SyntaxKind[Nonterminal]
+ (757,36)SyntaxKind[Identifier](text = "Expression")
+ (757,46)SyntaxKind[ArgumentList]
+ (757,46)SyntaxKind[OpenBracketToken]
+ (757,47)SyntaxKind[Argument]
+ (757,47)SyntaxKind[Identifier](text = "In")
+ (757,51)SyntaxKind[Argument]?
+ (757,51)SyntaxKind[QuestionToken]
+ (757,52)SyntaxKind[Identifier](text = "Yield")
+ (757,57)SyntaxKind[CloseBracketToken]
+ (757,59)SyntaxKind[SymbolSpan]
+ (757,59)SyntaxKind[Terminal](text = ";")
+ (758,1)SyntaxKind[DedentToken]
+ (759,1)SyntaxKind[Production]
+ (759,1)SyntaxKind[Identifier](text = "WithStatement")
+ (759,14)SyntaxKind[ParameterList]
+ (759,14)SyntaxKind[OpenBracketToken]
+ (759,15)SyntaxKind[Parameter]
+ (759,15)SyntaxKind[Identifier](text = "Yield")
+ (759,22)SyntaxKind[Parameter]
+ (759,22)SyntaxKind[Identifier](text = "Return")
+ (759,28)SyntaxKind[CloseBracketToken]
+ (760,1)SyntaxKind[RightHandSideList]
+ (760,1)SyntaxKind[IndentToken]
+ (760,2)SyntaxKind[RightHandSide]
+ (760,2)SyntaxKind[SymbolSpan]
+ (760,2)SyntaxKind[Terminal](text = "with")
+ (760,9)SyntaxKind[SymbolSpan]
+ (760,9)SyntaxKind[Terminal](text = "(")
+ (760,13)SyntaxKind[SymbolSpan]
+ (760,13)SyntaxKind[Nonterminal]
+ (760,13)SyntaxKind[Identifier](text = "Expression")
+ (760,23)SyntaxKind[ArgumentList]
+ (760,23)SyntaxKind[OpenBracketToken]
+ (760,24)SyntaxKind[Argument]
+ (760,24)SyntaxKind[Identifier](text = "In")
+ (760,28)SyntaxKind[Argument]?
+ (760,28)SyntaxKind[QuestionToken]
+ (760,29)SyntaxKind[Identifier](text = "Yield")
+ (760,34)SyntaxKind[CloseBracketToken]
+ (760,36)SyntaxKind[SymbolSpan]
+ (760,36)SyntaxKind[Terminal](text = ")")
+ (760,40)SyntaxKind[SymbolSpan]
+ (760,40)SyntaxKind[Nonterminal]
+ (760,40)SyntaxKind[Identifier](text = "Statement")
+ (760,49)SyntaxKind[ArgumentList]
+ (760,49)SyntaxKind[OpenBracketToken]
+ (760,50)SyntaxKind[Argument]?
+ (760,50)SyntaxKind[QuestionToken]
+ (760,51)SyntaxKind[Identifier](text = "Yield")
+ (760,58)SyntaxKind[Argument]?
+ (760,58)SyntaxKind[QuestionToken]
+ (760,59)SyntaxKind[Identifier](text = "Return")
+ (760,65)SyntaxKind[CloseBracketToken]
+ (761,1)SyntaxKind[DedentToken]
+ (762,1)SyntaxKind[Production]
+ (762,1)SyntaxKind[Identifier](text = "SwitchStatement")
+ (762,16)SyntaxKind[ParameterList]
+ (762,16)SyntaxKind[OpenBracketToken]
+ (762,17)SyntaxKind[Parameter]
+ (762,17)SyntaxKind[Identifier](text = "Yield")
+ (762,24)SyntaxKind[Parameter]
+ (762,24)SyntaxKind[Identifier](text = "Return")
+ (762,30)SyntaxKind[CloseBracketToken]
+ (763,1)SyntaxKind[RightHandSideList]
+ (763,1)SyntaxKind[IndentToken]
+ (763,2)SyntaxKind[RightHandSide]
+ (763,2)SyntaxKind[SymbolSpan]
+ (763,2)SyntaxKind[Terminal](text = "switch")
+ (763,11)SyntaxKind[SymbolSpan]
+ (763,11)SyntaxKind[Terminal](text = "(")
+ (763,15)SyntaxKind[SymbolSpan]
+ (763,15)SyntaxKind[Nonterminal]
+ (763,15)SyntaxKind[Identifier](text = "Expression")
+ (763,25)SyntaxKind[ArgumentList]
+ (763,25)SyntaxKind[OpenBracketToken]
+ (763,26)SyntaxKind[Argument]
+ (763,26)SyntaxKind[Identifier](text = "In")
+ (763,30)SyntaxKind[Argument]?
+ (763,30)SyntaxKind[QuestionToken]
+ (763,31)SyntaxKind[Identifier](text = "Yield")
+ (763,36)SyntaxKind[CloseBracketToken]
+ (763,38)SyntaxKind[SymbolSpan]
+ (763,38)SyntaxKind[Terminal](text = ")")
+ (763,42)SyntaxKind[SymbolSpan]
+ (763,42)SyntaxKind[Nonterminal]
+ (763,42)SyntaxKind[Identifier](text = "CaseBlock")
+ (763,51)SyntaxKind[ArgumentList]
+ (763,51)SyntaxKind[OpenBracketToken]
+ (763,52)SyntaxKind[Argument]?
+ (763,52)SyntaxKind[QuestionToken]
+ (763,53)SyntaxKind[Identifier](text = "Yield")
+ (763,60)SyntaxKind[Argument]?
+ (763,60)SyntaxKind[QuestionToken]
+ (763,61)SyntaxKind[Identifier](text = "Return")
+ (763,67)SyntaxKind[CloseBracketToken]
+ (764,1)SyntaxKind[DedentToken]
+ (765,1)SyntaxKind[Production]
+ (765,1)SyntaxKind[Identifier](text = "CaseBlock")
+ (765,10)SyntaxKind[ParameterList]
+ (765,10)SyntaxKind[OpenBracketToken]
+ (765,11)SyntaxKind[Parameter]
+ (765,11)SyntaxKind[Identifier](text = "Yield")
+ (765,18)SyntaxKind[Parameter]
+ (765,18)SyntaxKind[Identifier](text = "Return")
+ (765,24)SyntaxKind[CloseBracketToken]
+ (766,1)SyntaxKind[RightHandSideList]
+ (766,1)SyntaxKind[IndentToken]
+ (766,2)SyntaxKind[RightHandSide]
+ (766,2)SyntaxKind[SymbolSpan]
+ (766,2)SyntaxKind[Terminal](text = "{")
+ (766,6)SyntaxKind[SymbolSpan]
+ (766,6)SyntaxKind[Nonterminal]?
+ (766,6)SyntaxKind[Identifier](text = "CaseClauses")
+ (766,17)SyntaxKind[ArgumentList]
+ (766,17)SyntaxKind[OpenBracketToken]
+ (766,18)SyntaxKind[Argument]?
+ (766,18)SyntaxKind[QuestionToken]
+ (766,19)SyntaxKind[Identifier](text = "Yield")
+ (766,26)SyntaxKind[Argument]?
+ (766,26)SyntaxKind[QuestionToken]
+ (766,27)SyntaxKind[Identifier](text = "Return")
+ (766,33)SyntaxKind[CloseBracketToken]
+ (766,34)SyntaxKind[QuestionToken]
+ (766,36)SyntaxKind[SymbolSpan]
+ (766,36)SyntaxKind[Terminal](text = "}")
+ (767,2)SyntaxKind[RightHandSide]
+ (767,2)SyntaxKind[SymbolSpan]
+ (767,2)SyntaxKind[Terminal](text = "{")
+ (767,6)SyntaxKind[SymbolSpan]
+ (767,6)SyntaxKind[Nonterminal]?
+ (767,6)SyntaxKind[Identifier](text = "CaseClauses")
+ (767,17)SyntaxKind[ArgumentList]
+ (767,17)SyntaxKind[OpenBracketToken]
+ (767,18)SyntaxKind[Argument]?
+ (767,18)SyntaxKind[QuestionToken]
+ (767,19)SyntaxKind[Identifier](text = "Yield")
+ (767,26)SyntaxKind[Argument]?
+ (767,26)SyntaxKind[QuestionToken]
+ (767,27)SyntaxKind[Identifier](text = "Return")
+ (767,33)SyntaxKind[CloseBracketToken]
+ (767,34)SyntaxKind[QuestionToken]
+ (767,36)SyntaxKind[SymbolSpan]
+ (767,36)SyntaxKind[Nonterminal]
+ (767,36)SyntaxKind[Identifier](text = "DefaultClause")
+ (767,49)SyntaxKind[ArgumentList]
+ (767,49)SyntaxKind[OpenBracketToken]
+ (767,50)SyntaxKind[Argument]?
+ (767,50)SyntaxKind[QuestionToken]
+ (767,51)SyntaxKind[Identifier](text = "Yield")
+ (767,58)SyntaxKind[Argument]?
+ (767,58)SyntaxKind[QuestionToken]
+ (767,59)SyntaxKind[Identifier](text = "Return")
+ (767,65)SyntaxKind[CloseBracketToken]
+ (767,67)SyntaxKind[SymbolSpan]
+ (767,67)SyntaxKind[Nonterminal]?
+ (767,67)SyntaxKind[Identifier](text = "CaseClauses")
+ (767,78)SyntaxKind[ArgumentList]
+ (767,78)SyntaxKind[OpenBracketToken]
+ (767,79)SyntaxKind[Argument]?
+ (767,79)SyntaxKind[QuestionToken]
+ (767,80)SyntaxKind[Identifier](text = "Yield")
+ (767,87)SyntaxKind[Argument]?
+ (767,87)SyntaxKind[QuestionToken]
+ (767,88)SyntaxKind[Identifier](text = "Return")
+ (767,94)SyntaxKind[CloseBracketToken]
+ (767,95)SyntaxKind[QuestionToken]
+ (767,97)SyntaxKind[SymbolSpan]
+ (767,97)SyntaxKind[Terminal](text = "}")
+ (768,1)SyntaxKind[DedentToken]
+ (769,1)SyntaxKind[Production]
+ (769,1)SyntaxKind[Identifier](text = "CaseClauses")
+ (769,12)SyntaxKind[ParameterList]
+ (769,12)SyntaxKind[OpenBracketToken]
+ (769,13)SyntaxKind[Parameter]
+ (769,13)SyntaxKind[Identifier](text = "Yield")
+ (769,20)SyntaxKind[Parameter]
+ (769,20)SyntaxKind[Identifier](text = "Return")
+ (769,26)SyntaxKind[CloseBracketToken]
+ (770,1)SyntaxKind[RightHandSideList]
+ (770,1)SyntaxKind[IndentToken]
+ (770,2)SyntaxKind[RightHandSide]
+ (770,2)SyntaxKind[SymbolSpan]
+ (770,2)SyntaxKind[Nonterminal]
+ (770,2)SyntaxKind[Identifier](text = "CaseClause")
+ (770,12)SyntaxKind[ArgumentList]
+ (770,12)SyntaxKind[OpenBracketToken]
+ (770,13)SyntaxKind[Argument]?
+ (770,13)SyntaxKind[QuestionToken]
+ (770,14)SyntaxKind[Identifier](text = "Yield")
+ (770,21)SyntaxKind[Argument]?
+ (770,21)SyntaxKind[QuestionToken]
+ (770,22)SyntaxKind[Identifier](text = "Return")
+ (770,28)SyntaxKind[CloseBracketToken]
+ (771,2)SyntaxKind[RightHandSide]
+ (771,2)SyntaxKind[SymbolSpan]
+ (771,2)SyntaxKind[Nonterminal]
+ (771,2)SyntaxKind[Identifier](text = "CaseClauses")
+ (771,13)SyntaxKind[ArgumentList]
+ (771,13)SyntaxKind[OpenBracketToken]
+ (771,14)SyntaxKind[Argument]?
+ (771,14)SyntaxKind[QuestionToken]
+ (771,15)SyntaxKind[Identifier](text = "Yield")
+ (771,22)SyntaxKind[Argument]?
+ (771,22)SyntaxKind[QuestionToken]
+ (771,23)SyntaxKind[Identifier](text = "Return")
+ (771,29)SyntaxKind[CloseBracketToken]
+ (771,31)SyntaxKind[SymbolSpan]
+ (771,31)SyntaxKind[Nonterminal]
+ (771,31)SyntaxKind[Identifier](text = "CaseClause")
+ (771,41)SyntaxKind[ArgumentList]
+ (771,41)SyntaxKind[OpenBracketToken]
+ (771,42)SyntaxKind[Argument]?
+ (771,42)SyntaxKind[QuestionToken]
+ (771,43)SyntaxKind[Identifier](text = "Yield")
+ (771,50)SyntaxKind[Argument]?
+ (771,50)SyntaxKind[QuestionToken]
+ (771,51)SyntaxKind[Identifier](text = "Return")
+ (771,57)SyntaxKind[CloseBracketToken]
+ (772,1)SyntaxKind[DedentToken]
+ (773,1)SyntaxKind[Production]
+ (773,1)SyntaxKind[Identifier](text = "CaseClause")
+ (773,11)SyntaxKind[ParameterList]
+ (773,11)SyntaxKind[OpenBracketToken]
+ (773,12)SyntaxKind[Parameter]
+ (773,12)SyntaxKind[Identifier](text = "Yield")
+ (773,19)SyntaxKind[Parameter]
+ (773,19)SyntaxKind[Identifier](text = "Return")
+ (773,25)SyntaxKind[CloseBracketToken]
+ (774,1)SyntaxKind[RightHandSideList]
+ (774,1)SyntaxKind[IndentToken]
+ (774,2)SyntaxKind[RightHandSide]
+ (774,2)SyntaxKind[SymbolSpan]
+ (774,2)SyntaxKind[Terminal](text = "case")
+ (774,9)SyntaxKind[SymbolSpan]
+ (774,9)SyntaxKind[Nonterminal]
+ (774,9)SyntaxKind[Identifier](text = "Expression")
+ (774,19)SyntaxKind[ArgumentList]
+ (774,19)SyntaxKind[OpenBracketToken]
+ (774,20)SyntaxKind[Argument]
+ (774,20)SyntaxKind[Identifier](text = "In")
+ (774,24)SyntaxKind[Argument]?
+ (774,24)SyntaxKind[QuestionToken]
+ (774,25)SyntaxKind[Identifier](text = "Yield")
+ (774,30)SyntaxKind[CloseBracketToken]
+ (774,32)SyntaxKind[SymbolSpan]
+ (774,32)SyntaxKind[Terminal](text = ":")
+ (774,36)SyntaxKind[SymbolSpan]
+ (774,36)SyntaxKind[Nonterminal]?
+ (774,36)SyntaxKind[Identifier](text = "StatementList")
+ (774,49)SyntaxKind[ArgumentList]
+ (774,49)SyntaxKind[OpenBracketToken]
+ (774,50)SyntaxKind[Argument]?
+ (774,50)SyntaxKind[QuestionToken]
+ (774,51)SyntaxKind[Identifier](text = "Yield")
+ (774,58)SyntaxKind[Argument]?
+ (774,58)SyntaxKind[QuestionToken]
+ (774,59)SyntaxKind[Identifier](text = "Return")
+ (774,65)SyntaxKind[CloseBracketToken]
+ (774,66)SyntaxKind[QuestionToken]
+ (775,1)SyntaxKind[DedentToken]
+ (776,1)SyntaxKind[Production]
+ (776,1)SyntaxKind[Identifier](text = "DefaultClause")
+ (776,14)SyntaxKind[ParameterList]
+ (776,14)SyntaxKind[OpenBracketToken]
+ (776,15)SyntaxKind[Parameter]
+ (776,15)SyntaxKind[Identifier](text = "Yield")
+ (776,22)SyntaxKind[Parameter]
+ (776,22)SyntaxKind[Identifier](text = "Return")
+ (776,28)SyntaxKind[CloseBracketToken]
+ (777,1)SyntaxKind[RightHandSideList]
+ (777,1)SyntaxKind[IndentToken]
+ (777,2)SyntaxKind[RightHandSide]
+ (777,2)SyntaxKind[SymbolSpan]
+ (777,2)SyntaxKind[Terminal](text = "default")
+ (777,12)SyntaxKind[SymbolSpan]
+ (777,12)SyntaxKind[Terminal](text = ":")
+ (777,16)SyntaxKind[SymbolSpan]
+ (777,16)SyntaxKind[Nonterminal]?
+ (777,16)SyntaxKind[Identifier](text = "StatementList")
+ (777,29)SyntaxKind[ArgumentList]
+ (777,29)SyntaxKind[OpenBracketToken]
+ (777,30)SyntaxKind[Argument]?
+ (777,30)SyntaxKind[QuestionToken]
+ (777,31)SyntaxKind[Identifier](text = "Yield")
+ (777,38)SyntaxKind[Argument]?
+ (777,38)SyntaxKind[QuestionToken]
+ (777,39)SyntaxKind[Identifier](text = "Return")
+ (777,45)SyntaxKind[CloseBracketToken]
+ (777,46)SyntaxKind[QuestionToken]
+ (778,1)SyntaxKind[DedentToken]
+ (779,1)SyntaxKind[Production]
+ (779,1)SyntaxKind[Identifier](text = "LabelledStatement")
+ (779,18)SyntaxKind[ParameterList]
+ (779,18)SyntaxKind[OpenBracketToken]
+ (779,19)SyntaxKind[Parameter]
+ (779,19)SyntaxKind[Identifier](text = "Yield")
+ (779,26)SyntaxKind[Parameter]
+ (779,26)SyntaxKind[Identifier](text = "Return")
+ (779,32)SyntaxKind[CloseBracketToken]
+ (780,1)SyntaxKind[RightHandSideList]
+ (780,1)SyntaxKind[IndentToken]
+ (780,2)SyntaxKind[RightHandSide]
+ (780,2)SyntaxKind[SymbolSpan]
+ (780,2)SyntaxKind[Nonterminal]
+ (780,2)SyntaxKind[Identifier](text = "LabelIdentifier")
+ (780,17)SyntaxKind[ArgumentList]
+ (780,17)SyntaxKind[OpenBracketToken]
+ (780,18)SyntaxKind[Argument]?
+ (780,18)SyntaxKind[QuestionToken]
+ (780,19)SyntaxKind[Identifier](text = "Yield")
+ (780,24)SyntaxKind[CloseBracketToken]
+ (780,26)SyntaxKind[SymbolSpan]
+ (780,26)SyntaxKind[Terminal](text = ":")
+ (780,30)SyntaxKind[SymbolSpan]
+ (780,30)SyntaxKind[Nonterminal]
+ (780,30)SyntaxKind[Identifier](text = "LabelledItem")
+ (780,42)SyntaxKind[ArgumentList]
+ (780,42)SyntaxKind[OpenBracketToken]
+ (780,43)SyntaxKind[Argument]?
+ (780,43)SyntaxKind[QuestionToken]
+ (780,44)SyntaxKind[Identifier](text = "Yield")
+ (780,51)SyntaxKind[Argument]?
+ (780,51)SyntaxKind[QuestionToken]
+ (780,52)SyntaxKind[Identifier](text = "Return")
+ (780,58)SyntaxKind[CloseBracketToken]
+ (781,1)SyntaxKind[DedentToken]
+ (782,1)SyntaxKind[Production]
+ (782,1)SyntaxKind[Identifier](text = "LabelledItem")
+ (782,13)SyntaxKind[ParameterList]
+ (782,13)SyntaxKind[OpenBracketToken]
+ (782,14)SyntaxKind[Parameter]
+ (782,14)SyntaxKind[Identifier](text = "Yield")
+ (782,21)SyntaxKind[Parameter]
+ (782,21)SyntaxKind[Identifier](text = "Return")
+ (782,27)SyntaxKind[CloseBracketToken]
+ (783,1)SyntaxKind[RightHandSideList]
+ (783,1)SyntaxKind[IndentToken]
+ (783,2)SyntaxKind[RightHandSide]
+ (783,2)SyntaxKind[SymbolSpan]
+ (783,2)SyntaxKind[Nonterminal]
+ (783,2)SyntaxKind[Identifier](text = "Statement")
+ (783,11)SyntaxKind[ArgumentList]
+ (783,11)SyntaxKind[OpenBracketToken]
+ (783,12)SyntaxKind[Argument]?
+ (783,12)SyntaxKind[QuestionToken]
+ (783,13)SyntaxKind[Identifier](text = "Yield")
+ (783,20)SyntaxKind[Argument]?
+ (783,20)SyntaxKind[QuestionToken]
+ (783,21)SyntaxKind[Identifier](text = "Return")
+ (783,27)SyntaxKind[CloseBracketToken]
+ (784,2)SyntaxKind[RightHandSide]
+ (784,2)SyntaxKind[SymbolSpan]
+ (784,2)SyntaxKind[Nonterminal]
+ (784,2)SyntaxKind[Identifier](text = "FunctionDeclaration")
+ (784,21)SyntaxKind[ArgumentList]
+ (784,21)SyntaxKind[OpenBracketToken]
+ (784,22)SyntaxKind[Argument]?
+ (784,22)SyntaxKind[QuestionToken]
+ (784,23)SyntaxKind[Identifier](text = "Yield")
+ (784,28)SyntaxKind[CloseBracketToken]
+ (785,1)SyntaxKind[DedentToken]
+ (786,1)SyntaxKind[Production]
+ (786,1)SyntaxKind[Identifier](text = "ThrowStatement")
+ (786,15)SyntaxKind[ParameterList]
+ (786,15)SyntaxKind[OpenBracketToken]
+ (786,16)SyntaxKind[Parameter]
+ (786,16)SyntaxKind[Identifier](text = "Yield")
+ (786,21)SyntaxKind[CloseBracketToken]
+ (787,1)SyntaxKind[RightHandSideList]
+ (787,1)SyntaxKind[IndentToken]
+ (787,2)SyntaxKind[RightHandSide]
+ (787,2)SyntaxKind[SymbolSpan]
+ (787,2)SyntaxKind[Terminal](text = "throw")
+ (787,10)SyntaxKind[SymbolSpan]
+ (787,10)SyntaxKind[NoSymbolHereAssertion]
+ (787,10)SyntaxKind[OpenBracketToken]
+ (787,11)SyntaxKind[NoKeyword]
+ (787,14)SyntaxKind[Nonterminal]
+ (787,14)SyntaxKind[Identifier](text = "LineTerminator")
+ (787,29)SyntaxKind[HereKeyword]
+ (787,33)SyntaxKind[CloseBracketToken]
+ (787,35)SyntaxKind[SymbolSpan]
+ (787,35)SyntaxKind[Nonterminal]
+ (787,35)SyntaxKind[Identifier](text = "Expression")
+ (787,45)SyntaxKind[ArgumentList]
+ (787,45)SyntaxKind[OpenBracketToken]
+ (787,46)SyntaxKind[Argument]
+ (787,46)SyntaxKind[Identifier](text = "In")
+ (787,50)SyntaxKind[Argument]?
+ (787,50)SyntaxKind[QuestionToken]
+ (787,51)SyntaxKind[Identifier](text = "Yield")
+ (787,56)SyntaxKind[CloseBracketToken]
+ (787,58)SyntaxKind[SymbolSpan]
+ (787,58)SyntaxKind[Terminal](text = ";")
+ (788,1)SyntaxKind[DedentToken]
+ (789,1)SyntaxKind[Production]
+ (789,1)SyntaxKind[Identifier](text = "TryStatement")
+ (789,13)SyntaxKind[ParameterList]
+ (789,13)SyntaxKind[OpenBracketToken]
+ (789,14)SyntaxKind[Parameter]
+ (789,14)SyntaxKind[Identifier](text = "Yield")
+ (789,21)SyntaxKind[Parameter]
+ (789,21)SyntaxKind[Identifier](text = "Return")
+ (789,27)SyntaxKind[CloseBracketToken]
+ (790,1)SyntaxKind[RightHandSideList]
+ (790,1)SyntaxKind[IndentToken]
+ (790,2)SyntaxKind[RightHandSide]
+ (790,2)SyntaxKind[SymbolSpan]
+ (790,2)SyntaxKind[Terminal](text = "try")
+ (790,8)SyntaxKind[SymbolSpan]
+ (790,8)SyntaxKind[Nonterminal]
+ (790,8)SyntaxKind[Identifier](text = "Block")
+ (790,13)SyntaxKind[ArgumentList]
+ (790,13)SyntaxKind[OpenBracketToken]
+ (790,14)SyntaxKind[Argument]?
+ (790,14)SyntaxKind[QuestionToken]
+ (790,15)SyntaxKind[Identifier](text = "Yield")
+ (790,22)SyntaxKind[Argument]?
+ (790,22)SyntaxKind[QuestionToken]
+ (790,23)SyntaxKind[Identifier](text = "Return")
+ (790,29)SyntaxKind[CloseBracketToken]
+ (790,31)SyntaxKind[SymbolSpan]
+ (790,31)SyntaxKind[Nonterminal]
+ (790,31)SyntaxKind[Identifier](text = "Catch")
+ (790,36)SyntaxKind[ArgumentList]
+ (790,36)SyntaxKind[OpenBracketToken]
+ (790,37)SyntaxKind[Argument]?
+ (790,37)SyntaxKind[QuestionToken]
+ (790,38)SyntaxKind[Identifier](text = "Yield")
+ (790,45)SyntaxKind[Argument]?
+ (790,45)SyntaxKind[QuestionToken]
+ (790,46)SyntaxKind[Identifier](text = "Return")
+ (790,52)SyntaxKind[CloseBracketToken]
+ (791,2)SyntaxKind[RightHandSide]
+ (791,2)SyntaxKind[SymbolSpan]
+ (791,2)SyntaxKind[Terminal](text = "try")
+ (791,8)SyntaxKind[SymbolSpan]
+ (791,8)SyntaxKind[Nonterminal]
+ (791,8)SyntaxKind[Identifier](text = "Block")
+ (791,13)SyntaxKind[ArgumentList]
+ (791,13)SyntaxKind[OpenBracketToken]
+ (791,14)SyntaxKind[Argument]?
+ (791,14)SyntaxKind[QuestionToken]
+ (791,15)SyntaxKind[Identifier](text = "Yield")
+ (791,22)SyntaxKind[Argument]?
+ (791,22)SyntaxKind[QuestionToken]
+ (791,23)SyntaxKind[Identifier](text = "Return")
+ (791,29)SyntaxKind[CloseBracketToken]
+ (791,31)SyntaxKind[SymbolSpan]
+ (791,31)SyntaxKind[Nonterminal]
+ (791,31)SyntaxKind[Identifier](text = "Finally")
+ (791,38)SyntaxKind[ArgumentList]
+ (791,38)SyntaxKind[OpenBracketToken]
+ (791,39)SyntaxKind[Argument]?
+ (791,39)SyntaxKind[QuestionToken]
+ (791,40)SyntaxKind[Identifier](text = "Yield")
+ (791,47)SyntaxKind[Argument]?
+ (791,47)SyntaxKind[QuestionToken]
+ (791,48)SyntaxKind[Identifier](text = "Return")
+ (791,54)SyntaxKind[CloseBracketToken]
+ (792,2)SyntaxKind[RightHandSide]
+ (792,2)SyntaxKind[SymbolSpan]
+ (792,2)SyntaxKind[Terminal](text = "try")
+ (792,8)SyntaxKind[SymbolSpan]
+ (792,8)SyntaxKind[Nonterminal]
+ (792,8)SyntaxKind[Identifier](text = "Block")
+ (792,13)SyntaxKind[ArgumentList]
+ (792,13)SyntaxKind[OpenBracketToken]
+ (792,14)SyntaxKind[Argument]?
+ (792,14)SyntaxKind[QuestionToken]
+ (792,15)SyntaxKind[Identifier](text = "Yield")
+ (792,22)SyntaxKind[Argument]?
+ (792,22)SyntaxKind[QuestionToken]
+ (792,23)SyntaxKind[Identifier](text = "Return")
+ (792,29)SyntaxKind[CloseBracketToken]
+ (792,31)SyntaxKind[SymbolSpan]
+ (792,31)SyntaxKind[Nonterminal]
+ (792,31)SyntaxKind[Identifier](text = "Catch")
+ (792,36)SyntaxKind[ArgumentList]
+ (792,36)SyntaxKind[OpenBracketToken]
+ (792,37)SyntaxKind[Argument]?
+ (792,37)SyntaxKind[QuestionToken]
+ (792,38)SyntaxKind[Identifier](text = "Yield")
+ (792,45)SyntaxKind[Argument]?
+ (792,45)SyntaxKind[QuestionToken]
+ (792,46)SyntaxKind[Identifier](text = "Return")
+ (792,52)SyntaxKind[CloseBracketToken]
+ (792,54)SyntaxKind[SymbolSpan]
+ (792,54)SyntaxKind[Nonterminal]
+ (792,54)SyntaxKind[Identifier](text = "Finally")
+ (792,61)SyntaxKind[ArgumentList]
+ (792,61)SyntaxKind[OpenBracketToken]
+ (792,62)SyntaxKind[Argument]?
+ (792,62)SyntaxKind[QuestionToken]
+ (792,63)SyntaxKind[Identifier](text = "Yield")
+ (792,70)SyntaxKind[Argument]?
+ (792,70)SyntaxKind[QuestionToken]
+ (792,71)SyntaxKind[Identifier](text = "Return")
+ (792,77)SyntaxKind[CloseBracketToken]
+ (793,1)SyntaxKind[DedentToken]
+ (794,1)SyntaxKind[Production]
+ (794,1)SyntaxKind[Identifier](text = "Catch")
+ (794,6)SyntaxKind[ParameterList]
+ (794,6)SyntaxKind[OpenBracketToken]
+ (794,7)SyntaxKind[Parameter]
+ (794,7)SyntaxKind[Identifier](text = "Yield")
+ (794,14)SyntaxKind[Parameter]
+ (794,14)SyntaxKind[Identifier](text = "Return")
+ (794,20)SyntaxKind[CloseBracketToken]
+ (795,1)SyntaxKind[RightHandSideList]
+ (795,1)SyntaxKind[IndentToken]
+ (795,2)SyntaxKind[RightHandSide]
+ (795,2)SyntaxKind[SymbolSpan]
+ (795,2)SyntaxKind[Terminal](text = "catch")
+ (795,10)SyntaxKind[SymbolSpan]
+ (795,10)SyntaxKind[Terminal](text = "(")
+ (795,14)SyntaxKind[SymbolSpan]
+ (795,14)SyntaxKind[Nonterminal]
+ (795,14)SyntaxKind[Identifier](text = "CatchParameter")
+ (795,28)SyntaxKind[ArgumentList]
+ (795,28)SyntaxKind[OpenBracketToken]
+ (795,29)SyntaxKind[Argument]?
+ (795,29)SyntaxKind[QuestionToken]
+ (795,30)SyntaxKind[Identifier](text = "Yield")
+ (795,35)SyntaxKind[CloseBracketToken]
+ (795,37)SyntaxKind[SymbolSpan]
+ (795,37)SyntaxKind[Terminal](text = ")")
+ (795,41)SyntaxKind[SymbolSpan]
+ (795,41)SyntaxKind[Nonterminal]
+ (795,41)SyntaxKind[Identifier](text = "Block")
+ (795,46)SyntaxKind[ArgumentList]
+ (795,46)SyntaxKind[OpenBracketToken]
+ (795,47)SyntaxKind[Argument]?
+ (795,47)SyntaxKind[QuestionToken]
+ (795,48)SyntaxKind[Identifier](text = "Yield")
+ (795,55)SyntaxKind[Argument]?
+ (795,55)SyntaxKind[QuestionToken]
+ (795,56)SyntaxKind[Identifier](text = "Return")
+ (795,62)SyntaxKind[CloseBracketToken]
+ (796,1)SyntaxKind[DedentToken]
+ (797,1)SyntaxKind[Production]
+ (797,1)SyntaxKind[Identifier](text = "Finally")
+ (797,8)SyntaxKind[ParameterList]
+ (797,8)SyntaxKind[OpenBracketToken]
+ (797,9)SyntaxKind[Parameter]
+ (797,9)SyntaxKind[Identifier](text = "Yield")
+ (797,16)SyntaxKind[Parameter]
+ (797,16)SyntaxKind[Identifier](text = "Return")
+ (797,22)SyntaxKind[CloseBracketToken]
+ (798,1)SyntaxKind[RightHandSideList]
+ (798,1)SyntaxKind[IndentToken]
+ (798,2)SyntaxKind[RightHandSide]
+ (798,2)SyntaxKind[SymbolSpan]
+ (798,2)SyntaxKind[Terminal](text = "finally")
+ (798,12)SyntaxKind[SymbolSpan]
+ (798,12)SyntaxKind[Nonterminal]
+ (798,12)SyntaxKind[Identifier](text = "Block")
+ (798,17)SyntaxKind[ArgumentList]
+ (798,17)SyntaxKind[OpenBracketToken]
+ (798,18)SyntaxKind[Argument]?
+ (798,18)SyntaxKind[QuestionToken]
+ (798,19)SyntaxKind[Identifier](text = "Yield")
+ (798,26)SyntaxKind[Argument]?
+ (798,26)SyntaxKind[QuestionToken]
+ (798,27)SyntaxKind[Identifier](text = "Return")
+ (798,33)SyntaxKind[CloseBracketToken]
+ (799,1)SyntaxKind[DedentToken]
+ (800,1)SyntaxKind[Production]
+ (800,1)SyntaxKind[Identifier](text = "CatchParameter")
+ (800,15)SyntaxKind[ParameterList]
+ (800,15)SyntaxKind[OpenBracketToken]
+ (800,16)SyntaxKind[Parameter]
+ (800,16)SyntaxKind[Identifier](text = "Yield")
+ (800,21)SyntaxKind[CloseBracketToken]
+ (801,1)SyntaxKind[RightHandSideList]
+ (801,1)SyntaxKind[IndentToken]
+ (801,2)SyntaxKind[RightHandSide]
+ (801,2)SyntaxKind[SymbolSpan]
+ (801,2)SyntaxKind[Nonterminal]
+ (801,2)SyntaxKind[Identifier](text = "BindingIdentifier")
+ (801,19)SyntaxKind[ArgumentList]
+ (801,19)SyntaxKind[OpenBracketToken]
+ (801,20)SyntaxKind[Argument]?
+ (801,20)SyntaxKind[QuestionToken]
+ (801,21)SyntaxKind[Identifier](text = "Yield")
+ (801,26)SyntaxKind[CloseBracketToken]
+ (802,2)SyntaxKind[RightHandSide]
+ (802,2)SyntaxKind[SymbolSpan]
+ (802,2)SyntaxKind[Nonterminal]
+ (802,2)SyntaxKind[Identifier](text = "BindingPattern")
+ (802,16)SyntaxKind[ArgumentList]
+ (802,16)SyntaxKind[OpenBracketToken]
+ (802,17)SyntaxKind[Argument]?
+ (802,17)SyntaxKind[QuestionToken]
+ (802,18)SyntaxKind[Identifier](text = "Yield")
+ (802,23)SyntaxKind[CloseBracketToken]
+ (803,1)SyntaxKind[DedentToken]
+ (804,1)SyntaxKind[Production]
+ (804,1)SyntaxKind[Identifier](text = "DebuggerStatement")
+ (805,1)SyntaxKind[RightHandSideList]
+ (805,1)SyntaxKind[IndentToken]
+ (805,2)SyntaxKind[RightHandSide]
+ (805,2)SyntaxKind[SymbolSpan]
+ (805,2)SyntaxKind[Terminal](text = "debugger")
+ (805,13)SyntaxKind[SymbolSpan]
+ (805,13)SyntaxKind[Terminal](text = ";")
+ (806,1)SyntaxKind[DedentToken]
+ (809,1)SyntaxKind[Production]
+ (809,1)SyntaxKind[Identifier](text = "FunctionDeclaration")
+ (809,20)SyntaxKind[ParameterList]
+ (809,20)SyntaxKind[OpenBracketToken]
+ (809,21)SyntaxKind[Parameter]
+ (809,21)SyntaxKind[Identifier](text = "Yield")
+ (809,28)SyntaxKind[Parameter]
+ (809,28)SyntaxKind[Identifier](text = "Default")
+ (809,35)SyntaxKind[CloseBracketToken]
+ (810,1)SyntaxKind[RightHandSideList]
+ (810,1)SyntaxKind[IndentToken]
+ (810,2)SyntaxKind[RightHandSide]
+ (810,2)SyntaxKind[SymbolSpan]
+ (810,2)SyntaxKind[Terminal](text = "function")
+ (810,13)SyntaxKind[SymbolSpan]
+ (810,13)SyntaxKind[Nonterminal]
+ (810,13)SyntaxKind[Identifier](text = "BindingIdentifier")
+ (810,30)SyntaxKind[ArgumentList]
+ (810,30)SyntaxKind[OpenBracketToken]
+ (810,31)SyntaxKind[Argument]?
+ (810,31)SyntaxKind[QuestionToken]
+ (810,32)SyntaxKind[Identifier](text = "Yield")
+ (810,37)SyntaxKind[CloseBracketToken]
+ (810,39)SyntaxKind[SymbolSpan]
+ (810,39)SyntaxKind[Terminal](text = "(")
+ (810,43)SyntaxKind[SymbolSpan]
+ (810,43)SyntaxKind[Nonterminal]
+ (810,43)SyntaxKind[Identifier](text = "FormalParameters")
+ (810,60)SyntaxKind[SymbolSpan]
+ (810,60)SyntaxKind[Terminal](text = ")")
+ (810,64)SyntaxKind[SymbolSpan]
+ (810,64)SyntaxKind[Terminal](text = "{")
+ (810,68)SyntaxKind[SymbolSpan]
+ (810,68)SyntaxKind[Nonterminal]
+ (810,68)SyntaxKind[Identifier](text = "FunctionBody")
+ (810,81)SyntaxKind[SymbolSpan]
+ (810,81)SyntaxKind[Terminal](text = "}")
+ (811,2)SyntaxKind[RightHandSide]
+ (811,2)SyntaxKind[SymbolSpan]
+ (811,2)SyntaxKind[ParameterValueAssertion]
+ (811,2)SyntaxKind[OpenBracketToken]
+ (811,3)SyntaxKind[PlusToken]
+ (811,4)SyntaxKind[Identifier](text = "Default")
+ (811,11)SyntaxKind[CloseBracketToken]
+ (811,13)SyntaxKind[SymbolSpan]
+ (811,13)SyntaxKind[Terminal](text = "function")
+ (811,24)SyntaxKind[SymbolSpan]
+ (811,24)SyntaxKind[Terminal](text = "(")
+ (811,28)SyntaxKind[SymbolSpan]
+ (811,28)SyntaxKind[Nonterminal]
+ (811,28)SyntaxKind[Identifier](text = "FormalParameters")
+ (811,45)SyntaxKind[SymbolSpan]
+ (811,45)SyntaxKind[Terminal](text = ")")
+ (811,49)SyntaxKind[SymbolSpan]
+ (811,49)SyntaxKind[Terminal](text = "{")
+ (811,53)SyntaxKind[SymbolSpan]
+ (811,53)SyntaxKind[Nonterminal]
+ (811,53)SyntaxKind[Identifier](text = "FunctionBody")
+ (811,66)SyntaxKind[SymbolSpan]
+ (811,66)SyntaxKind[Terminal](text = "}")
+ (812,1)SyntaxKind[DedentToken]
+ (813,1)SyntaxKind[Production]
+ (813,1)SyntaxKind[Identifier](text = "FunctionExpression")
+ (814,1)SyntaxKind[RightHandSideList]
+ (814,1)SyntaxKind[IndentToken]
+ (814,2)SyntaxKind[RightHandSide]
+ (814,2)SyntaxKind[SymbolSpan]
+ (814,2)SyntaxKind[Terminal](text = "function")
+ (814,13)SyntaxKind[SymbolSpan]
+ (814,13)SyntaxKind[Nonterminal]?
+ (814,13)SyntaxKind[Identifier](text = "BindingIdentifier")
+ (814,30)SyntaxKind[QuestionToken]
+ (814,32)SyntaxKind[SymbolSpan]
+ (814,32)SyntaxKind[Terminal](text = "(")
+ (814,36)SyntaxKind[SymbolSpan]
+ (814,36)SyntaxKind[Nonterminal]
+ (814,36)SyntaxKind[Identifier](text = "FormalParameters")
+ (814,53)SyntaxKind[SymbolSpan]
+ (814,53)SyntaxKind[Terminal](text = ")")
+ (814,57)SyntaxKind[SymbolSpan]
+ (814,57)SyntaxKind[Terminal](text = "{")
+ (814,61)SyntaxKind[SymbolSpan]
+ (814,61)SyntaxKind[Nonterminal]
+ (814,61)SyntaxKind[Identifier](text = "FunctionBody")
+ (814,74)SyntaxKind[SymbolSpan]
+ (814,74)SyntaxKind[Terminal](text = "}")
+ (815,1)SyntaxKind[DedentToken]
+ (816,1)SyntaxKind[Production]
+ (816,1)SyntaxKind[Identifier](text = "StrictFormalParameters")
+ (816,23)SyntaxKind[ParameterList]
+ (816,23)SyntaxKind[OpenBracketToken]
+ (816,24)SyntaxKind[Parameter]
+ (816,24)SyntaxKind[Identifier](text = "Yield")
+ (816,29)SyntaxKind[CloseBracketToken]
+ (817,1)SyntaxKind[RightHandSideList]
+ (817,1)SyntaxKind[IndentToken]
+ (817,2)SyntaxKind[RightHandSide]
+ (817,2)SyntaxKind[SymbolSpan]
+ (817,2)SyntaxKind[Nonterminal]
+ (817,2)SyntaxKind[Identifier](text = "FormalParameters")
+ (817,18)SyntaxKind[ArgumentList]
+ (817,18)SyntaxKind[OpenBracketToken]
+ (817,19)SyntaxKind[Argument]?
+ (817,19)SyntaxKind[QuestionToken]
+ (817,20)SyntaxKind[Identifier](text = "Yield")
+ (817,25)SyntaxKind[CloseBracketToken]
+ (818,1)SyntaxKind[DedentToken]
+ (819,1)SyntaxKind[Production]
+ (819,1)SyntaxKind[Identifier](text = "FormalParameters")
+ (819,17)SyntaxKind[ParameterList]
+ (819,17)SyntaxKind[OpenBracketToken]
+ (819,18)SyntaxKind[Parameter]
+ (819,18)SyntaxKind[Identifier](text = "Yield")
+ (819,23)SyntaxKind[CloseBracketToken]
+ (820,1)SyntaxKind[RightHandSideList]
+ (820,1)SyntaxKind[IndentToken]
+ (820,2)SyntaxKind[RightHandSide]
+ (820,2)SyntaxKind[SymbolSpan]
+ (820,2)SyntaxKind[EmptyAssertion]
+ (820,2)SyntaxKind[OpenBracketToken]
+ (820,3)SyntaxKind[EmptyKeyword]
+ (820,8)SyntaxKind[CloseBracketToken]
+ (821,2)SyntaxKind[RightHandSide]
+ (821,2)SyntaxKind[SymbolSpan]
+ (821,2)SyntaxKind[Nonterminal]
+ (821,2)SyntaxKind[Identifier](text = "FormalParameterList")
+ (821,21)SyntaxKind[ArgumentList]
+ (821,21)SyntaxKind[OpenBracketToken]
+ (821,22)SyntaxKind[Argument]?
+ (821,22)SyntaxKind[QuestionToken]
+ (821,23)SyntaxKind[Identifier](text = "Yield")
+ (821,28)SyntaxKind[CloseBracketToken]
+ (822,1)SyntaxKind[DedentToken]
+ (823,1)SyntaxKind[Production]
+ (823,1)SyntaxKind[Identifier](text = "FormalParameterList")
+ (823,20)SyntaxKind[ParameterList]
+ (823,20)SyntaxKind[OpenBracketToken]
+ (823,21)SyntaxKind[Parameter]
+ (823,21)SyntaxKind[Identifier](text = "Yield")
+ (823,26)SyntaxKind[CloseBracketToken]
+ (824,1)SyntaxKind[RightHandSideList]
+ (824,1)SyntaxKind[IndentToken]
+ (824,2)SyntaxKind[RightHandSide]
+ (824,2)SyntaxKind[SymbolSpan]
+ (824,2)SyntaxKind[Nonterminal]
+ (824,2)SyntaxKind[Identifier](text = "FunctionRestParameter")
+ (824,23)SyntaxKind[ArgumentList]
+ (824,23)SyntaxKind[OpenBracketToken]
+ (824,24)SyntaxKind[Argument]?
+ (824,24)SyntaxKind[QuestionToken]
+ (824,25)SyntaxKind[Identifier](text = "Yield")
+ (824,30)SyntaxKind[CloseBracketToken]
+ (825,2)SyntaxKind[RightHandSide]
+ (825,2)SyntaxKind[SymbolSpan]
+ (825,2)SyntaxKind[Nonterminal]
+ (825,2)SyntaxKind[Identifier](text = "FormalsList")
+ (825,13)SyntaxKind[ArgumentList]
+ (825,13)SyntaxKind[OpenBracketToken]
+ (825,14)SyntaxKind[Argument]?
+ (825,14)SyntaxKind[QuestionToken]
+ (825,15)SyntaxKind[Identifier](text = "Yield")
+ (825,20)SyntaxKind[CloseBracketToken]
+ (826,2)SyntaxKind[RightHandSide]
+ (826,2)SyntaxKind[SymbolSpan]
+ (826,2)SyntaxKind[Nonterminal]
+ (826,2)SyntaxKind[Identifier](text = "FormalsList")
+ (826,13)SyntaxKind[ArgumentList]
+ (826,13)SyntaxKind[OpenBracketToken]
+ (826,14)SyntaxKind[Argument]?
+ (826,14)SyntaxKind[QuestionToken]
+ (826,15)SyntaxKind[Identifier](text = "Yield")
+ (826,20)SyntaxKind[CloseBracketToken]
+ (826,22)SyntaxKind[SymbolSpan]
+ (826,22)SyntaxKind[Terminal](text = ",")
+ (826,26)SyntaxKind[SymbolSpan]
+ (826,26)SyntaxKind[Nonterminal]
+ (826,26)SyntaxKind[Identifier](text = "FunctionRestParameter")
+ (826,47)SyntaxKind[ArgumentList]
+ (826,47)SyntaxKind[OpenBracketToken]
+ (826,48)SyntaxKind[Argument]?
+ (826,48)SyntaxKind[QuestionToken]
+ (826,49)SyntaxKind[Identifier](text = "Yield")
+ (826,54)SyntaxKind[CloseBracketToken]
+ (827,1)SyntaxKind[DedentToken]
+ (828,1)SyntaxKind[Production]
+ (828,1)SyntaxKind[Identifier](text = "FormalsList")
+ (828,12)SyntaxKind[ParameterList]
+ (828,12)SyntaxKind[OpenBracketToken]
+ (828,13)SyntaxKind[Parameter]
+ (828,13)SyntaxKind[Identifier](text = "Yield")
+ (828,18)SyntaxKind[CloseBracketToken]
+ (829,1)SyntaxKind[RightHandSideList]
+ (829,1)SyntaxKind[IndentToken]
+ (829,2)SyntaxKind[RightHandSide]
+ (829,2)SyntaxKind[SymbolSpan]
+ (829,2)SyntaxKind[Nonterminal]
+ (829,2)SyntaxKind[Identifier](text = "FormalParameter")
+ (829,17)SyntaxKind[ArgumentList]
+ (829,17)SyntaxKind[OpenBracketToken]
+ (829,18)SyntaxKind[Argument]?
+ (829,18)SyntaxKind[QuestionToken]
+ (829,19)SyntaxKind[Identifier](text = "Yield")
+ (829,24)SyntaxKind[CloseBracketToken]
+ (830,2)SyntaxKind[RightHandSide]
+ (830,2)SyntaxKind[SymbolSpan]
+ (830,2)SyntaxKind[Nonterminal]
+ (830,2)SyntaxKind[Identifier](text = "FormalsList")
+ (830,13)SyntaxKind[ArgumentList]
+ (830,13)SyntaxKind[OpenBracketToken]
+ (830,14)SyntaxKind[Argument]?
+ (830,14)SyntaxKind[QuestionToken]
+ (830,15)SyntaxKind[Identifier](text = "Yield")
+ (830,20)SyntaxKind[CloseBracketToken]
+ (830,22)SyntaxKind[SymbolSpan]
+ (830,22)SyntaxKind[Terminal](text = ",")
+ (830,26)SyntaxKind[SymbolSpan]
+ (830,26)SyntaxKind[Nonterminal]
+ (830,26)SyntaxKind[Identifier](text = "FormalParameter")
+ (830,41)SyntaxKind[ArgumentList]
+ (830,41)SyntaxKind[OpenBracketToken]
+ (830,42)SyntaxKind[Argument]?
+ (830,42)SyntaxKind[QuestionToken]
+ (830,43)SyntaxKind[Identifier](text = "Yield")
+ (830,48)SyntaxKind[CloseBracketToken]
+ (831,1)SyntaxKind[DedentToken]
+ (832,1)SyntaxKind[Production]
+ (832,1)SyntaxKind[Identifier](text = "FunctionRestParameter")
+ (832,22)SyntaxKind[ParameterList]
+ (832,22)SyntaxKind[OpenBracketToken]
+ (832,23)SyntaxKind[Parameter]
+ (832,23)SyntaxKind[Identifier](text = "Yield")
+ (832,28)SyntaxKind[CloseBracketToken]
+ (833,1)SyntaxKind[RightHandSideList]
+ (833,1)SyntaxKind[IndentToken]
+ (833,2)SyntaxKind[RightHandSide]
+ (833,2)SyntaxKind[SymbolSpan]
+ (833,2)SyntaxKind[Nonterminal]
+ (833,2)SyntaxKind[Identifier](text = "BindingRestElement")
+ (833,20)SyntaxKind[ArgumentList]
+ (833,20)SyntaxKind[OpenBracketToken]
+ (833,21)SyntaxKind[Argument]?
+ (833,21)SyntaxKind[QuestionToken]
+ (833,22)SyntaxKind[Identifier](text = "Yield")
+ (833,27)SyntaxKind[CloseBracketToken]
+ (834,1)SyntaxKind[DedentToken]
+ (835,1)SyntaxKind[Production]
+ (835,1)SyntaxKind[Identifier](text = "FormalParameter")
+ (835,16)SyntaxKind[ParameterList]
+ (835,16)SyntaxKind[OpenBracketToken]
+ (835,17)SyntaxKind[Parameter]
+ (835,17)SyntaxKind[Identifier](text = "Yield")
+ (835,22)SyntaxKind[CloseBracketToken]
+ (836,1)SyntaxKind[RightHandSideList]
+ (836,1)SyntaxKind[IndentToken]
+ (836,2)SyntaxKind[RightHandSide]
+ (836,2)SyntaxKind[SymbolSpan]
+ (836,2)SyntaxKind[Nonterminal]
+ (836,2)SyntaxKind[Identifier](text = "BindingElement")
+ (836,16)SyntaxKind[ArgumentList]
+ (836,16)SyntaxKind[OpenBracketToken]
+ (836,17)SyntaxKind[Argument]?
+ (836,17)SyntaxKind[QuestionToken]
+ (836,18)SyntaxKind[Identifier](text = "Yield")
+ (836,23)SyntaxKind[CloseBracketToken]
+ (837,1)SyntaxKind[DedentToken]
+ (838,1)SyntaxKind[Production]
+ (838,1)SyntaxKind[Identifier](text = "FunctionBody")
+ (838,13)SyntaxKind[ParameterList]
+ (838,13)SyntaxKind[OpenBracketToken]
+ (838,14)SyntaxKind[Parameter]
+ (838,14)SyntaxKind[Identifier](text = "Yield")
+ (838,19)SyntaxKind[CloseBracketToken]
+ (839,1)SyntaxKind[RightHandSideList]
+ (839,1)SyntaxKind[IndentToken]
+ (839,2)SyntaxKind[RightHandSide]
+ (839,2)SyntaxKind[SymbolSpan]
+ (839,2)SyntaxKind[Nonterminal]
+ (839,2)SyntaxKind[Identifier](text = "FunctionStatementList")
+ (839,23)SyntaxKind[ArgumentList]
+ (839,23)SyntaxKind[OpenBracketToken]
+ (839,24)SyntaxKind[Argument]?
+ (839,24)SyntaxKind[QuestionToken]
+ (839,25)SyntaxKind[Identifier](text = "Yield")
+ (839,30)SyntaxKind[CloseBracketToken]
+ (840,1)SyntaxKind[DedentToken]
+ (841,1)SyntaxKind[Production]
+ (841,1)SyntaxKind[Identifier](text = "FunctionStatementList")
+ (841,22)SyntaxKind[ParameterList]
+ (841,22)SyntaxKind[OpenBracketToken]
+ (841,23)SyntaxKind[Parameter]
+ (841,23)SyntaxKind[Identifier](text = "Yield")
+ (841,28)SyntaxKind[CloseBracketToken]
+ (842,1)SyntaxKind[RightHandSideList]
+ (842,1)SyntaxKind[IndentToken]
+ (842,2)SyntaxKind[RightHandSide]
+ (842,2)SyntaxKind[SymbolSpan]
+ (842,2)SyntaxKind[Nonterminal]?
+ (842,2)SyntaxKind[Identifier](text = "StatementList")
+ (842,15)SyntaxKind[ArgumentList]
+ (842,15)SyntaxKind[OpenBracketToken]
+ (842,16)SyntaxKind[Argument]?
+ (842,16)SyntaxKind[QuestionToken]
+ (842,17)SyntaxKind[Identifier](text = "Yield")
+ (842,24)SyntaxKind[Argument]
+ (842,24)SyntaxKind[Identifier](text = "Return")
+ (842,30)SyntaxKind[CloseBracketToken]
+ (842,31)SyntaxKind[QuestionToken]
+ (843,1)SyntaxKind[DedentToken]
+ (844,1)SyntaxKind[Production]
+ (844,1)SyntaxKind[Identifier](text = "ArrowFunction")
+ (844,14)SyntaxKind[ParameterList]
+ (844,14)SyntaxKind[OpenBracketToken]
+ (844,15)SyntaxKind[Parameter]
+ (844,15)SyntaxKind[Identifier](text = "In")
+ (844,19)SyntaxKind[Parameter]
+ (844,19)SyntaxKind[Identifier](text = "Yield")
+ (844,24)SyntaxKind[CloseBracketToken]
+ (845,1)SyntaxKind[RightHandSideList]
+ (845,1)SyntaxKind[IndentToken]
+ (845,2)SyntaxKind[RightHandSide]
+ (845,2)SyntaxKind[SymbolSpan]
+ (845,2)SyntaxKind[Nonterminal]
+ (845,2)SyntaxKind[Identifier](text = "ArrowParameters")
+ (845,17)SyntaxKind[ArgumentList]
+ (845,17)SyntaxKind[OpenBracketToken]
+ (845,18)SyntaxKind[Argument]?
+ (845,18)SyntaxKind[QuestionToken]
+ (845,19)SyntaxKind[Identifier](text = "Yield")
+ (845,24)SyntaxKind[CloseBracketToken]
+ (845,26)SyntaxKind[SymbolSpan]
+ (845,26)SyntaxKind[NoSymbolHereAssertion]
+ (845,26)SyntaxKind[OpenBracketToken]
+ (845,27)SyntaxKind[NoKeyword]
+ (845,30)SyntaxKind[Nonterminal]
+ (845,30)SyntaxKind[Identifier](text = "LineTerminator")
+ (845,45)SyntaxKind[HereKeyword]
+ (845,49)SyntaxKind[CloseBracketToken]
+ (845,51)SyntaxKind[SymbolSpan]
+ (845,51)SyntaxKind[Terminal](text = "=>")
+ (845,56)SyntaxKind[SymbolSpan]
+ (845,56)SyntaxKind[Nonterminal]
+ (845,56)SyntaxKind[Identifier](text = "ConciseBody")
+ (845,67)SyntaxKind[ArgumentList]
+ (845,67)SyntaxKind[OpenBracketToken]
+ (845,68)SyntaxKind[Argument]?
+ (845,68)SyntaxKind[QuestionToken]
+ (845,69)SyntaxKind[Identifier](text = "In")
+ (845,71)SyntaxKind[CloseBracketToken]
+ (846,1)SyntaxKind[DedentToken]
+ (847,1)SyntaxKind[Production]
+ (847,1)SyntaxKind[Identifier](text = "ArrowParameters")
+ (847,16)SyntaxKind[ParameterList]
+ (847,16)SyntaxKind[OpenBracketToken]
+ (847,17)SyntaxKind[Parameter]
+ (847,17)SyntaxKind[Identifier](text = "Yield")
+ (847,22)SyntaxKind[CloseBracketToken]
+ (848,1)SyntaxKind[RightHandSideList]
+ (848,1)SyntaxKind[IndentToken]
+ (848,2)SyntaxKind[RightHandSide]
+ (848,2)SyntaxKind[SymbolSpan]
+ (848,2)SyntaxKind[Nonterminal]
+ (848,2)SyntaxKind[Identifier](text = "BindingIdentifier")
+ (848,19)SyntaxKind[ArgumentList]
+ (848,19)SyntaxKind[OpenBracketToken]
+ (848,20)SyntaxKind[Argument]?
+ (848,20)SyntaxKind[QuestionToken]
+ (848,21)SyntaxKind[Identifier](text = "Yield")
+ (848,26)SyntaxKind[CloseBracketToken]
+ (849,2)SyntaxKind[RightHandSide]
+ (849,2)SyntaxKind[SymbolSpan]
+ (849,2)SyntaxKind[Nonterminal]
+ (849,2)SyntaxKind[Identifier](text = "CoverParenthesizedExpressionAndArrowParameterList")
+ (849,51)SyntaxKind[ArgumentList]
+ (849,51)SyntaxKind[OpenBracketToken]
+ (849,52)SyntaxKind[Argument]?
+ (849,52)SyntaxKind[QuestionToken]
+ (849,53)SyntaxKind[Identifier](text = "Yield")
+ (849,58)SyntaxKind[CloseBracketToken]
+ (850,1)SyntaxKind[DedentToken]
+ (851,1)SyntaxKind[Production]
+ (851,1)SyntaxKind[Identifier](text = "ConciseBody")
+ (851,12)SyntaxKind[ParameterList]
+ (851,12)SyntaxKind[OpenBracketToken]
+ (851,13)SyntaxKind[Parameter]
+ (851,13)SyntaxKind[Identifier](text = "In")
+ (851,15)SyntaxKind[CloseBracketToken]
+ (852,1)SyntaxKind[RightHandSideList]
+ (852,1)SyntaxKind[IndentToken]
+ (852,2)SyntaxKind[RightHandSide]
+ (852,2)SyntaxKind[SymbolSpan]
+ (852,2)SyntaxKind[LookaheadAssertion]
+ (852,2)SyntaxKind[OpenBracketToken]
+ (852,3)SyntaxKind[LookaheadKeyword]
+ (852,13)SyntaxKind[ExclamationEqualsToken]
+ (852,16)SyntaxKind[SymbolSpan]
+ (852,16)SyntaxKind[Terminal](text = "{")
+ (852,19)SyntaxKind[CloseBracketToken]
+ (852,21)SyntaxKind[SymbolSpan]
+ (852,21)SyntaxKind[Nonterminal]
+ (852,21)SyntaxKind[Identifier](text = "AssignmentExpression")
+ (852,41)SyntaxKind[ArgumentList]
+ (852,41)SyntaxKind[OpenBracketToken]
+ (852,42)SyntaxKind[Argument]?
+ (852,42)SyntaxKind[QuestionToken]
+ (852,43)SyntaxKind[Identifier](text = "In")
+ (852,45)SyntaxKind[CloseBracketToken]
+ (853,2)SyntaxKind[RightHandSide]
+ (853,2)SyntaxKind[SymbolSpan]
+ (853,2)SyntaxKind[Terminal](text = "{")
+ (853,6)SyntaxKind[SymbolSpan]
+ (853,6)SyntaxKind[Nonterminal]
+ (853,6)SyntaxKind[Identifier](text = "FunctionBody")
+ (853,19)SyntaxKind[SymbolSpan]
+ (853,19)SyntaxKind[Terminal](text = "}")
+ (854,1)SyntaxKind[DedentToken]
+ (855,1)SyntaxKind[Production]
+ (855,1)SyntaxKind[Identifier](text = "MethodDefinition")
+ (855,17)SyntaxKind[ParameterList]
+ (855,17)SyntaxKind[OpenBracketToken]
+ (855,18)SyntaxKind[Parameter]
+ (855,18)SyntaxKind[Identifier](text = "Yield")
+ (855,23)SyntaxKind[CloseBracketToken]
+ (856,1)SyntaxKind[RightHandSideList]
+ (856,1)SyntaxKind[IndentToken]
+ (856,2)SyntaxKind[RightHandSide]
+ (856,2)SyntaxKind[SymbolSpan]
+ (856,2)SyntaxKind[Nonterminal]
+ (856,2)SyntaxKind[Identifier](text = "PropertyName")
+ (856,14)SyntaxKind[ArgumentList]
+ (856,14)SyntaxKind[OpenBracketToken]
+ (856,15)SyntaxKind[Argument]?
+ (856,15)SyntaxKind[QuestionToken]
+ (856,16)SyntaxKind[Identifier](text = "Yield")
+ (856,21)SyntaxKind[CloseBracketToken]
+ (856,23)SyntaxKind[SymbolSpan]
+ (856,23)SyntaxKind[Terminal](text = "(")
+ (856,27)SyntaxKind[SymbolSpan]
+ (856,27)SyntaxKind[Nonterminal]
+ (856,27)SyntaxKind[Identifier](text = "StrictFormalParameters")
+ (856,50)SyntaxKind[SymbolSpan]
+ (856,50)SyntaxKind[Terminal](text = ")")
+ (856,54)SyntaxKind[SymbolSpan]
+ (856,54)SyntaxKind[Terminal](text = "{")
+ (856,58)SyntaxKind[SymbolSpan]
+ (856,58)SyntaxKind[Nonterminal]
+ (856,58)SyntaxKind[Identifier](text = "FunctionBody")
+ (856,71)SyntaxKind[SymbolSpan]
+ (856,71)SyntaxKind[Terminal](text = "}")
+ (857,2)SyntaxKind[RightHandSide]
+ (857,2)SyntaxKind[SymbolSpan]
+ (857,2)SyntaxKind[Nonterminal]
+ (857,2)SyntaxKind[Identifier](text = "GeneratorMethod")
+ (857,17)SyntaxKind[ArgumentList]
+ (857,17)SyntaxKind[OpenBracketToken]
+ (857,18)SyntaxKind[Argument]?
+ (857,18)SyntaxKind[QuestionToken]
+ (857,19)SyntaxKind[Identifier](text = "Yield")
+ (857,24)SyntaxKind[CloseBracketToken]
+ (858,2)SyntaxKind[RightHandSide]
+ (858,2)SyntaxKind[SymbolSpan]
+ (858,2)SyntaxKind[Terminal](text = "get")
+ (858,8)SyntaxKind[SymbolSpan]
+ (858,8)SyntaxKind[Nonterminal]
+ (858,8)SyntaxKind[Identifier](text = "PropertyName")
+ (858,20)SyntaxKind[ArgumentList]
+ (858,20)SyntaxKind[OpenBracketToken]
+ (858,21)SyntaxKind[Argument]?
+ (858,21)SyntaxKind[QuestionToken]
+ (858,22)SyntaxKind[Identifier](text = "Yield")
+ (858,27)SyntaxKind[CloseBracketToken]
+ (858,29)SyntaxKind[SymbolSpan]
+ (858,29)SyntaxKind[Terminal](text = "(")
+ (858,33)SyntaxKind[SymbolSpan]
+ (858,33)SyntaxKind[Terminal](text = ")")
+ (858,37)SyntaxKind[SymbolSpan]
+ (858,37)SyntaxKind[Terminal](text = "{")
+ (858,41)SyntaxKind[SymbolSpan]
+ (858,41)SyntaxKind[Nonterminal]
+ (858,41)SyntaxKind[Identifier](text = "FunctionBody")
+ (858,54)SyntaxKind[SymbolSpan]
+ (858,54)SyntaxKind[Terminal](text = "}")
+ (859,2)SyntaxKind[RightHandSide]
+ (859,2)SyntaxKind[SymbolSpan]
+ (859,2)SyntaxKind[Terminal](text = "set")
+ (859,8)SyntaxKind[SymbolSpan]
+ (859,8)SyntaxKind[Nonterminal]
+ (859,8)SyntaxKind[Identifier](text = "PropertyName")
+ (859,20)SyntaxKind[ArgumentList]
+ (859,20)SyntaxKind[OpenBracketToken]
+ (859,21)SyntaxKind[Argument]?
+ (859,21)SyntaxKind[QuestionToken]
+ (859,22)SyntaxKind[Identifier](text = "Yield")
+ (859,27)SyntaxKind[CloseBracketToken]
+ (859,29)SyntaxKind[SymbolSpan]
+ (859,29)SyntaxKind[Terminal](text = "(")
+ (859,33)SyntaxKind[SymbolSpan]
+ (859,33)SyntaxKind[Nonterminal]
+ (859,33)SyntaxKind[Identifier](text = "PropertySetParameterList")
+ (859,58)SyntaxKind[SymbolSpan]
+ (859,58)SyntaxKind[Terminal](text = ")")
+ (859,62)SyntaxKind[SymbolSpan]
+ (859,62)SyntaxKind[Terminal](text = "{")
+ (859,66)SyntaxKind[SymbolSpan]
+ (859,66)SyntaxKind[Nonterminal]
+ (859,66)SyntaxKind[Identifier](text = "FunctionBody")
+ (859,79)SyntaxKind[SymbolSpan]
+ (859,79)SyntaxKind[Terminal](text = "}")
+ (860,1)SyntaxKind[DedentToken]
+ (861,1)SyntaxKind[Production]
+ (861,1)SyntaxKind[Identifier](text = "PropertySetParameterList")
+ (862,1)SyntaxKind[RightHandSideList]
+ (862,1)SyntaxKind[IndentToken]
+ (862,2)SyntaxKind[RightHandSide]
+ (862,2)SyntaxKind[SymbolSpan]
+ (862,2)SyntaxKind[Nonterminal]
+ (862,2)SyntaxKind[Identifier](text = "FormalParameter")
+ (863,1)SyntaxKind[DedentToken]
+ (864,1)SyntaxKind[Production]
+ (864,1)SyntaxKind[Identifier](text = "GeneratorMethod")
+ (864,16)SyntaxKind[ParameterList]
+ (864,16)SyntaxKind[OpenBracketToken]
+ (864,17)SyntaxKind[Parameter]
+ (864,17)SyntaxKind[Identifier](text = "Yield")
+ (864,22)SyntaxKind[CloseBracketToken]
+ (865,1)SyntaxKind[RightHandSideList]
+ (865,1)SyntaxKind[IndentToken]
+ (865,2)SyntaxKind[RightHandSide]
+ (865,2)SyntaxKind[SymbolSpan]
+ (865,2)SyntaxKind[Terminal](text = "*")
+ (865,6)SyntaxKind[SymbolSpan]
+ (865,6)SyntaxKind[Nonterminal]
+ (865,6)SyntaxKind[Identifier](text = "PropertyName")
+ (865,18)SyntaxKind[ArgumentList]
+ (865,18)SyntaxKind[OpenBracketToken]
+ (865,19)SyntaxKind[Argument]?
+ (865,19)SyntaxKind[QuestionToken]
+ (865,20)SyntaxKind[Identifier](text = "Yield")
+ (865,25)SyntaxKind[CloseBracketToken]
+ (865,27)SyntaxKind[SymbolSpan]
+ (865,27)SyntaxKind[Terminal](text = "(")
+ (865,31)SyntaxKind[SymbolSpan]
+ (865,31)SyntaxKind[Nonterminal]
+ (865,31)SyntaxKind[Identifier](text = "StrictFormalParameters")
+ (865,53)SyntaxKind[ArgumentList]
+ (865,53)SyntaxKind[OpenBracketToken]
+ (865,54)SyntaxKind[Argument]
+ (865,54)SyntaxKind[Identifier](text = "Yield")
+ (865,59)SyntaxKind[CloseBracketToken]
+ (865,61)SyntaxKind[SymbolSpan]
+ (865,61)SyntaxKind[Terminal](text = ")")
+ (865,65)SyntaxKind[SymbolSpan]
+ (865,65)SyntaxKind[Terminal](text = "{")
+ (865,69)SyntaxKind[SymbolSpan]
+ (865,69)SyntaxKind[Nonterminal]
+ (865,69)SyntaxKind[Identifier](text = "GeneratorBody")
+ (865,83)SyntaxKind[SymbolSpan]
+ (865,83)SyntaxKind[Terminal](text = "}")
+ (866,1)SyntaxKind[DedentToken]
+ (867,1)SyntaxKind[Production]
+ (867,1)SyntaxKind[Identifier](text = "GeneratorDeclaration")
+ (867,21)SyntaxKind[ParameterList]
+ (867,21)SyntaxKind[OpenBracketToken]
+ (867,22)SyntaxKind[Parameter]
+ (867,22)SyntaxKind[Identifier](text = "Yield")
+ (867,29)SyntaxKind[Parameter]
+ (867,29)SyntaxKind[Identifier](text = "Default")
+ (867,36)SyntaxKind[CloseBracketToken]
+ (868,1)SyntaxKind[RightHandSideList]
+ (868,1)SyntaxKind[IndentToken]
+ (868,2)SyntaxKind[RightHandSide]
+ (868,2)SyntaxKind[SymbolSpan]
+ (868,2)SyntaxKind[Terminal](text = "function")
+ (868,13)SyntaxKind[SymbolSpan]
+ (868,13)SyntaxKind[Terminal](text = "*")
+ (868,17)SyntaxKind[SymbolSpan]
+ (868,17)SyntaxKind[Nonterminal]
+ (868,17)SyntaxKind[Identifier](text = "BindingIdentifier")
+ (868,34)SyntaxKind[ArgumentList]
+ (868,34)SyntaxKind[OpenBracketToken]
+ (868,35)SyntaxKind[Argument]?
+ (868,35)SyntaxKind[QuestionToken]
+ (868,36)SyntaxKind[Identifier](text = "Yield")
+ (868,41)SyntaxKind[CloseBracketToken]
+ (868,43)SyntaxKind[SymbolSpan]
+ (868,43)SyntaxKind[Terminal](text = "(")
+ (868,47)SyntaxKind[SymbolSpan]
+ (868,47)SyntaxKind[Nonterminal]
+ (868,47)SyntaxKind[Identifier](text = "FormalParameters")
+ (868,63)SyntaxKind[ArgumentList]
+ (868,63)SyntaxKind[OpenBracketToken]
+ (868,64)SyntaxKind[Argument]
+ (868,64)SyntaxKind[Identifier](text = "Yield")
+ (868,69)SyntaxKind[CloseBracketToken]
+ (868,71)SyntaxKind[SymbolSpan]
+ (868,71)SyntaxKind[Terminal](text = ")")
+ (868,75)SyntaxKind[SymbolSpan]
+ (868,75)SyntaxKind[Terminal](text = "{")
+ (868,79)SyntaxKind[SymbolSpan]
+ (868,79)SyntaxKind[Nonterminal]
+ (868,79)SyntaxKind[Identifier](text = "GeneratorBody")
+ (868,93)SyntaxKind[SymbolSpan]
+ (868,93)SyntaxKind[Terminal](text = "}")
+ (869,2)SyntaxKind[RightHandSide]
+ (869,2)SyntaxKind[SymbolSpan]
+ (869,2)SyntaxKind[ParameterValueAssertion]
+ (869,2)SyntaxKind[OpenBracketToken]
+ (869,3)SyntaxKind[PlusToken]
+ (869,4)SyntaxKind[Identifier](text = "Default")
+ (869,11)SyntaxKind[CloseBracketToken]
+ (869,13)SyntaxKind[SymbolSpan]
+ (869,13)SyntaxKind[Terminal](text = "function")
+ (869,24)SyntaxKind[SymbolSpan]
+ (869,24)SyntaxKind[Terminal](text = "*")
+ (869,28)SyntaxKind[SymbolSpan]
+ (869,28)SyntaxKind[Terminal](text = "(")
+ (869,32)SyntaxKind[SymbolSpan]
+ (869,32)SyntaxKind[Nonterminal]
+ (869,32)SyntaxKind[Identifier](text = "FormalParameters")
+ (869,48)SyntaxKind[ArgumentList]
+ (869,48)SyntaxKind[OpenBracketToken]
+ (869,49)SyntaxKind[Argument]
+ (869,49)SyntaxKind[Identifier](text = "Yield")
+ (869,54)SyntaxKind[CloseBracketToken]
+ (869,56)SyntaxKind[SymbolSpan]
+ (869,56)SyntaxKind[Terminal](text = ")")
+ (869,60)SyntaxKind[SymbolSpan]
+ (869,60)SyntaxKind[Terminal](text = "{")
+ (869,64)SyntaxKind[SymbolSpan]
+ (869,64)SyntaxKind[Nonterminal]
+ (869,64)SyntaxKind[Identifier](text = "GeneratorBody")
+ (869,78)SyntaxKind[SymbolSpan]
+ (869,78)SyntaxKind[Terminal](text = "}")
+ (870,1)SyntaxKind[DedentToken]
+ (871,1)SyntaxKind[Production]
+ (871,1)SyntaxKind[Identifier](text = "GeneratorExpression")
+ (872,1)SyntaxKind[RightHandSideList]
+ (872,1)SyntaxKind[IndentToken]
+ (872,2)SyntaxKind[RightHandSide]
+ (872,2)SyntaxKind[SymbolSpan]
+ (872,2)SyntaxKind[Terminal](text = "function")
+ (872,13)SyntaxKind[SymbolSpan]
+ (872,13)SyntaxKind[Terminal](text = "*")
+ (872,17)SyntaxKind[SymbolSpan]
+ (872,17)SyntaxKind[Nonterminal]?
+ (872,17)SyntaxKind[Identifier](text = "BindingIdentifier")
+ (872,34)SyntaxKind[ArgumentList]
+ (872,34)SyntaxKind[OpenBracketToken]
+ (872,35)SyntaxKind[Argument]
+ (872,35)SyntaxKind[Identifier](text = "Yield")
+ (872,40)SyntaxKind[CloseBracketToken]
+ (872,41)SyntaxKind[QuestionToken]
+ (872,43)SyntaxKind[SymbolSpan]
+ (872,43)SyntaxKind[Terminal](text = "(")
+ (872,47)SyntaxKind[SymbolSpan]
+ (872,47)SyntaxKind[Nonterminal]
+ (872,47)SyntaxKind[Identifier](text = "FormalParameters")
+ (872,63)SyntaxKind[ArgumentList]
+ (872,63)SyntaxKind[OpenBracketToken]
+ (872,64)SyntaxKind[Argument]
+ (872,64)SyntaxKind[Identifier](text = "Yield")
+ (872,69)SyntaxKind[CloseBracketToken]
+ (872,71)SyntaxKind[SymbolSpan]
+ (872,71)SyntaxKind[Terminal](text = ")")
+ (872,75)SyntaxKind[SymbolSpan]
+ (872,75)SyntaxKind[Terminal](text = "{")
+ (872,79)SyntaxKind[SymbolSpan]
+ (872,79)SyntaxKind[Nonterminal]
+ (872,79)SyntaxKind[Identifier](text = "GeneratorBody")
+ (872,93)SyntaxKind[SymbolSpan]
+ (872,93)SyntaxKind[Terminal](text = "}")
+ (873,1)SyntaxKind[DedentToken]
+ (874,1)SyntaxKind[Production]
+ (874,1)SyntaxKind[Identifier](text = "GeneratorBody")
+ (875,1)SyntaxKind[RightHandSideList]
+ (875,1)SyntaxKind[IndentToken]
+ (875,2)SyntaxKind[RightHandSide]
+ (875,2)SyntaxKind[SymbolSpan]
+ (875,2)SyntaxKind[Nonterminal]
+ (875,2)SyntaxKind[Identifier](text = "FunctionBody")
+ (875,14)SyntaxKind[ArgumentList]
+ (875,14)SyntaxKind[OpenBracketToken]
+ (875,15)SyntaxKind[Argument]
+ (875,15)SyntaxKind[Identifier](text = "Yield")
+ (875,20)SyntaxKind[CloseBracketToken]
+ (876,1)SyntaxKind[DedentToken]
+ (877,1)SyntaxKind[Production]
+ (877,1)SyntaxKind[Identifier](text = "YieldExpression")
+ (877,16)SyntaxKind[ParameterList]
+ (877,16)SyntaxKind[OpenBracketToken]
+ (877,17)SyntaxKind[Parameter]
+ (877,17)SyntaxKind[Identifier](text = "In")
+ (877,19)SyntaxKind[CloseBracketToken]
+ (878,1)SyntaxKind[RightHandSideList]
+ (878,1)SyntaxKind[IndentToken]
+ (878,2)SyntaxKind[RightHandSide]
+ (878,2)SyntaxKind[SymbolSpan]
+ (878,2)SyntaxKind[Terminal](text = "yield")
+ (879,2)SyntaxKind[RightHandSide]
+ (879,2)SyntaxKind[SymbolSpan]
+ (879,2)SyntaxKind[Terminal](text = "yield")
+ (879,10)SyntaxKind[SymbolSpan]
+ (879,10)SyntaxKind[NoSymbolHereAssertion]
+ (879,10)SyntaxKind[OpenBracketToken]
+ (879,11)SyntaxKind[NoKeyword]
+ (879,14)SyntaxKind[Nonterminal]
+ (879,14)SyntaxKind[Identifier](text = "LineTerminator")
+ (879,29)SyntaxKind[HereKeyword]
+ (879,33)SyntaxKind[CloseBracketToken]
+ (879,35)SyntaxKind[SymbolSpan]
+ (879,35)SyntaxKind[Nonterminal]
+ (879,35)SyntaxKind[Identifier](text = "AssignmentExpression")
+ (879,55)SyntaxKind[ArgumentList]
+ (879,55)SyntaxKind[OpenBracketToken]
+ (879,56)SyntaxKind[Argument]?
+ (879,56)SyntaxKind[QuestionToken]
+ (879,57)SyntaxKind[Identifier](text = "In")
+ (879,61)SyntaxKind[Argument]
+ (879,61)SyntaxKind[Identifier](text = "Yield")
+ (879,66)SyntaxKind[CloseBracketToken]
+ (880,2)SyntaxKind[RightHandSide]
+ (880,2)SyntaxKind[SymbolSpan]
+ (880,2)SyntaxKind[Terminal](text = "yield")
+ (880,10)SyntaxKind[SymbolSpan]
+ (880,10)SyntaxKind[NoSymbolHereAssertion]
+ (880,10)SyntaxKind[OpenBracketToken]
+ (880,11)SyntaxKind[NoKeyword]
+ (880,14)SyntaxKind[Nonterminal]
+ (880,14)SyntaxKind[Identifier](text = "LineTerminator")
+ (880,29)SyntaxKind[HereKeyword]
+ (880,33)SyntaxKind[CloseBracketToken]
+ (880,35)SyntaxKind[SymbolSpan]
+ (880,35)SyntaxKind[Terminal](text = "*")
+ (880,39)SyntaxKind[SymbolSpan]
+ (880,39)SyntaxKind[Nonterminal]
+ (880,39)SyntaxKind[Identifier](text = "AssignmentExpression")
+ (880,59)SyntaxKind[ArgumentList]
+ (880,59)SyntaxKind[OpenBracketToken]
+ (880,60)SyntaxKind[Argument]?
+ (880,60)SyntaxKind[QuestionToken]
+ (880,61)SyntaxKind[Identifier](text = "In")
+ (880,65)SyntaxKind[Argument]
+ (880,65)SyntaxKind[Identifier](text = "Yield")
+ (880,70)SyntaxKind[CloseBracketToken]
+ (881,1)SyntaxKind[DedentToken]
+ (882,1)SyntaxKind[Production]
+ (882,1)SyntaxKind[Identifier](text = "ClassDeclaration")
+ (882,17)SyntaxKind[ParameterList]
+ (882,17)SyntaxKind[OpenBracketToken]
+ (882,18)SyntaxKind[Parameter]
+ (882,18)SyntaxKind[Identifier](text = "Yield")
+ (882,25)SyntaxKind[Parameter]
+ (882,25)SyntaxKind[Identifier](text = "Default")
+ (882,32)SyntaxKind[CloseBracketToken]
+ (883,1)SyntaxKind[RightHandSideList]
+ (883,1)SyntaxKind[IndentToken]
+ (883,2)SyntaxKind[RightHandSide]
+ (883,2)SyntaxKind[SymbolSpan]
+ (883,2)SyntaxKind[Terminal](text = "class")
+ (883,10)SyntaxKind[SymbolSpan]
+ (883,10)SyntaxKind[Nonterminal]
+ (883,10)SyntaxKind[Identifier](text = "BindingIdentifier")
+ (883,27)SyntaxKind[ArgumentList]
+ (883,27)SyntaxKind[OpenBracketToken]
+ (883,28)SyntaxKind[Argument]?
+ (883,28)SyntaxKind[QuestionToken]
+ (883,29)SyntaxKind[Identifier](text = "Yield")
+ (883,34)SyntaxKind[CloseBracketToken]
+ (883,36)SyntaxKind[SymbolSpan]
+ (883,36)SyntaxKind[Nonterminal]
+ (883,36)SyntaxKind[Identifier](text = "ClassTail")
+ (883,45)SyntaxKind[ArgumentList]
+ (883,45)SyntaxKind[OpenBracketToken]
+ (883,46)SyntaxKind[Argument]?
+ (883,46)SyntaxKind[QuestionToken]
+ (883,47)SyntaxKind[Identifier](text = "Yield")
+ (883,52)SyntaxKind[CloseBracketToken]
+ (884,2)SyntaxKind[RightHandSide]
+ (884,2)SyntaxKind[SymbolSpan]
+ (884,2)SyntaxKind[ParameterValueAssertion]
+ (884,2)SyntaxKind[OpenBracketToken]
+ (884,3)SyntaxKind[PlusToken]
+ (884,4)SyntaxKind[Identifier](text = "Default")
+ (884,11)SyntaxKind[CloseBracketToken]
+ (884,13)SyntaxKind[SymbolSpan]
+ (884,13)SyntaxKind[Terminal](text = "class")
+ (884,21)SyntaxKind[SymbolSpan]
+ (884,21)SyntaxKind[Nonterminal]
+ (884,21)SyntaxKind[Identifier](text = "ClassTail")
+ (884,30)SyntaxKind[ArgumentList]
+ (884,30)SyntaxKind[OpenBracketToken]
+ (884,31)SyntaxKind[Argument]?
+ (884,31)SyntaxKind[QuestionToken]
+ (884,32)SyntaxKind[Identifier](text = "Yield")
+ (884,37)SyntaxKind[CloseBracketToken]
+ (885,1)SyntaxKind[DedentToken]
+ (886,1)SyntaxKind[Production]
+ (886,1)SyntaxKind[Identifier](text = "ClassExpression")
+ (886,16)SyntaxKind[ParameterList]
+ (886,16)SyntaxKind[OpenBracketToken]
+ (886,17)SyntaxKind[Parameter]
+ (886,17)SyntaxKind[Identifier](text = "Yield")
+ (886,22)SyntaxKind[CloseBracketToken]
+ (887,1)SyntaxKind[RightHandSideList]
+ (887,1)SyntaxKind[IndentToken]
+ (887,2)SyntaxKind[RightHandSide]
+ (887,2)SyntaxKind[SymbolSpan]
+ (887,2)SyntaxKind[Terminal](text = "class")
+ (887,10)SyntaxKind[SymbolSpan]
+ (887,10)SyntaxKind[Nonterminal]?
+ (887,10)SyntaxKind[Identifier](text = "BindingIdentifier")
+ (887,27)SyntaxKind[ArgumentList]
+ (887,27)SyntaxKind[OpenBracketToken]
+ (887,28)SyntaxKind[Argument]?
+ (887,28)SyntaxKind[QuestionToken]
+ (887,29)SyntaxKind[Identifier](text = "Yield")
+ (887,34)SyntaxKind[CloseBracketToken]
+ (887,35)SyntaxKind[QuestionToken]
+ (887,37)SyntaxKind[SymbolSpan]
+ (887,37)SyntaxKind[Nonterminal]
+ (887,37)SyntaxKind[Identifier](text = "ClassTail")
+ (887,46)SyntaxKind[ArgumentList]
+ (887,46)SyntaxKind[OpenBracketToken]
+ (887,47)SyntaxKind[Argument]?
+ (887,47)SyntaxKind[QuestionToken]
+ (887,48)SyntaxKind[Identifier](text = "Yield")
+ (887,53)SyntaxKind[CloseBracketToken]
+ (888,1)SyntaxKind[DedentToken]
+ (889,1)SyntaxKind[Production]
+ (889,1)SyntaxKind[Identifier](text = "ClassTail")
+ (889,10)SyntaxKind[ParameterList]
+ (889,10)SyntaxKind[OpenBracketToken]
+ (889,11)SyntaxKind[Parameter]
+ (889,11)SyntaxKind[Identifier](text = "Yield")
+ (889,16)SyntaxKind[CloseBracketToken]
+ (890,1)SyntaxKind[RightHandSideList]
+ (890,1)SyntaxKind[IndentToken]
+ (890,2)SyntaxKind[RightHandSide]
+ (890,2)SyntaxKind[SymbolSpan]
+ (890,2)SyntaxKind[Nonterminal]?
+ (890,2)SyntaxKind[Identifier](text = "ClassHeritage")
+ (890,15)SyntaxKind[ArgumentList]
+ (890,15)SyntaxKind[OpenBracketToken]
+ (890,16)SyntaxKind[Argument]?
+ (890,16)SyntaxKind[QuestionToken]
+ (890,17)SyntaxKind[Identifier](text = "Yield")
+ (890,22)SyntaxKind[CloseBracketToken]
+ (890,23)SyntaxKind[QuestionToken]
+ (890,25)SyntaxKind[SymbolSpan]
+ (890,25)SyntaxKind[Terminal](text = "{")
+ (890,29)SyntaxKind[SymbolSpan]
+ (890,29)SyntaxKind[Nonterminal]?
+ (890,29)SyntaxKind[Identifier](text = "ClassBody")
+ (890,38)SyntaxKind[ArgumentList]
+ (890,38)SyntaxKind[OpenBracketToken]
+ (890,39)SyntaxKind[Argument]?
+ (890,39)SyntaxKind[QuestionToken]
+ (890,40)SyntaxKind[Identifier](text = "Yield")
+ (890,45)SyntaxKind[CloseBracketToken]
+ (890,46)SyntaxKind[QuestionToken]
+ (890,48)SyntaxKind[SymbolSpan]
+ (890,48)SyntaxKind[Terminal](text = "}")
+ (891,1)SyntaxKind[DedentToken]
+ (892,1)SyntaxKind[Production]
+ (892,1)SyntaxKind[Identifier](text = "ClassHeritage")
+ (892,14)SyntaxKind[ParameterList]
+ (892,14)SyntaxKind[OpenBracketToken]
+ (892,15)SyntaxKind[Parameter]
+ (892,15)SyntaxKind[Identifier](text = "Yield")
+ (892,20)SyntaxKind[CloseBracketToken]
+ (893,1)SyntaxKind[RightHandSideList]
+ (893,1)SyntaxKind[IndentToken]
+ (893,2)SyntaxKind[RightHandSide]
+ (893,2)SyntaxKind[SymbolSpan]
+ (893,2)SyntaxKind[Terminal](text = "extends")
+ (893,12)SyntaxKind[SymbolSpan]
+ (893,12)SyntaxKind[Nonterminal]
+ (893,12)SyntaxKind[Identifier](text = "LeftHandSideExpression")
+ (893,34)SyntaxKind[ArgumentList]
+ (893,34)SyntaxKind[OpenBracketToken]
+ (893,35)SyntaxKind[Argument]?
+ (893,35)SyntaxKind[QuestionToken]
+ (893,36)SyntaxKind[Identifier](text = "Yield")
+ (893,41)SyntaxKind[CloseBracketToken]
+ (894,1)SyntaxKind[DedentToken]
+ (895,1)SyntaxKind[Production]
+ (895,1)SyntaxKind[Identifier](text = "ClassBody")
+ (895,10)SyntaxKind[ParameterList]
+ (895,10)SyntaxKind[OpenBracketToken]
+ (895,11)SyntaxKind[Parameter]
+ (895,11)SyntaxKind[Identifier](text = "Yield")
+ (895,16)SyntaxKind[CloseBracketToken]
+ (896,1)SyntaxKind[RightHandSideList]
+ (896,1)SyntaxKind[IndentToken]
+ (896,2)SyntaxKind[RightHandSide]
+ (896,2)SyntaxKind[SymbolSpan]
+ (896,2)SyntaxKind[Nonterminal]
+ (896,2)SyntaxKind[Identifier](text = "ClassElementList")
+ (896,18)SyntaxKind[ArgumentList]
+ (896,18)SyntaxKind[OpenBracketToken]
+ (896,19)SyntaxKind[Argument]?
+ (896,19)SyntaxKind[QuestionToken]
+ (896,20)SyntaxKind[Identifier](text = "Yield")
+ (896,25)SyntaxKind[CloseBracketToken]
+ (897,1)SyntaxKind[DedentToken]
+ (898,1)SyntaxKind[Production]
+ (898,1)SyntaxKind[Identifier](text = "ClassElementList")
+ (898,17)SyntaxKind[ParameterList]
+ (898,17)SyntaxKind[OpenBracketToken]
+ (898,18)SyntaxKind[Parameter]
+ (898,18)SyntaxKind[Identifier](text = "Yield")
+ (898,23)SyntaxKind[CloseBracketToken]
+ (899,1)SyntaxKind[RightHandSideList]
+ (899,1)SyntaxKind[IndentToken]
+ (899,2)SyntaxKind[RightHandSide]
+ (899,2)SyntaxKind[SymbolSpan]
+ (899,2)SyntaxKind[Nonterminal]
+ (899,2)SyntaxKind[Identifier](text = "ClassElement")
+ (899,14)SyntaxKind[ArgumentList]
+ (899,14)SyntaxKind[OpenBracketToken]
+ (899,15)SyntaxKind[Argument]?
+ (899,15)SyntaxKind[QuestionToken]
+ (899,16)SyntaxKind[Identifier](text = "Yield")
+ (899,21)SyntaxKind[CloseBracketToken]
+ (900,2)SyntaxKind[RightHandSide]
+ (900,2)SyntaxKind[SymbolSpan]
+ (900,2)SyntaxKind[Nonterminal]
+ (900,2)SyntaxKind[Identifier](text = "ClassElementList")
+ (900,18)SyntaxKind[ArgumentList]
+ (900,18)SyntaxKind[OpenBracketToken]
+ (900,19)SyntaxKind[Argument]?
+ (900,19)SyntaxKind[QuestionToken]
+ (900,20)SyntaxKind[Identifier](text = "Yield")
+ (900,25)SyntaxKind[CloseBracketToken]
+ (900,28)SyntaxKind[SymbolSpan]
+ (900,28)SyntaxKind[Nonterminal]
+ (900,28)SyntaxKind[Identifier](text = "ClassElement")
+ (900,40)SyntaxKind[ArgumentList]
+ (900,40)SyntaxKind[OpenBracketToken]
+ (900,41)SyntaxKind[Argument]?
+ (900,41)SyntaxKind[QuestionToken]
+ (900,42)SyntaxKind[Identifier](text = "Yield")
+ (900,47)SyntaxKind[CloseBracketToken]
+ (901,1)SyntaxKind[DedentToken]
+ (902,1)SyntaxKind[Production]
+ (902,1)SyntaxKind[Identifier](text = "ClassElement")
+ (902,13)SyntaxKind[ParameterList]
+ (902,13)SyntaxKind[OpenBracketToken]
+ (902,14)SyntaxKind[Parameter]
+ (902,14)SyntaxKind[Identifier](text = "Yield")
+ (902,19)SyntaxKind[CloseBracketToken]
+ (903,1)SyntaxKind[RightHandSideList]
+ (903,1)SyntaxKind[IndentToken]
+ (903,2)SyntaxKind[RightHandSide]
+ (903,2)SyntaxKind[SymbolSpan]
+ (903,2)SyntaxKind[Nonterminal]
+ (903,2)SyntaxKind[Identifier](text = "MethodDefinition")
+ (903,18)SyntaxKind[ArgumentList]
+ (903,18)SyntaxKind[OpenBracketToken]
+ (903,19)SyntaxKind[Argument]?
+ (903,19)SyntaxKind[QuestionToken]
+ (903,20)SyntaxKind[Identifier](text = "Yield")
+ (903,25)SyntaxKind[CloseBracketToken]
+ (904,2)SyntaxKind[RightHandSide]
+ (904,2)SyntaxKind[SymbolSpan]
+ (904,2)SyntaxKind[Terminal](text = "static")
+ (904,11)SyntaxKind[SymbolSpan]
+ (904,11)SyntaxKind[Nonterminal]
+ (904,11)SyntaxKind[Identifier](text = "MethodDefinition")
+ (904,27)SyntaxKind[ArgumentList]
+ (904,27)SyntaxKind[OpenBracketToken]
+ (904,28)SyntaxKind[Argument]?
+ (904,28)SyntaxKind[QuestionToken]
+ (904,29)SyntaxKind[Identifier](text = "Yield")
+ (904,34)SyntaxKind[CloseBracketToken]
+ (905,2)SyntaxKind[RightHandSide]
+ (905,2)SyntaxKind[SymbolSpan]
+ (905,2)SyntaxKind[Terminal](text = ";")
+ (906,1)SyntaxKind[DedentToken]
+ (908,1)SyntaxKind[Production]
+ (908,1)SyntaxKind[Identifier](text = "Script")
+ (909,1)SyntaxKind[RightHandSideList]
+ (909,1)SyntaxKind[IndentToken]
+ (909,2)SyntaxKind[RightHandSide]
+ (909,2)SyntaxKind[SymbolSpan]
+ (909,2)SyntaxKind[Nonterminal]?
+ (909,2)SyntaxKind[Identifier](text = "ScriptBody")
+ (909,12)SyntaxKind[QuestionToken]
+ (910,1)SyntaxKind[DedentToken]
+ (911,1)SyntaxKind[Production]
+ (911,1)SyntaxKind[Identifier](text = "ScriptBody")
+ (912,1)SyntaxKind[RightHandSideList]
+ (912,1)SyntaxKind[IndentToken]
+ (912,2)SyntaxKind[RightHandSide]
+ (912,2)SyntaxKind[SymbolSpan]
+ (912,2)SyntaxKind[Nonterminal]
+ (912,2)SyntaxKind[Identifier](text = "StatementList")
+ (913,1)SyntaxKind[DedentToken]
+ (914,1)SyntaxKind[Production]
+ (914,1)SyntaxKind[Identifier](text = "Module")
+ (915,1)SyntaxKind[RightHandSideList]
+ (915,1)SyntaxKind[IndentToken]
+ (915,2)SyntaxKind[RightHandSide]
+ (915,2)SyntaxKind[SymbolSpan]
+ (915,2)SyntaxKind[Nonterminal]?
+ (915,2)SyntaxKind[Identifier](text = "ModuleBody")
+ (915,12)SyntaxKind[QuestionToken]
+ (916,1)SyntaxKind[DedentToken]
+ (917,1)SyntaxKind[Production]
+ (917,1)SyntaxKind[Identifier](text = "ModuleBody")
+ (918,1)SyntaxKind[RightHandSideList]
+ (918,1)SyntaxKind[IndentToken]
+ (918,2)SyntaxKind[RightHandSide]
+ (918,2)SyntaxKind[SymbolSpan]
+ (918,2)SyntaxKind[Nonterminal]
+ (918,2)SyntaxKind[Identifier](text = "ModuleItemList")
+ (919,1)SyntaxKind[DedentToken]
+ (920,1)SyntaxKind[Production]
+ (920,1)SyntaxKind[Identifier](text = "ModuleItemList")
+ (921,1)SyntaxKind[RightHandSideList]
+ (921,1)SyntaxKind[IndentToken]
+ (921,2)SyntaxKind[RightHandSide]
+ (921,2)SyntaxKind[SymbolSpan]
+ (921,2)SyntaxKind[Nonterminal]
+ (921,2)SyntaxKind[Identifier](text = "ModuleItem")
+ (922,2)SyntaxKind[RightHandSide]
+ (922,2)SyntaxKind[SymbolSpan]
+ (922,2)SyntaxKind[Nonterminal]
+ (922,2)SyntaxKind[Identifier](text = "ModuleItemList")
+ (922,18)SyntaxKind[SymbolSpan]
+ (922,18)SyntaxKind[Nonterminal]
+ (922,18)SyntaxKind[Identifier](text = "ModuleItem")
+ (923,1)SyntaxKind[DedentToken]
+ (924,1)SyntaxKind[Production]
+ (924,1)SyntaxKind[Identifier](text = "ModuleItem")
+ (925,1)SyntaxKind[RightHandSideList]
+ (925,1)SyntaxKind[IndentToken]
+ (925,2)SyntaxKind[RightHandSide]
+ (925,2)SyntaxKind[SymbolSpan]
+ (925,2)SyntaxKind[Nonterminal]
+ (925,2)SyntaxKind[Identifier](text = "ImportDeclaration")
+ (926,2)SyntaxKind[RightHandSide]
+ (926,2)SyntaxKind[SymbolSpan]
+ (926,2)SyntaxKind[Nonterminal]
+ (926,2)SyntaxKind[Identifier](text = "ExportDeclaration")
+ (927,2)SyntaxKind[RightHandSide]
+ (927,2)SyntaxKind[SymbolSpan]
+ (927,2)SyntaxKind[Nonterminal]
+ (927,2)SyntaxKind[Identifier](text = "StatementListItem")
+ (928,1)SyntaxKind[DedentToken]
+ (929,1)SyntaxKind[Production]
+ (929,1)SyntaxKind[Identifier](text = "ImportDeclaration")
+ (930,1)SyntaxKind[RightHandSideList]
+ (930,1)SyntaxKind[IndentToken]
+ (930,2)SyntaxKind[RightHandSide]
+ (930,2)SyntaxKind[SymbolSpan]
+ (930,2)SyntaxKind[Terminal](text = "import")
+ (930,12)SyntaxKind[SymbolSpan]
+ (930,12)SyntaxKind[Nonterminal]
+ (930,12)SyntaxKind[Identifier](text = "ImportClause")
+ (930,25)SyntaxKind[SymbolSpan]
+ (930,25)SyntaxKind[Nonterminal]
+ (930,25)SyntaxKind[Identifier](text = "FromClause")
+ (930,36)SyntaxKind[SymbolSpan]
+ (930,36)SyntaxKind[Terminal](text = ";")
+ (931,2)SyntaxKind[RightHandSide]
+ (931,2)SyntaxKind[SymbolSpan]
+ (931,2)SyntaxKind[Terminal](text = "import")
+ (931,12)SyntaxKind[SymbolSpan]
+ (931,12)SyntaxKind[Nonterminal]
+ (931,12)SyntaxKind[Identifier](text = "ModuleSpecifier")
+ (931,28)SyntaxKind[SymbolSpan]
+ (931,28)SyntaxKind[Terminal](text = ";")
+ (932,1)SyntaxKind[DedentToken]
+ (933,1)SyntaxKind[Production]
+ (933,1)SyntaxKind[Identifier](text = "ImportClause")
+ (934,1)SyntaxKind[RightHandSideList]
+ (934,1)SyntaxKind[IndentToken]
+ (934,2)SyntaxKind[RightHandSide]
+ (934,2)SyntaxKind[SymbolSpan]
+ (934,2)SyntaxKind[Nonterminal]
+ (934,2)SyntaxKind[Identifier](text = "ImportedDefaultBinding")
+ (935,2)SyntaxKind[RightHandSide]
+ (935,2)SyntaxKind[SymbolSpan]
+ (935,2)SyntaxKind[Nonterminal]
+ (935,2)SyntaxKind[Identifier](text = "NameSpaceImport")
+ (936,2)SyntaxKind[RightHandSide]
+ (936,2)SyntaxKind[SymbolSpan]
+ (936,2)SyntaxKind[Nonterminal]
+ (936,2)SyntaxKind[Identifier](text = "NamedImports")
+ (937,2)SyntaxKind[RightHandSide]
+ (937,2)SyntaxKind[SymbolSpan]
+ (937,2)SyntaxKind[Nonterminal]
+ (937,2)SyntaxKind[Identifier](text = "ImportedDefaultBinding")
+ (937,25)SyntaxKind[SymbolSpan]
+ (937,25)SyntaxKind[Terminal](text = ",")
+ (937,29)SyntaxKind[SymbolSpan]
+ (937,29)SyntaxKind[Nonterminal]
+ (937,29)SyntaxKind[Identifier](text = "NameSpaceImport")
+ (938,2)SyntaxKind[RightHandSide]
+ (938,2)SyntaxKind[SymbolSpan]
+ (938,2)SyntaxKind[Nonterminal]
+ (938,2)SyntaxKind[Identifier](text = "ImportedDefaultBinding")
+ (938,25)SyntaxKind[SymbolSpan]
+ (938,25)SyntaxKind[Terminal](text = ",")
+ (938,29)SyntaxKind[SymbolSpan]
+ (938,29)SyntaxKind[Nonterminal]
+ (938,29)SyntaxKind[Identifier](text = "NamedImports")
+ (939,1)SyntaxKind[DedentToken]
+ (940,1)SyntaxKind[Production]
+ (940,1)SyntaxKind[Identifier](text = "ImportedDefaultBinding")
+ (941,1)SyntaxKind[RightHandSideList]
+ (941,1)SyntaxKind[IndentToken]
+ (941,2)SyntaxKind[RightHandSide]
+ (941,2)SyntaxKind[SymbolSpan]
+ (941,2)SyntaxKind[Nonterminal]
+ (941,2)SyntaxKind[Identifier](text = "ImportedBinding")
+ (942,1)SyntaxKind[DedentToken]
+ (943,1)SyntaxKind[Production]
+ (943,1)SyntaxKind[Identifier](text = "NameSpaceImport")
+ (944,1)SyntaxKind[RightHandSideList]
+ (944,1)SyntaxKind[IndentToken]
+ (944,2)SyntaxKind[RightHandSide]
+ (944,2)SyntaxKind[SymbolSpan]
+ (944,2)SyntaxKind[Terminal](text = "*")
+ (944,6)SyntaxKind[SymbolSpan]
+ (944,6)SyntaxKind[Terminal](text = "as")
+ (944,11)SyntaxKind[SymbolSpan]
+ (944,11)SyntaxKind[Nonterminal]
+ (944,11)SyntaxKind[Identifier](text = "ImportedBinding")
+ (945,1)SyntaxKind[DedentToken]
+ (946,1)SyntaxKind[Production]
+ (946,1)SyntaxKind[Identifier](text = "NamedImports")
+ (947,1)SyntaxKind[RightHandSideList]
+ (947,1)SyntaxKind[IndentToken]
+ (947,2)SyntaxKind[RightHandSide]
+ (947,2)SyntaxKind[SymbolSpan]
+ (947,2)SyntaxKind[Terminal](text = "{")
+ (947,6)SyntaxKind[SymbolSpan]
+ (947,6)SyntaxKind[Terminal](text = "}")
+ (948,2)SyntaxKind[RightHandSide]
+ (948,2)SyntaxKind[SymbolSpan]
+ (948,2)SyntaxKind[Terminal](text = "{")
+ (948,6)SyntaxKind[SymbolSpan]
+ (948,6)SyntaxKind[Nonterminal]
+ (948,6)SyntaxKind[Identifier](text = "ImportsList")
+ (948,18)SyntaxKind[SymbolSpan]
+ (948,18)SyntaxKind[Terminal](text = "}")
+ (949,2)SyntaxKind[RightHandSide]
+ (949,2)SyntaxKind[SymbolSpan]
+ (949,2)SyntaxKind[Terminal](text = "{")
+ (949,6)SyntaxKind[SymbolSpan]
+ (949,6)SyntaxKind[Nonterminal]
+ (949,6)SyntaxKind[Identifier](text = "ImportsList")
+ (949,18)SyntaxKind[SymbolSpan]
+ (949,18)SyntaxKind[Terminal](text = ",")
+ (949,22)SyntaxKind[SymbolSpan]
+ (949,22)SyntaxKind[Terminal](text = "}")
+ (950,1)SyntaxKind[DedentToken]
+ (951,1)SyntaxKind[Production]
+ (951,1)SyntaxKind[Identifier](text = "FromClause")
+ (952,1)SyntaxKind[RightHandSideList]
+ (952,1)SyntaxKind[IndentToken]
+ (952,2)SyntaxKind[RightHandSide]
+ (952,2)SyntaxKind[SymbolSpan]
+ (952,2)SyntaxKind[Terminal](text = "from")
+ (952,9)SyntaxKind[SymbolSpan]
+ (952,9)SyntaxKind[Nonterminal]
+ (952,9)SyntaxKind[Identifier](text = "ModuleSpecifier")
+ (953,1)SyntaxKind[DedentToken]
+ (954,1)SyntaxKind[Production]
+ (954,1)SyntaxKind[Identifier](text = "ImportsList")
+ (955,1)SyntaxKind[RightHandSideList]
+ (955,1)SyntaxKind[IndentToken]
+ (955,2)SyntaxKind[RightHandSide]
+ (955,2)SyntaxKind[SymbolSpan]
+ (955,2)SyntaxKind[Nonterminal]
+ (955,2)SyntaxKind[Identifier](text = "ImportSpecifier")
+ (956,2)SyntaxKind[RightHandSide]
+ (956,2)SyntaxKind[SymbolSpan]
+ (956,2)SyntaxKind[Nonterminal]
+ (956,2)SyntaxKind[Identifier](text = "ImportsList")
+ (956,14)SyntaxKind[SymbolSpan]
+ (956,14)SyntaxKind[Terminal](text = ",")
+ (956,18)SyntaxKind[SymbolSpan]
+ (956,18)SyntaxKind[Nonterminal]
+ (956,18)SyntaxKind[Identifier](text = "ImportSpecifier")
+ (957,1)SyntaxKind[DedentToken]
+ (958,1)SyntaxKind[Production]
+ (958,1)SyntaxKind[Identifier](text = "ImportSpecifier")
+ (959,1)SyntaxKind[RightHandSideList]
+ (959,1)SyntaxKind[IndentToken]
+ (959,2)SyntaxKind[RightHandSide]
+ (959,2)SyntaxKind[SymbolSpan]
+ (959,2)SyntaxKind[Nonterminal]
+ (959,2)SyntaxKind[Identifier](text = "ImportedBinding")
+ (960,2)SyntaxKind[RightHandSide]
+ (960,2)SyntaxKind[SymbolSpan]
+ (960,2)SyntaxKind[Nonterminal]
+ (960,2)SyntaxKind[Identifier](text = "IdentifierName")
+ (960,17)SyntaxKind[SymbolSpan]
+ (960,17)SyntaxKind[Terminal](text = "as")
+ (960,22)SyntaxKind[SymbolSpan]
+ (960,22)SyntaxKind[Nonterminal]
+ (960,22)SyntaxKind[Identifier](text = "ImportedBinding")
+ (961,1)SyntaxKind[DedentToken]
+ (962,1)SyntaxKind[Production]
+ (962,1)SyntaxKind[Identifier](text = "ModuleSpecifier")
+ (963,1)SyntaxKind[RightHandSideList]
+ (963,1)SyntaxKind[IndentToken]
+ (963,2)SyntaxKind[RightHandSide]
+ (963,2)SyntaxKind[SymbolSpan]
+ (963,2)SyntaxKind[Nonterminal]
+ (963,2)SyntaxKind[Identifier](text = "StringLiteral")
+ (964,1)SyntaxKind[DedentToken]
+ (965,1)SyntaxKind[Production]
+ (965,1)SyntaxKind[Identifier](text = "ImportedBinding")
+ (966,1)SyntaxKind[RightHandSideList]
+ (966,1)SyntaxKind[IndentToken]
+ (966,2)SyntaxKind[RightHandSide]
+ (966,2)SyntaxKind[SymbolSpan]
+ (966,2)SyntaxKind[Nonterminal]
+ (966,2)SyntaxKind[Identifier](text = "BindingIdentifier")
+ (967,1)SyntaxKind[DedentToken]
+ (968,1)SyntaxKind[Production]
+ (968,1)SyntaxKind[Identifier](text = "ExportDeclaration")
+ (969,1)SyntaxKind[RightHandSideList]
+ (969,1)SyntaxKind[IndentToken]
+ (969,2)SyntaxKind[RightHandSide]
+ (969,2)SyntaxKind[SymbolSpan]
+ (969,2)SyntaxKind[Terminal](text = "export")
+ (969,11)SyntaxKind[SymbolSpan]
+ (969,11)SyntaxKind[Terminal](text = "*")
+ (969,15)SyntaxKind[SymbolSpan]
+ (969,15)SyntaxKind[Nonterminal]
+ (969,15)SyntaxKind[Identifier](text = "FromClause")
+ (969,26)SyntaxKind[SymbolSpan]
+ (969,26)SyntaxKind[Terminal](text = ";")
+ (970,2)SyntaxKind[RightHandSide]
+ (970,2)SyntaxKind[SymbolSpan]
+ (970,2)SyntaxKind[Terminal](text = "export")
+ (970,11)SyntaxKind[SymbolSpan]
+ (970,11)SyntaxKind[Nonterminal]
+ (970,11)SyntaxKind[Identifier](text = "ExportClause")
+ (970,24)SyntaxKind[SymbolSpan]
+ (970,24)SyntaxKind[Nonterminal]
+ (970,24)SyntaxKind[Identifier](text = "FromClause")
+ (970,35)SyntaxKind[SymbolSpan]
+ (970,35)SyntaxKind[Terminal](text = ";")
+ (971,2)SyntaxKind[RightHandSide]
+ (971,2)SyntaxKind[SymbolSpan]
+ (971,2)SyntaxKind[Terminal](text = "export")
+ (971,11)SyntaxKind[SymbolSpan]
+ (971,11)SyntaxKind[Nonterminal]
+ (971,11)SyntaxKind[Identifier](text = "ExportClause")
+ (971,24)SyntaxKind[SymbolSpan]
+ (971,24)SyntaxKind[Terminal](text = ";")
+ (972,2)SyntaxKind[RightHandSide]
+ (972,2)SyntaxKind[SymbolSpan]
+ (972,2)SyntaxKind[Terminal](text = "export")
+ (972,11)SyntaxKind[SymbolSpan]
+ (972,11)SyntaxKind[Nonterminal]
+ (972,11)SyntaxKind[Identifier](text = "VariableStatement")
+ (973,2)SyntaxKind[RightHandSide]
+ (973,2)SyntaxKind[SymbolSpan]
+ (973,2)SyntaxKind[Terminal](text = "export")
+ (973,11)SyntaxKind[SymbolSpan]
+ (973,11)SyntaxKind[Nonterminal]
+ (973,11)SyntaxKind[Identifier](text = "Declaration")
+ (974,2)SyntaxKind[RightHandSide]
+ (974,2)SyntaxKind[SymbolSpan]
+ (974,2)SyntaxKind[Terminal](text = "export")
+ (974,11)SyntaxKind[SymbolSpan]
+ (974,11)SyntaxKind[Terminal](text = "default")
+ (974,21)SyntaxKind[SymbolSpan]
+ (974,21)SyntaxKind[Nonterminal]
+ (974,21)SyntaxKind[Identifier](text = "HoistableDeclaration")
+ (974,41)SyntaxKind[ArgumentList]
+ (974,41)SyntaxKind[OpenBracketToken]
+ (974,42)SyntaxKind[Argument]
+ (974,42)SyntaxKind[Identifier](text = "Default")
+ (974,49)SyntaxKind[CloseBracketToken]
+ (975,2)SyntaxKind[RightHandSide]
+ (975,2)SyntaxKind[SymbolSpan]
+ (975,2)SyntaxKind[Terminal](text = "export")
+ (975,11)SyntaxKind[SymbolSpan]
+ (975,11)SyntaxKind[Terminal](text = "default")
+ (975,21)SyntaxKind[SymbolSpan]
+ (975,21)SyntaxKind[Nonterminal]
+ (975,21)SyntaxKind[Identifier](text = "ClassDeclaration")
+ (975,37)SyntaxKind[ArgumentList]
+ (975,37)SyntaxKind[OpenBracketToken]
+ (975,38)SyntaxKind[Argument]
+ (975,38)SyntaxKind[Identifier](text = "Default")
+ (975,45)SyntaxKind[CloseBracketToken]
+ (976,2)SyntaxKind[RightHandSide]
+ (976,2)SyntaxKind[SymbolSpan]
+ (976,2)SyntaxKind[Terminal](text = "export")
+ (976,11)SyntaxKind[SymbolSpan]
+ (976,11)SyntaxKind[Terminal](text = "default")
+ (976,21)SyntaxKind[SymbolSpan]
+ (976,21)SyntaxKind[LookaheadAssertion]
+ (976,21)SyntaxKind[OpenBracketToken]
+ (976,22)SyntaxKind[LookaheadKeyword]
+ (976,32)SyntaxKind[LessThanExclamationToken]
+ (976,35)SyntaxKind[SymbolSet]
+ (976,35)SyntaxKind[OpenBraceToken]
+ (976,37)SyntaxKind[SymbolSpan]
+ (976,37)SyntaxKind[Terminal](text = "function")
+ (976,49)SyntaxKind[SymbolSpan]
+ (976,49)SyntaxKind[Terminal](text = "class")
+ (976,57)SyntaxKind[CloseBraceToken]
+ (976,58)SyntaxKind[CloseBracketToken]
+ (976,60)SyntaxKind[SymbolSpan]
+ (976,60)SyntaxKind[Nonterminal]
+ (976,60)SyntaxKind[Identifier](text = "AssignmentExpression")
+ (976,80)SyntaxKind[ArgumentList]
+ (976,80)SyntaxKind[OpenBracketToken]
+ (976,81)SyntaxKind[Argument]
+ (976,81)SyntaxKind[Identifier](text = "In")
+ (976,83)SyntaxKind[CloseBracketToken]
+ (976,85)SyntaxKind[SymbolSpan]
+ (976,85)SyntaxKind[Terminal](text = ";")
+ (977,1)SyntaxKind[DedentToken]
+ (978,1)SyntaxKind[Production]
+ (978,1)SyntaxKind[Identifier](text = "ExportClause")
+ (979,1)SyntaxKind[RightHandSideList]
+ (979,1)SyntaxKind[IndentToken]
+ (979,2)SyntaxKind[RightHandSide]
+ (979,2)SyntaxKind[SymbolSpan]
+ (979,2)SyntaxKind[Terminal](text = "{")
+ (979,6)SyntaxKind[SymbolSpan]
+ (979,6)SyntaxKind[Terminal](text = "}")
+ (980,2)SyntaxKind[RightHandSide]
+ (980,2)SyntaxKind[SymbolSpan]
+ (980,2)SyntaxKind[Terminal](text = "{")
+ (980,6)SyntaxKind[SymbolSpan]
+ (980,6)SyntaxKind[Nonterminal]
+ (980,6)SyntaxKind[Identifier](text = "ExportsList")
+ (980,18)SyntaxKind[SymbolSpan]
+ (980,18)SyntaxKind[Terminal](text = "}")
+ (981,2)SyntaxKind[RightHandSide]
+ (981,2)SyntaxKind[SymbolSpan]
+ (981,2)SyntaxKind[Terminal](text = "{")
+ (981,6)SyntaxKind[SymbolSpan]
+ (981,6)SyntaxKind[Nonterminal]
+ (981,6)SyntaxKind[Identifier](text = "ExportsList")
+ (981,18)SyntaxKind[SymbolSpan]
+ (981,18)SyntaxKind[Terminal](text = ",")
+ (981,22)SyntaxKind[SymbolSpan]
+ (981,22)SyntaxKind[Terminal](text = "}")
+ (982,1)SyntaxKind[DedentToken]
+ (983,1)SyntaxKind[Production]
+ (983,1)SyntaxKind[Identifier](text = "ExportsList")
+ (984,1)SyntaxKind[RightHandSideList]
+ (984,1)SyntaxKind[IndentToken]
+ (984,2)SyntaxKind[RightHandSide]
+ (984,2)SyntaxKind[SymbolSpan]
+ (984,2)SyntaxKind[Nonterminal]
+ (984,2)SyntaxKind[Identifier](text = "ExportSpecifier")
+ (985,2)SyntaxKind[RightHandSide]
+ (985,2)SyntaxKind[SymbolSpan]
+ (985,2)SyntaxKind[Nonterminal]
+ (985,2)SyntaxKind[Identifier](text = "ExportsList")
+ (985,14)SyntaxKind[SymbolSpan]
+ (985,14)SyntaxKind[Terminal](text = ",")
+ (985,18)SyntaxKind[SymbolSpan]
+ (985,18)SyntaxKind[Nonterminal]
+ (985,18)SyntaxKind[Identifier](text = "ExportSpecifier")
+ (986,1)SyntaxKind[DedentToken]
+ (987,1)SyntaxKind[Production]
+ (987,1)SyntaxKind[Identifier](text = "ExportSpecifier")
+ (988,1)SyntaxKind[RightHandSideList]
+ (988,1)SyntaxKind[IndentToken]
+ (988,2)SyntaxKind[RightHandSide]
+ (988,2)SyntaxKind[SymbolSpan]
+ (988,2)SyntaxKind[Nonterminal]
+ (988,2)SyntaxKind[Identifier](text = "IdentifierName")
+ (989,2)SyntaxKind[RightHandSide]
+ (989,2)SyntaxKind[SymbolSpan]
+ (989,2)SyntaxKind[Nonterminal]
+ (989,2)SyntaxKind[Identifier](text = "IdentifierName")
+ (989,17)SyntaxKind[SymbolSpan]
+ (989,17)SyntaxKind[Terminal](text = "as")
+ (989,22)SyntaxKind[SymbolSpan]
+ (989,22)SyntaxKind[Nonterminal]
+ (989,22)SyntaxKind[Identifier](text = "IdentifierName")
+ (990,1)SyntaxKind[DedentToken]
diff --git a/tests/baselines/reference/es6.grammar.tokens b/tests/baselines/reference/es6.grammar.tokens
new file mode 100644
index 0000000..23ba79a
--- /dev/null
+++ b/tests/baselines/reference/es6.grammar.tokens
@@ -0,0 +1,5593 @@
+/// es6.grammar:
+SyntaxKind[AtToken](1,1): @
+SyntaxKind[DefineKeyword](1,2): define
+SyntaxKind[Identifier](1,9): noStrictParametricProductions
+SyntaxKind[TrueKeyword](1,39): true
+SyntaxKind[LineTerminatorToken](2,1): «line terminator»
+SyntaxKind[LineTerminatorToken](3,1): «line terminator»
+SyntaxKind[LineTerminatorToken](4,1): «line terminator»
+SyntaxKind[LineTerminatorToken](5,1): «line terminator»
+SyntaxKind[Identifier](5,1): SourceCharacter
+SyntaxKind[ColonColonToken](5,17): ::
+SyntaxKind[LineTerminatorToken](6,1): «line terminator»
+SyntaxKind[IndentToken](6,1): «indent»
+SyntaxKind[GreaterThanToken](6,2): >
+SyntaxKind[ProseFull](6,4): any Unicode code point
+SyntaxKind[LineTerminatorToken](7,1): «line terminator»
+SyntaxKind[DedentToken](7,1): «dedent»
+SyntaxKind[LineTerminatorToken](8,1): «line terminator»
+SyntaxKind[Identifier](8,1): InputElementDiv
+SyntaxKind[ColonColonToken](8,17): ::
+SyntaxKind[LineTerminatorToken](9,1): «line terminator»
+SyntaxKind[IndentToken](9,1): «indent»
+SyntaxKind[Identifier](9,2): WhiteSpace
+SyntaxKind[LineTerminatorToken](10,1): «line terminator»
+SyntaxKind[Identifier](10,2): LineTerminator
+SyntaxKind[LineTerminatorToken](11,1): «line terminator»
+SyntaxKind[Identifier](11,2): Comment
+SyntaxKind[LineTerminatorToken](12,1): «line terminator»
+SyntaxKind[Identifier](12,2): CommonToken
+SyntaxKind[LineTerminatorToken](13,1): «line terminator»
+SyntaxKind[Identifier](13,2): DivPunctuator
+SyntaxKind[LineTerminatorToken](14,1): «line terminator»
+SyntaxKind[Identifier](14,2): RightBracePunctuator
+SyntaxKind[LineTerminatorToken](15,1): «line terminator»
+SyntaxKind[DedentToken](15,1): «dedent»
+SyntaxKind[LineTerminatorToken](16,1): «line terminator»
+SyntaxKind[Identifier](16,1): InputElementRegExp
+SyntaxKind[ColonColonToken](16,20): ::
+SyntaxKind[LineTerminatorToken](17,1): «line terminator»
+SyntaxKind[IndentToken](17,1): «indent»
+SyntaxKind[Identifier](17,2): WhiteSpace
+SyntaxKind[LineTerminatorToken](18,1): «line terminator»
+SyntaxKind[Identifier](18,2): LineTerminator
+SyntaxKind[LineTerminatorToken](19,1): «line terminator»
+SyntaxKind[Identifier](19,2): Comment
+SyntaxKind[LineTerminatorToken](20,1): «line terminator»
+SyntaxKind[Identifier](20,2): CommonToken
+SyntaxKind[LineTerminatorToken](21,1): «line terminator»
+SyntaxKind[Identifier](21,2): RightBracePunctuator
+SyntaxKind[LineTerminatorToken](22,1): «line terminator»
+SyntaxKind[Identifier](22,2): RegularExpressionLiteral
+SyntaxKind[LineTerminatorToken](23,1): «line terminator»
+SyntaxKind[DedentToken](23,1): «dedent»
+SyntaxKind[LineTerminatorToken](24,1): «line terminator»
+SyntaxKind[Identifier](24,1): InputElementRegExpOrTemplateTail
+SyntaxKind[ColonColonToken](24,34): ::
+SyntaxKind[LineTerminatorToken](25,1): «line terminator»
+SyntaxKind[IndentToken](25,1): «indent»
+SyntaxKind[Identifier](25,2): WhiteSpace
+SyntaxKind[LineTerminatorToken](26,1): «line terminator»
+SyntaxKind[Identifier](26,2): LineTerminator
+SyntaxKind[LineTerminatorToken](27,1): «line terminator»
+SyntaxKind[Identifier](27,2): Comment
+SyntaxKind[LineTerminatorToken](28,1): «line terminator»
+SyntaxKind[Identifier](28,2): CommonToken
+SyntaxKind[LineTerminatorToken](29,1): «line terminator»
+SyntaxKind[Identifier](29,2): RegularExpressionLiteral
+SyntaxKind[LineTerminatorToken](30,1): «line terminator»
+SyntaxKind[Identifier](30,2): TemplateSubstitutionTail
+SyntaxKind[LineTerminatorToken](31,1): «line terminator»
+SyntaxKind[DedentToken](31,1): «dedent»
+SyntaxKind[LineTerminatorToken](32,1): «line terminator»
+SyntaxKind[Identifier](32,1): InputElementTemplateTail
+SyntaxKind[ColonColonToken](32,26): ::
+SyntaxKind[LineTerminatorToken](33,1): «line terminator»
+SyntaxKind[IndentToken](33,1): «indent»
+SyntaxKind[Identifier](33,2): WhiteSpace
+SyntaxKind[LineTerminatorToken](34,1): «line terminator»
+SyntaxKind[Identifier](34,2): LineTerminator
+SyntaxKind[LineTerminatorToken](35,1): «line terminator»
+SyntaxKind[Identifier](35,2): Comment
+SyntaxKind[LineTerminatorToken](36,1): «line terminator»
+SyntaxKind[Identifier](36,2): CommonToken
+SyntaxKind[LineTerminatorToken](37,1): «line terminator»
+SyntaxKind[Identifier](37,2): DivPunctuator
+SyntaxKind[LineTerminatorToken](38,1): «line terminator»
+SyntaxKind[Identifier](38,2): TemplateSubstitutionTail
+SyntaxKind[LineTerminatorToken](39,1): «line terminator»
+SyntaxKind[DedentToken](39,1): «dedent»
+SyntaxKind[LineTerminatorToken](40,1): «line terminator»
+SyntaxKind[Identifier](40,1): WhiteSpace
+SyntaxKind[ColonColonToken](40,12): ::
+SyntaxKind[LineTerminatorToken](41,1): «line terminator»
+SyntaxKind[IndentToken](41,1): «indent»
+SyntaxKind[UnicodeCharacterLiteral](41,2):
+SyntaxKind[LineTerminatorToken](42,1): «line terminator»
+SyntaxKind[UnicodeCharacterLiteral](42,2):
+SyntaxKind[LineTerminatorToken](43,1): «line terminator»
+SyntaxKind[UnicodeCharacterLiteral](43,2):
+SyntaxKind[LineTerminatorToken](44,1): «line terminator»
+SyntaxKind[UnicodeCharacterLiteral](44,2):
+SyntaxKind[LineTerminatorToken](45,1): «line terminator»
+SyntaxKind[UnicodeCharacterLiteral](45,2):
+SyntaxKind[LineTerminatorToken](46,1): «line terminator»
+SyntaxKind[UnicodeCharacterLiteral](46,2):
+SyntaxKind[LineTerminatorToken](47,1): «line terminator»
+SyntaxKind[UnicodeCharacterLiteral](47,2):
+SyntaxKind[LineTerminatorToken](48,1): «line terminator»
+SyntaxKind[DedentToken](48,1): «dedent»
+SyntaxKind[LineTerminatorToken](49,1): «line terminator»
+SyntaxKind[Identifier](49,1): LineTerminator
+SyntaxKind[ColonColonToken](49,16): ::
+SyntaxKind[LineTerminatorToken](50,1): «line terminator»
+SyntaxKind[IndentToken](50,1): «indent»
+SyntaxKind[UnicodeCharacterLiteral](50,2):
+SyntaxKind[LineTerminatorToken](51,1): «line terminator»
+SyntaxKind[UnicodeCharacterLiteral](51,2):
+SyntaxKind[LineTerminatorToken](52,1): «line terminator»
+SyntaxKind[UnicodeCharacterLiteral](52,2):
+SyntaxKind[LineTerminatorToken](53,1): «line terminator»
+SyntaxKind[UnicodeCharacterLiteral](53,2):
+SyntaxKind[LineTerminatorToken](54,1): «line terminator»
+SyntaxKind[DedentToken](54,1): «dedent»
+SyntaxKind[LineTerminatorToken](55,1): «line terminator»
+SyntaxKind[Identifier](55,1): LineTerminatorSequence
+SyntaxKind[ColonColonToken](55,24): ::
+SyntaxKind[LineTerminatorToken](56,1): «line terminator»
+SyntaxKind[IndentToken](56,1): «indent»
+SyntaxKind[UnicodeCharacterLiteral](56,2):
+SyntaxKind[LineTerminatorToken](57,1): «line terminator»
+SyntaxKind[UnicodeCharacterLiteral](57,2):
+SyntaxKind[OpenBracketToken](57,7): [
+SyntaxKind[LookaheadKeyword](57,8): lookahead
+SyntaxKind[ExclamationEqualsToken](57,18): !=
+SyntaxKind[UnicodeCharacterLiteral](57,21):
+SyntaxKind[CloseBracketToken](57,25): ]
+SyntaxKind[LineTerminatorToken](58,1): «line terminator»
+SyntaxKind[UnicodeCharacterLiteral](58,2):
+SyntaxKind[LineTerminatorToken](59,1): «line terminator»
+SyntaxKind[UnicodeCharacterLiteral](59,2):
+SyntaxKind[LineTerminatorToken](60,1): «line terminator»
+SyntaxKind[UnicodeCharacterLiteral](60,2):
+SyntaxKind[UnicodeCharacterLiteral](60,7):
+SyntaxKind[LineTerminatorToken](61,1): «line terminator»
+SyntaxKind[DedentToken](61,1): «dedent»
+SyntaxKind[LineTerminatorToken](62,1): «line terminator»
+SyntaxKind[Identifier](62,1): Comment
+SyntaxKind[ColonColonToken](62,9): ::
+SyntaxKind[LineTerminatorToken](63,1): «line terminator»
+SyntaxKind[IndentToken](63,1): «indent»
+SyntaxKind[Identifier](63,2): MultiLineComment
+SyntaxKind[LineTerminatorToken](64,1): «line terminator»
+SyntaxKind[Identifier](64,2): SingleLineComment
+SyntaxKind[LineTerminatorToken](65,1): «line terminator»
+SyntaxKind[DedentToken](65,1): «dedent»
+SyntaxKind[LineTerminatorToken](66,1): «line terminator»
+SyntaxKind[Identifier](66,1): MultiLineComment
+SyntaxKind[ColonColonToken](66,18): ::
+SyntaxKind[LineTerminatorToken](67,1): «line terminator»
+SyntaxKind[IndentToken](67,1): «indent»
+SyntaxKind[Terminal](67,2): `/*`
+SyntaxKind[Identifier](67,7): MultiLineCommentChars
+SyntaxKind[QuestionToken](67,28): ?
+SyntaxKind[Terminal](67,30): `*/`
+SyntaxKind[LineTerminatorToken](68,1): «line terminator»
+SyntaxKind[DedentToken](68,1): «dedent»
+SyntaxKind[LineTerminatorToken](69,1): «line terminator»
+SyntaxKind[Identifier](69,1): MultiLineCommentChars
+SyntaxKind[ColonColonToken](69,23): ::
+SyntaxKind[LineTerminatorToken](70,1): «line terminator»
+SyntaxKind[IndentToken](70,1): «indent»
+SyntaxKind[Identifier](70,2): MultiLineNotAsteriskChar
+SyntaxKind[Identifier](70,27): MultiLineCommentChars
+SyntaxKind[QuestionToken](70,48): ?
+SyntaxKind[LineTerminatorToken](71,1): «line terminator»
+SyntaxKind[Terminal](71,2): `*`
+SyntaxKind[Identifier](71,6): PostAsteriskCommentChars
+SyntaxKind[QuestionToken](71,30): ?
+SyntaxKind[LineTerminatorToken](72,1): «line terminator»
+SyntaxKind[DedentToken](72,1): «dedent»
+SyntaxKind[LineTerminatorToken](73,1): «line terminator»
+SyntaxKind[Identifier](73,1): PostAsteriskCommentChars
+SyntaxKind[ColonColonToken](73,26): ::
+SyntaxKind[LineTerminatorToken](74,1): «line terminator»
+SyntaxKind[IndentToken](74,1): «indent»
+SyntaxKind[Identifier](74,2): MultiLineNotForwardSlashOrAsteriskChar
+SyntaxKind[Identifier](74,41): MultiLineCommentChars
+SyntaxKind[QuestionToken](74,62): ?
+SyntaxKind[LineTerminatorToken](75,1): «line terminator»
+SyntaxKind[Terminal](75,2): `*`
+SyntaxKind[Identifier](75,6): PostAsteriskCommentChars
+SyntaxKind[QuestionToken](75,30): ?
+SyntaxKind[LineTerminatorToken](76,1): «line terminator»
+SyntaxKind[DedentToken](76,1): «dedent»
+SyntaxKind[LineTerminatorToken](77,1): «line terminator»
+SyntaxKind[Identifier](77,1): MultiLineNotAsteriskChar
+SyntaxKind[ColonColonToken](77,26): ::
+SyntaxKind[LineTerminatorToken](78,1): «line terminator»
+SyntaxKind[IndentToken](78,1): «indent»
+SyntaxKind[Identifier](78,2): SourceCharacter
+SyntaxKind[ButKeyword](78,18): but
+SyntaxKind[NotKeyword](78,22): not
+SyntaxKind[Terminal](78,26): `*`
+SyntaxKind[LineTerminatorToken](79,1): «line terminator»
+SyntaxKind[DedentToken](79,1): «dedent»
+SyntaxKind[LineTerminatorToken](80,1): «line terminator»
+SyntaxKind[Identifier](80,1): MultiLineNotForwardSlashOrAsteriskChar
+SyntaxKind[ColonColonToken](80,40): ::
+SyntaxKind[LineTerminatorToken](81,1): «line terminator»
+SyntaxKind[IndentToken](81,1): «indent»
+SyntaxKind[Identifier](81,2): SourceCharacter
+SyntaxKind[ButKeyword](81,18): but
+SyntaxKind[NotKeyword](81,22): not
+SyntaxKind[OneKeyword](81,26): one
+SyntaxKind[OfKeyword](81,30): of
+SyntaxKind[Terminal](81,33): `/`
+SyntaxKind[OrKeyword](81,37): or
+SyntaxKind[Terminal](81,40): `*`
+SyntaxKind[LineTerminatorToken](82,1): «line terminator»
+SyntaxKind[DedentToken](82,1): «dedent»
+SyntaxKind[LineTerminatorToken](83,1): «line terminator»
+SyntaxKind[Identifier](83,1): SingleLineComment
+SyntaxKind[ColonColonToken](83,19): ::
+SyntaxKind[LineTerminatorToken](84,1): «line terminator»
+SyntaxKind[IndentToken](84,1): «indent»
+SyntaxKind[Terminal](84,2): `//`
+SyntaxKind[Identifier](84,7): SingleLineCommentChars
+SyntaxKind[QuestionToken](84,29): ?
+SyntaxKind[LineTerminatorToken](85,1): «line terminator»
+SyntaxKind[DedentToken](85,1): «dedent»
+SyntaxKind[LineTerminatorToken](86,1): «line terminator»
+SyntaxKind[Identifier](86,1): SingleLineCommentChars
+SyntaxKind[ColonColonToken](86,24): ::
+SyntaxKind[LineTerminatorToken](87,1): «line terminator»
+SyntaxKind[IndentToken](87,1): «indent»
+SyntaxKind[Identifier](87,2): SingleLineCommentChar
+SyntaxKind[Identifier](87,24): SingleLineCommentChars
+SyntaxKind[QuestionToken](87,46): ?
+SyntaxKind[LineTerminatorToken](88,1): «line terminator»
+SyntaxKind[DedentToken](88,1): «dedent»
+SyntaxKind[LineTerminatorToken](89,1): «line terminator»
+SyntaxKind[Identifier](89,1): SingleLineCommentChar
+SyntaxKind[ColonColonToken](89,23): ::
+SyntaxKind[LineTerminatorToken](90,1): «line terminator»
+SyntaxKind[IndentToken](90,1): «indent»
+SyntaxKind[Identifier](90,2): SourceCharacter
+SyntaxKind[ButKeyword](90,18): but
+SyntaxKind[NotKeyword](90,22): not
+SyntaxKind[Identifier](90,26): LineTerminator
+SyntaxKind[LineTerminatorToken](91,1): «line terminator»
+SyntaxKind[DedentToken](91,1): «dedent»
+SyntaxKind[LineTerminatorToken](92,1): «line terminator»
+SyntaxKind[Identifier](92,1): CommonToken
+SyntaxKind[ColonColonToken](92,13): ::
+SyntaxKind[LineTerminatorToken](93,1): «line terminator»
+SyntaxKind[IndentToken](93,1): «indent»
+SyntaxKind[Identifier](93,2): IdentifierName
+SyntaxKind[LineTerminatorToken](94,1): «line terminator»
+SyntaxKind[Identifier](94,2): Punctuator
+SyntaxKind[LineTerminatorToken](95,1): «line terminator»
+SyntaxKind[Identifier](95,2): NumericLiteral
+SyntaxKind[LineTerminatorToken](96,1): «line terminator»
+SyntaxKind[Identifier](96,2): StringLiteral
+SyntaxKind[LineTerminatorToken](97,1): «line terminator»
+SyntaxKind[Identifier](97,2): Template
+SyntaxKind[LineTerminatorToken](98,1): «line terminator»
+SyntaxKind[DedentToken](98,1): «dedent»
+SyntaxKind[LineTerminatorToken](99,1): «line terminator»
+SyntaxKind[Identifier](99,1): IdentifierName
+SyntaxKind[ColonColonToken](99,16): ::
+SyntaxKind[LineTerminatorToken](100,1): «line terminator»
+SyntaxKind[IndentToken](100,1): «indent»
+SyntaxKind[Identifier](100,2): IdentifierStart
+SyntaxKind[LineTerminatorToken](101,1): «line terminator»
+SyntaxKind[Identifier](101,2): IdentifierName
+SyntaxKind[Identifier](101,17): IdentifierPart
+SyntaxKind[LineTerminatorToken](102,1): «line terminator»
+SyntaxKind[DedentToken](102,1): «dedent»
+SyntaxKind[LineTerminatorToken](103,1): «line terminator»
+SyntaxKind[Identifier](103,1): IdentifierStart
+SyntaxKind[ColonColonToken](103,17): ::
+SyntaxKind[LineTerminatorToken](104,1): «line terminator»
+SyntaxKind[IndentToken](104,1): «indent»
+SyntaxKind[Identifier](104,2): UnicodeIDStart
+SyntaxKind[LineTerminatorToken](105,1): «line terminator»
+SyntaxKind[Terminal](105,2): `$`
+SyntaxKind[LineTerminatorToken](106,1): «line terminator»
+SyntaxKind[Terminal](106,2): `_`
+SyntaxKind[LineTerminatorToken](107,1): «line terminator»
+SyntaxKind[Terminal](107,2): `\`
+SyntaxKind[Identifier](107,6): UnicodeEscapeSequence
+SyntaxKind[LineTerminatorToken](108,1): «line terminator»
+SyntaxKind[DedentToken](108,1): «dedent»
+SyntaxKind[LineTerminatorToken](109,1): «line terminator»
+SyntaxKind[Identifier](109,1): IdentifierPart
+SyntaxKind[ColonColonToken](109,16): ::
+SyntaxKind[LineTerminatorToken](110,1): «line terminator»
+SyntaxKind[IndentToken](110,1): «indent»
+SyntaxKind[Identifier](110,2): UnicodeIDContinue
+SyntaxKind[LineTerminatorToken](111,1): «line terminator»
+SyntaxKind[Terminal](111,2): `$`
+SyntaxKind[LineTerminatorToken](112,1): «line terminator»
+SyntaxKind[Terminal](112,2): `_`
+SyntaxKind[LineTerminatorToken](113,1): «line terminator»
+SyntaxKind[Terminal](113,2): `\`
+SyntaxKind[Identifier](113,6): UnicodeEscapeSequence
+SyntaxKind[LineTerminatorToken](114,1): «line terminator»
+SyntaxKind[UnicodeCharacterLiteral](114,2):
+SyntaxKind[LineTerminatorToken](115,1): «line terminator»
+SyntaxKind[UnicodeCharacterLiteral](115,2):
+SyntaxKind[LineTerminatorToken](116,1): «line terminator»
+SyntaxKind[DedentToken](116,1): «dedent»
+SyntaxKind[LineTerminatorToken](117,1): «line terminator»
+SyntaxKind[Identifier](117,1): UnicodeIDStart
+SyntaxKind[ColonColonToken](117,16): ::
+SyntaxKind[LineTerminatorToken](118,1): «line terminator»
+SyntaxKind[IndentToken](118,1): «indent»
+SyntaxKind[GreaterThanToken](118,2): >
+SyntaxKind[ProseFull](118,4): any Unicode code point with the Unicode property "ID_Start" or "Other_ID_Start"
+SyntaxKind[LineTerminatorToken](119,1): «line terminator»
+SyntaxKind[DedentToken](119,1): «dedent»
+SyntaxKind[LineTerminatorToken](120,1): «line terminator»
+SyntaxKind[Identifier](120,1): UnicodeIDContinue
+SyntaxKind[ColonColonToken](120,19): ::
+SyntaxKind[LineTerminatorToken](121,1): «line terminator»
+SyntaxKind[IndentToken](121,1): «indent»
+SyntaxKind[GreaterThanToken](121,2): >
+SyntaxKind[ProseFull](121,4): any Unicode code point with the Unicode property "ID_Continue" or "Other_ID_Continue", or "Other_ID_Start"
+SyntaxKind[LineTerminatorToken](122,1): «line terminator»
+SyntaxKind[DedentToken](122,1): «dedent»
+SyntaxKind[LineTerminatorToken](123,1): «line terminator»
+SyntaxKind[Identifier](123,1): ReservedWord
+SyntaxKind[ColonColonToken](123,14): ::
+SyntaxKind[LineTerminatorToken](124,1): «line terminator»
+SyntaxKind[IndentToken](124,1): «indent»
+SyntaxKind[Identifier](124,2): Keyword
+SyntaxKind[LineTerminatorToken](125,1): «line terminator»
+SyntaxKind[Identifier](125,2): FutureReservedWord
+SyntaxKind[LineTerminatorToken](126,1): «line terminator»
+SyntaxKind[Identifier](126,2): NullLiteral
+SyntaxKind[LineTerminatorToken](127,1): «line terminator»
+SyntaxKind[Identifier](127,2): BooleanLiteral
+SyntaxKind[LineTerminatorToken](128,1): «line terminator»
+SyntaxKind[DedentToken](128,1): «dedent»
+SyntaxKind[LineTerminatorToken](129,1): «line terminator»
+SyntaxKind[Identifier](129,1): Keyword
+SyntaxKind[ColonColonToken](129,9): ::
+SyntaxKind[OneKeyword](129,12): one
+SyntaxKind[OfKeyword](129,16): of
+SyntaxKind[LineTerminatorToken](130,1): «line terminator»
+SyntaxKind[IndentToken](130,1): «indent»
+SyntaxKind[Terminal](130,2): `break`
+SyntaxKind[Terminal](130,11): `do`
+SyntaxKind[Terminal](130,17): `in`
+SyntaxKind[Terminal](130,24): `typeof`
+SyntaxKind[LineTerminatorToken](131,1): «line terminator»
+SyntaxKind[Terminal](131,2): `case`
+SyntaxKind[Terminal](131,10): `else`
+SyntaxKind[Terminal](131,18): `instanceof`
+SyntaxKind[Terminal](131,31): `var`
+SyntaxKind[LineTerminatorToken](132,1): «line terminator»
+SyntaxKind[Terminal](132,2): `catch`
+SyntaxKind[Terminal](132,11): `export`
+SyntaxKind[Terminal](132,20): `new`
+SyntaxKind[Terminal](132,28): `void`
+SyntaxKind[LineTerminatorToken](133,1): «line terminator»
+SyntaxKind[Terminal](133,2): `class`
+SyntaxKind[Terminal](133,11): `extends`
+SyntaxKind[Terminal](133,21): `return`
+SyntaxKind[Terminal](133,31): `while`
+SyntaxKind[LineTerminatorToken](134,1): «line terminator»
+SyntaxKind[Terminal](134,2): `const`
+SyntaxKind[Terminal](134,11): `finally`
+SyntaxKind[Terminal](134,21): `super`
+SyntaxKind[Terminal](134,31): `with`
+SyntaxKind[LineTerminatorToken](135,1): «line terminator»
+SyntaxKind[Terminal](135,2): `continue`
+SyntaxKind[Terminal](135,13): `for`
+SyntaxKind[Terminal](135,20): `switch`
+SyntaxKind[Terminal](135,30): `yield`
+SyntaxKind[LineTerminatorToken](136,1): «line terminator»
+SyntaxKind[Terminal](136,2): `debugger`
+SyntaxKind[Terminal](136,13): `function`
+SyntaxKind[Terminal](136,24): `this`
+SyntaxKind[LineTerminatorToken](137,1): «line terminator»
+SyntaxKind[Terminal](137,2): `default`
+SyntaxKind[Terminal](137,12): `if`
+SyntaxKind[Terminal](137,18): `throw`
+SyntaxKind[LineTerminatorToken](138,1): «line terminator»
+SyntaxKind[Terminal](138,2): `delete`
+SyntaxKind[Terminal](138,11): `import`
+SyntaxKind[Terminal](138,20): `try`
+SyntaxKind[LineTerminatorToken](139,1): «line terminator»
+SyntaxKind[DedentToken](139,1): «dedent»
+SyntaxKind[LineTerminatorToken](140,1): «line terminator»
+SyntaxKind[Identifier](140,1): FutureReservedWord
+SyntaxKind[ColonColonToken](140,20): ::
+SyntaxKind[OneKeyword](140,23): one
+SyntaxKind[OfKeyword](140,27): of
+SyntaxKind[LineTerminatorToken](141,1): «line terminator»
+SyntaxKind[IndentToken](141,1): «indent»
+SyntaxKind[Terminal](141,2): `enum`
+SyntaxKind[LineTerminatorToken](142,1): «line terminator»
+SyntaxKind[LineTerminatorToken](143,1): «line terminator»
+SyntaxKind[Terminal](143,2): `await`
+SyntaxKind[LineTerminatorToken](144,1): «line terminator»
+SyntaxKind[LineTerminatorToken](145,1): «line terminator»
+SyntaxKind[Terminal](145,2): `implements`
+SyntaxKind[Terminal](145,15): `package`
+SyntaxKind[Terminal](145,25): `protected`
+SyntaxKind[LineTerminatorToken](146,1): «line terminator»
+SyntaxKind[Terminal](146,2): `interface`
+SyntaxKind[Terminal](146,15): `private`
+SyntaxKind[Terminal](146,25): `public`
+SyntaxKind[LineTerminatorToken](147,1): «line terminator»
+SyntaxKind[DedentToken](147,1): «dedent»
+SyntaxKind[LineTerminatorToken](148,1): «line terminator»
+SyntaxKind[Identifier](148,1): Punctuator
+SyntaxKind[ColonColonToken](148,12): ::
+SyntaxKind[OneKeyword](148,15): one
+SyntaxKind[OfKeyword](148,19): of
+SyntaxKind[LineTerminatorToken](149,1): «line terminator»
+SyntaxKind[IndentToken](149,1): «indent»
+SyntaxKind[Terminal](149,2): `{`
+SyntaxKind[Terminal](149,7): `}`
+SyntaxKind[Terminal](149,12): `(`
+SyntaxKind[Terminal](149,17): `)`
+SyntaxKind[Terminal](149,22): `[`
+SyntaxKind[Terminal](149,27): `]`
+SyntaxKind[LineTerminatorToken](150,1): «line terminator»
+SyntaxKind[Terminal](150,2): `.`
+SyntaxKind[Terminal](150,7): `;`
+SyntaxKind[Terminal](150,12): `,`
+SyntaxKind[Terminal](150,17): `<`
+SyntaxKind[Terminal](150,22): `>`
+SyntaxKind[Terminal](150,27): `<=`
+SyntaxKind[LineTerminatorToken](151,1): «line terminator»
+SyntaxKind[Terminal](151,2): `>=`
+SyntaxKind[Terminal](151,7): `==`
+SyntaxKind[Terminal](151,12): `!=`
+SyntaxKind[Terminal](151,17): `===`
+SyntaxKind[Terminal](151,23): `!==`
+SyntaxKind[LineTerminatorToken](152,1): «line terminator»
+SyntaxKind[Terminal](152,2): `+`
+SyntaxKind[Terminal](152,7): `-`
+SyntaxKind[Terminal](152,12): `*`
+SyntaxKind[Terminal](152,17): `%`
+SyntaxKind[Terminal](152,22): `++`
+SyntaxKind[Terminal](152,27): `--`
+SyntaxKind[LineTerminatorToken](153,1): «line terminator»
+SyntaxKind[Terminal](153,2): `<<`
+SyntaxKind[Terminal](153,7): `>>`
+SyntaxKind[Terminal](153,12): `>>>`
+SyntaxKind[Terminal](153,18): `&`
+SyntaxKind[Terminal](153,23): `|`
+SyntaxKind[Terminal](153,28): `^`
+SyntaxKind[LineTerminatorToken](154,1): «line terminator»
+SyntaxKind[Terminal](154,2): `!`
+SyntaxKind[Terminal](154,7): `~`
+SyntaxKind[Terminal](154,12): `&&`
+SyntaxKind[Terminal](154,17): `||`
+SyntaxKind[Terminal](154,22): `?`
+SyntaxKind[Terminal](154,27): ` ::`
+SyntaxKind[LineTerminatorToken](155,1): «line terminator»
+SyntaxKind[Terminal](155,2): `=`
+SyntaxKind[Terminal](155,7): `+=`
+SyntaxKind[Terminal](155,12): `-=`
+SyntaxKind[Terminal](155,17): `*=`
+SyntaxKind[Terminal](155,22): `%=`
+SyntaxKind[Terminal](155,27): `<<=`
+SyntaxKind[LineTerminatorToken](156,1): «line terminator»
+SyntaxKind[Terminal](156,2): `>>=`
+SyntaxKind[Terminal](156,8): `>>>=`
+SyntaxKind[Terminal](156,15): `&=`
+SyntaxKind[Terminal](156,20): `|=`
+SyntaxKind[Terminal](156,25): `^=`
+SyntaxKind[Terminal](156,30): `=>`
+SyntaxKind[LineTerminatorToken](157,1): «line terminator»
+SyntaxKind[DedentToken](157,1): «dedent»
+SyntaxKind[LineTerminatorToken](158,1): «line terminator»
+SyntaxKind[Identifier](158,1): DivPunctuator
+SyntaxKind[ColonColonToken](158,15): ::
+SyntaxKind[OneKeyword](158,18): one
+SyntaxKind[OfKeyword](158,22): of
+SyntaxKind[LineTerminatorToken](159,1): «line terminator»
+SyntaxKind[IndentToken](159,1): «indent»
+SyntaxKind[Terminal](159,2): `/`
+SyntaxKind[Terminal](159,7): `/=`
+SyntaxKind[LineTerminatorToken](160,1): «line terminator»
+SyntaxKind[DedentToken](160,1): «dedent»
+SyntaxKind[LineTerminatorToken](161,1): «line terminator»
+SyntaxKind[Identifier](161,1): RightBracePunctuator
+SyntaxKind[ColonColonToken](161,22): ::
+SyntaxKind[OneKeyword](161,25): one
+SyntaxKind[OfKeyword](161,29): of
+SyntaxKind[LineTerminatorToken](162,1): «line terminator»
+SyntaxKind[IndentToken](162,1): «indent»
+SyntaxKind[Terminal](162,2): `)`
+SyntaxKind[LineTerminatorToken](163,1): «line terminator»
+SyntaxKind[DedentToken](163,1): «dedent»
+SyntaxKind[LineTerminatorToken](164,1): «line terminator»
+SyntaxKind[Identifier](164,1): NullLiteral
+SyntaxKind[ColonColonToken](164,13): ::
+SyntaxKind[LineTerminatorToken](165,1): «line terminator»
+SyntaxKind[IndentToken](165,1): «indent»
+SyntaxKind[Terminal](165,2): `null`
+SyntaxKind[LineTerminatorToken](166,1): «line terminator»
+SyntaxKind[DedentToken](166,1): «dedent»
+SyntaxKind[LineTerminatorToken](167,1): «line terminator»
+SyntaxKind[Identifier](167,1): BooleanLiteral
+SyntaxKind[ColonColonToken](167,16): ::
+SyntaxKind[LineTerminatorToken](168,1): «line terminator»
+SyntaxKind[IndentToken](168,1): «indent»
+SyntaxKind[Terminal](168,2): `true`
+SyntaxKind[LineTerminatorToken](169,1): «line terminator»
+SyntaxKind[Terminal](169,2): `false`
+SyntaxKind[LineTerminatorToken](170,1): «line terminator»
+SyntaxKind[DedentToken](170,1): «dedent»
+SyntaxKind[LineTerminatorToken](171,1): «line terminator»
+SyntaxKind[Identifier](171,1): NumericLiteral
+SyntaxKind[ColonColonToken](171,16): ::
+SyntaxKind[LineTerminatorToken](172,1): «line terminator»
+SyntaxKind[IndentToken](172,1): «indent»
+SyntaxKind[Identifier](172,2): DecimalLiteral
+SyntaxKind[LineTerminatorToken](173,1): «line terminator»
+SyntaxKind[Identifier](173,2): BinaryIntegerLiteral
+SyntaxKind[LineTerminatorToken](174,1): «line terminator»
+SyntaxKind[Identifier](174,2): OctalIntegerLiteral
+SyntaxKind[LineTerminatorToken](175,1): «line terminator»
+SyntaxKind[Identifier](175,2): HexIntegerLiteral
+SyntaxKind[LineTerminatorToken](176,1): «line terminator»
+SyntaxKind[DedentToken](176,1): «dedent»
+SyntaxKind[LineTerminatorToken](177,1): «line terminator»
+SyntaxKind[Identifier](177,1): DecimalLiteral
+SyntaxKind[ColonColonToken](177,16): ::
+SyntaxKind[LineTerminatorToken](178,1): «line terminator»
+SyntaxKind[IndentToken](178,1): «indent»
+SyntaxKind[Identifier](178,2): DecimalIntegerLiteral
+SyntaxKind[Terminal](178,24): `.`
+SyntaxKind[Identifier](178,28): DecimalDigits
+SyntaxKind[QuestionToken](178,41): ?
+SyntaxKind[Identifier](178,43): ExponentPart
+SyntaxKind[QuestionToken](178,55): ?
+SyntaxKind[LineTerminatorToken](179,1): «line terminator»
+SyntaxKind[Terminal](179,2): `.`
+SyntaxKind[Identifier](179,6): DecimalDigits
+SyntaxKind[Identifier](179,20): ExponentPart
+SyntaxKind[QuestionToken](179,32): ?
+SyntaxKind[LineTerminatorToken](180,1): «line terminator»
+SyntaxKind[Identifier](180,2): DecimalIntegerLiteral
+SyntaxKind[Identifier](180,24): ExponentPart
+SyntaxKind[QuestionToken](180,36): ?
+SyntaxKind[LineTerminatorToken](181,1): «line terminator»
+SyntaxKind[DedentToken](181,1): «dedent»
+SyntaxKind[LineTerminatorToken](182,1): «line terminator»
+SyntaxKind[Identifier](182,1): DecimalIntegerLiteral
+SyntaxKind[ColonColonToken](182,23): ::
+SyntaxKind[LineTerminatorToken](183,1): «line terminator»
+SyntaxKind[IndentToken](183,1): «indent»
+SyntaxKind[Terminal](183,2): `0`
+SyntaxKind[LineTerminatorToken](184,1): «line terminator»
+SyntaxKind[Identifier](184,2): NonZeroDigit
+SyntaxKind[Identifier](184,15): DecimalDigits
+SyntaxKind[QuestionToken](184,28): ?
+SyntaxKind[LineTerminatorToken](185,1): «line terminator»
+SyntaxKind[DedentToken](185,1): «dedent»
+SyntaxKind[LineTerminatorToken](186,1): «line terminator»
+SyntaxKind[Identifier](186,1): DecimalDigits
+SyntaxKind[ColonColonToken](186,15): ::
+SyntaxKind[LineTerminatorToken](187,1): «line terminator»
+SyntaxKind[IndentToken](187,1): «indent»
+SyntaxKind[Identifier](187,2): DecimalDigit
+SyntaxKind[LineTerminatorToken](188,1): «line terminator»
+SyntaxKind[Identifier](188,2): DecimalDigits
+SyntaxKind[Identifier](188,16): DecimalDigit
+SyntaxKind[LineTerminatorToken](189,1): «line terminator»
+SyntaxKind[DedentToken](189,1): «dedent»
+SyntaxKind[LineTerminatorToken](190,1): «line terminator»
+SyntaxKind[Identifier](190,1): DecimalDigit
+SyntaxKind[ColonColonToken](190,14): ::
+SyntaxKind[OneKeyword](190,17): one
+SyntaxKind[OfKeyword](190,21): of
+SyntaxKind[LineTerminatorToken](191,1): «line terminator»
+SyntaxKind[IndentToken](191,1): «indent»
+SyntaxKind[Terminal](191,2): `0`
+SyntaxKind[Terminal](191,6): `1`
+SyntaxKind[Terminal](191,10): `2`
+SyntaxKind[Terminal](191,14): `3`
+SyntaxKind[Terminal](191,18): `4`
+SyntaxKind[Terminal](191,22): `5`
+SyntaxKind[Terminal](191,26): `6`
+SyntaxKind[Terminal](191,30): `7`
+SyntaxKind[Terminal](191,34): `8`
+SyntaxKind[Terminal](191,38): `9`
+SyntaxKind[LineTerminatorToken](192,1): «line terminator»
+SyntaxKind[DedentToken](192,1): «dedent»
+SyntaxKind[LineTerminatorToken](193,1): «line terminator»
+SyntaxKind[Identifier](193,1): NonZeroDigit
+SyntaxKind[ColonColonToken](193,14): ::
+SyntaxKind[OneKeyword](193,17): one
+SyntaxKind[OfKeyword](193,21): of
+SyntaxKind[LineTerminatorToken](194,1): «line terminator»
+SyntaxKind[IndentToken](194,1): «indent»
+SyntaxKind[Terminal](194,2): `1`
+SyntaxKind[Terminal](194,6): `2`
+SyntaxKind[Terminal](194,10): `3`
+SyntaxKind[Terminal](194,14): `4`
+SyntaxKind[Terminal](194,18): `5`
+SyntaxKind[Terminal](194,22): `6`
+SyntaxKind[Terminal](194,26): `7`
+SyntaxKind[Terminal](194,30): `8`
+SyntaxKind[Terminal](194,34): `9`
+SyntaxKind[LineTerminatorToken](195,1): «line terminator»
+SyntaxKind[DedentToken](195,1): «dedent»
+SyntaxKind[LineTerminatorToken](196,1): «line terminator»
+SyntaxKind[Identifier](196,1): ExponentPart
+SyntaxKind[ColonColonToken](196,14): ::
+SyntaxKind[LineTerminatorToken](197,1): «line terminator»
+SyntaxKind[IndentToken](197,1): «indent»
+SyntaxKind[Identifier](197,2): ExponentIndicator
+SyntaxKind[Identifier](197,20): SignedInteger
+SyntaxKind[LineTerminatorToken](198,1): «line terminator»
+SyntaxKind[DedentToken](198,1): «dedent»
+SyntaxKind[LineTerminatorToken](199,1): «line terminator»
+SyntaxKind[Identifier](199,1): ExponentIndicator
+SyntaxKind[ColonColonToken](199,19): ::
+SyntaxKind[OneKeyword](199,22): one
+SyntaxKind[OfKeyword](199,26): of
+SyntaxKind[LineTerminatorToken](200,1): «line terminator»
+SyntaxKind[IndentToken](200,1): «indent»
+SyntaxKind[Terminal](200,2): `e`
+SyntaxKind[Terminal](200,6): `E`
+SyntaxKind[LineTerminatorToken](201,1): «line terminator»
+SyntaxKind[DedentToken](201,1): «dedent»
+SyntaxKind[LineTerminatorToken](202,1): «line terminator»
+SyntaxKind[Identifier](202,1): SignedInteger
+SyntaxKind[ColonColonToken](202,15): ::
+SyntaxKind[LineTerminatorToken](203,1): «line terminator»
+SyntaxKind[IndentToken](203,1): «indent»
+SyntaxKind[Identifier](203,2): DecimalDigits
+SyntaxKind[LineTerminatorToken](204,1): «line terminator»
+SyntaxKind[Terminal](204,2): `+`
+SyntaxKind[Identifier](204,6): DecimalDigits
+SyntaxKind[LineTerminatorToken](205,1): «line terminator»
+SyntaxKind[Terminal](205,2): `-`
+SyntaxKind[Identifier](205,6): DecimalDigits
+SyntaxKind[LineTerminatorToken](206,1): «line terminator»
+SyntaxKind[DedentToken](206,1): «dedent»
+SyntaxKind[LineTerminatorToken](207,1): «line terminator»
+SyntaxKind[Identifier](207,1): BinaryIntegerLiteral
+SyntaxKind[ColonColonToken](207,22): ::
+SyntaxKind[LineTerminatorToken](208,1): «line terminator»
+SyntaxKind[IndentToken](208,1): «indent»
+SyntaxKind[Terminal](208,2): `0b`
+SyntaxKind[Identifier](208,7): BinaryDigits
+SyntaxKind[LineTerminatorToken](209,1): «line terminator»
+SyntaxKind[Terminal](209,2): `0B`
+SyntaxKind[Identifier](209,7): BinaryDigits
+SyntaxKind[LineTerminatorToken](210,1): «line terminator»
+SyntaxKind[DedentToken](210,1): «dedent»
+SyntaxKind[LineTerminatorToken](211,1): «line terminator»
+SyntaxKind[Identifier](211,1): BinaryDigits
+SyntaxKind[ColonColonToken](211,14): ::
+SyntaxKind[LineTerminatorToken](212,1): «line terminator»
+SyntaxKind[IndentToken](212,1): «indent»
+SyntaxKind[Identifier](212,2): BinaryDigit
+SyntaxKind[LineTerminatorToken](213,1): «line terminator»
+SyntaxKind[Identifier](213,2): BinaryDigits
+SyntaxKind[Identifier](213,15): BinaryDigit
+SyntaxKind[LineTerminatorToken](214,1): «line terminator»
+SyntaxKind[DedentToken](214,1): «dedent»
+SyntaxKind[LineTerminatorToken](215,1): «line terminator»
+SyntaxKind[Identifier](215,1): BinaryDigit
+SyntaxKind[ColonColonToken](215,13): ::
+SyntaxKind[OneKeyword](215,16): one
+SyntaxKind[OfKeyword](215,20): of
+SyntaxKind[LineTerminatorToken](216,1): «line terminator»
+SyntaxKind[IndentToken](216,1): «indent»
+SyntaxKind[Terminal](216,2): `0`
+SyntaxKind[Terminal](216,6): `1`
+SyntaxKind[LineTerminatorToken](217,1): «line terminator»
+SyntaxKind[DedentToken](217,1): «dedent»
+SyntaxKind[LineTerminatorToken](218,1): «line terminator»
+SyntaxKind[Identifier](218,1): OctalIntegerLiteral
+SyntaxKind[ColonColonToken](218,21): ::
+SyntaxKind[LineTerminatorToken](219,1): «line terminator»
+SyntaxKind[IndentToken](219,1): «indent»
+SyntaxKind[Terminal](219,2): `0o`
+SyntaxKind[Identifier](219,7): OctalDigits
+SyntaxKind[LineTerminatorToken](220,1): «line terminator»
+SyntaxKind[Terminal](220,2): `0O`
+SyntaxKind[Identifier](220,7): OctalDigits
+SyntaxKind[LineTerminatorToken](221,1): «line terminator»
+SyntaxKind[DedentToken](221,1): «dedent»
+SyntaxKind[LineTerminatorToken](222,1): «line terminator»
+SyntaxKind[Identifier](222,1): OctalDigits
+SyntaxKind[ColonColonToken](222,13): ::
+SyntaxKind[LineTerminatorToken](223,1): «line terminator»
+SyntaxKind[IndentToken](223,1): «indent»
+SyntaxKind[Identifier](223,2): OctalDigit
+SyntaxKind[LineTerminatorToken](224,1): «line terminator»
+SyntaxKind[Identifier](224,2): OctalDigits
+SyntaxKind[Identifier](224,14): OctalDigit
+SyntaxKind[LineTerminatorToken](225,1): «line terminator»
+SyntaxKind[DedentToken](225,1): «dedent»
+SyntaxKind[LineTerminatorToken](226,1): «line terminator»
+SyntaxKind[Identifier](226,1): OctalDigit
+SyntaxKind[ColonColonToken](226,12): ::
+SyntaxKind[OneKeyword](226,15): one
+SyntaxKind[OfKeyword](226,19): of
+SyntaxKind[LineTerminatorToken](227,1): «line terminator»
+SyntaxKind[IndentToken](227,1): «indent»
+SyntaxKind[Terminal](227,2): `0`
+SyntaxKind[Terminal](227,6): `1`
+SyntaxKind[Terminal](227,10): `2`
+SyntaxKind[Terminal](227,14): `3`
+SyntaxKind[Terminal](227,18): `4`
+SyntaxKind[Terminal](227,22): `5`
+SyntaxKind[Terminal](227,26): `6`
+SyntaxKind[Terminal](227,30): `7`
+SyntaxKind[LineTerminatorToken](228,1): «line terminator»
+SyntaxKind[DedentToken](228,1): «dedent»
+SyntaxKind[LineTerminatorToken](229,1): «line terminator»
+SyntaxKind[Identifier](229,1): HexIntegerLiteral
+SyntaxKind[ColonColonToken](229,19): ::
+SyntaxKind[LineTerminatorToken](230,1): «line terminator»
+SyntaxKind[IndentToken](230,1): «indent»
+SyntaxKind[Terminal](230,2): `0x`
+SyntaxKind[Identifier](230,7): HexDigits
+SyntaxKind[LineTerminatorToken](231,1): «line terminator»
+SyntaxKind[Terminal](231,2): `0X`
+SyntaxKind[Identifier](231,7): HexDigits
+SyntaxKind[LineTerminatorToken](232,1): «line terminator»
+SyntaxKind[DedentToken](232,1): «dedent»
+SyntaxKind[LineTerminatorToken](233,1): «line terminator»
+SyntaxKind[Identifier](233,1): HexDigits
+SyntaxKind[ColonColonToken](233,11): ::
+SyntaxKind[LineTerminatorToken](234,1): «line terminator»
+SyntaxKind[IndentToken](234,1): «indent»
+SyntaxKind[Identifier](234,2): HexDigit
+SyntaxKind[LineTerminatorToken](235,1): «line terminator»
+SyntaxKind[Identifier](235,2): HexDigits
+SyntaxKind[Identifier](235,12): HexDigit
+SyntaxKind[LineTerminatorToken](236,1): «line terminator»
+SyntaxKind[DedentToken](236,1): «dedent»
+SyntaxKind[LineTerminatorToken](237,1): «line terminator»
+SyntaxKind[Identifier](237,1): HexDigit
+SyntaxKind[ColonColonToken](237,10): ::
+SyntaxKind[OneKeyword](237,13): one
+SyntaxKind[OfKeyword](237,17): of
+SyntaxKind[LineTerminatorToken](238,1): «line terminator»
+SyntaxKind[IndentToken](238,1): «indent»
+SyntaxKind[Terminal](238,2): `0`
+SyntaxKind[Terminal](238,6): `1`
+SyntaxKind[Terminal](238,10): `2`
+SyntaxKind[Terminal](238,14): `3`
+SyntaxKind[Terminal](238,18): `4`
+SyntaxKind[Terminal](238,22): `5`
+SyntaxKind[Terminal](238,26): `6`
+SyntaxKind[Terminal](238,30): `7`
+SyntaxKind[Terminal](238,34): `8`
+SyntaxKind[Terminal](238,38): `9`
+SyntaxKind[Terminal](238,42): `a`
+SyntaxKind[Terminal](238,46): `b`
+SyntaxKind[Terminal](238,50): `c`
+SyntaxKind[Terminal](238,54): `d`
+SyntaxKind[Terminal](238,58): `e`
+SyntaxKind[Terminal](238,62): `f`
+SyntaxKind[Terminal](238,66): `A`
+SyntaxKind[Terminal](238,70): `B`
+SyntaxKind[Terminal](238,74): `C`
+SyntaxKind[Terminal](238,78): `D`
+SyntaxKind[Terminal](238,82): `E`
+SyntaxKind[Terminal](238,86): `F`
+SyntaxKind[LineTerminatorToken](239,1): «line terminator»
+SyntaxKind[DedentToken](239,1): «dedent»
+SyntaxKind[LineTerminatorToken](240,1): «line terminator»
+SyntaxKind[Identifier](240,1): StringLiteral
+SyntaxKind[ColonColonToken](240,15): ::
+SyntaxKind[LineTerminatorToken](241,1): «line terminator»
+SyntaxKind[IndentToken](241,1): «indent»
+SyntaxKind[Terminal](241,2): `"`
+SyntaxKind[Identifier](241,6): DoubleStringCharacters
+SyntaxKind[QuestionToken](241,28): ?
+SyntaxKind[Terminal](241,30): `"`
+SyntaxKind[LineTerminatorToken](242,1): «line terminator»
+SyntaxKind[Terminal](242,2): `'`
+SyntaxKind[Identifier](242,6): SingleStringCharacters
+SyntaxKind[QuestionToken](242,28): ?
+SyntaxKind[Terminal](242,30): `'`
+SyntaxKind[LineTerminatorToken](243,1): «line terminator»
+SyntaxKind[DedentToken](243,1): «dedent»
+SyntaxKind[LineTerminatorToken](244,1): «line terminator»
+SyntaxKind[Identifier](244,1): DoubleStringCharacters
+SyntaxKind[ColonColonToken](244,24): ::
+SyntaxKind[LineTerminatorToken](245,1): «line terminator»
+SyntaxKind[IndentToken](245,1): «indent»
+SyntaxKind[Identifier](245,2): DoubleStringCharacter
+SyntaxKind[Identifier](245,24): DoubleStringCharacters
+SyntaxKind[QuestionToken](245,46): ?
+SyntaxKind[LineTerminatorToken](246,1): «line terminator»
+SyntaxKind[DedentToken](246,1): «dedent»
+SyntaxKind[LineTerminatorToken](247,1): «line terminator»
+SyntaxKind[Identifier](247,1): SingleStringCharacters
+SyntaxKind[ColonColonToken](247,24): ::
+SyntaxKind[LineTerminatorToken](248,1): «line terminator»
+SyntaxKind[IndentToken](248,1): «indent»
+SyntaxKind[Identifier](248,2): SingleStringCharacter
+SyntaxKind[Identifier](248,24): SingleStringCharacters
+SyntaxKind[QuestionToken](248,46): ?
+SyntaxKind[LineTerminatorToken](249,1): «line terminator»
+SyntaxKind[DedentToken](249,1): «dedent»
+SyntaxKind[LineTerminatorToken](250,1): «line terminator»
+SyntaxKind[Identifier](250,1): DoubleStringCharacter
+SyntaxKind[ColonColonToken](250,23): ::
+SyntaxKind[LineTerminatorToken](251,1): «line terminator»
+SyntaxKind[IndentToken](251,1): «indent»
+SyntaxKind[Identifier](251,2): SourceCharacter
+SyntaxKind[ButKeyword](251,18): but
+SyntaxKind[NotKeyword](251,22): not
+SyntaxKind[OneKeyword](251,26): one
+SyntaxKind[OfKeyword](251,30): of
+SyntaxKind[Terminal](251,33): `"`
+SyntaxKind[OrKeyword](251,37): or
+SyntaxKind[Terminal](251,40): `\`
+SyntaxKind[OrKeyword](251,44): or
+SyntaxKind[Identifier](251,47): LineTerminator
+SyntaxKind[LineTerminatorToken](252,1): «line terminator»
+SyntaxKind[Terminal](252,2): `\`
+SyntaxKind[Identifier](252,6): EscapeSequence
+SyntaxKind[LineTerminatorToken](253,1): «line terminator»
+SyntaxKind[Identifier](253,2): LineContinuation
+SyntaxKind[LineTerminatorToken](254,1): «line terminator»
+SyntaxKind[DedentToken](254,1): «dedent»
+SyntaxKind[LineTerminatorToken](255,1): «line terminator»
+SyntaxKind[Identifier](255,1): SingleStringCharacter
+SyntaxKind[ColonColonToken](255,23): ::
+SyntaxKind[LineTerminatorToken](256,1): «line terminator»
+SyntaxKind[IndentToken](256,1): «indent»
+SyntaxKind[Identifier](256,2): SourceCharacter
+SyntaxKind[ButKeyword](256,18): but
+SyntaxKind[NotKeyword](256,22): not
+SyntaxKind[OneKeyword](256,26): one
+SyntaxKind[OfKeyword](256,30): of
+SyntaxKind[Terminal](256,33): `'`
+SyntaxKind[OrKeyword](256,37): or
+SyntaxKind[Terminal](256,40): `\`
+SyntaxKind[OrKeyword](256,44): or
+SyntaxKind[Identifier](256,47): LineTerminator
+SyntaxKind[LineTerminatorToken](257,1): «line terminator»
+SyntaxKind[Terminal](257,2): `\`
+SyntaxKind[Identifier](257,6): EscapeSequence
+SyntaxKind[LineTerminatorToken](258,1): «line terminator»
+SyntaxKind[Identifier](258,2): LineContinuation
+SyntaxKind[LineTerminatorToken](259,1): «line terminator»
+SyntaxKind[DedentToken](259,1): «dedent»
+SyntaxKind[LineTerminatorToken](260,1): «line terminator»
+SyntaxKind[Identifier](260,1): LineContinuation
+SyntaxKind[ColonColonToken](260,18): ::
+SyntaxKind[LineTerminatorToken](261,1): «line terminator»
+SyntaxKind[IndentToken](261,1): «indent»
+SyntaxKind[Terminal](261,2): `\`
+SyntaxKind[Identifier](261,6): LineTerminatorSequence
+SyntaxKind[LineTerminatorToken](262,1): «line terminator»
+SyntaxKind[DedentToken](262,1): «dedent»
+SyntaxKind[LineTerminatorToken](263,1): «line terminator»
+SyntaxKind[Identifier](263,1): EscapeSequence
+SyntaxKind[ColonColonToken](263,16): ::
+SyntaxKind[LineTerminatorToken](264,1): «line terminator»
+SyntaxKind[IndentToken](264,1): «indent»
+SyntaxKind[Identifier](264,2): CharacterEscapeSequence
+SyntaxKind[LineTerminatorToken](265,1): «line terminator»
+SyntaxKind[Terminal](265,2): `0`
+SyntaxKind[OpenBracketToken](265,6): [
+SyntaxKind[LookaheadKeyword](265,7): lookahead
+SyntaxKind[ExclamationEqualsToken](265,17): !=
+SyntaxKind[Identifier](265,20): DecimalDigit
+SyntaxKind[CloseBracketToken](265,32): ]
+SyntaxKind[LineTerminatorToken](266,1): «line terminator»
+SyntaxKind[Identifier](266,2): HexEscapeSequence
+SyntaxKind[LineTerminatorToken](267,1): «line terminator»
+SyntaxKind[Identifier](267,2): UnicodeEscapeSequence
+SyntaxKind[LineTerminatorToken](268,1): «line terminator»
+SyntaxKind[DedentToken](268,1): «dedent»
+SyntaxKind[LineTerminatorToken](269,1): «line terminator»
+SyntaxKind[Identifier](269,1): CharacterEscapeSequence
+SyntaxKind[ColonColonToken](269,25): ::
+SyntaxKind[LineTerminatorToken](270,1): «line terminator»
+SyntaxKind[IndentToken](270,1): «indent»
+SyntaxKind[Identifier](270,2): SingleEscapeCharacter
+SyntaxKind[LineTerminatorToken](271,1): «line terminator»
+SyntaxKind[Identifier](271,2): NonEscapeCharacter
+SyntaxKind[LineTerminatorToken](272,1): «line terminator»
+SyntaxKind[DedentToken](272,1): «dedent»
+SyntaxKind[LineTerminatorToken](273,1): «line terminator»
+SyntaxKind[Identifier](273,1): SingleEscapeCharacter
+SyntaxKind[ColonColonToken](273,23): ::
+SyntaxKind[OneKeyword](273,26): one
+SyntaxKind[OfKeyword](273,30): of
+SyntaxKind[LineTerminatorToken](274,1): «line terminator»
+SyntaxKind[IndentToken](274,1): «indent»
+SyntaxKind[Terminal](274,2): `'`
+SyntaxKind[Terminal](274,6): `"`
+SyntaxKind[Terminal](274,10): `\`
+SyntaxKind[Terminal](274,14): `b`
+SyntaxKind[Terminal](274,18): `f`
+SyntaxKind[Terminal](274,22): `n`
+SyntaxKind[Terminal](274,26): `r`
+SyntaxKind[Terminal](274,30): `t`
+SyntaxKind[Terminal](274,34): `v`
+SyntaxKind[LineTerminatorToken](275,1): «line terminator»
+SyntaxKind[DedentToken](275,1): «dedent»
+SyntaxKind[LineTerminatorToken](276,1): «line terminator»
+SyntaxKind[Identifier](276,1): NonEscapeCharacter
+SyntaxKind[ColonColonToken](276,20): ::
+SyntaxKind[LineTerminatorToken](277,1): «line terminator»
+SyntaxKind[IndentToken](277,1): «indent»
+SyntaxKind[Identifier](277,2): SourceCharacter
+SyntaxKind[ButKeyword](277,18): but
+SyntaxKind[NotKeyword](277,22): not
+SyntaxKind[OneKeyword](277,26): one
+SyntaxKind[OfKeyword](277,30): of
+SyntaxKind[Identifier](277,33): EscapeCharacter
+SyntaxKind[OrKeyword](277,49): or
+SyntaxKind[Identifier](277,52): LineTerminator
+SyntaxKind[LineTerminatorToken](278,1): «line terminator»
+SyntaxKind[DedentToken](278,1): «dedent»
+SyntaxKind[LineTerminatorToken](279,1): «line terminator»
+SyntaxKind[Identifier](279,1): EscapeCharacter
+SyntaxKind[ColonColonToken](279,17): ::
+SyntaxKind[LineTerminatorToken](280,1): «line terminator»
+SyntaxKind[IndentToken](280,1): «indent»
+SyntaxKind[Identifier](280,2): SingleEscapeCharacter
+SyntaxKind[LineTerminatorToken](281,1): «line terminator»
+SyntaxKind[Identifier](281,2): DecimalDigit
+SyntaxKind[LineTerminatorToken](282,1): «line terminator»
+SyntaxKind[Terminal](282,2): `x`
+SyntaxKind[LineTerminatorToken](283,1): «line terminator»
+SyntaxKind[Terminal](283,2): `u`
+SyntaxKind[LineTerminatorToken](284,1): «line terminator»
+SyntaxKind[DedentToken](284,1): «dedent»
+SyntaxKind[LineTerminatorToken](285,1): «line terminator»
+SyntaxKind[Identifier](285,1): HexEscapeSequence
+SyntaxKind[ColonColonToken](285,19): ::
+SyntaxKind[LineTerminatorToken](286,1): «line terminator»
+SyntaxKind[IndentToken](286,1): «indent»
+SyntaxKind[Terminal](286,2): `x`
+SyntaxKind[Identifier](286,6): HexDigit
+SyntaxKind[Identifier](286,15): HexDigit
+SyntaxKind[LineTerminatorToken](287,1): «line terminator»
+SyntaxKind[DedentToken](287,1): «dedent»
+SyntaxKind[LineTerminatorToken](288,1): «line terminator»
+SyntaxKind[Identifier](288,1): UnicodeEscapeSequence
+SyntaxKind[ColonColonToken](288,23): ::
+SyntaxKind[LineTerminatorToken](289,1): «line terminator»
+SyntaxKind[IndentToken](289,1): «indent»
+SyntaxKind[Terminal](289,2): `u`
+SyntaxKind[Identifier](289,6): Hex4Digits
+SyntaxKind[LineTerminatorToken](290,1): «line terminator»
+SyntaxKind[Terminal](290,2): `u{`
+SyntaxKind[Identifier](290,7): HexDigits
+SyntaxKind[Terminal](290,17): `}`
+SyntaxKind[LineTerminatorToken](291,1): «line terminator»
+SyntaxKind[DedentToken](291,1): «dedent»
+SyntaxKind[LineTerminatorToken](292,1): «line terminator»
+SyntaxKind[Identifier](292,1): Hex4Digits
+SyntaxKind[ColonColonToken](292,12): ::
+SyntaxKind[LineTerminatorToken](293,1): «line terminator»
+SyntaxKind[IndentToken](293,1): «indent»
+SyntaxKind[Identifier](293,2): HexDigit
+SyntaxKind[Identifier](293,11): HexDigit
+SyntaxKind[Identifier](293,20): HexDigit
+SyntaxKind[Identifier](293,29): HexDigit
+SyntaxKind[LineTerminatorToken](294,1): «line terminator»
+SyntaxKind[DedentToken](294,1): «dedent»
+SyntaxKind[LineTerminatorToken](295,1): «line terminator»
+SyntaxKind[Identifier](295,1): RegularExpressionLiteral
+SyntaxKind[ColonColonToken](295,26): ::
+SyntaxKind[LineTerminatorToken](296,1): «line terminator»
+SyntaxKind[IndentToken](296,1): «indent»
+SyntaxKind[Terminal](296,2): `/`
+SyntaxKind[Identifier](296,6): RegularExpressionBody
+SyntaxKind[Terminal](296,28): `/`
+SyntaxKind[Identifier](296,32): RegularExpressionFlags
+SyntaxKind[LineTerminatorToken](297,1): «line terminator»
+SyntaxKind[DedentToken](297,1): «dedent»
+SyntaxKind[LineTerminatorToken](298,1): «line terminator»
+SyntaxKind[Identifier](298,1): RegularExpressionBody
+SyntaxKind[ColonColonToken](298,23): ::
+SyntaxKind[LineTerminatorToken](299,1): «line terminator»
+SyntaxKind[IndentToken](299,1): «indent»
+SyntaxKind[Identifier](299,2): RegularExpressionFirstChar
+SyntaxKind[Identifier](299,29): RegularExpressionChars
+SyntaxKind[LineTerminatorToken](300,1): «line terminator»
+SyntaxKind[DedentToken](300,1): «dedent»
+SyntaxKind[LineTerminatorToken](301,1): «line terminator»
+SyntaxKind[Identifier](301,1): RegularExpressionChars
+SyntaxKind[ColonColonToken](301,24): ::
+SyntaxKind[LineTerminatorToken](302,1): «line terminator»
+SyntaxKind[IndentToken](302,1): «indent»
+SyntaxKind[OpenBracketToken](302,2): [
+SyntaxKind[EmptyKeyword](302,3): empty
+SyntaxKind[CloseBracketToken](302,8): ]
+SyntaxKind[LineTerminatorToken](303,1): «line terminator»
+SyntaxKind[Identifier](303,2): RegularExpressionChars
+SyntaxKind[Identifier](303,25): RegularExpressionChar
+SyntaxKind[LineTerminatorToken](304,1): «line terminator»
+SyntaxKind[DedentToken](304,1): «dedent»
+SyntaxKind[LineTerminatorToken](305,1): «line terminator»
+SyntaxKind[Identifier](305,1): RegularExpressionFirstChar
+SyntaxKind[ColonColonToken](305,28): ::
+SyntaxKind[LineTerminatorToken](306,1): «line terminator»
+SyntaxKind[IndentToken](306,1): «indent»
+SyntaxKind[Identifier](306,2): RegularExpressionNonTerminator
+SyntaxKind[ButKeyword](306,33): but
+SyntaxKind[NotKeyword](306,37): not
+SyntaxKind[OneKeyword](306,41): one
+SyntaxKind[OfKeyword](306,45): of
+SyntaxKind[Terminal](306,48): `*`
+SyntaxKind[OrKeyword](306,52): or
+SyntaxKind[Terminal](306,55): `\`
+SyntaxKind[OrKeyword](306,59): or
+SyntaxKind[Terminal](306,62): `/`
+SyntaxKind[OrKeyword](306,66): or
+SyntaxKind[Terminal](306,69): `[`
+SyntaxKind[LineTerminatorToken](307,1): «line terminator»
+SyntaxKind[Identifier](307,2): RegularExpressionBackslashSequence
+SyntaxKind[LineTerminatorToken](308,1): «line terminator»
+SyntaxKind[Identifier](308,2): RegularExpressionClass
+SyntaxKind[LineTerminatorToken](309,1): «line terminator»
+SyntaxKind[DedentToken](309,1): «dedent»
+SyntaxKind[LineTerminatorToken](310,1): «line terminator»
+SyntaxKind[Identifier](310,1): RegularExpressionChar
+SyntaxKind[ColonColonToken](310,23): ::
+SyntaxKind[LineTerminatorToken](311,1): «line terminator»
+SyntaxKind[IndentToken](311,1): «indent»
+SyntaxKind[Identifier](311,2): RegularExpressionNonTerminator
+SyntaxKind[ButKeyword](311,33): but
+SyntaxKind[NotKeyword](311,37): not
+SyntaxKind[OneKeyword](311,41): one
+SyntaxKind[OfKeyword](311,45): of
+SyntaxKind[Terminal](311,48): `\`
+SyntaxKind[OrKeyword](311,52): or
+SyntaxKind[Terminal](311,55): `/`
+SyntaxKind[OrKeyword](311,59): or
+SyntaxKind[Terminal](311,62): `[`
+SyntaxKind[LineTerminatorToken](312,1): «line terminator»
+SyntaxKind[Identifier](312,2): RegularExpressionBackslashSequence
+SyntaxKind[LineTerminatorToken](313,1): «line terminator»
+SyntaxKind[Identifier](313,2): RegularExpressionClass
+SyntaxKind[LineTerminatorToken](314,1): «line terminator»
+SyntaxKind[DedentToken](314,1): «dedent»
+SyntaxKind[LineTerminatorToken](315,1): «line terminator»
+SyntaxKind[Identifier](315,1): RegularExpressionBackslashSequence
+SyntaxKind[ColonColonToken](315,36): ::
+SyntaxKind[LineTerminatorToken](316,1): «line terminator»
+SyntaxKind[IndentToken](316,1): «indent»
+SyntaxKind[Terminal](316,2): `\`
+SyntaxKind[Identifier](316,6): RegularExpressionNonTerminator
+SyntaxKind[LineTerminatorToken](317,1): «line terminator»
+SyntaxKind[DedentToken](317,1): «dedent»
+SyntaxKind[LineTerminatorToken](318,1): «line terminator»
+SyntaxKind[Identifier](318,1): RegularExpressionNonTerminator
+SyntaxKind[ColonColonToken](318,32): ::
+SyntaxKind[LineTerminatorToken](319,1): «line terminator»
+SyntaxKind[IndentToken](319,1): «indent»
+SyntaxKind[Identifier](319,2): SourceCharacter
+SyntaxKind[ButKeyword](319,18): but
+SyntaxKind[NotKeyword](319,22): not
+SyntaxKind[Identifier](319,26): LineTerminator
+SyntaxKind[LineTerminatorToken](320,1): «line terminator»
+SyntaxKind[DedentToken](320,1): «dedent»
+SyntaxKind[LineTerminatorToken](321,1): «line terminator»
+SyntaxKind[Identifier](321,1): RegularExpressionClass
+SyntaxKind[ColonColonToken](321,24): ::
+SyntaxKind[LineTerminatorToken](322,1): «line terminator»
+SyntaxKind[IndentToken](322,1): «indent»
+SyntaxKind[Terminal](322,2): `[`
+SyntaxKind[Identifier](322,6): RegularExpressionClassChars
+SyntaxKind[Terminal](322,34): `]`
+SyntaxKind[LineTerminatorToken](323,1): «line terminator»
+SyntaxKind[DedentToken](323,1): «dedent»
+SyntaxKind[LineTerminatorToken](324,1): «line terminator»
+SyntaxKind[Identifier](324,1): RegularExpressionClassChars
+SyntaxKind[ColonColonToken](324,29): ::
+SyntaxKind[LineTerminatorToken](325,1): «line terminator»
+SyntaxKind[IndentToken](325,1): «indent»
+SyntaxKind[OpenBracketToken](325,2): [
+SyntaxKind[EmptyKeyword](325,3): empty
+SyntaxKind[CloseBracketToken](325,8): ]
+SyntaxKind[LineTerminatorToken](326,1): «line terminator»
+SyntaxKind[Identifier](326,2): RegularExpressionClassChars
+SyntaxKind[Identifier](326,30): RegularExpressionClassChar
+SyntaxKind[LineTerminatorToken](327,1): «line terminator»
+SyntaxKind[DedentToken](327,1): «dedent»
+SyntaxKind[LineTerminatorToken](328,1): «line terminator»
+SyntaxKind[Identifier](328,1): RegularExpressionClassChar
+SyntaxKind[ColonColonToken](328,28): ::
+SyntaxKind[LineTerminatorToken](329,1): «line terminator»
+SyntaxKind[IndentToken](329,1): «indent»
+SyntaxKind[Identifier](329,2): RegularExpressionNonTerminator
+SyntaxKind[ButKeyword](329,33): but
+SyntaxKind[NotKeyword](329,37): not
+SyntaxKind[OneKeyword](329,41): one
+SyntaxKind[OfKeyword](329,45): of
+SyntaxKind[Terminal](329,48): `]`
+SyntaxKind[OrKeyword](329,52): or
+SyntaxKind[Terminal](329,55): `\`
+SyntaxKind[LineTerminatorToken](330,1): «line terminator»
+SyntaxKind[Identifier](330,2): RegularExpressionBackslashSequence
+SyntaxKind[LineTerminatorToken](331,1): «line terminator»
+SyntaxKind[DedentToken](331,1): «dedent»
+SyntaxKind[LineTerminatorToken](332,1): «line terminator»
+SyntaxKind[Identifier](332,1): RegularExpressionFlags
+SyntaxKind[ColonColonToken](332,24): ::
+SyntaxKind[LineTerminatorToken](333,1): «line terminator»
+SyntaxKind[IndentToken](333,1): «indent»
+SyntaxKind[OpenBracketToken](333,2): [
+SyntaxKind[EmptyKeyword](333,3): empty
+SyntaxKind[CloseBracketToken](333,8): ]
+SyntaxKind[LineTerminatorToken](334,1): «line terminator»
+SyntaxKind[Identifier](334,2): RegularExpressionFlags
+SyntaxKind[Identifier](334,25): IdentifierPart
+SyntaxKind[LineTerminatorToken](335,1): «line terminator»
+SyntaxKind[DedentToken](335,1): «dedent»
+SyntaxKind[LineTerminatorToken](336,1): «line terminator»
+SyntaxKind[Identifier](336,1): Template
+SyntaxKind[ColonColonToken](336,10): ::
+SyntaxKind[LineTerminatorToken](337,1): «line terminator»
+SyntaxKind[IndentToken](337,1): «indent»
+SyntaxKind[Identifier](337,2): NoSubstitutionTemplate
+SyntaxKind[LineTerminatorToken](338,1): «line terminator»
+SyntaxKind[Identifier](338,2): TemplateHead
+SyntaxKind[LineTerminatorToken](339,1): «line terminator»
+SyntaxKind[DedentToken](339,1): «dedent»
+SyntaxKind[LineTerminatorToken](340,1): «line terminator»
+SyntaxKind[Identifier](340,1): NoSubstitutionTemplate
+SyntaxKind[ColonColonToken](340,24): ::
+SyntaxKind[LineTerminatorToken](341,1): «line terminator»
+SyntaxKind[IndentToken](341,1): «indent»
+SyntaxKind[Terminal](341,2): ```
+SyntaxKind[Identifier](341,6): TemplateCharacters
+SyntaxKind[QuestionToken](341,24): ?
+SyntaxKind[Terminal](341,26): ```
+SyntaxKind[LineTerminatorToken](342,1): «line terminator»
+SyntaxKind[DedentToken](342,1): «dedent»
+SyntaxKind[LineTerminatorToken](343,1): «line terminator»
+SyntaxKind[Identifier](343,1): TemplateHead
+SyntaxKind[ColonColonToken](343,14): ::
+SyntaxKind[LineTerminatorToken](344,1): «line terminator»
+SyntaxKind[IndentToken](344,1): «indent»
+SyntaxKind[Terminal](344,2): ```
+SyntaxKind[Identifier](344,6): TemplateCharacters
+SyntaxKind[QuestionToken](344,24): ?
+SyntaxKind[Terminal](344,26): `${`
+SyntaxKind[LineTerminatorToken](345,1): «line terminator»
+SyntaxKind[DedentToken](345,1): «dedent»
+SyntaxKind[LineTerminatorToken](346,1): «line terminator»
+SyntaxKind[Identifier](346,1): TemplateSubstitutionTail
+SyntaxKind[ColonColonToken](346,26): ::
+SyntaxKind[LineTerminatorToken](347,1): «line terminator»
+SyntaxKind[IndentToken](347,1): «indent»
+SyntaxKind[Identifier](347,2): TemplateMiddle
+SyntaxKind[LineTerminatorToken](348,1): «line terminator»
+SyntaxKind[Identifier](348,2): TemplateTail
+SyntaxKind[LineTerminatorToken](349,1): «line terminator»
+SyntaxKind[DedentToken](349,1): «dedent»
+SyntaxKind[LineTerminatorToken](350,1): «line terminator»
+SyntaxKind[Identifier](350,1): TemplateMiddle
+SyntaxKind[ColonColonToken](350,16): ::
+SyntaxKind[LineTerminatorToken](351,1): «line terminator»
+SyntaxKind[IndentToken](351,1): «indent»
+SyntaxKind[Terminal](351,2): `}`
+SyntaxKind[Identifier](351,6): TemplateCharacters
+SyntaxKind[QuestionToken](351,24): ?
+SyntaxKind[Terminal](351,26): `${`
+SyntaxKind[LineTerminatorToken](352,1): «line terminator»
+SyntaxKind[DedentToken](352,1): «dedent»
+SyntaxKind[LineTerminatorToken](353,1): «line terminator»
+SyntaxKind[Identifier](353,1): TemplateTail
+SyntaxKind[ColonColonToken](353,14): ::
+SyntaxKind[LineTerminatorToken](354,1): «line terminator»
+SyntaxKind[IndentToken](354,1): «indent»
+SyntaxKind[Terminal](354,2): `}`
+SyntaxKind[Identifier](354,6): TemplateCharacters
+SyntaxKind[QuestionToken](354,24): ?
+SyntaxKind[Terminal](354,26): ```
+SyntaxKind[LineTerminatorToken](355,1): «line terminator»
+SyntaxKind[DedentToken](355,1): «dedent»
+SyntaxKind[LineTerminatorToken](356,1): «line terminator»
+SyntaxKind[Identifier](356,1): TemplateCharacters
+SyntaxKind[ColonColonToken](356,20): ::
+SyntaxKind[LineTerminatorToken](357,1): «line terminator»
+SyntaxKind[IndentToken](357,1): «indent»
+SyntaxKind[Identifier](357,2): TemplateCharacter
+SyntaxKind[Identifier](357,20): TemplateCharacters
+SyntaxKind[QuestionToken](357,38): ?
+SyntaxKind[LineTerminatorToken](358,1): «line terminator»
+SyntaxKind[DedentToken](358,1): «dedent»
+SyntaxKind[LineTerminatorToken](359,1): «line terminator»
+SyntaxKind[Identifier](359,1): TemplateCharacter
+SyntaxKind[ColonColonToken](359,19): ::
+SyntaxKind[LineTerminatorToken](360,1): «line terminator»
+SyntaxKind[IndentToken](360,1): «indent»
+SyntaxKind[Terminal](360,2): `$`
+SyntaxKind[OpenBracketToken](360,6): [
+SyntaxKind[LookaheadKeyword](360,7): lookahead
+SyntaxKind[ExclamationEqualsToken](360,17): !=
+SyntaxKind[Terminal](360,20): `{`
+SyntaxKind[CloseBracketToken](360,24): ]
+SyntaxKind[LineTerminatorToken](361,1): «line terminator»
+SyntaxKind[Terminal](361,2): `\`
+SyntaxKind[Identifier](361,6): EscapeSequence
+SyntaxKind[LineTerminatorToken](362,1): «line terminator»
+SyntaxKind[Identifier](362,2): LineContinuation
+SyntaxKind[LineTerminatorToken](363,1): «line terminator»
+SyntaxKind[Identifier](363,2): LineTerminatorSequence
+SyntaxKind[LineTerminatorToken](364,1): «line terminator»
+SyntaxKind[Identifier](364,2): SourceCharacter
+SyntaxKind[ButKeyword](364,18): but
+SyntaxKind[NotKeyword](364,22): not
+SyntaxKind[OneKeyword](364,26): one
+SyntaxKind[OfKeyword](364,30): of
+SyntaxKind[Terminal](364,33): ```
+SyntaxKind[OrKeyword](364,37): or
+SyntaxKind[Terminal](364,40): `\`
+SyntaxKind[OrKeyword](364,44): or
+SyntaxKind[Terminal](364,47): `$`
+SyntaxKind[OrKeyword](364,51): or
+SyntaxKind[Identifier](364,54): LineTerminator
+SyntaxKind[LineTerminatorToken](365,1): «line terminator»
+SyntaxKind[DedentToken](365,1): «dedent»
+SyntaxKind[LineTerminatorToken](366,1): «line terminator»
+SyntaxKind[LineTerminatorToken](367,1): «line terminator»
+SyntaxKind[Identifier](367,1): IdentifierReference
+SyntaxKind[OpenBracketToken](367,20): [
+SyntaxKind[Identifier](367,21): Yield
+SyntaxKind[CloseBracketToken](367,26): ]
+SyntaxKind[ColonToken](367,28): :
+SyntaxKind[LineTerminatorToken](368,1): «line terminator»
+SyntaxKind[IndentToken](368,1): «indent»
+SyntaxKind[Identifier](368,2): Identifier
+SyntaxKind[LineTerminatorToken](369,1): «line terminator»
+SyntaxKind[OpenBracketToken](369,2): [
+SyntaxKind[TildeToken](369,3): ~
+SyntaxKind[Identifier](369,4): Yield
+SyntaxKind[CloseBracketToken](369,9): ]
+SyntaxKind[Terminal](369,11): `yield`
+SyntaxKind[LineTerminatorToken](370,1): «line terminator»
+SyntaxKind[DedentToken](370,1): «dedent»
+SyntaxKind[LineTerminatorToken](371,1): «line terminator»
+SyntaxKind[Identifier](371,1): BindingIdentifier
+SyntaxKind[OpenBracketToken](371,18): [
+SyntaxKind[Identifier](371,19): Yield
+SyntaxKind[CloseBracketToken](371,24): ]
+SyntaxKind[ColonToken](371,26): :
+SyntaxKind[LineTerminatorToken](372,1): «line terminator»
+SyntaxKind[IndentToken](372,1): «indent»
+SyntaxKind[Identifier](372,2): Identifier
+SyntaxKind[LineTerminatorToken](373,1): «line terminator»
+SyntaxKind[OpenBracketToken](373,2): [
+SyntaxKind[TildeToken](373,3): ~
+SyntaxKind[Identifier](373,4): Yield
+SyntaxKind[CloseBracketToken](373,9): ]
+SyntaxKind[Terminal](373,11): `yield`
+SyntaxKind[LineTerminatorToken](374,1): «line terminator»
+SyntaxKind[DedentToken](374,1): «dedent»
+SyntaxKind[LineTerminatorToken](375,1): «line terminator»
+SyntaxKind[Identifier](375,1): LabelIdentifier
+SyntaxKind[OpenBracketToken](375,16): [
+SyntaxKind[Identifier](375,17): Yield
+SyntaxKind[CloseBracketToken](375,22): ]
+SyntaxKind[ColonToken](375,24): :
+SyntaxKind[LineTerminatorToken](376,1): «line terminator»
+SyntaxKind[IndentToken](376,1): «indent»
+SyntaxKind[Identifier](376,2): Identifier
+SyntaxKind[LineTerminatorToken](377,1): «line terminator»
+SyntaxKind[OpenBracketToken](377,2): [
+SyntaxKind[TildeToken](377,3): ~
+SyntaxKind[Identifier](377,4): Yield
+SyntaxKind[CloseBracketToken](377,9): ]
+SyntaxKind[Terminal](377,11): `yield`
+SyntaxKind[LineTerminatorToken](378,1): «line terminator»
+SyntaxKind[DedentToken](378,1): «dedent»
+SyntaxKind[LineTerminatorToken](379,1): «line terminator»
+SyntaxKind[Identifier](379,1): Identifier
+SyntaxKind[ColonToken](379,12): :
+SyntaxKind[LineTerminatorToken](380,1): «line terminator»
+SyntaxKind[IndentToken](380,1): «indent»
+SyntaxKind[Identifier](380,2): IdentifierName
+SyntaxKind[ButKeyword](380,17): but
+SyntaxKind[NotKeyword](380,21): not
+SyntaxKind[Identifier](380,25): ReservedWord
+SyntaxKind[LineTerminatorToken](381,1): «line terminator»
+SyntaxKind[DedentToken](381,1): «dedent»
+SyntaxKind[LineTerminatorToken](382,1): «line terminator»
+SyntaxKind[Identifier](382,1): PrimaryExpression
+SyntaxKind[OpenBracketToken](382,18): [
+SyntaxKind[Identifier](382,19): Yield
+SyntaxKind[CloseBracketToken](382,24): ]
+SyntaxKind[ColonToken](382,26): :
+SyntaxKind[LineTerminatorToken](383,1): «line terminator»
+SyntaxKind[IndentToken](383,1): «indent»
+SyntaxKind[Terminal](383,2): `this`
+SyntaxKind[LineTerminatorToken](384,1): «line terminator»
+SyntaxKind[Identifier](384,2): IdentifierReference
+SyntaxKind[OpenBracketToken](384,21): [
+SyntaxKind[QuestionToken](384,22): ?
+SyntaxKind[Identifier](384,23): Yield
+SyntaxKind[CloseBracketToken](384,28): ]
+SyntaxKind[LineTerminatorToken](385,1): «line terminator»
+SyntaxKind[Identifier](385,2): Literal
+SyntaxKind[LineTerminatorToken](386,1): «line terminator»
+SyntaxKind[Identifier](386,2): ArrayLiteral
+SyntaxKind[OpenBracketToken](386,14): [
+SyntaxKind[QuestionToken](386,15): ?
+SyntaxKind[Identifier](386,16): Yield
+SyntaxKind[CloseBracketToken](386,21): ]
+SyntaxKind[LineTerminatorToken](387,1): «line terminator»
+SyntaxKind[Identifier](387,2): ObjectLiteral
+SyntaxKind[OpenBracketToken](387,15): [
+SyntaxKind[QuestionToken](387,16): ?
+SyntaxKind[Identifier](387,17): Yield
+SyntaxKind[CloseBracketToken](387,22): ]
+SyntaxKind[LineTerminatorToken](388,1): «line terminator»
+SyntaxKind[Identifier](388,2): FunctionExpression
+SyntaxKind[LineTerminatorToken](389,1): «line terminator»
+SyntaxKind[Identifier](389,2): ClassExpression
+SyntaxKind[OpenBracketToken](389,17): [
+SyntaxKind[QuestionToken](389,18): ?
+SyntaxKind[Identifier](389,19): Yield
+SyntaxKind[CloseBracketToken](389,24): ]
+SyntaxKind[LineTerminatorToken](390,1): «line terminator»
+SyntaxKind[Identifier](390,2): GeneratorExpression
+SyntaxKind[LineTerminatorToken](391,1): «line terminator»
+SyntaxKind[Identifier](391,2): RegularExpressionLiteral
+SyntaxKind[LineTerminatorToken](392,1): «line terminator»
+SyntaxKind[Identifier](392,2): TemplateLiteral
+SyntaxKind[OpenBracketToken](392,17): [
+SyntaxKind[QuestionToken](392,18): ?
+SyntaxKind[Identifier](392,19): Yield
+SyntaxKind[CloseBracketToken](392,24): ]
+SyntaxKind[LineTerminatorToken](393,1): «line terminator»
+SyntaxKind[Identifier](393,2): CoverParenthesizedExpressionAndArrowParameterList
+SyntaxKind[OpenBracketToken](393,51): [
+SyntaxKind[QuestionToken](393,52): ?
+SyntaxKind[Identifier](393,53): Yield
+SyntaxKind[CloseBracketToken](393,58): ]
+SyntaxKind[LineTerminatorToken](394,1): «line terminator»
+SyntaxKind[DedentToken](394,1): «dedent»
+SyntaxKind[LineTerminatorToken](395,1): «line terminator»
+SyntaxKind[Identifier](395,1): CoverParenthesizedExpressionAndArrowParameterList
+SyntaxKind[OpenBracketToken](395,50): [
+SyntaxKind[Identifier](395,51): Yield
+SyntaxKind[CloseBracketToken](395,56): ]
+SyntaxKind[ColonToken](395,58): :
+SyntaxKind[LineTerminatorToken](396,1): «line terminator»
+SyntaxKind[IndentToken](396,1): «indent»
+SyntaxKind[Terminal](396,2): `(`
+SyntaxKind[Identifier](396,6): Expression
+SyntaxKind[OpenBracketToken](396,16): [
+SyntaxKind[PlusToken](396,17): +
+SyntaxKind[Identifier](396,18): In
+SyntaxKind[CommaToken](396,20): ,
+SyntaxKind[QuestionToken](396,22): ?
+SyntaxKind[Identifier](396,23): Yield
+SyntaxKind[CloseBracketToken](396,28): ]
+SyntaxKind[Terminal](396,30): `)`
+SyntaxKind[LineTerminatorToken](397,1): «line terminator»
+SyntaxKind[Terminal](397,2): `(`
+SyntaxKind[Terminal](397,6): `)`
+SyntaxKind[LineTerminatorToken](398,1): «line terminator»
+SyntaxKind[Terminal](398,2): `(`
+SyntaxKind[Terminal](398,6): `...`
+SyntaxKind[Identifier](398,12): BindingIdentifier
+SyntaxKind[OpenBracketToken](398,29): [
+SyntaxKind[QuestionToken](398,30): ?
+SyntaxKind[Identifier](398,31): Yield
+SyntaxKind[CloseBracketToken](398,36): ]
+SyntaxKind[Terminal](398,38): `)`
+SyntaxKind[LineTerminatorToken](399,1): «line terminator»
+SyntaxKind[Terminal](399,2): `(`
+SyntaxKind[Identifier](399,6): Expression
+SyntaxKind[OpenBracketToken](399,16): [
+SyntaxKind[PlusToken](399,17): +
+SyntaxKind[Identifier](399,18): In
+SyntaxKind[CommaToken](399,20): ,
+SyntaxKind[QuestionToken](399,22): ?
+SyntaxKind[Identifier](399,23): Yield
+SyntaxKind[CloseBracketToken](399,28): ]
+SyntaxKind[Terminal](399,30): `,`
+SyntaxKind[Terminal](399,34): `...`
+SyntaxKind[Identifier](399,40): BindingIdentifier
+SyntaxKind[OpenBracketToken](399,57): [
+SyntaxKind[QuestionToken](399,58): ?
+SyntaxKind[Identifier](399,59): Yield
+SyntaxKind[CloseBracketToken](399,64): ]
+SyntaxKind[Terminal](399,66): `)`
+SyntaxKind[LineTerminatorToken](400,1): «line terminator»
+SyntaxKind[DedentToken](400,1): «dedent»
+SyntaxKind[LineTerminatorToken](401,1): «line terminator»
+SyntaxKind[Identifier](401,1): Literal
+SyntaxKind[ColonToken](401,9): :
+SyntaxKind[LineTerminatorToken](402,1): «line terminator»
+SyntaxKind[IndentToken](402,1): «indent»
+SyntaxKind[Identifier](402,2): NullLiteral
+SyntaxKind[LineTerminatorToken](403,1): «line terminator»
+SyntaxKind[Identifier](403,2): BooleanLiteral
+SyntaxKind[LineTerminatorToken](404,1): «line terminator»
+SyntaxKind[Identifier](404,2): NumericLiteral
+SyntaxKind[LineTerminatorToken](405,1): «line terminator»
+SyntaxKind[Identifier](405,2): StringLiteral
+SyntaxKind[LineTerminatorToken](406,1): «line terminator»
+SyntaxKind[DedentToken](406,1): «dedent»
+SyntaxKind[LineTerminatorToken](407,1): «line terminator»
+SyntaxKind[Identifier](407,1): ArrayLiteral
+SyntaxKind[OpenBracketToken](407,13): [
+SyntaxKind[Identifier](407,14): Yield
+SyntaxKind[CloseBracketToken](407,19): ]
+SyntaxKind[ColonToken](407,21): :
+SyntaxKind[LineTerminatorToken](408,1): «line terminator»
+SyntaxKind[IndentToken](408,1): «indent»
+SyntaxKind[Terminal](408,2): `[`
+SyntaxKind[Identifier](408,6): Elision
+SyntaxKind[QuestionToken](408,13): ?
+SyntaxKind[Terminal](408,15): `]`
+SyntaxKind[LineTerminatorToken](409,1): «line terminator»
+SyntaxKind[Terminal](409,2): `[`
+SyntaxKind[Identifier](409,6): ElementList
+SyntaxKind[OpenBracketToken](409,17): [
+SyntaxKind[QuestionToken](409,18): ?
+SyntaxKind[Identifier](409,19): Yield
+SyntaxKind[CloseBracketToken](409,24): ]
+SyntaxKind[Terminal](409,26): `]`
+SyntaxKind[LineTerminatorToken](410,1): «line terminator»
+SyntaxKind[Terminal](410,2): `[`
+SyntaxKind[Identifier](410,6): ElementList
+SyntaxKind[OpenBracketToken](410,17): [
+SyntaxKind[QuestionToken](410,18): ?
+SyntaxKind[Identifier](410,19): Yield
+SyntaxKind[CloseBracketToken](410,24): ]
+SyntaxKind[Terminal](410,26): `,`
+SyntaxKind[Identifier](410,30): Elision
+SyntaxKind[QuestionToken](410,37): ?
+SyntaxKind[Terminal](410,39): `]`
+SyntaxKind[LineTerminatorToken](411,1): «line terminator»
+SyntaxKind[DedentToken](411,1): «dedent»
+SyntaxKind[LineTerminatorToken](412,1): «line terminator»
+SyntaxKind[Identifier](412,1): ElementList
+SyntaxKind[OpenBracketToken](412,12): [
+SyntaxKind[Identifier](412,13): Yield
+SyntaxKind[CloseBracketToken](412,18): ]
+SyntaxKind[ColonToken](412,20): :
+SyntaxKind[LineTerminatorToken](413,1): «line terminator»
+SyntaxKind[IndentToken](413,1): «indent»
+SyntaxKind[Identifier](413,2): Elision
+SyntaxKind[QuestionToken](413,9): ?
+SyntaxKind[Identifier](413,11): AssignmentExpression
+SyntaxKind[OpenBracketToken](413,31): [
+SyntaxKind[Identifier](413,32): In
+SyntaxKind[CommaToken](413,34): ,
+SyntaxKind[QuestionToken](413,36): ?
+SyntaxKind[Identifier](413,37): Yield
+SyntaxKind[CloseBracketToken](413,42): ]
+SyntaxKind[LineTerminatorToken](414,1): «line terminator»
+SyntaxKind[Identifier](414,2): Elision
+SyntaxKind[QuestionToken](414,9): ?
+SyntaxKind[Identifier](414,11): SpreadElement
+SyntaxKind[OpenBracketToken](414,24): [
+SyntaxKind[QuestionToken](414,25): ?
+SyntaxKind[Identifier](414,26): Yield
+SyntaxKind[CloseBracketToken](414,31): ]
+SyntaxKind[LineTerminatorToken](415,1): «line terminator»
+SyntaxKind[Identifier](415,2): ElementList
+SyntaxKind[OpenBracketToken](415,13): [
+SyntaxKind[QuestionToken](415,14): ?
+SyntaxKind[Identifier](415,15): Yield
+SyntaxKind[CloseBracketToken](415,20): ]
+SyntaxKind[Terminal](415,22): `,`
+SyntaxKind[Identifier](415,26): Elision
+SyntaxKind[QuestionToken](415,33): ?
+SyntaxKind[Identifier](415,35): AssignmentExpression
+SyntaxKind[OpenBracketToken](415,55): [
+SyntaxKind[Identifier](415,56): In
+SyntaxKind[CommaToken](415,58): ,
+SyntaxKind[QuestionToken](415,60): ?
+SyntaxKind[Identifier](415,61): Yield
+SyntaxKind[CloseBracketToken](415,66): ]
+SyntaxKind[LineTerminatorToken](416,1): «line terminator»
+SyntaxKind[Identifier](416,2): ElementList
+SyntaxKind[OpenBracketToken](416,13): [
+SyntaxKind[QuestionToken](416,14): ?
+SyntaxKind[Identifier](416,15): Yield
+SyntaxKind[CloseBracketToken](416,20): ]
+SyntaxKind[Terminal](416,22): `,`
+SyntaxKind[Identifier](416,26): Elision
+SyntaxKind[QuestionToken](416,33): ?
+SyntaxKind[Identifier](416,35): SpreadElement
+SyntaxKind[OpenBracketToken](416,48): [
+SyntaxKind[QuestionToken](416,49): ?
+SyntaxKind[Identifier](416,50): Yield
+SyntaxKind[CloseBracketToken](416,55): ]
+SyntaxKind[LineTerminatorToken](417,1): «line terminator»
+SyntaxKind[DedentToken](417,1): «dedent»
+SyntaxKind[LineTerminatorToken](418,1): «line terminator»
+SyntaxKind[Identifier](418,1): Elision
+SyntaxKind[ColonToken](418,9): :
+SyntaxKind[LineTerminatorToken](419,1): «line terminator»
+SyntaxKind[IndentToken](419,1): «indent»
+SyntaxKind[Terminal](419,2): `,`
+SyntaxKind[LineTerminatorToken](420,1): «line terminator»
+SyntaxKind[Identifier](420,2): Elision
+SyntaxKind[Terminal](420,10): `,`
+SyntaxKind[LineTerminatorToken](421,1): «line terminator»
+SyntaxKind[DedentToken](421,1): «dedent»
+SyntaxKind[LineTerminatorToken](422,1): «line terminator»
+SyntaxKind[Identifier](422,1): SpreadElement
+SyntaxKind[OpenBracketToken](422,14): [
+SyntaxKind[Identifier](422,15): Yield
+SyntaxKind[CloseBracketToken](422,20): ]
+SyntaxKind[ColonToken](422,22): :
+SyntaxKind[LineTerminatorToken](423,1): «line terminator»
+SyntaxKind[IndentToken](423,1): «indent»
+SyntaxKind[Terminal](423,2): `...`
+SyntaxKind[Identifier](423,8): AssignmentExpression
+SyntaxKind[OpenBracketToken](423,28): [
+SyntaxKind[Identifier](423,29): In
+SyntaxKind[CommaToken](423,31): ,
+SyntaxKind[QuestionToken](423,33): ?
+SyntaxKind[Identifier](423,34): Yield
+SyntaxKind[CloseBracketToken](423,39): ]
+SyntaxKind[LineTerminatorToken](424,1): «line terminator»
+SyntaxKind[DedentToken](424,1): «dedent»
+SyntaxKind[LineTerminatorToken](425,1): «line terminator»
+SyntaxKind[Identifier](425,1): ObjectLiteral
+SyntaxKind[OpenBracketToken](425,14): [
+SyntaxKind[Identifier](425,15): Yield
+SyntaxKind[CloseBracketToken](425,20): ]
+SyntaxKind[ColonToken](425,22): :
+SyntaxKind[LineTerminatorToken](426,1): «line terminator»
+SyntaxKind[IndentToken](426,1): «indent»
+SyntaxKind[Terminal](426,2): `{`
+SyntaxKind[Terminal](426,6): `}`
+SyntaxKind[LineTerminatorToken](427,1): «line terminator»
+SyntaxKind[Terminal](427,2): `{`
+SyntaxKind[Identifier](427,6): PropertyDefinitionList
+SyntaxKind[OpenBracketToken](427,28): [
+SyntaxKind[QuestionToken](427,29): ?
+SyntaxKind[Identifier](427,30): Yield
+SyntaxKind[CloseBracketToken](427,35): ]
+SyntaxKind[Terminal](427,37): `}`
+SyntaxKind[LineTerminatorToken](428,1): «line terminator»
+SyntaxKind[Terminal](428,2): `{`
+SyntaxKind[Identifier](428,6): PropertyDefinitionList
+SyntaxKind[OpenBracketToken](428,28): [
+SyntaxKind[QuestionToken](428,29): ?
+SyntaxKind[Identifier](428,30): Yield
+SyntaxKind[CloseBracketToken](428,35): ]
+SyntaxKind[Terminal](428,37): `,`
+SyntaxKind[Terminal](428,41): `}`
+SyntaxKind[LineTerminatorToken](429,1): «line terminator»
+SyntaxKind[DedentToken](429,1): «dedent»
+SyntaxKind[LineTerminatorToken](430,1): «line terminator»
+SyntaxKind[Identifier](430,1): PropertyDefinitionList
+SyntaxKind[OpenBracketToken](430,23): [
+SyntaxKind[Identifier](430,24): Yield
+SyntaxKind[CloseBracketToken](430,29): ]
+SyntaxKind[ColonToken](430,31): :
+SyntaxKind[LineTerminatorToken](431,1): «line terminator»
+SyntaxKind[IndentToken](431,1): «indent»
+SyntaxKind[Identifier](431,2): PropertyDefinition
+SyntaxKind[OpenBracketToken](431,20): [
+SyntaxKind[QuestionToken](431,21): ?
+SyntaxKind[Identifier](431,22): Yield
+SyntaxKind[CloseBracketToken](431,27): ]
+SyntaxKind[LineTerminatorToken](432,1): «line terminator»
+SyntaxKind[Identifier](432,2): PropertyDefinitionList
+SyntaxKind[OpenBracketToken](432,24): [
+SyntaxKind[QuestionToken](432,25): ?
+SyntaxKind[Identifier](432,26): Yield
+SyntaxKind[CloseBracketToken](432,31): ]
+SyntaxKind[Terminal](432,33): `,`
+SyntaxKind[Identifier](432,37): PropertyDefinition
+SyntaxKind[OpenBracketToken](432,55): [
+SyntaxKind[QuestionToken](432,56): ?
+SyntaxKind[Identifier](432,57): Yield
+SyntaxKind[CloseBracketToken](432,62): ]
+SyntaxKind[LineTerminatorToken](433,1): «line terminator»
+SyntaxKind[DedentToken](433,1): «dedent»
+SyntaxKind[LineTerminatorToken](434,1): «line terminator»
+SyntaxKind[Identifier](434,1): PropertyDefinition
+SyntaxKind[OpenBracketToken](434,19): [
+SyntaxKind[Identifier](434,20): Yield
+SyntaxKind[CloseBracketToken](434,25): ]
+SyntaxKind[ColonToken](434,27): :
+SyntaxKind[LineTerminatorToken](435,1): «line terminator»
+SyntaxKind[IndentToken](435,1): «indent»
+SyntaxKind[Identifier](435,2): IdentifierReference
+SyntaxKind[OpenBracketToken](435,21): [
+SyntaxKind[QuestionToken](435,22): ?
+SyntaxKind[Identifier](435,23): Yield
+SyntaxKind[CloseBracketToken](435,28): ]
+SyntaxKind[LineTerminatorToken](436,1): «line terminator»
+SyntaxKind[Identifier](436,2): CoverInitializedName
+SyntaxKind[OpenBracketToken](436,22): [
+SyntaxKind[QuestionToken](436,23): ?
+SyntaxKind[Identifier](436,24): Yield
+SyntaxKind[CloseBracketToken](436,29): ]
+SyntaxKind[LineTerminatorToken](437,1): «line terminator»
+SyntaxKind[Identifier](437,2): PropertyName
+SyntaxKind[OpenBracketToken](437,14): [
+SyntaxKind[QuestionToken](437,15): ?
+SyntaxKind[Identifier](437,16): Yield
+SyntaxKind[CloseBracketToken](437,21): ]
+SyntaxKind[Terminal](437,23): `:`
+SyntaxKind[Identifier](437,27): AssignmentExpression
+SyntaxKind[OpenBracketToken](437,47): [
+SyntaxKind[Identifier](437,48): In
+SyntaxKind[CommaToken](437,50): ,
+SyntaxKind[QuestionToken](437,52): ?
+SyntaxKind[Identifier](437,53): Yield
+SyntaxKind[CloseBracketToken](437,58): ]
+SyntaxKind[LineTerminatorToken](438,1): «line terminator»
+SyntaxKind[Identifier](438,2): MethodDefinition
+SyntaxKind[OpenBracketToken](438,18): [
+SyntaxKind[QuestionToken](438,19): ?
+SyntaxKind[Identifier](438,20): Yield
+SyntaxKind[CloseBracketToken](438,25): ]
+SyntaxKind[LineTerminatorToken](439,1): «line terminator»
+SyntaxKind[DedentToken](439,1): «dedent»
+SyntaxKind[LineTerminatorToken](440,1): «line terminator»
+SyntaxKind[Identifier](440,1): PropertyName
+SyntaxKind[OpenBracketToken](440,13): [
+SyntaxKind[Identifier](440,14): Yield
+SyntaxKind[CloseBracketToken](440,19): ]
+SyntaxKind[ColonToken](440,21): :
+SyntaxKind[LineTerminatorToken](441,1): «line terminator»
+SyntaxKind[IndentToken](441,1): «indent»
+SyntaxKind[Identifier](441,2): LiteralPropertyName
+SyntaxKind[LineTerminatorToken](442,1): «line terminator»
+SyntaxKind[Identifier](442,2): ComputedPropertyName
+SyntaxKind[OpenBracketToken](442,22): [
+SyntaxKind[QuestionToken](442,23): ?
+SyntaxKind[Identifier](442,24): Yield
+SyntaxKind[CloseBracketToken](442,29): ]
+SyntaxKind[LineTerminatorToken](443,1): «line terminator»
+SyntaxKind[DedentToken](443,1): «dedent»
+SyntaxKind[LineTerminatorToken](444,1): «line terminator»
+SyntaxKind[Identifier](444,1): LiteralPropertyName
+SyntaxKind[ColonToken](444,21): :
+SyntaxKind[LineTerminatorToken](445,1): «line terminator»
+SyntaxKind[IndentToken](445,1): «indent»
+SyntaxKind[Identifier](445,2): IdentifierName
+SyntaxKind[LineTerminatorToken](446,1): «line terminator»
+SyntaxKind[Identifier](446,2): StringLiteral
+SyntaxKind[LineTerminatorToken](447,1): «line terminator»
+SyntaxKind[Identifier](447,2): NumericLiteral
+SyntaxKind[LineTerminatorToken](448,1): «line terminator»
+SyntaxKind[DedentToken](448,1): «dedent»
+SyntaxKind[LineTerminatorToken](449,1): «line terminator»
+SyntaxKind[Identifier](449,1): ComputedPropertyName
+SyntaxKind[OpenBracketToken](449,21): [
+SyntaxKind[Identifier](449,22): Yield
+SyntaxKind[CloseBracketToken](449,27): ]
+SyntaxKind[ColonToken](449,29): :
+SyntaxKind[LineTerminatorToken](450,1): «line terminator»
+SyntaxKind[IndentToken](450,1): «indent»
+SyntaxKind[Terminal](450,2): `[`
+SyntaxKind[Identifier](450,6): AssignmentExpression
+SyntaxKind[OpenBracketToken](450,26): [
+SyntaxKind[Identifier](450,27): In
+SyntaxKind[CommaToken](450,29): ,
+SyntaxKind[QuestionToken](450,31): ?
+SyntaxKind[Identifier](450,32): Yield
+SyntaxKind[CloseBracketToken](450,37): ]
+SyntaxKind[Terminal](450,40): `]`
+SyntaxKind[LineTerminatorToken](451,1): «line terminator»
+SyntaxKind[DedentToken](451,1): «dedent»
+SyntaxKind[LineTerminatorToken](452,1): «line terminator»
+SyntaxKind[Identifier](452,1): CoverInitializedName
+SyntaxKind[OpenBracketToken](452,21): [
+SyntaxKind[Identifier](452,22): Yield
+SyntaxKind[CloseBracketToken](452,27): ]
+SyntaxKind[ColonToken](452,29): :
+SyntaxKind[LineTerminatorToken](453,1): «line terminator»
+SyntaxKind[IndentToken](453,1): «indent»
+SyntaxKind[Identifier](453,2): IdentifierReference
+SyntaxKind[OpenBracketToken](453,21): [
+SyntaxKind[QuestionToken](453,22): ?
+SyntaxKind[Identifier](453,23): Yield
+SyntaxKind[CloseBracketToken](453,28): ]
+SyntaxKind[Identifier](453,30): Initializer
+SyntaxKind[OpenBracketToken](453,41): [
+SyntaxKind[Identifier](453,42): In
+SyntaxKind[CommaToken](453,44): ,
+SyntaxKind[QuestionToken](453,46): ?
+SyntaxKind[Identifier](453,47): Yield
+SyntaxKind[CloseBracketToken](453,52): ]
+SyntaxKind[LineTerminatorToken](454,1): «line terminator»
+SyntaxKind[DedentToken](454,1): «dedent»
+SyntaxKind[LineTerminatorToken](455,1): «line terminator»
+SyntaxKind[Identifier](455,1): Initializer
+SyntaxKind[OpenBracketToken](455,12): [
+SyntaxKind[Identifier](455,13): In
+SyntaxKind[CommaToken](455,15): ,
+SyntaxKind[Identifier](455,17): Yield
+SyntaxKind[CloseBracketToken](455,22): ]
+SyntaxKind[ColonToken](455,24): :
+SyntaxKind[LineTerminatorToken](456,1): «line terminator»
+SyntaxKind[IndentToken](456,1): «indent»
+SyntaxKind[Terminal](456,2): `=`
+SyntaxKind[Identifier](456,6): AssignmentExpression
+SyntaxKind[OpenBracketToken](456,26): [
+SyntaxKind[QuestionToken](456,27): ?
+SyntaxKind[Identifier](456,28): In
+SyntaxKind[CommaToken](456,30): ,
+SyntaxKind[QuestionToken](456,32): ?
+SyntaxKind[Identifier](456,33): Yield
+SyntaxKind[CloseBracketToken](456,38): ]
+SyntaxKind[LineTerminatorToken](457,1): «line terminator»
+SyntaxKind[DedentToken](457,1): «dedent»
+SyntaxKind[LineTerminatorToken](458,1): «line terminator»
+SyntaxKind[Identifier](458,1): TemplateLiteral
+SyntaxKind[OpenBracketToken](458,16): [
+SyntaxKind[Identifier](458,17): Yield
+SyntaxKind[CloseBracketToken](458,22): ]
+SyntaxKind[ColonToken](458,24): :
+SyntaxKind[LineTerminatorToken](459,1): «line terminator»
+SyntaxKind[IndentToken](459,1): «indent»
+SyntaxKind[Identifier](459,2): NoSubstitutionTemplate
+SyntaxKind[LineTerminatorToken](460,1): «line terminator»
+SyntaxKind[Identifier](460,2): TemplateHead
+SyntaxKind[Identifier](460,15): Expression
+SyntaxKind[OpenBracketToken](460,25): [
+SyntaxKind[Identifier](460,26): In
+SyntaxKind[CommaToken](460,28): ,
+SyntaxKind[QuestionToken](460,30): ?
+SyntaxKind[Identifier](460,31): Yield
+SyntaxKind[CloseBracketToken](460,36): ]
+SyntaxKind[Identifier](460,38): TemplateSpans
+SyntaxKind[OpenBracketToken](460,51): [
+SyntaxKind[QuestionToken](460,52): ?
+SyntaxKind[Identifier](460,53): Yield
+SyntaxKind[CloseBracketToken](460,58): ]
+SyntaxKind[LineTerminatorToken](461,1): «line terminator»
+SyntaxKind[DedentToken](461,1): «dedent»
+SyntaxKind[LineTerminatorToken](462,1): «line terminator»
+SyntaxKind[Identifier](462,1): TemplateSpans
+SyntaxKind[OpenBracketToken](462,14): [
+SyntaxKind[Identifier](462,15): Yield
+SyntaxKind[CloseBracketToken](462,20): ]
+SyntaxKind[ColonToken](462,22): :
+SyntaxKind[LineTerminatorToken](463,1): «line terminator»
+SyntaxKind[IndentToken](463,1): «indent»
+SyntaxKind[Identifier](463,2): TemplateTail
+SyntaxKind[LineTerminatorToken](464,1): «line terminator»
+SyntaxKind[Identifier](464,2): TemplateMiddleList
+SyntaxKind[OpenBracketToken](464,20): [
+SyntaxKind[QuestionToken](464,21): ?
+SyntaxKind[Identifier](464,22): Yield
+SyntaxKind[CloseBracketToken](464,27): ]
+SyntaxKind[Identifier](464,29): TemplateTail
+SyntaxKind[LineTerminatorToken](465,1): «line terminator»
+SyntaxKind[DedentToken](465,1): «dedent»
+SyntaxKind[LineTerminatorToken](466,1): «line terminator»
+SyntaxKind[Identifier](466,1): TemplateMiddleList
+SyntaxKind[OpenBracketToken](466,19): [
+SyntaxKind[Identifier](466,20): Yield
+SyntaxKind[CloseBracketToken](466,25): ]
+SyntaxKind[ColonToken](466,27): :
+SyntaxKind[LineTerminatorToken](467,1): «line terminator»
+SyntaxKind[IndentToken](467,1): «indent»
+SyntaxKind[Identifier](467,2): TemplateMiddle
+SyntaxKind[Identifier](467,18): Expression
+SyntaxKind[OpenBracketToken](467,28): [
+SyntaxKind[Identifier](467,29): In
+SyntaxKind[CommaToken](467,31): ,
+SyntaxKind[QuestionToken](467,33): ?
+SyntaxKind[Identifier](467,34): Yield
+SyntaxKind[CloseBracketToken](467,39): ]
+SyntaxKind[LineTerminatorToken](468,1): «line terminator»
+SyntaxKind[Identifier](468,2): TemplateMiddleList
+SyntaxKind[OpenBracketToken](468,20): [
+SyntaxKind[QuestionToken](468,21): ?
+SyntaxKind[Identifier](468,22): Yield
+SyntaxKind[CloseBracketToken](468,27): ]
+SyntaxKind[Identifier](468,30): TemplateMiddle
+SyntaxKind[Identifier](468,46): Expression
+SyntaxKind[OpenBracketToken](468,56): [
+SyntaxKind[Identifier](468,57): In
+SyntaxKind[CommaToken](468,59): ,
+SyntaxKind[QuestionToken](468,61): ?
+SyntaxKind[Identifier](468,62): Yield
+SyntaxKind[CloseBracketToken](468,67): ]
+SyntaxKind[LineTerminatorToken](469,1): «line terminator»
+SyntaxKind[DedentToken](469,1): «dedent»
+SyntaxKind[LineTerminatorToken](470,1): «line terminator»
+SyntaxKind[Identifier](470,1): MemberExpression
+SyntaxKind[OpenBracketToken](470,17): [
+SyntaxKind[Identifier](470,18): Yield
+SyntaxKind[CloseBracketToken](470,23): ]
+SyntaxKind[ColonToken](470,25): :
+SyntaxKind[LineTerminatorToken](471,1): «line terminator»
+SyntaxKind[IndentToken](471,1): «indent»
+SyntaxKind[Identifier](471,2): PrimaryExpression
+SyntaxKind[OpenBracketToken](471,19): [
+SyntaxKind[QuestionToken](471,20): ?
+SyntaxKind[Identifier](471,21): Yield
+SyntaxKind[CloseBracketToken](471,26): ]
+SyntaxKind[LineTerminatorToken](472,1): «line terminator»
+SyntaxKind[Identifier](472,2): MemberExpression
+SyntaxKind[OpenBracketToken](472,18): [
+SyntaxKind[QuestionToken](472,19): ?
+SyntaxKind[Identifier](472,20): Yield
+SyntaxKind[CloseBracketToken](472,25): ]
+SyntaxKind[Terminal](472,27): `[`
+SyntaxKind[Identifier](472,31): Expression
+SyntaxKind[OpenBracketToken](472,41): [
+SyntaxKind[Identifier](472,42): In
+SyntaxKind[CommaToken](472,44): ,
+SyntaxKind[QuestionToken](472,46): ?
+SyntaxKind[Identifier](472,47): Yield
+SyntaxKind[CloseBracketToken](472,52): ]
+SyntaxKind[Terminal](472,54): `]`
+SyntaxKind[LineTerminatorToken](473,1): «line terminator»
+SyntaxKind[Identifier](473,2): MemberExpression
+SyntaxKind[OpenBracketToken](473,18): [
+SyntaxKind[QuestionToken](473,19): ?
+SyntaxKind[Identifier](473,20): Yield
+SyntaxKind[CloseBracketToken](473,25): ]
+SyntaxKind[Terminal](473,27): `.`
+SyntaxKind[Identifier](473,31): IdentifierName
+SyntaxKind[LineTerminatorToken](474,1): «line terminator»
+SyntaxKind[Identifier](474,2): MemberExpression
+SyntaxKind[OpenBracketToken](474,18): [
+SyntaxKind[QuestionToken](474,19): ?
+SyntaxKind[Identifier](474,20): Yield
+SyntaxKind[CloseBracketToken](474,25): ]
+SyntaxKind[Identifier](474,27): TemplateLiteral
+SyntaxKind[OpenBracketToken](474,42): [
+SyntaxKind[QuestionToken](474,43): ?
+SyntaxKind[Identifier](474,44): Yield
+SyntaxKind[CloseBracketToken](474,49): ]
+SyntaxKind[LineTerminatorToken](475,1): «line terminator»
+SyntaxKind[Identifier](475,2): SuperProperty
+SyntaxKind[OpenBracketToken](475,15): [
+SyntaxKind[QuestionToken](475,16): ?
+SyntaxKind[Identifier](475,17): Yield
+SyntaxKind[CloseBracketToken](475,22): ]
+SyntaxKind[LineTerminatorToken](476,1): «line terminator»
+SyntaxKind[Identifier](476,2): MetaProperty
+SyntaxKind[LineTerminatorToken](477,1): «line terminator»
+SyntaxKind[Terminal](477,2): `new`
+SyntaxKind[Identifier](477,8): MemberExpression
+SyntaxKind[OpenBracketToken](477,24): [
+SyntaxKind[QuestionToken](477,25): ?
+SyntaxKind[Identifier](477,26): Yield
+SyntaxKind[CloseBracketToken](477,31): ]
+SyntaxKind[Identifier](477,33): Arguments
+SyntaxKind[OpenBracketToken](477,42): [
+SyntaxKind[QuestionToken](477,43): ?
+SyntaxKind[Identifier](477,44): Yield
+SyntaxKind[CloseBracketToken](477,49): ]
+SyntaxKind[LineTerminatorToken](478,1): «line terminator»
+SyntaxKind[DedentToken](478,1): «dedent»
+SyntaxKind[LineTerminatorToken](479,1): «line terminator»
+SyntaxKind[Identifier](479,1): SuperProperty
+SyntaxKind[OpenBracketToken](479,14): [
+SyntaxKind[Identifier](479,15): Yield
+SyntaxKind[CloseBracketToken](479,20): ]
+SyntaxKind[ColonToken](479,22): :
+SyntaxKind[LineTerminatorToken](480,1): «line terminator»
+SyntaxKind[IndentToken](480,1): «indent»
+SyntaxKind[Terminal](480,2): `super`
+SyntaxKind[Terminal](480,10): `[`
+SyntaxKind[Identifier](480,14): Expression
+SyntaxKind[OpenBracketToken](480,24): [
+SyntaxKind[Identifier](480,25): In
+SyntaxKind[CommaToken](480,27): ,
+SyntaxKind[QuestionToken](480,29): ?
+SyntaxKind[Identifier](480,30): Yield
+SyntaxKind[CloseBracketToken](480,35): ]
+SyntaxKind[Terminal](480,37): `]`
+SyntaxKind[LineTerminatorToken](481,1): «line terminator»
+SyntaxKind[Terminal](481,2): `super`
+SyntaxKind[Terminal](481,10): `.`
+SyntaxKind[Identifier](481,14): IdentifierName
+SyntaxKind[LineTerminatorToken](482,1): «line terminator»
+SyntaxKind[DedentToken](482,1): «dedent»
+SyntaxKind[LineTerminatorToken](483,1): «line terminator»
+SyntaxKind[Identifier](483,1): MetaProperty
+SyntaxKind[ColonToken](483,14): :
+SyntaxKind[LineTerminatorToken](484,1): «line terminator»
+SyntaxKind[IndentToken](484,1): «indent»
+SyntaxKind[Identifier](484,2): NewTarget
+SyntaxKind[LineTerminatorToken](485,1): «line terminator»
+SyntaxKind[DedentToken](485,1): «dedent»
+SyntaxKind[LineTerminatorToken](486,1): «line terminator»
+SyntaxKind[Identifier](486,1): NewTarget
+SyntaxKind[ColonToken](486,11): :
+SyntaxKind[LineTerminatorToken](487,1): «line terminator»
+SyntaxKind[IndentToken](487,1): «indent»
+SyntaxKind[Terminal](487,2): `new`
+SyntaxKind[Terminal](487,8): `.`
+SyntaxKind[Terminal](487,12): `target`
+SyntaxKind[LineTerminatorToken](488,1): «line terminator»
+SyntaxKind[DedentToken](488,1): «dedent»
+SyntaxKind[LineTerminatorToken](489,1): «line terminator»
+SyntaxKind[Identifier](489,1): NewExpression
+SyntaxKind[OpenBracketToken](489,14): [
+SyntaxKind[Identifier](489,15): Yield
+SyntaxKind[CloseBracketToken](489,20): ]
+SyntaxKind[ColonToken](489,22): :
+SyntaxKind[LineTerminatorToken](490,1): «line terminator»
+SyntaxKind[IndentToken](490,1): «indent»
+SyntaxKind[Identifier](490,2): MemberExpression
+SyntaxKind[OpenBracketToken](490,18): [
+SyntaxKind[QuestionToken](490,19): ?
+SyntaxKind[Identifier](490,20): Yield
+SyntaxKind[CloseBracketToken](490,25): ]
+SyntaxKind[LineTerminatorToken](491,1): «line terminator»
+SyntaxKind[Terminal](491,2): `new`
+SyntaxKind[Identifier](491,8): NewExpression
+SyntaxKind[OpenBracketToken](491,21): [
+SyntaxKind[QuestionToken](491,22): ?
+SyntaxKind[Identifier](491,23): Yield
+SyntaxKind[CloseBracketToken](491,28): ]
+SyntaxKind[LineTerminatorToken](492,1): «line terminator»
+SyntaxKind[DedentToken](492,1): «dedent»
+SyntaxKind[LineTerminatorToken](493,1): «line terminator»
+SyntaxKind[Identifier](493,1): CallExpression
+SyntaxKind[OpenBracketToken](493,15): [
+SyntaxKind[Identifier](493,16): Yield
+SyntaxKind[CloseBracketToken](493,21): ]
+SyntaxKind[ColonToken](493,23): :
+SyntaxKind[LineTerminatorToken](494,1): «line terminator»
+SyntaxKind[IndentToken](494,1): «indent»
+SyntaxKind[Identifier](494,2): MemberExpression
+SyntaxKind[OpenBracketToken](494,18): [
+SyntaxKind[QuestionToken](494,19): ?
+SyntaxKind[Identifier](494,20): Yield
+SyntaxKind[CloseBracketToken](494,25): ]
+SyntaxKind[Identifier](494,27): Arguments
+SyntaxKind[OpenBracketToken](494,36): [
+SyntaxKind[QuestionToken](494,37): ?
+SyntaxKind[Identifier](494,38): Yield
+SyntaxKind[CloseBracketToken](494,43): ]
+SyntaxKind[LineTerminatorToken](495,1): «line terminator»
+SyntaxKind[Identifier](495,2): SuperCall
+SyntaxKind[OpenBracketToken](495,11): [
+SyntaxKind[QuestionToken](495,12): ?
+SyntaxKind[Identifier](495,13): Yield
+SyntaxKind[CloseBracketToken](495,18): ]
+SyntaxKind[LineTerminatorToken](496,1): «line terminator»
+SyntaxKind[Identifier](496,2): CallExpression
+SyntaxKind[OpenBracketToken](496,16): [
+SyntaxKind[QuestionToken](496,17): ?
+SyntaxKind[Identifier](496,18): Yield
+SyntaxKind[CloseBracketToken](496,23): ]
+SyntaxKind[Identifier](496,25): Arguments
+SyntaxKind[OpenBracketToken](496,34): [
+SyntaxKind[QuestionToken](496,35): ?
+SyntaxKind[Identifier](496,36): Yield
+SyntaxKind[CloseBracketToken](496,41): ]
+SyntaxKind[LineTerminatorToken](497,1): «line terminator»
+SyntaxKind[Identifier](497,2): CallExpression
+SyntaxKind[OpenBracketToken](497,16): [
+SyntaxKind[QuestionToken](497,17): ?
+SyntaxKind[Identifier](497,18): Yield
+SyntaxKind[CloseBracketToken](497,23): ]
+SyntaxKind[Terminal](497,25): `[`
+SyntaxKind[Identifier](497,29): Expression
+SyntaxKind[OpenBracketToken](497,39): [
+SyntaxKind[Identifier](497,40): In
+SyntaxKind[CommaToken](497,42): ,
+SyntaxKind[QuestionToken](497,44): ?
+SyntaxKind[Identifier](497,45): Yield
+SyntaxKind[CloseBracketToken](497,50): ]
+SyntaxKind[Terminal](497,52): `]`
+SyntaxKind[LineTerminatorToken](498,1): «line terminator»
+SyntaxKind[Identifier](498,2): CallExpression
+SyntaxKind[OpenBracketToken](498,16): [
+SyntaxKind[QuestionToken](498,17): ?
+SyntaxKind[Identifier](498,18): Yield
+SyntaxKind[CloseBracketToken](498,23): ]
+SyntaxKind[Terminal](498,25): `.`
+SyntaxKind[Identifier](498,29): IdentifierName
+SyntaxKind[LineTerminatorToken](499,1): «line terminator»
+SyntaxKind[Identifier](499,2): CallExpression
+SyntaxKind[OpenBracketToken](499,16): [
+SyntaxKind[QuestionToken](499,17): ?
+SyntaxKind[Identifier](499,18): Yield
+SyntaxKind[CloseBracketToken](499,23): ]
+SyntaxKind[Identifier](499,25): TemplateLiteral
+SyntaxKind[OpenBracketToken](499,40): [
+SyntaxKind[QuestionToken](499,41): ?
+SyntaxKind[Identifier](499,42): Yield
+SyntaxKind[CloseBracketToken](499,47): ]
+SyntaxKind[LineTerminatorToken](500,1): «line terminator»
+SyntaxKind[DedentToken](500,1): «dedent»
+SyntaxKind[LineTerminatorToken](501,1): «line terminator»
+SyntaxKind[Identifier](501,1): SuperCall
+SyntaxKind[OpenBracketToken](501,10): [
+SyntaxKind[Identifier](501,11): Yield
+SyntaxKind[CloseBracketToken](501,16): ]
+SyntaxKind[ColonToken](501,18): :
+SyntaxKind[LineTerminatorToken](502,1): «line terminator»
+SyntaxKind[IndentToken](502,1): «indent»
+SyntaxKind[Terminal](502,2): `super`
+SyntaxKind[Identifier](502,10): Arguments
+SyntaxKind[OpenBracketToken](502,19): [
+SyntaxKind[QuestionToken](502,20): ?
+SyntaxKind[Identifier](502,21): Yield
+SyntaxKind[CloseBracketToken](502,26): ]
+SyntaxKind[LineTerminatorToken](503,1): «line terminator»
+SyntaxKind[DedentToken](503,1): «dedent»
+SyntaxKind[LineTerminatorToken](504,1): «line terminator»
+SyntaxKind[Identifier](504,1): Arguments
+SyntaxKind[OpenBracketToken](504,10): [
+SyntaxKind[Identifier](504,11): Yield
+SyntaxKind[CloseBracketToken](504,16): ]
+SyntaxKind[ColonToken](504,18): :
+SyntaxKind[LineTerminatorToken](505,1): «line terminator»
+SyntaxKind[IndentToken](505,1): «indent»
+SyntaxKind[Terminal](505,2): `(`
+SyntaxKind[Terminal](505,6): `)`
+SyntaxKind[LineTerminatorToken](506,1): «line terminator»
+SyntaxKind[Terminal](506,2): `(`
+SyntaxKind[Identifier](506,6): ArgumentList
+SyntaxKind[OpenBracketToken](506,18): [
+SyntaxKind[QuestionToken](506,19): ?
+SyntaxKind[Identifier](506,20): Yield
+SyntaxKind[CloseBracketToken](506,25): ]
+SyntaxKind[Terminal](506,28): `)`
+SyntaxKind[LineTerminatorToken](507,1): «line terminator»
+SyntaxKind[DedentToken](507,1): «dedent»
+SyntaxKind[LineTerminatorToken](508,1): «line terminator»
+SyntaxKind[Identifier](508,1): ArgumentList
+SyntaxKind[OpenBracketToken](508,13): [
+SyntaxKind[Identifier](508,14): Yield
+SyntaxKind[CloseBracketToken](508,19): ]
+SyntaxKind[ColonToken](508,21): :
+SyntaxKind[LineTerminatorToken](509,1): «line terminator»
+SyntaxKind[IndentToken](509,1): «indent»
+SyntaxKind[Identifier](509,2): AssignmentExpression
+SyntaxKind[OpenBracketToken](509,22): [
+SyntaxKind[Identifier](509,23): In
+SyntaxKind[CommaToken](509,25): ,
+SyntaxKind[QuestionToken](509,27): ?
+SyntaxKind[Identifier](509,28): Yield
+SyntaxKind[CloseBracketToken](509,33): ]
+SyntaxKind[LineTerminatorToken](510,1): «line terminator»
+SyntaxKind[Terminal](510,2): `...`
+SyntaxKind[Identifier](510,8): AssignmentExpression
+SyntaxKind[OpenBracketToken](510,28): [
+SyntaxKind[Identifier](510,29): In
+SyntaxKind[CommaToken](510,31): ,
+SyntaxKind[QuestionToken](510,33): ?
+SyntaxKind[Identifier](510,34): Yield
+SyntaxKind[CloseBracketToken](510,39): ]
+SyntaxKind[LineTerminatorToken](511,1): «line terminator»
+SyntaxKind[Identifier](511,2): ArgumentList
+SyntaxKind[OpenBracketToken](511,14): [
+SyntaxKind[QuestionToken](511,15): ?
+SyntaxKind[Identifier](511,16): Yield
+SyntaxKind[CloseBracketToken](511,21): ]
+SyntaxKind[Terminal](511,23): `,`
+SyntaxKind[Identifier](511,27): AssignmentExpression
+SyntaxKind[OpenBracketToken](511,47): [
+SyntaxKind[Identifier](511,48): In
+SyntaxKind[CommaToken](511,50): ,
+SyntaxKind[QuestionToken](511,52): ?
+SyntaxKind[Identifier](511,53): Yield
+SyntaxKind[CloseBracketToken](511,58): ]
+SyntaxKind[LineTerminatorToken](512,1): «line terminator»
+SyntaxKind[Identifier](512,2): ArgumentList
+SyntaxKind[OpenBracketToken](512,14): [
+SyntaxKind[QuestionToken](512,15): ?
+SyntaxKind[Identifier](512,16): Yield
+SyntaxKind[CloseBracketToken](512,21): ]
+SyntaxKind[Terminal](512,23): `,`
+SyntaxKind[Terminal](512,27): `...`
+SyntaxKind[Identifier](512,33): AssignmentExpression
+SyntaxKind[OpenBracketToken](512,53): [
+SyntaxKind[Identifier](512,54): In
+SyntaxKind[CommaToken](512,56): ,
+SyntaxKind[QuestionToken](512,58): ?
+SyntaxKind[Identifier](512,59): Yield
+SyntaxKind[CloseBracketToken](512,64): ]
+SyntaxKind[LineTerminatorToken](513,1): «line terminator»
+SyntaxKind[DedentToken](513,1): «dedent»
+SyntaxKind[LineTerminatorToken](514,1): «line terminator»
+SyntaxKind[Identifier](514,1): LeftHandSideExpression
+SyntaxKind[OpenBracketToken](514,23): [
+SyntaxKind[Identifier](514,24): Yield
+SyntaxKind[CloseBracketToken](514,29): ]
+SyntaxKind[ColonToken](514,31): :
+SyntaxKind[LineTerminatorToken](515,1): «line terminator»
+SyntaxKind[IndentToken](515,1): «indent»
+SyntaxKind[Identifier](515,2): NewExpression
+SyntaxKind[OpenBracketToken](515,15): [
+SyntaxKind[QuestionToken](515,16): ?
+SyntaxKind[Identifier](515,17): Yield
+SyntaxKind[CloseBracketToken](515,22): ]
+SyntaxKind[LineTerminatorToken](516,1): «line terminator»
+SyntaxKind[Identifier](516,2): CallExpression
+SyntaxKind[OpenBracketToken](516,16): [
+SyntaxKind[QuestionToken](516,17): ?
+SyntaxKind[Identifier](516,18): Yield
+SyntaxKind[CloseBracketToken](516,23): ]
+SyntaxKind[LineTerminatorToken](517,1): «line terminator»
+SyntaxKind[DedentToken](517,1): «dedent»
+SyntaxKind[LineTerminatorToken](518,1): «line terminator»
+SyntaxKind[Identifier](518,1): PostfixExpression
+SyntaxKind[OpenBracketToken](518,18): [
+SyntaxKind[Identifier](518,19): Yield
+SyntaxKind[CloseBracketToken](518,24): ]
+SyntaxKind[ColonToken](518,26): :
+SyntaxKind[LineTerminatorToken](519,1): «line terminator»
+SyntaxKind[IndentToken](519,1): «indent»
+SyntaxKind[Identifier](519,2): LeftHandSideExpression
+SyntaxKind[OpenBracketToken](519,24): [
+SyntaxKind[QuestionToken](519,25): ?
+SyntaxKind[Identifier](519,26): Yield
+SyntaxKind[CloseBracketToken](519,31): ]
+SyntaxKind[LineTerminatorToken](520,1): «line terminator»
+SyntaxKind[Identifier](520,2): LeftHandSideExpression
+SyntaxKind[OpenBracketToken](520,24): [
+SyntaxKind[QuestionToken](520,25): ?
+SyntaxKind[Identifier](520,26): Yield
+SyntaxKind[CloseBracketToken](520,31): ]
+SyntaxKind[OpenBracketToken](520,33): [
+SyntaxKind[NoKeyword](520,34): no
+SyntaxKind[Identifier](520,37): LineTerminator
+SyntaxKind[HereKeyword](520,52): here
+SyntaxKind[CloseBracketToken](520,56): ]
+SyntaxKind[Terminal](520,58): `++`
+SyntaxKind[LineTerminatorToken](521,1): «line terminator»
+SyntaxKind[Identifier](521,2): LeftHandSideExpression
+SyntaxKind[OpenBracketToken](521,24): [
+SyntaxKind[QuestionToken](521,25): ?
+SyntaxKind[Identifier](521,26): Yield
+SyntaxKind[CloseBracketToken](521,31): ]
+SyntaxKind[OpenBracketToken](521,33): [
+SyntaxKind[NoKeyword](521,34): no
+SyntaxKind[Identifier](521,37): LineTerminator
+SyntaxKind[HereKeyword](521,52): here
+SyntaxKind[CloseBracketToken](521,56): ]
+SyntaxKind[Terminal](521,58): `--`
+SyntaxKind[LineTerminatorToken](522,1): «line terminator»
+SyntaxKind[DedentToken](522,1): «dedent»
+SyntaxKind[LineTerminatorToken](523,1): «line terminator»
+SyntaxKind[Identifier](523,1): UnaryExpression
+SyntaxKind[OpenBracketToken](523,16): [
+SyntaxKind[Identifier](523,17): Yield
+SyntaxKind[CloseBracketToken](523,22): ]
+SyntaxKind[ColonToken](523,24): :
+SyntaxKind[LineTerminatorToken](524,1): «line terminator»
+SyntaxKind[IndentToken](524,1): «indent»
+SyntaxKind[Identifier](524,2): PostfixExpression
+SyntaxKind[OpenBracketToken](524,19): [
+SyntaxKind[QuestionToken](524,20): ?
+SyntaxKind[Identifier](524,21): Yield
+SyntaxKind[CloseBracketToken](524,26): ]
+SyntaxKind[LineTerminatorToken](525,1): «line terminator»
+SyntaxKind[Terminal](525,2): `delete`
+SyntaxKind[Identifier](525,11): UnaryExpression
+SyntaxKind[OpenBracketToken](525,26): [
+SyntaxKind[QuestionToken](525,27): ?
+SyntaxKind[Identifier](525,28): Yield
+SyntaxKind[CloseBracketToken](525,33): ]
+SyntaxKind[LineTerminatorToken](526,1): «line terminator»
+SyntaxKind[Terminal](526,2): `void`
+SyntaxKind[Identifier](526,9): UnaryExpression
+SyntaxKind[OpenBracketToken](526,24): [
+SyntaxKind[QuestionToken](526,25): ?
+SyntaxKind[Identifier](526,26): Yield
+SyntaxKind[CloseBracketToken](526,31): ]
+SyntaxKind[LineTerminatorToken](527,1): «line terminator»
+SyntaxKind[Terminal](527,2): `typeof`
+SyntaxKind[Identifier](527,11): UnaryExpression
+SyntaxKind[OpenBracketToken](527,26): [
+SyntaxKind[QuestionToken](527,27): ?
+SyntaxKind[Identifier](527,28): Yield
+SyntaxKind[CloseBracketToken](527,33): ]
+SyntaxKind[LineTerminatorToken](528,1): «line terminator»
+SyntaxKind[Terminal](528,2): `++`
+SyntaxKind[Identifier](528,7): UnaryExpression
+SyntaxKind[OpenBracketToken](528,22): [
+SyntaxKind[QuestionToken](528,23): ?
+SyntaxKind[Identifier](528,24): Yield
+SyntaxKind[CloseBracketToken](528,29): ]
+SyntaxKind[LineTerminatorToken](529,1): «line terminator»
+SyntaxKind[Terminal](529,2): `--`
+SyntaxKind[Identifier](529,7): UnaryExpression
+SyntaxKind[OpenBracketToken](529,22): [
+SyntaxKind[QuestionToken](529,23): ?
+SyntaxKind[Identifier](529,24): Yield
+SyntaxKind[CloseBracketToken](529,29): ]
+SyntaxKind[LineTerminatorToken](530,1): «line terminator»
+SyntaxKind[Terminal](530,2): `+`
+SyntaxKind[Identifier](530,6): UnaryExpression
+SyntaxKind[OpenBracketToken](530,21): [
+SyntaxKind[QuestionToken](530,22): ?
+SyntaxKind[Identifier](530,23): Yield
+SyntaxKind[CloseBracketToken](530,28): ]
+SyntaxKind[LineTerminatorToken](531,1): «line terminator»
+SyntaxKind[Terminal](531,2): `-`
+SyntaxKind[Identifier](531,6): UnaryExpression
+SyntaxKind[OpenBracketToken](531,21): [
+SyntaxKind[QuestionToken](531,22): ?
+SyntaxKind[Identifier](531,23): Yield
+SyntaxKind[CloseBracketToken](531,28): ]
+SyntaxKind[LineTerminatorToken](532,1): «line terminator»
+SyntaxKind[Terminal](532,2): `~`
+SyntaxKind[Identifier](532,6): UnaryExpression
+SyntaxKind[OpenBracketToken](532,21): [
+SyntaxKind[QuestionToken](532,22): ?
+SyntaxKind[Identifier](532,23): Yield
+SyntaxKind[CloseBracketToken](532,28): ]
+SyntaxKind[LineTerminatorToken](533,1): «line terminator»
+SyntaxKind[Terminal](533,2): `!`
+SyntaxKind[Identifier](533,6): UnaryExpression
+SyntaxKind[OpenBracketToken](533,21): [
+SyntaxKind[QuestionToken](533,22): ?
+SyntaxKind[Identifier](533,23): Yield
+SyntaxKind[CloseBracketToken](533,28): ]
+SyntaxKind[LineTerminatorToken](534,1): «line terminator»
+SyntaxKind[DedentToken](534,1): «dedent»
+SyntaxKind[LineTerminatorToken](535,1): «line terminator»
+SyntaxKind[Identifier](535,1): MultiplicativeExpression
+SyntaxKind[OpenBracketToken](535,25): [
+SyntaxKind[Identifier](535,26): Yield
+SyntaxKind[CloseBracketToken](535,31): ]
+SyntaxKind[ColonToken](535,33): :
+SyntaxKind[LineTerminatorToken](536,1): «line terminator»
+SyntaxKind[IndentToken](536,1): «indent»
+SyntaxKind[Identifier](536,2): UnaryExpression
+SyntaxKind[OpenBracketToken](536,17): [
+SyntaxKind[QuestionToken](536,18): ?
+SyntaxKind[Identifier](536,19): Yield
+SyntaxKind[CloseBracketToken](536,24): ]
+SyntaxKind[LineTerminatorToken](537,1): «line terminator»
+SyntaxKind[Identifier](537,2): MultiplicativeExpression
+SyntaxKind[OpenBracketToken](537,26): [
+SyntaxKind[QuestionToken](537,27): ?
+SyntaxKind[Identifier](537,28): Yield
+SyntaxKind[CloseBracketToken](537,33): ]
+SyntaxKind[Identifier](537,35): MultiplicativeOperator
+SyntaxKind[Identifier](537,58): UnaryExpression
+SyntaxKind[OpenBracketToken](537,73): [
+SyntaxKind[QuestionToken](537,74): ?
+SyntaxKind[Identifier](537,75): Yield
+SyntaxKind[CloseBracketToken](537,80): ]
+SyntaxKind[LineTerminatorToken](538,1): «line terminator»
+SyntaxKind[DedentToken](538,1): «dedent»
+SyntaxKind[LineTerminatorToken](539,1): «line terminator»
+SyntaxKind[Identifier](539,1): MultiplicativeOperator
+SyntaxKind[ColonToken](539,24): :
+SyntaxKind[OneKeyword](539,26): one
+SyntaxKind[OfKeyword](539,30): of
+SyntaxKind[LineTerminatorToken](540,1): «line terminator»
+SyntaxKind[IndentToken](540,1): «indent»
+SyntaxKind[Terminal](540,2): `*`
+SyntaxKind[Terminal](540,6): `/`
+SyntaxKind[Terminal](540,10): `%`
+SyntaxKind[LineTerminatorToken](541,1): «line terminator»
+SyntaxKind[DedentToken](541,1): «dedent»
+SyntaxKind[LineTerminatorToken](542,1): «line terminator»
+SyntaxKind[Identifier](542,1): AdditiveExpression
+SyntaxKind[OpenBracketToken](542,19): [
+SyntaxKind[Identifier](542,20): Yield
+SyntaxKind[CloseBracketToken](542,25): ]
+SyntaxKind[ColonToken](542,27): :
+SyntaxKind[LineTerminatorToken](543,1): «line terminator»
+SyntaxKind[IndentToken](543,1): «indent»
+SyntaxKind[Identifier](543,2): MultiplicativeExpression
+SyntaxKind[OpenBracketToken](543,26): [
+SyntaxKind[QuestionToken](543,27): ?
+SyntaxKind[Identifier](543,28): Yield
+SyntaxKind[CloseBracketToken](543,33): ]
+SyntaxKind[LineTerminatorToken](544,1): «line terminator»
+SyntaxKind[Identifier](544,2): AdditiveExpression
+SyntaxKind[OpenBracketToken](544,20): [
+SyntaxKind[QuestionToken](544,21): ?
+SyntaxKind[Identifier](544,22): Yield
+SyntaxKind[CloseBracketToken](544,27): ]
+SyntaxKind[Terminal](544,29): `+`
+SyntaxKind[Identifier](544,33): MultiplicativeExpression
+SyntaxKind[OpenBracketToken](544,57): [
+SyntaxKind[QuestionToken](544,58): ?
+SyntaxKind[Identifier](544,59): Yield
+SyntaxKind[CloseBracketToken](544,64): ]
+SyntaxKind[LineTerminatorToken](545,1): «line terminator»
+SyntaxKind[Identifier](545,2): AdditiveExpression
+SyntaxKind[OpenBracketToken](545,20): [
+SyntaxKind[QuestionToken](545,21): ?
+SyntaxKind[Identifier](545,22): Yield
+SyntaxKind[CloseBracketToken](545,27): ]
+SyntaxKind[Terminal](545,29): `-`
+SyntaxKind[Identifier](545,33): MultiplicativeExpression
+SyntaxKind[OpenBracketToken](545,57): [
+SyntaxKind[QuestionToken](545,58): ?
+SyntaxKind[Identifier](545,59): Yield
+SyntaxKind[CloseBracketToken](545,64): ]
+SyntaxKind[LineTerminatorToken](546,1): «line terminator»
+SyntaxKind[DedentToken](546,1): «dedent»
+SyntaxKind[LineTerminatorToken](547,1): «line terminator»
+SyntaxKind[Identifier](547,1): ShiftExpression
+SyntaxKind[OpenBracketToken](547,16): [
+SyntaxKind[Identifier](547,17): Yield
+SyntaxKind[CloseBracketToken](547,22): ]
+SyntaxKind[ColonToken](547,24): :
+SyntaxKind[LineTerminatorToken](548,1): «line terminator»
+SyntaxKind[IndentToken](548,1): «indent»
+SyntaxKind[Identifier](548,2): AdditiveExpression
+SyntaxKind[OpenBracketToken](548,20): [
+SyntaxKind[QuestionToken](548,21): ?
+SyntaxKind[Identifier](548,22): Yield
+SyntaxKind[CloseBracketToken](548,27): ]
+SyntaxKind[LineTerminatorToken](549,1): «line terminator»
+SyntaxKind[Identifier](549,2): ShiftExpression
+SyntaxKind[OpenBracketToken](549,17): [
+SyntaxKind[QuestionToken](549,18): ?
+SyntaxKind[Identifier](549,19): Yield
+SyntaxKind[CloseBracketToken](549,24): ]
+SyntaxKind[Terminal](549,26): `<<`
+SyntaxKind[Identifier](549,31): AdditiveExpression
+SyntaxKind[OpenBracketToken](549,49): [
+SyntaxKind[QuestionToken](549,50): ?
+SyntaxKind[Identifier](549,51): Yield
+SyntaxKind[CloseBracketToken](549,56): ]
+SyntaxKind[LineTerminatorToken](550,1): «line terminator»
+SyntaxKind[Identifier](550,2): ShiftExpression
+SyntaxKind[OpenBracketToken](550,17): [
+SyntaxKind[QuestionToken](550,18): ?
+SyntaxKind[Identifier](550,19): Yield
+SyntaxKind[CloseBracketToken](550,24): ]
+SyntaxKind[Terminal](550,26): `>>`
+SyntaxKind[Identifier](550,31): AdditiveExpression
+SyntaxKind[OpenBracketToken](550,49): [
+SyntaxKind[QuestionToken](550,50): ?
+SyntaxKind[Identifier](550,51): Yield
+SyntaxKind[CloseBracketToken](550,56): ]
+SyntaxKind[LineTerminatorToken](551,1): «line terminator»
+SyntaxKind[Identifier](551,2): ShiftExpression
+SyntaxKind[OpenBracketToken](551,17): [
+SyntaxKind[QuestionToken](551,18): ?
+SyntaxKind[Identifier](551,19): Yield
+SyntaxKind[CloseBracketToken](551,24): ]
+SyntaxKind[Terminal](551,26): `>>>`
+SyntaxKind[Identifier](551,32): AdditiveExpression
+SyntaxKind[OpenBracketToken](551,50): [
+SyntaxKind[QuestionToken](551,51): ?
+SyntaxKind[Identifier](551,52): Yield
+SyntaxKind[CloseBracketToken](551,57): ]
+SyntaxKind[LineTerminatorToken](552,1): «line terminator»
+SyntaxKind[DedentToken](552,1): «dedent»
+SyntaxKind[LineTerminatorToken](553,1): «line terminator»
+SyntaxKind[Identifier](553,1): RelationalExpression
+SyntaxKind[OpenBracketToken](553,21): [
+SyntaxKind[Identifier](553,22): In
+SyntaxKind[CommaToken](553,24): ,
+SyntaxKind[Identifier](553,26): Yield
+SyntaxKind[CloseBracketToken](553,31): ]
+SyntaxKind[ColonToken](553,33): :
+SyntaxKind[LineTerminatorToken](554,1): «line terminator»
+SyntaxKind[IndentToken](554,1): «indent»
+SyntaxKind[Identifier](554,2): ShiftExpression
+SyntaxKind[OpenBracketToken](554,17): [
+SyntaxKind[QuestionToken](554,18): ?
+SyntaxKind[Identifier](554,19): Yield
+SyntaxKind[CloseBracketToken](554,24): ]
+SyntaxKind[LineTerminatorToken](555,1): «line terminator»
+SyntaxKind[Identifier](555,2): RelationalExpression
+SyntaxKind[OpenBracketToken](555,22): [
+SyntaxKind[QuestionToken](555,23): ?
+SyntaxKind[Identifier](555,24): In
+SyntaxKind[CommaToken](555,26): ,
+SyntaxKind[QuestionToken](555,28): ?
+SyntaxKind[Identifier](555,29): Yield
+SyntaxKind[CloseBracketToken](555,34): ]
+SyntaxKind[Terminal](555,36): `<`
+SyntaxKind[Identifier](555,40): ShiftExpression
+SyntaxKind[OpenBracketToken](555,55): [
+SyntaxKind[QuestionToken](555,56): ?
+SyntaxKind[Identifier](555,57): Yield
+SyntaxKind[CloseBracketToken](555,62): ]
+SyntaxKind[LineTerminatorToken](556,1): «line terminator»
+SyntaxKind[Identifier](556,2): RelationalExpression
+SyntaxKind[OpenBracketToken](556,22): [
+SyntaxKind[QuestionToken](556,23): ?
+SyntaxKind[Identifier](556,24): In
+SyntaxKind[CommaToken](556,26): ,
+SyntaxKind[QuestionToken](556,28): ?
+SyntaxKind[Identifier](556,29): Yield
+SyntaxKind[CloseBracketToken](556,34): ]
+SyntaxKind[Terminal](556,36): `>`
+SyntaxKind[Identifier](556,40): ShiftExpression
+SyntaxKind[OpenBracketToken](556,55): [
+SyntaxKind[QuestionToken](556,56): ?
+SyntaxKind[Identifier](556,57): Yield
+SyntaxKind[CloseBracketToken](556,62): ]
+SyntaxKind[LineTerminatorToken](557,1): «line terminator»
+SyntaxKind[Identifier](557,2): RelationalExpression
+SyntaxKind[OpenBracketToken](557,22): [
+SyntaxKind[QuestionToken](557,23): ?
+SyntaxKind[Identifier](557,24): In
+SyntaxKind[CommaToken](557,26): ,
+SyntaxKind[QuestionToken](557,28): ?
+SyntaxKind[Identifier](557,29): Yield
+SyntaxKind[CloseBracketToken](557,34): ]
+SyntaxKind[Terminal](557,36): `<=`
+SyntaxKind[Identifier](557,41): ShiftExpression
+SyntaxKind[OpenBracketToken](557,56): [
+SyntaxKind[QuestionToken](557,57): ?
+SyntaxKind[Identifier](557,58): Yield
+SyntaxKind[CloseBracketToken](557,63): ]
+SyntaxKind[LineTerminatorToken](558,1): «line terminator»
+SyntaxKind[Identifier](558,2): RelationalExpression
+SyntaxKind[OpenBracketToken](558,22): [
+SyntaxKind[QuestionToken](558,23): ?
+SyntaxKind[Identifier](558,24): In
+SyntaxKind[CommaToken](558,26): ,
+SyntaxKind[QuestionToken](558,28): ?
+SyntaxKind[Identifier](558,29): Yield
+SyntaxKind[CloseBracketToken](558,34): ]
+SyntaxKind[Terminal](558,36): `>=`
+SyntaxKind[Identifier](558,41): ShiftExpression
+SyntaxKind[OpenBracketToken](558,56): [
+SyntaxKind[QuestionToken](558,57): ?
+SyntaxKind[Identifier](558,58): Yield
+SyntaxKind[CloseBracketToken](558,63): ]
+SyntaxKind[LineTerminatorToken](559,1): «line terminator»
+SyntaxKind[Identifier](559,2): RelationalExpression
+SyntaxKind[OpenBracketToken](559,22): [
+SyntaxKind[QuestionToken](559,23): ?
+SyntaxKind[Identifier](559,24): In
+SyntaxKind[CommaToken](559,26): ,
+SyntaxKind[QuestionToken](559,28): ?
+SyntaxKind[Identifier](559,29): Yield
+SyntaxKind[CloseBracketToken](559,34): ]
+SyntaxKind[Terminal](559,36): `instanceof`
+SyntaxKind[Identifier](559,49): ShiftExpression
+SyntaxKind[OpenBracketToken](559,64): [
+SyntaxKind[QuestionToken](559,65): ?
+SyntaxKind[Identifier](559,66): Yield
+SyntaxKind[CloseBracketToken](559,71): ]
+SyntaxKind[LineTerminatorToken](560,1): «line terminator»
+SyntaxKind[OpenBracketToken](560,2): [
+SyntaxKind[PlusToken](560,3): +
+SyntaxKind[Identifier](560,4): In
+SyntaxKind[CloseBracketToken](560,6): ]
+SyntaxKind[Identifier](560,8): RelationalExpression
+SyntaxKind[OpenBracketToken](560,28): [
+SyntaxKind[Identifier](560,29): In
+SyntaxKind[CommaToken](560,31): ,
+SyntaxKind[QuestionToken](560,33): ?
+SyntaxKind[Identifier](560,34): Yield
+SyntaxKind[CloseBracketToken](560,39): ]
+SyntaxKind[Terminal](560,41): `in`
+SyntaxKind[Identifier](560,46): ShiftExpression
+SyntaxKind[OpenBracketToken](560,61): [
+SyntaxKind[QuestionToken](560,62): ?
+SyntaxKind[Identifier](560,63): Yield
+SyntaxKind[CloseBracketToken](560,68): ]
+SyntaxKind[LineTerminatorToken](561,1): «line terminator»
+SyntaxKind[DedentToken](561,1): «dedent»
+SyntaxKind[LineTerminatorToken](562,1): «line terminator»
+SyntaxKind[Identifier](562,1): EqualityExpression
+SyntaxKind[OpenBracketToken](562,19): [
+SyntaxKind[Identifier](562,20): In
+SyntaxKind[CommaToken](562,22): ,
+SyntaxKind[Identifier](562,24): Yield
+SyntaxKind[CloseBracketToken](562,29): ]
+SyntaxKind[ColonToken](562,31): :
+SyntaxKind[LineTerminatorToken](563,1): «line terminator»
+SyntaxKind[IndentToken](563,1): «indent»
+SyntaxKind[Identifier](563,2): RelationalExpression
+SyntaxKind[OpenBracketToken](563,22): [
+SyntaxKind[QuestionToken](563,23): ?
+SyntaxKind[Identifier](563,24): In
+SyntaxKind[CommaToken](563,26): ,
+SyntaxKind[QuestionToken](563,28): ?
+SyntaxKind[Identifier](563,29): Yield
+SyntaxKind[CloseBracketToken](563,34): ]
+SyntaxKind[LineTerminatorToken](564,1): «line terminator»
+SyntaxKind[Identifier](564,2): EqualityExpression
+SyntaxKind[OpenBracketToken](564,20): [
+SyntaxKind[QuestionToken](564,21): ?
+SyntaxKind[Identifier](564,22): In
+SyntaxKind[CommaToken](564,24): ,
+SyntaxKind[QuestionToken](564,26): ?
+SyntaxKind[Identifier](564,27): Yield
+SyntaxKind[CloseBracketToken](564,32): ]
+SyntaxKind[Terminal](564,34): `==`
+SyntaxKind[Identifier](564,39): RelationalExpression
+SyntaxKind[OpenBracketToken](564,59): [
+SyntaxKind[QuestionToken](564,60): ?
+SyntaxKind[Identifier](564,61): In
+SyntaxKind[CommaToken](564,63): ,
+SyntaxKind[QuestionToken](564,65): ?
+SyntaxKind[Identifier](564,66): Yield
+SyntaxKind[CloseBracketToken](564,71): ]
+SyntaxKind[LineTerminatorToken](565,1): «line terminator»
+SyntaxKind[Identifier](565,2): EqualityExpression
+SyntaxKind[OpenBracketToken](565,20): [
+SyntaxKind[QuestionToken](565,21): ?
+SyntaxKind[Identifier](565,22): In
+SyntaxKind[CommaToken](565,24): ,
+SyntaxKind[QuestionToken](565,26): ?
+SyntaxKind[Identifier](565,27): Yield
+SyntaxKind[CloseBracketToken](565,32): ]
+SyntaxKind[Terminal](565,34): `!=`
+SyntaxKind[Identifier](565,39): RelationalExpression
+SyntaxKind[OpenBracketToken](565,59): [
+SyntaxKind[QuestionToken](565,60): ?
+SyntaxKind[Identifier](565,61): In
+SyntaxKind[CommaToken](565,63): ,
+SyntaxKind[QuestionToken](565,65): ?
+SyntaxKind[Identifier](565,66): Yield
+SyntaxKind[CloseBracketToken](565,71): ]
+SyntaxKind[LineTerminatorToken](566,1): «line terminator»
+SyntaxKind[Identifier](566,2): EqualityExpression
+SyntaxKind[OpenBracketToken](566,20): [
+SyntaxKind[QuestionToken](566,21): ?
+SyntaxKind[Identifier](566,22): In
+SyntaxKind[CommaToken](566,24): ,
+SyntaxKind[QuestionToken](566,26): ?
+SyntaxKind[Identifier](566,27): Yield
+SyntaxKind[CloseBracketToken](566,32): ]
+SyntaxKind[Terminal](566,34): `===`
+SyntaxKind[Identifier](566,40): RelationalExpression
+SyntaxKind[OpenBracketToken](566,60): [
+SyntaxKind[QuestionToken](566,61): ?
+SyntaxKind[Identifier](566,62): In
+SyntaxKind[CommaToken](566,64): ,
+SyntaxKind[QuestionToken](566,66): ?
+SyntaxKind[Identifier](566,67): Yield
+SyntaxKind[CloseBracketToken](566,72): ]
+SyntaxKind[LineTerminatorToken](567,1): «line terminator»
+SyntaxKind[Identifier](567,2): EqualityExpression
+SyntaxKind[OpenBracketToken](567,20): [
+SyntaxKind[QuestionToken](567,21): ?
+SyntaxKind[Identifier](567,22): In
+SyntaxKind[CommaToken](567,24): ,
+SyntaxKind[QuestionToken](567,26): ?
+SyntaxKind[Identifier](567,27): Yield
+SyntaxKind[CloseBracketToken](567,32): ]
+SyntaxKind[Terminal](567,34): `!==`
+SyntaxKind[Identifier](567,40): RelationalExpression
+SyntaxKind[OpenBracketToken](567,60): [
+SyntaxKind[QuestionToken](567,61): ?
+SyntaxKind[Identifier](567,62): In
+SyntaxKind[CommaToken](567,64): ,
+SyntaxKind[QuestionToken](567,66): ?
+SyntaxKind[Identifier](567,67): Yield
+SyntaxKind[CloseBracketToken](567,72): ]
+SyntaxKind[LineTerminatorToken](568,1): «line terminator»
+SyntaxKind[DedentToken](568,1): «dedent»
+SyntaxKind[LineTerminatorToken](569,1): «line terminator»
+SyntaxKind[Identifier](569,1): BitwiseANDExpression
+SyntaxKind[OpenBracketToken](569,21): [
+SyntaxKind[Identifier](569,22): In
+SyntaxKind[CommaToken](569,24): ,
+SyntaxKind[Identifier](569,26): Yield
+SyntaxKind[CloseBracketToken](569,31): ]
+SyntaxKind[ColonToken](569,33): :
+SyntaxKind[LineTerminatorToken](570,1): «line terminator»
+SyntaxKind[IndentToken](570,1): «indent»
+SyntaxKind[Identifier](570,2): EqualityExpression
+SyntaxKind[OpenBracketToken](570,20): [
+SyntaxKind[QuestionToken](570,21): ?
+SyntaxKind[Identifier](570,22): In
+SyntaxKind[CommaToken](570,24): ,
+SyntaxKind[QuestionToken](570,26): ?
+SyntaxKind[Identifier](570,27): Yield
+SyntaxKind[CloseBracketToken](570,32): ]
+SyntaxKind[LineTerminatorToken](571,1): «line terminator»
+SyntaxKind[Identifier](571,2): BitwiseANDExpression
+SyntaxKind[OpenBracketToken](571,22): [
+SyntaxKind[QuestionToken](571,23): ?
+SyntaxKind[Identifier](571,24): In
+SyntaxKind[CommaToken](571,26): ,
+SyntaxKind[QuestionToken](571,28): ?
+SyntaxKind[Identifier](571,29): Yield
+SyntaxKind[CloseBracketToken](571,34): ]
+SyntaxKind[Terminal](571,36): `&`
+SyntaxKind[Identifier](571,40): EqualityExpression
+SyntaxKind[OpenBracketToken](571,58): [
+SyntaxKind[QuestionToken](571,59): ?
+SyntaxKind[Identifier](571,60): In
+SyntaxKind[CommaToken](571,62): ,
+SyntaxKind[QuestionToken](571,64): ?
+SyntaxKind[Identifier](571,65): Yield
+SyntaxKind[CloseBracketToken](571,70): ]
+SyntaxKind[LineTerminatorToken](572,1): «line terminator»
+SyntaxKind[DedentToken](572,1): «dedent»
+SyntaxKind[LineTerminatorToken](573,1): «line terminator»
+SyntaxKind[Identifier](573,1): BitwiseXORExpression
+SyntaxKind[OpenBracketToken](573,21): [
+SyntaxKind[Identifier](573,22): In
+SyntaxKind[CommaToken](573,24): ,
+SyntaxKind[Identifier](573,26): Yield
+SyntaxKind[CloseBracketToken](573,31): ]
+SyntaxKind[ColonToken](573,33): :
+SyntaxKind[LineTerminatorToken](574,1): «line terminator»
+SyntaxKind[IndentToken](574,1): «indent»
+SyntaxKind[Identifier](574,2): BitwiseANDExpression
+SyntaxKind[OpenBracketToken](574,22): [
+SyntaxKind[QuestionToken](574,23): ?
+SyntaxKind[Identifier](574,24): In
+SyntaxKind[CommaToken](574,26): ,
+SyntaxKind[QuestionToken](574,28): ?
+SyntaxKind[Identifier](574,29): Yield
+SyntaxKind[CloseBracketToken](574,34): ]
+SyntaxKind[LineTerminatorToken](575,1): «line terminator»
+SyntaxKind[Identifier](575,2): BitwiseXORExpression
+SyntaxKind[OpenBracketToken](575,22): [
+SyntaxKind[QuestionToken](575,23): ?
+SyntaxKind[Identifier](575,24): In
+SyntaxKind[CommaToken](575,26): ,
+SyntaxKind[QuestionToken](575,28): ?
+SyntaxKind[Identifier](575,29): Yield
+SyntaxKind[CloseBracketToken](575,34): ]
+SyntaxKind[Terminal](575,36): `^`
+SyntaxKind[Identifier](575,40): BitwiseANDExpression
+SyntaxKind[OpenBracketToken](575,60): [
+SyntaxKind[QuestionToken](575,61): ?
+SyntaxKind[Identifier](575,62): In
+SyntaxKind[CommaToken](575,64): ,
+SyntaxKind[QuestionToken](575,66): ?
+SyntaxKind[Identifier](575,67): Yield
+SyntaxKind[CloseBracketToken](575,72): ]
+SyntaxKind[LineTerminatorToken](576,1): «line terminator»
+SyntaxKind[DedentToken](576,1): «dedent»
+SyntaxKind[LineTerminatorToken](577,1): «line terminator»
+SyntaxKind[Identifier](577,1): BitwiseORExpression
+SyntaxKind[OpenBracketToken](577,20): [
+SyntaxKind[Identifier](577,21): In
+SyntaxKind[CommaToken](577,23): ,
+SyntaxKind[Identifier](577,25): Yield
+SyntaxKind[CloseBracketToken](577,30): ]
+SyntaxKind[ColonToken](577,32): :
+SyntaxKind[LineTerminatorToken](578,1): «line terminator»
+SyntaxKind[IndentToken](578,1): «indent»
+SyntaxKind[Identifier](578,2): BitwiseXORExpression
+SyntaxKind[OpenBracketToken](578,22): [
+SyntaxKind[QuestionToken](578,23): ?
+SyntaxKind[Identifier](578,24): In
+SyntaxKind[CommaToken](578,26): ,
+SyntaxKind[QuestionToken](578,28): ?
+SyntaxKind[Identifier](578,29): Yield
+SyntaxKind[CloseBracketToken](578,34): ]
+SyntaxKind[LineTerminatorToken](579,1): «line terminator»
+SyntaxKind[Identifier](579,2): BitwiseORExpression
+SyntaxKind[OpenBracketToken](579,21): [
+SyntaxKind[QuestionToken](579,22): ?
+SyntaxKind[Identifier](579,23): In
+SyntaxKind[CommaToken](579,25): ,
+SyntaxKind[QuestionToken](579,27): ?
+SyntaxKind[Identifier](579,28): Yield
+SyntaxKind[CloseBracketToken](579,33): ]
+SyntaxKind[Terminal](579,35): `|`
+SyntaxKind[Identifier](579,39): BitwiseXORExpression
+SyntaxKind[OpenBracketToken](579,59): [
+SyntaxKind[QuestionToken](579,60): ?
+SyntaxKind[Identifier](579,61): In
+SyntaxKind[CommaToken](579,63): ,
+SyntaxKind[QuestionToken](579,65): ?
+SyntaxKind[Identifier](579,66): Yield
+SyntaxKind[CloseBracketToken](579,71): ]
+SyntaxKind[LineTerminatorToken](580,1): «line terminator»
+SyntaxKind[DedentToken](580,1): «dedent»
+SyntaxKind[LineTerminatorToken](581,1): «line terminator»
+SyntaxKind[Identifier](581,1): LogicalANDExpression
+SyntaxKind[OpenBracketToken](581,21): [
+SyntaxKind[Identifier](581,22): In
+SyntaxKind[CommaToken](581,24): ,
+SyntaxKind[Identifier](581,26): Yield
+SyntaxKind[CloseBracketToken](581,31): ]
+SyntaxKind[ColonToken](581,33): :
+SyntaxKind[LineTerminatorToken](582,1): «line terminator»
+SyntaxKind[IndentToken](582,1): «indent»
+SyntaxKind[Identifier](582,2): BitwiseORExpression
+SyntaxKind[OpenBracketToken](582,21): [
+SyntaxKind[QuestionToken](582,22): ?
+SyntaxKind[Identifier](582,23): In
+SyntaxKind[CommaToken](582,25): ,
+SyntaxKind[QuestionToken](582,27): ?
+SyntaxKind[Identifier](582,28): Yield
+SyntaxKind[CloseBracketToken](582,33): ]
+SyntaxKind[LineTerminatorToken](583,1): «line terminator»
+SyntaxKind[Identifier](583,2): LogicalANDExpression
+SyntaxKind[OpenBracketToken](583,22): [
+SyntaxKind[QuestionToken](583,23): ?
+SyntaxKind[Identifier](583,24): In
+SyntaxKind[CommaToken](583,26): ,
+SyntaxKind[QuestionToken](583,28): ?
+SyntaxKind[Identifier](583,29): Yield
+SyntaxKind[CloseBracketToken](583,34): ]
+SyntaxKind[Terminal](583,36): `&&`
+SyntaxKind[Identifier](583,41): BitwiseORExpression
+SyntaxKind[OpenBracketToken](583,60): [
+SyntaxKind[QuestionToken](583,61): ?
+SyntaxKind[Identifier](583,62): In
+SyntaxKind[CommaToken](583,64): ,
+SyntaxKind[QuestionToken](583,66): ?
+SyntaxKind[Identifier](583,67): Yield
+SyntaxKind[CloseBracketToken](583,72): ]
+SyntaxKind[LineTerminatorToken](584,1): «line terminator»
+SyntaxKind[DedentToken](584,1): «dedent»
+SyntaxKind[LineTerminatorToken](585,1): «line terminator»
+SyntaxKind[Identifier](585,1): LogicalORExpression
+SyntaxKind[OpenBracketToken](585,20): [
+SyntaxKind[Identifier](585,21): In
+SyntaxKind[CommaToken](585,23): ,
+SyntaxKind[Identifier](585,25): Yield
+SyntaxKind[CloseBracketToken](585,30): ]
+SyntaxKind[ColonToken](585,32): :
+SyntaxKind[LineTerminatorToken](586,1): «line terminator»
+SyntaxKind[IndentToken](586,1): «indent»
+SyntaxKind[Identifier](586,2): LogicalANDExpression
+SyntaxKind[OpenBracketToken](586,22): [
+SyntaxKind[QuestionToken](586,23): ?
+SyntaxKind[Identifier](586,24): In
+SyntaxKind[CommaToken](586,26): ,
+SyntaxKind[QuestionToken](586,28): ?
+SyntaxKind[Identifier](586,29): Yield
+SyntaxKind[CloseBracketToken](586,34): ]
+SyntaxKind[LineTerminatorToken](587,1): «line terminator»
+SyntaxKind[Identifier](587,2): LogicalORExpression
+SyntaxKind[OpenBracketToken](587,21): [
+SyntaxKind[QuestionToken](587,22): ?
+SyntaxKind[Identifier](587,23): In
+SyntaxKind[CommaToken](587,25): ,
+SyntaxKind[QuestionToken](587,27): ?
+SyntaxKind[Identifier](587,28): Yield
+SyntaxKind[CloseBracketToken](587,33): ]
+SyntaxKind[Terminal](587,35): `||`
+SyntaxKind[Identifier](587,40): LogicalANDExpression
+SyntaxKind[OpenBracketToken](587,60): [
+SyntaxKind[QuestionToken](587,61): ?
+SyntaxKind[Identifier](587,62): In
+SyntaxKind[CommaToken](587,64): ,
+SyntaxKind[QuestionToken](587,66): ?
+SyntaxKind[Identifier](587,67): Yield
+SyntaxKind[CloseBracketToken](587,72): ]
+SyntaxKind[LineTerminatorToken](588,1): «line terminator»
+SyntaxKind[DedentToken](588,1): «dedent»
+SyntaxKind[LineTerminatorToken](589,1): «line terminator»
+SyntaxKind[Identifier](589,1): ConditionalExpression
+SyntaxKind[OpenBracketToken](589,22): [
+SyntaxKind[Identifier](589,23): In
+SyntaxKind[CommaToken](589,25): ,
+SyntaxKind[Identifier](589,27): Yield
+SyntaxKind[CloseBracketToken](589,32): ]
+SyntaxKind[ColonToken](589,34): :
+SyntaxKind[LineTerminatorToken](590,1): «line terminator»
+SyntaxKind[IndentToken](590,1): «indent»
+SyntaxKind[Identifier](590,2): LogicalORExpression
+SyntaxKind[OpenBracketToken](590,21): [
+SyntaxKind[QuestionToken](590,22): ?
+SyntaxKind[Identifier](590,23): In
+SyntaxKind[CommaToken](590,25): ,
+SyntaxKind[QuestionToken](590,27): ?
+SyntaxKind[Identifier](590,28): Yield
+SyntaxKind[CloseBracketToken](590,33): ]
+SyntaxKind[LineTerminatorToken](591,1): «line terminator»
+SyntaxKind[Identifier](591,2): LogicalORExpression
+SyntaxKind[OpenBracketToken](591,21): [
+SyntaxKind[QuestionToken](591,22): ?
+SyntaxKind[Identifier](591,23): In
+SyntaxKind[CommaToken](591,25): ,
+SyntaxKind[QuestionToken](591,27): ?
+SyntaxKind[Identifier](591,28): Yield
+SyntaxKind[CloseBracketToken](591,33): ]
+SyntaxKind[Terminal](591,35): `?`
+SyntaxKind[Identifier](591,39): AssignmentExpression
+SyntaxKind[OpenBracketToken](591,59): [
+SyntaxKind[Identifier](591,60): In
+SyntaxKind[CommaToken](591,62): ,
+SyntaxKind[QuestionToken](591,64): ?
+SyntaxKind[Identifier](591,65): Yield
+SyntaxKind[CloseBracketToken](591,70): ]
+SyntaxKind[Terminal](591,72): `:`
+SyntaxKind[Identifier](591,76): AssignmentExpression
+SyntaxKind[OpenBracketToken](591,96): [
+SyntaxKind[QuestionToken](591,97): ?
+SyntaxKind[Identifier](591,98): In
+SyntaxKind[CommaToken](591,100): ,
+SyntaxKind[QuestionToken](591,102): ?
+SyntaxKind[Identifier](591,103): Yield
+SyntaxKind[CloseBracketToken](591,108): ]
+SyntaxKind[LineTerminatorToken](592,1): «line terminator»
+SyntaxKind[DedentToken](592,1): «dedent»
+SyntaxKind[LineTerminatorToken](593,1): «line terminator»
+SyntaxKind[Identifier](593,1): AssignmentExpression
+SyntaxKind[OpenBracketToken](593,21): [
+SyntaxKind[Identifier](593,22): In
+SyntaxKind[CommaToken](593,24): ,
+SyntaxKind[Identifier](593,26): Yield
+SyntaxKind[CloseBracketToken](593,31): ]
+SyntaxKind[ColonToken](593,33): :
+SyntaxKind[LineTerminatorToken](594,1): «line terminator»
+SyntaxKind[IndentToken](594,1): «indent»
+SyntaxKind[Identifier](594,2): ConditionalExpression
+SyntaxKind[OpenBracketToken](594,23): [
+SyntaxKind[QuestionToken](594,24): ?
+SyntaxKind[Identifier](594,25): In
+SyntaxKind[CommaToken](594,27): ,
+SyntaxKind[QuestionToken](594,29): ?
+SyntaxKind[Identifier](594,30): Yield
+SyntaxKind[CloseBracketToken](594,35): ]
+SyntaxKind[LineTerminatorToken](595,1): «line terminator»
+SyntaxKind[OpenBracketToken](595,2): [
+SyntaxKind[PlusToken](595,3): +
+SyntaxKind[Identifier](595,4): Yield
+SyntaxKind[CloseBracketToken](595,9): ]
+SyntaxKind[Identifier](595,11): YieldExpression
+SyntaxKind[OpenBracketToken](595,26): [
+SyntaxKind[QuestionToken](595,27): ?
+SyntaxKind[Identifier](595,28): In
+SyntaxKind[CloseBracketToken](595,30): ]
+SyntaxKind[LineTerminatorToken](596,1): «line terminator»
+SyntaxKind[Identifier](596,2): ArrowFunction
+SyntaxKind[OpenBracketToken](596,15): [
+SyntaxKind[QuestionToken](596,16): ?
+SyntaxKind[Identifier](596,17): In
+SyntaxKind[CommaToken](596,19): ,
+SyntaxKind[QuestionToken](596,21): ?
+SyntaxKind[Identifier](596,22): Yield
+SyntaxKind[CloseBracketToken](596,27): ]
+SyntaxKind[LineTerminatorToken](597,1): «line terminator»
+SyntaxKind[Identifier](597,2): LeftHandSideExpression
+SyntaxKind[OpenBracketToken](597,24): [
+SyntaxKind[QuestionToken](597,25): ?
+SyntaxKind[Identifier](597,26): Yield
+SyntaxKind[CloseBracketToken](597,31): ]
+SyntaxKind[Terminal](597,33): `=`
+SyntaxKind[Identifier](597,37): AssignmentExpression
+SyntaxKind[OpenBracketToken](597,57): [
+SyntaxKind[QuestionToken](597,58): ?
+SyntaxKind[Identifier](597,59): In
+SyntaxKind[CommaToken](597,61): ,
+SyntaxKind[QuestionToken](597,63): ?
+SyntaxKind[Identifier](597,64): Yield
+SyntaxKind[CloseBracketToken](597,69): ]
+SyntaxKind[LineTerminatorToken](598,1): «line terminator»
+SyntaxKind[Identifier](598,2): LeftHandSideExpression
+SyntaxKind[OpenBracketToken](598,24): [
+SyntaxKind[QuestionToken](598,25): ?
+SyntaxKind[Identifier](598,26): Yield
+SyntaxKind[CloseBracketToken](598,31): ]
+SyntaxKind[Identifier](598,33): AssignmentOperator
+SyntaxKind[Identifier](598,52): AssignmentExpression
+SyntaxKind[OpenBracketToken](598,72): [
+SyntaxKind[QuestionToken](598,73): ?
+SyntaxKind[Identifier](598,74): In
+SyntaxKind[CommaToken](598,76): ,
+SyntaxKind[QuestionToken](598,78): ?
+SyntaxKind[Identifier](598,79): Yield
+SyntaxKind[CloseBracketToken](598,84): ]
+SyntaxKind[LineTerminatorToken](599,1): «line terminator»
+SyntaxKind[DedentToken](599,1): «dedent»
+SyntaxKind[LineTerminatorToken](600,1): «line terminator»
+SyntaxKind[Identifier](600,1): AssignmentOperator
+SyntaxKind[ColonToken](600,20): :
+SyntaxKind[OneKeyword](600,22): one
+SyntaxKind[OfKeyword](600,26): of
+SyntaxKind[LineTerminatorToken](601,1): «line terminator»
+SyntaxKind[IndentToken](601,1): «indent»
+SyntaxKind[Terminal](601,2): `*=`
+SyntaxKind[Terminal](601,7): `/=`
+SyntaxKind[Terminal](601,12): `%=`
+SyntaxKind[Terminal](601,17): `+=`
+SyntaxKind[Terminal](601,22): `-=`
+SyntaxKind[Terminal](601,27): `<<=`
+SyntaxKind[Terminal](601,33): `>>=`
+SyntaxKind[Terminal](601,39): `>>>=`
+SyntaxKind[Terminal](601,46): `&=`
+SyntaxKind[Terminal](601,51): `^=`
+SyntaxKind[Terminal](601,56): `|=`
+SyntaxKind[LineTerminatorToken](602,1): «line terminator»
+SyntaxKind[DedentToken](602,1): «dedent»
+SyntaxKind[LineTerminatorToken](603,1): «line terminator»
+SyntaxKind[Identifier](603,1): Expression
+SyntaxKind[OpenBracketToken](603,11): [
+SyntaxKind[Identifier](603,12): In
+SyntaxKind[CommaToken](603,14): ,
+SyntaxKind[Identifier](603,16): Yield
+SyntaxKind[CloseBracketToken](603,21): ]
+SyntaxKind[ColonToken](603,23): :
+SyntaxKind[LineTerminatorToken](604,1): «line terminator»
+SyntaxKind[IndentToken](604,1): «indent»
+SyntaxKind[Identifier](604,2): AssignmentExpression
+SyntaxKind[OpenBracketToken](604,22): [
+SyntaxKind[QuestionToken](604,23): ?
+SyntaxKind[Identifier](604,24): In
+SyntaxKind[CommaToken](604,26): ,
+SyntaxKind[QuestionToken](604,28): ?
+SyntaxKind[Identifier](604,29): Yield
+SyntaxKind[CloseBracketToken](604,34): ]
+SyntaxKind[LineTerminatorToken](605,1): «line terminator»
+SyntaxKind[Identifier](605,2): Expression
+SyntaxKind[OpenBracketToken](605,12): [
+SyntaxKind[QuestionToken](605,13): ?
+SyntaxKind[Identifier](605,14): In
+SyntaxKind[CommaToken](605,16): ,
+SyntaxKind[QuestionToken](605,18): ?
+SyntaxKind[Identifier](605,19): Yield
+SyntaxKind[CloseBracketToken](605,24): ]
+SyntaxKind[Terminal](605,26): `,`
+SyntaxKind[Identifier](605,30): AssignmentExpression
+SyntaxKind[OpenBracketToken](605,50): [
+SyntaxKind[QuestionToken](605,51): ?
+SyntaxKind[Identifier](605,52): In
+SyntaxKind[CommaToken](605,54): ,
+SyntaxKind[QuestionToken](605,56): ?
+SyntaxKind[Identifier](605,57): Yield
+SyntaxKind[CloseBracketToken](605,62): ]
+SyntaxKind[LineTerminatorToken](606,1): «line terminator»
+SyntaxKind[DedentToken](606,1): «dedent»
+SyntaxKind[LineTerminatorToken](607,1): «line terminator»
+SyntaxKind[LineTerminatorToken](608,1): «line terminator»
+SyntaxKind[LineTerminatorToken](609,1): «line terminator»
+SyntaxKind[Identifier](609,1): Statement
+SyntaxKind[OpenBracketToken](609,10): [
+SyntaxKind[Identifier](609,11): Yield
+SyntaxKind[CommaToken](609,16): ,
+SyntaxKind[Identifier](609,18): Return
+SyntaxKind[CloseBracketToken](609,24): ]
+SyntaxKind[ColonToken](609,26): :
+SyntaxKind[LineTerminatorToken](610,1): «line terminator»
+SyntaxKind[IndentToken](610,1): «indent»
+SyntaxKind[Identifier](610,2): BlockStatement
+SyntaxKind[OpenBracketToken](610,16): [
+SyntaxKind[QuestionToken](610,17): ?
+SyntaxKind[Identifier](610,18): Yield
+SyntaxKind[CommaToken](610,23): ,
+SyntaxKind[QuestionToken](610,25): ?
+SyntaxKind[Identifier](610,26): Return
+SyntaxKind[CloseBracketToken](610,32): ]
+SyntaxKind[LineTerminatorToken](611,1): «line terminator»
+SyntaxKind[Identifier](611,2): VariableStatement
+SyntaxKind[OpenBracketToken](611,19): [
+SyntaxKind[QuestionToken](611,20): ?
+SyntaxKind[Identifier](611,21): Yield
+SyntaxKind[CloseBracketToken](611,26): ]
+SyntaxKind[LineTerminatorToken](612,1): «line terminator»
+SyntaxKind[Identifier](612,2): EmptyStatement
+SyntaxKind[LineTerminatorToken](613,1): «line terminator»
+SyntaxKind[Identifier](613,2): ExpressionStatement
+SyntaxKind[OpenBracketToken](613,21): [
+SyntaxKind[QuestionToken](613,22): ?
+SyntaxKind[Identifier](613,23): Yield
+SyntaxKind[CloseBracketToken](613,28): ]
+SyntaxKind[LineTerminatorToken](614,1): «line terminator»
+SyntaxKind[Identifier](614,2): IfStatement
+SyntaxKind[OpenBracketToken](614,13): [
+SyntaxKind[QuestionToken](614,14): ?
+SyntaxKind[Identifier](614,15): Yield
+SyntaxKind[CommaToken](614,20): ,
+SyntaxKind[QuestionToken](614,22): ?
+SyntaxKind[Identifier](614,23): Return
+SyntaxKind[CloseBracketToken](614,29): ]
+SyntaxKind[LineTerminatorToken](615,1): «line terminator»
+SyntaxKind[Identifier](615,2): BreakableStatement
+SyntaxKind[OpenBracketToken](615,20): [
+SyntaxKind[QuestionToken](615,21): ?
+SyntaxKind[Identifier](615,22): Yield
+SyntaxKind[CommaToken](615,27): ,
+SyntaxKind[QuestionToken](615,29): ?
+SyntaxKind[Identifier](615,30): Return
+SyntaxKind[CloseBracketToken](615,36): ]
+SyntaxKind[LineTerminatorToken](616,1): «line terminator»
+SyntaxKind[Identifier](616,2): ContinueStatement
+SyntaxKind[OpenBracketToken](616,19): [
+SyntaxKind[QuestionToken](616,20): ?
+SyntaxKind[Identifier](616,21): Yield
+SyntaxKind[CloseBracketToken](616,26): ]
+SyntaxKind[LineTerminatorToken](617,1): «line terminator»
+SyntaxKind[Identifier](617,2): BreakStatement
+SyntaxKind[OpenBracketToken](617,16): [
+SyntaxKind[QuestionToken](617,17): ?
+SyntaxKind[Identifier](617,18): Yield
+SyntaxKind[CloseBracketToken](617,23): ]
+SyntaxKind[LineTerminatorToken](618,1): «line terminator»
+SyntaxKind[OpenBracketToken](618,2): [
+SyntaxKind[PlusToken](618,3): +
+SyntaxKind[Identifier](618,4): Return
+SyntaxKind[CloseBracketToken](618,10): ]
+SyntaxKind[Identifier](618,12): ReturnStatement
+SyntaxKind[OpenBracketToken](618,27): [
+SyntaxKind[QuestionToken](618,28): ?
+SyntaxKind[Identifier](618,29): Yield
+SyntaxKind[CloseBracketToken](618,34): ]
+SyntaxKind[LineTerminatorToken](619,1): «line terminator»
+SyntaxKind[Identifier](619,2): WithStatement
+SyntaxKind[OpenBracketToken](619,15): [
+SyntaxKind[QuestionToken](619,16): ?
+SyntaxKind[Identifier](619,17): Yield
+SyntaxKind[CommaToken](619,22): ,
+SyntaxKind[QuestionToken](619,24): ?
+SyntaxKind[Identifier](619,25): Return
+SyntaxKind[CloseBracketToken](619,31): ]
+SyntaxKind[LineTerminatorToken](620,1): «line terminator»
+SyntaxKind[Identifier](620,2): LabelledStatement
+SyntaxKind[OpenBracketToken](620,19): [
+SyntaxKind[QuestionToken](620,20): ?
+SyntaxKind[Identifier](620,21): Yield
+SyntaxKind[CommaToken](620,26): ,
+SyntaxKind[QuestionToken](620,28): ?
+SyntaxKind[Identifier](620,29): Return
+SyntaxKind[CloseBracketToken](620,35): ]
+SyntaxKind[LineTerminatorToken](621,1): «line terminator»
+SyntaxKind[Identifier](621,2): ThrowStatement
+SyntaxKind[OpenBracketToken](621,16): [
+SyntaxKind[QuestionToken](621,17): ?
+SyntaxKind[Identifier](621,18): Yield
+SyntaxKind[CloseBracketToken](621,23): ]
+SyntaxKind[LineTerminatorToken](622,1): «line terminator»
+SyntaxKind[Identifier](622,2): TryStatement
+SyntaxKind[OpenBracketToken](622,14): [
+SyntaxKind[QuestionToken](622,15): ?
+SyntaxKind[Identifier](622,16): Yield
+SyntaxKind[CommaToken](622,21): ,
+SyntaxKind[QuestionToken](622,23): ?
+SyntaxKind[Identifier](622,24): Return
+SyntaxKind[CloseBracketToken](622,30): ]
+SyntaxKind[LineTerminatorToken](623,1): «line terminator»
+SyntaxKind[Identifier](623,2): DebuggerStatement
+SyntaxKind[LineTerminatorToken](624,1): «line terminator»
+SyntaxKind[DedentToken](624,1): «dedent»
+SyntaxKind[LineTerminatorToken](625,1): «line terminator»
+SyntaxKind[Identifier](625,1): Declaration
+SyntaxKind[OpenBracketToken](625,12): [
+SyntaxKind[Identifier](625,13): Yield
+SyntaxKind[CloseBracketToken](625,18): ]
+SyntaxKind[ColonToken](625,20): :
+SyntaxKind[LineTerminatorToken](626,1): «line terminator»
+SyntaxKind[IndentToken](626,1): «indent»
+SyntaxKind[Identifier](626,2): HoistableDeclaration
+SyntaxKind[OpenBracketToken](626,22): [
+SyntaxKind[QuestionToken](626,23): ?
+SyntaxKind[Identifier](626,24): Yield
+SyntaxKind[CloseBracketToken](626,29): ]
+SyntaxKind[LineTerminatorToken](627,1): «line terminator»
+SyntaxKind[Identifier](627,2): ClassDeclaration
+SyntaxKind[OpenBracketToken](627,18): [
+SyntaxKind[QuestionToken](627,19): ?
+SyntaxKind[Identifier](627,20): Yield
+SyntaxKind[CloseBracketToken](627,25): ]
+SyntaxKind[LineTerminatorToken](628,1): «line terminator»
+SyntaxKind[Identifier](628,2): LexicalDeclaration
+SyntaxKind[OpenBracketToken](628,20): [
+SyntaxKind[Identifier](628,21): In
+SyntaxKind[CommaToken](628,23): ,
+SyntaxKind[QuestionToken](628,25): ?
+SyntaxKind[Identifier](628,26): Yield
+SyntaxKind[CloseBracketToken](628,31): ]
+SyntaxKind[LineTerminatorToken](629,1): «line terminator»
+SyntaxKind[DedentToken](629,1): «dedent»
+SyntaxKind[LineTerminatorToken](630,1): «line terminator»
+SyntaxKind[Identifier](630,1): HoistableDeclaration
+SyntaxKind[OpenBracketToken](630,21): [
+SyntaxKind[Identifier](630,22): Yield
+SyntaxKind[CommaToken](630,27): ,
+SyntaxKind[Identifier](630,29): Default
+SyntaxKind[CloseBracketToken](630,36): ]
+SyntaxKind[ColonToken](630,38): :
+SyntaxKind[LineTerminatorToken](631,1): «line terminator»
+SyntaxKind[IndentToken](631,1): «indent»
+SyntaxKind[Identifier](631,2): FunctionDeclaration
+SyntaxKind[OpenBracketToken](631,21): [
+SyntaxKind[QuestionToken](631,22): ?
+SyntaxKind[Identifier](631,23): Yield
+SyntaxKind[CommaToken](631,28): ,
+SyntaxKind[QuestionToken](631,30): ?
+SyntaxKind[Identifier](631,31): Default
+SyntaxKind[CloseBracketToken](631,38): ]
+SyntaxKind[LineTerminatorToken](632,1): «line terminator»
+SyntaxKind[Identifier](632,2): GeneratorDeclaration
+SyntaxKind[OpenBracketToken](632,22): [
+SyntaxKind[QuestionToken](632,23): ?
+SyntaxKind[Identifier](632,24): Yield
+SyntaxKind[CommaToken](632,29): ,
+SyntaxKind[QuestionToken](632,31): ?
+SyntaxKind[Identifier](632,32): Default
+SyntaxKind[CloseBracketToken](632,39): ]
+SyntaxKind[LineTerminatorToken](633,1): «line terminator»
+SyntaxKind[DedentToken](633,1): «dedent»
+SyntaxKind[LineTerminatorToken](634,1): «line terminator»
+SyntaxKind[Identifier](634,1): BreakableStatement
+SyntaxKind[OpenBracketToken](634,19): [
+SyntaxKind[Identifier](634,20): Yield
+SyntaxKind[CommaToken](634,25): ,
+SyntaxKind[Identifier](634,27): Return
+SyntaxKind[CloseBracketToken](634,33): ]
+SyntaxKind[ColonToken](634,35): :
+SyntaxKind[LineTerminatorToken](635,1): «line terminator»
+SyntaxKind[IndentToken](635,1): «indent»
+SyntaxKind[Identifier](635,2): IterationStatement
+SyntaxKind[OpenBracketToken](635,20): [
+SyntaxKind[QuestionToken](635,21): ?
+SyntaxKind[Identifier](635,22): Yield
+SyntaxKind[CommaToken](635,27): ,
+SyntaxKind[QuestionToken](635,29): ?
+SyntaxKind[Identifier](635,30): Return
+SyntaxKind[CloseBracketToken](635,36): ]
+SyntaxKind[LineTerminatorToken](636,1): «line terminator»
+SyntaxKind[Identifier](636,2): SwitchStatement
+SyntaxKind[OpenBracketToken](636,17): [
+SyntaxKind[QuestionToken](636,18): ?
+SyntaxKind[Identifier](636,19): Yield
+SyntaxKind[CommaToken](636,24): ,
+SyntaxKind[QuestionToken](636,26): ?
+SyntaxKind[Identifier](636,27): Return
+SyntaxKind[CloseBracketToken](636,33): ]
+SyntaxKind[LineTerminatorToken](637,1): «line terminator»
+SyntaxKind[DedentToken](637,1): «dedent»
+SyntaxKind[LineTerminatorToken](638,1): «line terminator»
+SyntaxKind[Identifier](638,1): BlockStatement
+SyntaxKind[OpenBracketToken](638,15): [
+SyntaxKind[Identifier](638,16): Yield
+SyntaxKind[CommaToken](638,21): ,
+SyntaxKind[Identifier](638,23): Return
+SyntaxKind[CloseBracketToken](638,29): ]
+SyntaxKind[ColonToken](638,31): :
+SyntaxKind[LineTerminatorToken](639,1): «line terminator»
+SyntaxKind[IndentToken](639,1): «indent»
+SyntaxKind[Identifier](639,2): Block
+SyntaxKind[OpenBracketToken](639,7): [
+SyntaxKind[QuestionToken](639,8): ?
+SyntaxKind[Identifier](639,9): Yield
+SyntaxKind[CommaToken](639,14): ,
+SyntaxKind[QuestionToken](639,16): ?
+SyntaxKind[Identifier](639,17): Return
+SyntaxKind[CloseBracketToken](639,23): ]
+SyntaxKind[LineTerminatorToken](640,1): «line terminator»
+SyntaxKind[DedentToken](640,1): «dedent»
+SyntaxKind[LineTerminatorToken](641,1): «line terminator»
+SyntaxKind[Identifier](641,1): Block
+SyntaxKind[OpenBracketToken](641,6): [
+SyntaxKind[Identifier](641,7): Yield
+SyntaxKind[CommaToken](641,12): ,
+SyntaxKind[Identifier](641,14): Return
+SyntaxKind[CloseBracketToken](641,20): ]
+SyntaxKind[ColonToken](641,22): :
+SyntaxKind[LineTerminatorToken](642,1): «line terminator»
+SyntaxKind[IndentToken](642,1): «indent»
+SyntaxKind[Terminal](642,2): `{`
+SyntaxKind[Identifier](642,6): StatementList
+SyntaxKind[OpenBracketToken](642,19): [
+SyntaxKind[QuestionToken](642,20): ?
+SyntaxKind[Identifier](642,21): Yield
+SyntaxKind[CommaToken](642,26): ,
+SyntaxKind[QuestionToken](642,28): ?
+SyntaxKind[Identifier](642,29): Return
+SyntaxKind[CloseBracketToken](642,35): ]
+SyntaxKind[QuestionToken](642,36): ?
+SyntaxKind[Terminal](642,38): `}`
+SyntaxKind[LineTerminatorToken](643,1): «line terminator»
+SyntaxKind[DedentToken](643,1): «dedent»
+SyntaxKind[LineTerminatorToken](644,1): «line terminator»
+SyntaxKind[Identifier](644,1): StatementList
+SyntaxKind[OpenBracketToken](644,14): [
+SyntaxKind[Identifier](644,15): Yield
+SyntaxKind[CommaToken](644,20): ,
+SyntaxKind[Identifier](644,22): Return
+SyntaxKind[CloseBracketToken](644,28): ]
+SyntaxKind[ColonToken](644,30): :
+SyntaxKind[LineTerminatorToken](645,1): «line terminator»
+SyntaxKind[IndentToken](645,1): «indent»
+SyntaxKind[Identifier](645,2): StatementListItem
+SyntaxKind[OpenBracketToken](645,19): [
+SyntaxKind[QuestionToken](645,20): ?
+SyntaxKind[Identifier](645,21): Yield
+SyntaxKind[CommaToken](645,26): ,
+SyntaxKind[QuestionToken](645,28): ?
+SyntaxKind[Identifier](645,29): Return
+SyntaxKind[CloseBracketToken](645,35): ]
+SyntaxKind[LineTerminatorToken](646,1): «line terminator»
+SyntaxKind[Identifier](646,2): StatementList
+SyntaxKind[OpenBracketToken](646,15): [
+SyntaxKind[QuestionToken](646,16): ?
+SyntaxKind[Identifier](646,17): Yield
+SyntaxKind[CommaToken](646,22): ,
+SyntaxKind[QuestionToken](646,24): ?
+SyntaxKind[Identifier](646,25): Return
+SyntaxKind[CloseBracketToken](646,31): ]
+SyntaxKind[Identifier](646,33): StatementListItem
+SyntaxKind[OpenBracketToken](646,50): [
+SyntaxKind[QuestionToken](646,51): ?
+SyntaxKind[Identifier](646,52): Yield
+SyntaxKind[CommaToken](646,57): ,
+SyntaxKind[QuestionToken](646,59): ?
+SyntaxKind[Identifier](646,60): Return
+SyntaxKind[CloseBracketToken](646,66): ]
+SyntaxKind[LineTerminatorToken](647,1): «line terminator»
+SyntaxKind[DedentToken](647,1): «dedent»
+SyntaxKind[LineTerminatorToken](648,1): «line terminator»
+SyntaxKind[Identifier](648,1): StatementListItem
+SyntaxKind[OpenBracketToken](648,18): [
+SyntaxKind[Identifier](648,19): Yield
+SyntaxKind[CommaToken](648,24): ,
+SyntaxKind[Identifier](648,26): Return
+SyntaxKind[CloseBracketToken](648,32): ]
+SyntaxKind[ColonToken](648,34): :
+SyntaxKind[LineTerminatorToken](649,1): «line terminator»
+SyntaxKind[IndentToken](649,1): «indent»
+SyntaxKind[Identifier](649,2): Statement
+SyntaxKind[OpenBracketToken](649,11): [
+SyntaxKind[QuestionToken](649,12): ?
+SyntaxKind[Identifier](649,13): Yield
+SyntaxKind[CommaToken](649,18): ,
+SyntaxKind[QuestionToken](649,20): ?
+SyntaxKind[Identifier](649,21): Return
+SyntaxKind[CloseBracketToken](649,27): ]
+SyntaxKind[LineTerminatorToken](650,1): «line terminator»
+SyntaxKind[Identifier](650,2): Declaration
+SyntaxKind[OpenBracketToken](650,13): [
+SyntaxKind[QuestionToken](650,14): ?
+SyntaxKind[Identifier](650,15): Yield
+SyntaxKind[CloseBracketToken](650,20): ]
+SyntaxKind[LineTerminatorToken](651,1): «line terminator»
+SyntaxKind[DedentToken](651,1): «dedent»
+SyntaxKind[LineTerminatorToken](652,1): «line terminator»
+SyntaxKind[Identifier](652,1): LexicalDeclaration
+SyntaxKind[OpenBracketToken](652,19): [
+SyntaxKind[Identifier](652,20): In
+SyntaxKind[CommaToken](652,22): ,
+SyntaxKind[Identifier](652,24): Yield
+SyntaxKind[CloseBracketToken](652,29): ]
+SyntaxKind[ColonToken](652,31): :
+SyntaxKind[LineTerminatorToken](653,1): «line terminator»
+SyntaxKind[IndentToken](653,1): «indent»
+SyntaxKind[Identifier](653,2): LetOrConst
+SyntaxKind[Identifier](653,13): BindingList
+SyntaxKind[OpenBracketToken](653,24): [
+SyntaxKind[QuestionToken](653,25): ?
+SyntaxKind[Identifier](653,26): In
+SyntaxKind[CommaToken](653,28): ,
+SyntaxKind[QuestionToken](653,30): ?
+SyntaxKind[Identifier](653,31): Yield
+SyntaxKind[CloseBracketToken](653,36): ]
+SyntaxKind[Terminal](653,38): `;`
+SyntaxKind[LineTerminatorToken](654,1): «line terminator»
+SyntaxKind[DedentToken](654,1): «dedent»
+SyntaxKind[LineTerminatorToken](655,1): «line terminator»
+SyntaxKind[Identifier](655,1): LetOrConst
+SyntaxKind[ColonToken](655,12): :
+SyntaxKind[LineTerminatorToken](656,1): «line terminator»
+SyntaxKind[IndentToken](656,1): «indent»
+SyntaxKind[Terminal](656,2): `let`
+SyntaxKind[LineTerminatorToken](657,1): «line terminator»
+SyntaxKind[Terminal](657,2): `const`
+SyntaxKind[LineTerminatorToken](658,1): «line terminator»
+SyntaxKind[DedentToken](658,1): «dedent»
+SyntaxKind[LineTerminatorToken](659,1): «line terminator»
+SyntaxKind[Identifier](659,1): BindingList
+SyntaxKind[OpenBracketToken](659,12): [
+SyntaxKind[Identifier](659,13): In
+SyntaxKind[CommaToken](659,15): ,
+SyntaxKind[Identifier](659,17): Yield
+SyntaxKind[CloseBracketToken](659,22): ]
+SyntaxKind[ColonToken](659,24): :
+SyntaxKind[LineTerminatorToken](660,1): «line terminator»
+SyntaxKind[IndentToken](660,1): «indent»
+SyntaxKind[Identifier](660,2): LexicalBinding
+SyntaxKind[OpenBracketToken](660,16): [
+SyntaxKind[QuestionToken](660,17): ?
+SyntaxKind[Identifier](660,18): In
+SyntaxKind[CommaToken](660,20): ,
+SyntaxKind[QuestionToken](660,22): ?
+SyntaxKind[Identifier](660,23): Yield
+SyntaxKind[CloseBracketToken](660,28): ]
+SyntaxKind[LineTerminatorToken](661,1): «line terminator»
+SyntaxKind[Identifier](661,2): BindingList
+SyntaxKind[OpenBracketToken](661,13): [
+SyntaxKind[QuestionToken](661,14): ?
+SyntaxKind[Identifier](661,15): In
+SyntaxKind[CommaToken](661,17): ,
+SyntaxKind[QuestionToken](661,19): ?
+SyntaxKind[Identifier](661,20): Yield
+SyntaxKind[CloseBracketToken](661,25): ]
+SyntaxKind[Terminal](661,27): `,`
+SyntaxKind[Identifier](661,31): LexicalBinding
+SyntaxKind[OpenBracketToken](661,45): [
+SyntaxKind[QuestionToken](661,46): ?
+SyntaxKind[Identifier](661,47): In
+SyntaxKind[CommaToken](661,49): ,
+SyntaxKind[QuestionToken](661,51): ?
+SyntaxKind[Identifier](661,52): Yield
+SyntaxKind[CloseBracketToken](661,57): ]
+SyntaxKind[LineTerminatorToken](662,1): «line terminator»
+SyntaxKind[DedentToken](662,1): «dedent»
+SyntaxKind[LineTerminatorToken](663,1): «line terminator»
+SyntaxKind[Identifier](663,1): LexicalBinding
+SyntaxKind[OpenBracketToken](663,15): [
+SyntaxKind[Identifier](663,16): In
+SyntaxKind[CommaToken](663,18): ,
+SyntaxKind[Identifier](663,20): Yield
+SyntaxKind[CloseBracketToken](663,25): ]
+SyntaxKind[ColonToken](663,28): :
+SyntaxKind[LineTerminatorToken](664,1): «line terminator»
+SyntaxKind[IndentToken](664,1): «indent»
+SyntaxKind[Identifier](664,2): BindingIdentifier
+SyntaxKind[OpenBracketToken](664,19): [
+SyntaxKind[QuestionToken](664,20): ?
+SyntaxKind[Identifier](664,21): Yield
+SyntaxKind[CloseBracketToken](664,26): ]
+SyntaxKind[Identifier](664,28): Initializer
+SyntaxKind[OpenBracketToken](664,39): [
+SyntaxKind[QuestionToken](664,40): ?
+SyntaxKind[Identifier](664,41): In
+SyntaxKind[CommaToken](664,43): ,
+SyntaxKind[QuestionToken](664,45): ?
+SyntaxKind[Identifier](664,46): Yield
+SyntaxKind[CloseBracketToken](664,51): ]
+SyntaxKind[QuestionToken](664,52): ?
+SyntaxKind[LineTerminatorToken](665,1): «line terminator»
+SyntaxKind[Identifier](665,2): BindingPattern
+SyntaxKind[OpenBracketToken](665,16): [
+SyntaxKind[QuestionToken](665,17): ?
+SyntaxKind[Identifier](665,18): Yield
+SyntaxKind[CloseBracketToken](665,23): ]
+SyntaxKind[Identifier](665,25): Initializer
+SyntaxKind[OpenBracketToken](665,36): [
+SyntaxKind[QuestionToken](665,37): ?
+SyntaxKind[Identifier](665,38): In
+SyntaxKind[CommaToken](665,40): ,
+SyntaxKind[QuestionToken](665,42): ?
+SyntaxKind[Identifier](665,43): Yield
+SyntaxKind[CloseBracketToken](665,48): ]
+SyntaxKind[LineTerminatorToken](666,1): «line terminator»
+SyntaxKind[DedentToken](666,1): «dedent»
+SyntaxKind[LineTerminatorToken](667,1): «line terminator»
+SyntaxKind[Identifier](667,1): VariableStatement
+SyntaxKind[OpenBracketToken](667,18): [
+SyntaxKind[Identifier](667,19): Yield
+SyntaxKind[CloseBracketToken](667,24): ]
+SyntaxKind[ColonToken](667,26): :
+SyntaxKind[LineTerminatorToken](668,1): «line terminator»
+SyntaxKind[IndentToken](668,1): «indent»
+SyntaxKind[Terminal](668,2): `var`
+SyntaxKind[Identifier](668,8): VariableDeclarationList
+SyntaxKind[OpenBracketToken](668,31): [
+SyntaxKind[Identifier](668,32): In
+SyntaxKind[CommaToken](668,34): ,
+SyntaxKind[QuestionToken](668,36): ?
+SyntaxKind[Identifier](668,37): Yield
+SyntaxKind[CloseBracketToken](668,42): ]
+SyntaxKind[Terminal](668,44): `;`
+SyntaxKind[LineTerminatorToken](669,1): «line terminator»
+SyntaxKind[DedentToken](669,1): «dedent»
+SyntaxKind[LineTerminatorToken](670,1): «line terminator»
+SyntaxKind[Identifier](670,1): VariableDeclarationList
+SyntaxKind[OpenBracketToken](670,24): [
+SyntaxKind[Identifier](670,25): In
+SyntaxKind[CommaToken](670,27): ,
+SyntaxKind[Identifier](670,29): Yield
+SyntaxKind[CloseBracketToken](670,34): ]
+SyntaxKind[ColonToken](670,36): :
+SyntaxKind[LineTerminatorToken](671,1): «line terminator»
+SyntaxKind[IndentToken](671,1): «indent»
+SyntaxKind[Identifier](671,2): VariableDeclaration
+SyntaxKind[OpenBracketToken](671,21): [
+SyntaxKind[QuestionToken](671,22): ?
+SyntaxKind[Identifier](671,23): In
+SyntaxKind[CommaToken](671,25): ,
+SyntaxKind[QuestionToken](671,27): ?
+SyntaxKind[Identifier](671,28): Yield
+SyntaxKind[CloseBracketToken](671,33): ]
+SyntaxKind[LineTerminatorToken](672,1): «line terminator»
+SyntaxKind[Identifier](672,2): VariableDeclarationList
+SyntaxKind[OpenBracketToken](672,25): [
+SyntaxKind[QuestionToken](672,26): ?
+SyntaxKind[Identifier](672,27): In
+SyntaxKind[CommaToken](672,29): ,
+SyntaxKind[QuestionToken](672,31): ?
+SyntaxKind[Identifier](672,32): Yield
+SyntaxKind[CloseBracketToken](672,37): ]
+SyntaxKind[Terminal](672,39): `,`
+SyntaxKind[Identifier](672,43): VariableDeclaration
+SyntaxKind[OpenBracketToken](672,62): [
+SyntaxKind[QuestionToken](672,63): ?
+SyntaxKind[Identifier](672,64): In
+SyntaxKind[CommaToken](672,66): ,
+SyntaxKind[QuestionToken](672,68): ?
+SyntaxKind[Identifier](672,69): Yield
+SyntaxKind[CloseBracketToken](672,74): ]
+SyntaxKind[LineTerminatorToken](673,1): «line terminator»
+SyntaxKind[DedentToken](673,1): «dedent»
+SyntaxKind[LineTerminatorToken](674,1): «line terminator»
+SyntaxKind[Identifier](674,1): VariableDeclaration
+SyntaxKind[OpenBracketToken](674,20): [
+SyntaxKind[Identifier](674,21): In
+SyntaxKind[CommaToken](674,23): ,
+SyntaxKind[Identifier](674,25): Yield
+SyntaxKind[CloseBracketToken](674,30): ]
+SyntaxKind[ColonToken](674,32): :
+SyntaxKind[LineTerminatorToken](675,1): «line terminator»
+SyntaxKind[IndentToken](675,1): «indent»
+SyntaxKind[Identifier](675,2): BindingIdentifier
+SyntaxKind[OpenBracketToken](675,19): [
+SyntaxKind[QuestionToken](675,20): ?
+SyntaxKind[Identifier](675,21): Yield
+SyntaxKind[CloseBracketToken](675,26): ]
+SyntaxKind[Identifier](675,28): Initializer
+SyntaxKind[OpenBracketToken](675,39): [
+SyntaxKind[QuestionToken](675,40): ?
+SyntaxKind[Identifier](675,41): In
+SyntaxKind[CommaToken](675,43): ,
+SyntaxKind[QuestionToken](675,45): ?
+SyntaxKind[Identifier](675,46): Yield
+SyntaxKind[CloseBracketToken](675,51): ]
+SyntaxKind[QuestionToken](675,52): ?
+SyntaxKind[LineTerminatorToken](676,1): «line terminator»
+SyntaxKind[Identifier](676,2): BindingPattern
+SyntaxKind[OpenBracketToken](676,16): [
+SyntaxKind[QuestionToken](676,17): ?
+SyntaxKind[Identifier](676,18): Yield
+SyntaxKind[CloseBracketToken](676,23): ]
+SyntaxKind[Identifier](676,25): Initializer
+SyntaxKind[OpenBracketToken](676,36): [
+SyntaxKind[QuestionToken](676,37): ?
+SyntaxKind[Identifier](676,38): In
+SyntaxKind[CommaToken](676,40): ,
+SyntaxKind[QuestionToken](676,42): ?
+SyntaxKind[Identifier](676,43): Yield
+SyntaxKind[CloseBracketToken](676,48): ]
+SyntaxKind[LineTerminatorToken](677,1): «line terminator»
+SyntaxKind[DedentToken](677,1): «dedent»
+SyntaxKind[LineTerminatorToken](678,1): «line terminator»
+SyntaxKind[Identifier](678,1): BindingPattern
+SyntaxKind[OpenBracketToken](678,15): [
+SyntaxKind[Identifier](678,16): Yield
+SyntaxKind[CloseBracketToken](678,21): ]
+SyntaxKind[ColonToken](678,23): :
+SyntaxKind[LineTerminatorToken](679,1): «line terminator»
+SyntaxKind[IndentToken](679,1): «indent»
+SyntaxKind[Identifier](679,2): ObjectBindingPattern
+SyntaxKind[OpenBracketToken](679,22): [
+SyntaxKind[QuestionToken](679,23): ?
+SyntaxKind[Identifier](679,24): Yield
+SyntaxKind[CloseBracketToken](679,29): ]
+SyntaxKind[LineTerminatorToken](680,1): «line terminator»
+SyntaxKind[Identifier](680,2): ArrayBindingPattern
+SyntaxKind[OpenBracketToken](680,21): [
+SyntaxKind[QuestionToken](680,22): ?
+SyntaxKind[Identifier](680,23): Yield
+SyntaxKind[CloseBracketToken](680,28): ]
+SyntaxKind[LineTerminatorToken](681,1): «line terminator»
+SyntaxKind[DedentToken](681,1): «dedent»
+SyntaxKind[LineTerminatorToken](682,1): «line terminator»
+SyntaxKind[Identifier](682,1): ObjectBindingPattern
+SyntaxKind[OpenBracketToken](682,21): [
+SyntaxKind[Identifier](682,22): Yield
+SyntaxKind[CloseBracketToken](682,27): ]
+SyntaxKind[ColonToken](682,29): :
+SyntaxKind[LineTerminatorToken](683,1): «line terminator»
+SyntaxKind[IndentToken](683,1): «indent»
+SyntaxKind[Terminal](683,2): `{`
+SyntaxKind[Terminal](683,6): `}`
+SyntaxKind[LineTerminatorToken](684,1): «line terminator»
+SyntaxKind[Terminal](684,2): `{`
+SyntaxKind[Identifier](684,6): BindingPropertyList
+SyntaxKind[OpenBracketToken](684,25): [
+SyntaxKind[QuestionToken](684,26): ?
+SyntaxKind[Identifier](684,27): Yield
+SyntaxKind[CloseBracketToken](684,32): ]
+SyntaxKind[Terminal](684,34): `}`
+SyntaxKind[LineTerminatorToken](685,1): «line terminator»
+SyntaxKind[Terminal](685,2): `{`
+SyntaxKind[Identifier](685,6): BindingPropertyList
+SyntaxKind[OpenBracketToken](685,25): [
+SyntaxKind[QuestionToken](685,26): ?
+SyntaxKind[Identifier](685,27): Yield
+SyntaxKind[CloseBracketToken](685,32): ]
+SyntaxKind[Terminal](685,34): `,`
+SyntaxKind[Terminal](685,38): `}`
+SyntaxKind[LineTerminatorToken](686,1): «line terminator»
+SyntaxKind[DedentToken](686,1): «dedent»
+SyntaxKind[LineTerminatorToken](687,1): «line terminator»
+SyntaxKind[Identifier](687,1): ArrayBindingPattern
+SyntaxKind[OpenBracketToken](687,20): [
+SyntaxKind[Identifier](687,21): Yield
+SyntaxKind[CloseBracketToken](687,26): ]
+SyntaxKind[ColonToken](687,28): :
+SyntaxKind[LineTerminatorToken](688,1): «line terminator»
+SyntaxKind[IndentToken](688,1): «indent»
+SyntaxKind[Terminal](688,2): `[`
+SyntaxKind[Identifier](688,6): Elision
+SyntaxKind[QuestionToken](688,13): ?
+SyntaxKind[Identifier](688,15): BindingRestElement
+SyntaxKind[OpenBracketToken](688,33): [
+SyntaxKind[QuestionToken](688,34): ?
+SyntaxKind[Identifier](688,35): Yield
+SyntaxKind[CloseBracketToken](688,40): ]
+SyntaxKind[QuestionToken](688,41): ?
+SyntaxKind[Terminal](688,43): `]`
+SyntaxKind[LineTerminatorToken](689,1): «line terminator»
+SyntaxKind[Terminal](689,2): `[`
+SyntaxKind[Identifier](689,6): BindingElementList
+SyntaxKind[OpenBracketToken](689,24): [
+SyntaxKind[QuestionToken](689,25): ?
+SyntaxKind[Identifier](689,26): Yield
+SyntaxKind[CloseBracketToken](689,31): ]
+SyntaxKind[Terminal](689,33): `]`
+SyntaxKind[LineTerminatorToken](690,1): «line terminator»
+SyntaxKind[Terminal](690,2): `[`
+SyntaxKind[Identifier](690,6): BindingElementList
+SyntaxKind[OpenBracketToken](690,24): [
+SyntaxKind[QuestionToken](690,25): ?
+SyntaxKind[Identifier](690,26): Yield
+SyntaxKind[CloseBracketToken](690,31): ]
+SyntaxKind[Terminal](690,33): `,`
+SyntaxKind[Identifier](690,37): Elision
+SyntaxKind[QuestionToken](690,44): ?
+SyntaxKind[Identifier](690,46): BindingRestElement
+SyntaxKind[OpenBracketToken](690,64): [
+SyntaxKind[QuestionToken](690,65): ?
+SyntaxKind[Identifier](690,66): Yield
+SyntaxKind[CloseBracketToken](690,71): ]
+SyntaxKind[QuestionToken](690,72): ?
+SyntaxKind[Terminal](690,74): `]`
+SyntaxKind[LineTerminatorToken](691,1): «line terminator»
+SyntaxKind[DedentToken](691,1): «dedent»
+SyntaxKind[LineTerminatorToken](692,1): «line terminator»
+SyntaxKind[Identifier](692,1): BindingPropertyList
+SyntaxKind[OpenBracketToken](692,20): [
+SyntaxKind[Identifier](692,21): Yield
+SyntaxKind[CloseBracketToken](692,26): ]
+SyntaxKind[ColonToken](692,28): :
+SyntaxKind[LineTerminatorToken](693,1): «line terminator»
+SyntaxKind[IndentToken](693,1): «indent»
+SyntaxKind[Identifier](693,2): BindingProperty
+SyntaxKind[OpenBracketToken](693,17): [
+SyntaxKind[QuestionToken](693,18): ?
+SyntaxKind[Identifier](693,19): Yield
+SyntaxKind[CloseBracketToken](693,24): ]
+SyntaxKind[LineTerminatorToken](694,1): «line terminator»
+SyntaxKind[Identifier](694,2): BindingPropertyList
+SyntaxKind[OpenBracketToken](694,21): [
+SyntaxKind[QuestionToken](694,22): ?
+SyntaxKind[Identifier](694,23): Yield
+SyntaxKind[CloseBracketToken](694,28): ]
+SyntaxKind[Terminal](694,30): `,`
+SyntaxKind[Identifier](694,34): BindingProperty
+SyntaxKind[OpenBracketToken](694,49): [
+SyntaxKind[QuestionToken](694,50): ?
+SyntaxKind[Identifier](694,51): Yield
+SyntaxKind[CloseBracketToken](694,56): ]
+SyntaxKind[LineTerminatorToken](695,1): «line terminator»
+SyntaxKind[DedentToken](695,1): «dedent»
+SyntaxKind[LineTerminatorToken](696,1): «line terminator»
+SyntaxKind[Identifier](696,1): BindingElementList
+SyntaxKind[OpenBracketToken](696,19): [
+SyntaxKind[Identifier](696,20): Yield
+SyntaxKind[CloseBracketToken](696,25): ]
+SyntaxKind[ColonToken](696,27): :
+SyntaxKind[LineTerminatorToken](697,1): «line terminator»
+SyntaxKind[IndentToken](697,1): «indent»
+SyntaxKind[Identifier](697,2): BindingElisionElement
+SyntaxKind[OpenBracketToken](697,23): [
+SyntaxKind[QuestionToken](697,24): ?
+SyntaxKind[Identifier](697,25): Yield
+SyntaxKind[CloseBracketToken](697,30): ]
+SyntaxKind[LineTerminatorToken](698,1): «line terminator»
+SyntaxKind[Identifier](698,2): BindingElementList
+SyntaxKind[OpenBracketToken](698,20): [
+SyntaxKind[QuestionToken](698,21): ?
+SyntaxKind[Identifier](698,22): Yield
+SyntaxKind[CloseBracketToken](698,27): ]
+SyntaxKind[Terminal](698,29): `,`
+SyntaxKind[Identifier](698,33): BindingElisionElement
+SyntaxKind[OpenBracketToken](698,54): [
+SyntaxKind[QuestionToken](698,55): ?
+SyntaxKind[Identifier](698,56): Yield
+SyntaxKind[CloseBracketToken](698,61): ]
+SyntaxKind[LineTerminatorToken](699,1): «line terminator»
+SyntaxKind[DedentToken](699,1): «dedent»
+SyntaxKind[LineTerminatorToken](700,1): «line terminator»
+SyntaxKind[Identifier](700,1): BindingElisionElement
+SyntaxKind[OpenBracketToken](700,22): [
+SyntaxKind[Identifier](700,23): Yield
+SyntaxKind[CloseBracketToken](700,28): ]
+SyntaxKind[ColonToken](700,30): :
+SyntaxKind[LineTerminatorToken](701,1): «line terminator»
+SyntaxKind[IndentToken](701,1): «indent»
+SyntaxKind[Identifier](701,2): Elision
+SyntaxKind[QuestionToken](701,9): ?
+SyntaxKind[Identifier](701,11): BindingElement
+SyntaxKind[OpenBracketToken](701,25): [
+SyntaxKind[QuestionToken](701,26): ?
+SyntaxKind[Identifier](701,27): Yield
+SyntaxKind[CloseBracketToken](701,32): ]
+SyntaxKind[LineTerminatorToken](702,1): «line terminator»
+SyntaxKind[DedentToken](702,1): «dedent»
+SyntaxKind[LineTerminatorToken](703,1): «line terminator»
+SyntaxKind[Identifier](703,1): BindingProperty
+SyntaxKind[OpenBracketToken](703,16): [
+SyntaxKind[Identifier](703,17): Yield
+SyntaxKind[CloseBracketToken](703,22): ]
+SyntaxKind[ColonToken](703,24): :
+SyntaxKind[LineTerminatorToken](704,1): «line terminator»
+SyntaxKind[IndentToken](704,1): «indent»
+SyntaxKind[Identifier](704,2): SingleNameBinding
+SyntaxKind[OpenBracketToken](704,19): [
+SyntaxKind[QuestionToken](704,20): ?
+SyntaxKind[Identifier](704,21): Yield
+SyntaxKind[CloseBracketToken](704,26): ]
+SyntaxKind[LineTerminatorToken](705,1): «line terminator»
+SyntaxKind[Identifier](705,2): PropertyName
+SyntaxKind[OpenBracketToken](705,14): [
+SyntaxKind[QuestionToken](705,15): ?
+SyntaxKind[Identifier](705,16): Yield
+SyntaxKind[CloseBracketToken](705,21): ]
+SyntaxKind[Terminal](705,23): `:`
+SyntaxKind[Identifier](705,27): BindingElement
+SyntaxKind[OpenBracketToken](705,41): [
+SyntaxKind[QuestionToken](705,42): ?
+SyntaxKind[Identifier](705,43): Yield
+SyntaxKind[CloseBracketToken](705,48): ]
+SyntaxKind[LineTerminatorToken](706,1): «line terminator»
+SyntaxKind[DedentToken](706,1): «dedent»
+SyntaxKind[LineTerminatorToken](707,1): «line terminator»
+SyntaxKind[Identifier](707,1): BindingElement
+SyntaxKind[OpenBracketToken](707,15): [
+SyntaxKind[Identifier](707,16): Yield
+SyntaxKind[CloseBracketToken](707,21): ]
+SyntaxKind[ColonToken](707,23): :
+SyntaxKind[LineTerminatorToken](708,1): «line terminator»
+SyntaxKind[IndentToken](708,1): «indent»
+SyntaxKind[Identifier](708,2): SingleNameBinding
+SyntaxKind[OpenBracketToken](708,19): [
+SyntaxKind[QuestionToken](708,20): ?
+SyntaxKind[Identifier](708,21): Yield
+SyntaxKind[CloseBracketToken](708,26): ]
+SyntaxKind[LineTerminatorToken](709,1): «line terminator»
+SyntaxKind[Identifier](709,2): BindingPattern
+SyntaxKind[OpenBracketToken](709,16): [
+SyntaxKind[QuestionToken](709,17): ?
+SyntaxKind[Identifier](709,18): Yield
+SyntaxKind[CloseBracketToken](709,23): ]
+SyntaxKind[Identifier](709,25): Initializer
+SyntaxKind[OpenBracketToken](709,36): [
+SyntaxKind[Identifier](709,37): In
+SyntaxKind[CommaToken](709,39): ,
+SyntaxKind[QuestionToken](709,41): ?
+SyntaxKind[Identifier](709,42): Yield
+SyntaxKind[CloseBracketToken](709,47): ]
+SyntaxKind[QuestionToken](709,48): ?
+SyntaxKind[LineTerminatorToken](710,1): «line terminator»
+SyntaxKind[DedentToken](710,1): «dedent»
+SyntaxKind[LineTerminatorToken](711,1): «line terminator»
+SyntaxKind[Identifier](711,1): SingleNameBinding
+SyntaxKind[OpenBracketToken](711,18): [
+SyntaxKind[Identifier](711,19): Yield
+SyntaxKind[CloseBracketToken](711,24): ]
+SyntaxKind[ColonToken](711,26): :
+SyntaxKind[LineTerminatorToken](712,1): «line terminator»
+SyntaxKind[IndentToken](712,1): «indent»
+SyntaxKind[Identifier](712,2): BindingIdentifier
+SyntaxKind[OpenBracketToken](712,19): [
+SyntaxKind[QuestionToken](712,20): ?
+SyntaxKind[Identifier](712,21): Yield
+SyntaxKind[CloseBracketToken](712,26): ]
+SyntaxKind[Identifier](712,28): Initializer
+SyntaxKind[OpenBracketToken](712,39): [
+SyntaxKind[Identifier](712,40): In
+SyntaxKind[CommaToken](712,42): ,
+SyntaxKind[QuestionToken](712,44): ?
+SyntaxKind[Identifier](712,45): Yield
+SyntaxKind[CloseBracketToken](712,50): ]
+SyntaxKind[QuestionToken](712,51): ?
+SyntaxKind[LineTerminatorToken](713,1): «line terminator»
+SyntaxKind[DedentToken](713,1): «dedent»
+SyntaxKind[LineTerminatorToken](714,1): «line terminator»
+SyntaxKind[Identifier](714,1): BindingRestElement
+SyntaxKind[OpenBracketToken](714,19): [
+SyntaxKind[Identifier](714,20): Yield
+SyntaxKind[CloseBracketToken](714,25): ]
+SyntaxKind[ColonToken](714,27): :
+SyntaxKind[LineTerminatorToken](715,1): «line terminator»
+SyntaxKind[IndentToken](715,1): «indent»
+SyntaxKind[Terminal](715,2): `...`
+SyntaxKind[Identifier](715,8): BindingIdentifier
+SyntaxKind[OpenBracketToken](715,25): [
+SyntaxKind[QuestionToken](715,26): ?
+SyntaxKind[Identifier](715,27): Yield
+SyntaxKind[CloseBracketToken](715,32): ]
+SyntaxKind[LineTerminatorToken](716,1): «line terminator»
+SyntaxKind[DedentToken](716,1): «dedent»
+SyntaxKind[LineTerminatorToken](717,1): «line terminator»
+SyntaxKind[Identifier](717,1): EmptyStatement
+SyntaxKind[ColonToken](717,16): :
+SyntaxKind[LineTerminatorToken](718,1): «line terminator»
+SyntaxKind[IndentToken](718,1): «indent»
+SyntaxKind[Terminal](718,2): `;`
+SyntaxKind[LineTerminatorToken](719,1): «line terminator»
+SyntaxKind[DedentToken](719,1): «dedent»
+SyntaxKind[LineTerminatorToken](720,1): «line terminator»
+SyntaxKind[Identifier](720,1): ExpressionStatement
+SyntaxKind[OpenBracketToken](720,20): [
+SyntaxKind[Identifier](720,21): Yield
+SyntaxKind[CloseBracketToken](720,26): ]
+SyntaxKind[ColonToken](720,28): :
+SyntaxKind[LineTerminatorToken](721,1): «line terminator»
+SyntaxKind[IndentToken](721,1): «indent»
+SyntaxKind[OpenBracketToken](721,2): [
+SyntaxKind[LookaheadKeyword](721,3): lookahead
+SyntaxKind[LessThanExclamationToken](721,13): `
+SyntaxKind[Identifier](845,56): ConciseBody
+SyntaxKind[OpenBracketToken](845,67): [
+SyntaxKind[QuestionToken](845,68): ?
+SyntaxKind[Identifier](845,69): In
+SyntaxKind[CloseBracketToken](845,71): ]
+SyntaxKind[LineTerminatorToken](846,1): «line terminator»
+SyntaxKind[DedentToken](846,1): «dedent»
+SyntaxKind[LineTerminatorToken](847,1): «line terminator»
+SyntaxKind[Identifier](847,1): ArrowParameters
+SyntaxKind[OpenBracketToken](847,16): [
+SyntaxKind[Identifier](847,17): Yield
+SyntaxKind[CloseBracketToken](847,22): ]
+SyntaxKind[ColonToken](847,25): :
+SyntaxKind[LineTerminatorToken](848,1): «line terminator»
+SyntaxKind[IndentToken](848,1): «indent»
+SyntaxKind[Identifier](848,2): BindingIdentifier
+SyntaxKind[OpenBracketToken](848,19): [
+SyntaxKind[QuestionToken](848,20): ?
+SyntaxKind[Identifier](848,21): Yield
+SyntaxKind[CloseBracketToken](848,26): ]
+SyntaxKind[LineTerminatorToken](849,1): «line terminator»
+SyntaxKind[Identifier](849,2): CoverParenthesizedExpressionAndArrowParameterList
+SyntaxKind[OpenBracketToken](849,51): [
+SyntaxKind[QuestionToken](849,52): ?
+SyntaxKind[Identifier](849,53): Yield
+SyntaxKind[CloseBracketToken](849,58): ]
+SyntaxKind[LineTerminatorToken](850,1): «line terminator»
+SyntaxKind[DedentToken](850,1): «dedent»
+SyntaxKind[LineTerminatorToken](851,1): «line terminator»
+SyntaxKind[Identifier](851,1): ConciseBody
+SyntaxKind[OpenBracketToken](851,12): [
+SyntaxKind[Identifier](851,13): In
+SyntaxKind[CloseBracketToken](851,15): ]
+SyntaxKind[ColonToken](851,17): :
+SyntaxKind[LineTerminatorToken](852,1): «line terminator»
+SyntaxKind[IndentToken](852,1): «indent»
+SyntaxKind[OpenBracketToken](852,2): [
+SyntaxKind[LookaheadKeyword](852,3): lookahead
+SyntaxKind[ExclamationEqualsToken](852,13): !=
+SyntaxKind[Terminal](852,16): `{`
+SyntaxKind[CloseBracketToken](852,19): ]
+SyntaxKind[Identifier](852,21): AssignmentExpression
+SyntaxKind[OpenBracketToken](852,41): [
+SyntaxKind[QuestionToken](852,42): ?
+SyntaxKind[Identifier](852,43): In
+SyntaxKind[CloseBracketToken](852,45): ]
+SyntaxKind[LineTerminatorToken](853,1): «line terminator»
+SyntaxKind[Terminal](853,2): `{`
+SyntaxKind[Identifier](853,6): FunctionBody
+SyntaxKind[Terminal](853,19): `}`
+SyntaxKind[LineTerminatorToken](854,1): «line terminator»
+SyntaxKind[DedentToken](854,1): «dedent»
+SyntaxKind[LineTerminatorToken](855,1): «line terminator»
+SyntaxKind[Identifier](855,1): MethodDefinition
+SyntaxKind[OpenBracketToken](855,17): [
+SyntaxKind[Identifier](855,18): Yield
+SyntaxKind[CloseBracketToken](855,23): ]
+SyntaxKind[ColonToken](855,25): :
+SyntaxKind[LineTerminatorToken](856,1): «line terminator»
+SyntaxKind[IndentToken](856,1): «indent»
+SyntaxKind[Identifier](856,2): PropertyName
+SyntaxKind[OpenBracketToken](856,14): [
+SyntaxKind[QuestionToken](856,15): ?
+SyntaxKind[Identifier](856,16): Yield
+SyntaxKind[CloseBracketToken](856,21): ]
+SyntaxKind[Terminal](856,23): `(`
+SyntaxKind[Identifier](856,27): StrictFormalParameters
+SyntaxKind[Terminal](856,50): `)`
+SyntaxKind[Terminal](856,54): `{`
+SyntaxKind[Identifier](856,58): FunctionBody
+SyntaxKind[Terminal](856,71): `}`
+SyntaxKind[LineTerminatorToken](857,1): «line terminator»
+SyntaxKind[Identifier](857,2): GeneratorMethod
+SyntaxKind[OpenBracketToken](857,17): [
+SyntaxKind[QuestionToken](857,18): ?
+SyntaxKind[Identifier](857,19): Yield
+SyntaxKind[CloseBracketToken](857,24): ]
+SyntaxKind[LineTerminatorToken](858,1): «line terminator»
+SyntaxKind[Terminal](858,2): `get`
+SyntaxKind[Identifier](858,8): PropertyName
+SyntaxKind[OpenBracketToken](858,20): [
+SyntaxKind[QuestionToken](858,21): ?
+SyntaxKind[Identifier](858,22): Yield
+SyntaxKind[CloseBracketToken](858,27): ]
+SyntaxKind[Terminal](858,29): `(`
+SyntaxKind[Terminal](858,33): `)`
+SyntaxKind[Terminal](858,37): `{`
+SyntaxKind[Identifier](858,41): FunctionBody
+SyntaxKind[Terminal](858,54): `}`
+SyntaxKind[LineTerminatorToken](859,1): «line terminator»
+SyntaxKind[Terminal](859,2): `set`
+SyntaxKind[Identifier](859,8): PropertyName
+SyntaxKind[OpenBracketToken](859,20): [
+SyntaxKind[QuestionToken](859,21): ?
+SyntaxKind[Identifier](859,22): Yield
+SyntaxKind[CloseBracketToken](859,27): ]
+SyntaxKind[Terminal](859,29): `(`
+SyntaxKind[Identifier](859,33): PropertySetParameterList
+SyntaxKind[Terminal](859,58): `)`
+SyntaxKind[Terminal](859,62): `{`
+SyntaxKind[Identifier](859,66): FunctionBody
+SyntaxKind[Terminal](859,79): `}`
+SyntaxKind[LineTerminatorToken](860,1): «line terminator»
+SyntaxKind[DedentToken](860,1): «dedent»
+SyntaxKind[LineTerminatorToken](861,1): «line terminator»
+SyntaxKind[Identifier](861,1): PropertySetParameterList
+SyntaxKind[ColonToken](861,26): :
+SyntaxKind[LineTerminatorToken](862,1): «line terminator»
+SyntaxKind[IndentToken](862,1): «indent»
+SyntaxKind[Identifier](862,2): FormalParameter
+SyntaxKind[LineTerminatorToken](863,1): «line terminator»
+SyntaxKind[DedentToken](863,1): «dedent»
+SyntaxKind[LineTerminatorToken](864,1): «line terminator»
+SyntaxKind[Identifier](864,1): GeneratorMethod
+SyntaxKind[OpenBracketToken](864,16): [
+SyntaxKind[Identifier](864,17): Yield
+SyntaxKind[CloseBracketToken](864,22): ]
+SyntaxKind[ColonToken](864,24): :
+SyntaxKind[LineTerminatorToken](865,1): «line terminator»
+SyntaxKind[IndentToken](865,1): «indent»
+SyntaxKind[Terminal](865,2): `*`
+SyntaxKind[Identifier](865,6): PropertyName
+SyntaxKind[OpenBracketToken](865,18): [
+SyntaxKind[QuestionToken](865,19): ?
+SyntaxKind[Identifier](865,20): Yield
+SyntaxKind[CloseBracketToken](865,25): ]
+SyntaxKind[Terminal](865,27): `(`
+SyntaxKind[Identifier](865,31): StrictFormalParameters
+SyntaxKind[OpenBracketToken](865,53): [
+SyntaxKind[Identifier](865,54): Yield
+SyntaxKind[CloseBracketToken](865,59): ]
+SyntaxKind[Terminal](865,61): `)`
+SyntaxKind[Terminal](865,65): `{`
+SyntaxKind[Identifier](865,69): GeneratorBody
+SyntaxKind[Terminal](865,83): `}`
+SyntaxKind[LineTerminatorToken](866,1): «line terminator»
+SyntaxKind[DedentToken](866,1): «dedent»
+SyntaxKind[LineTerminatorToken](867,1): «line terminator»
+SyntaxKind[Identifier](867,1): GeneratorDeclaration
+SyntaxKind[OpenBracketToken](867,21): [
+SyntaxKind[Identifier](867,22): Yield
+SyntaxKind[CommaToken](867,27): ,
+SyntaxKind[Identifier](867,29): Default
+SyntaxKind[CloseBracketToken](867,36): ]
+SyntaxKind[ColonToken](867,38): :
+SyntaxKind[LineTerminatorToken](868,1): «line terminator»
+SyntaxKind[IndentToken](868,1): «indent»
+SyntaxKind[Terminal](868,2): `function`
+SyntaxKind[Terminal](868,13): `*`
+SyntaxKind[Identifier](868,17): BindingIdentifier
+SyntaxKind[OpenBracketToken](868,34): [
+SyntaxKind[QuestionToken](868,35): ?
+SyntaxKind[Identifier](868,36): Yield
+SyntaxKind[CloseBracketToken](868,41): ]
+SyntaxKind[Terminal](868,43): `(`
+SyntaxKind[Identifier](868,47): FormalParameters
+SyntaxKind[OpenBracketToken](868,63): [
+SyntaxKind[Identifier](868,64): Yield
+SyntaxKind[CloseBracketToken](868,69): ]
+SyntaxKind[Terminal](868,71): `)`
+SyntaxKind[Terminal](868,75): `{`
+SyntaxKind[Identifier](868,79): GeneratorBody
+SyntaxKind[Terminal](868,93): `}`
+SyntaxKind[LineTerminatorToken](869,1): «line terminator»
+SyntaxKind[OpenBracketToken](869,2): [
+SyntaxKind[PlusToken](869,3): +
+SyntaxKind[Identifier](869,4): Default
+SyntaxKind[CloseBracketToken](869,11): ]
+SyntaxKind[Terminal](869,13): `function`
+SyntaxKind[Terminal](869,24): `*`
+SyntaxKind[Terminal](869,28): `(`
+SyntaxKind[Identifier](869,32): FormalParameters
+SyntaxKind[OpenBracketToken](869,48): [
+SyntaxKind[Identifier](869,49): Yield
+SyntaxKind[CloseBracketToken](869,54): ]
+SyntaxKind[Terminal](869,56): `)`
+SyntaxKind[Terminal](869,60): `{`
+SyntaxKind[Identifier](869,64): GeneratorBody
+SyntaxKind[Terminal](869,78): `}`
+SyntaxKind[LineTerminatorToken](870,1): «line terminator»
+SyntaxKind[DedentToken](870,1): «dedent»
+SyntaxKind[LineTerminatorToken](871,1): «line terminator»
+SyntaxKind[Identifier](871,1): GeneratorExpression
+SyntaxKind[ColonToken](871,21): :
+SyntaxKind[LineTerminatorToken](872,1): «line terminator»
+SyntaxKind[IndentToken](872,1): «indent»
+SyntaxKind[Terminal](872,2): `function`
+SyntaxKind[Terminal](872,13): `*`
+SyntaxKind[Identifier](872,17): BindingIdentifier
+SyntaxKind[OpenBracketToken](872,34): [
+SyntaxKind[Identifier](872,35): Yield
+SyntaxKind[CloseBracketToken](872,40): ]
+SyntaxKind[QuestionToken](872,41): ?
+SyntaxKind[Terminal](872,43): `(`
+SyntaxKind[Identifier](872,47): FormalParameters
+SyntaxKind[OpenBracketToken](872,63): [
+SyntaxKind[Identifier](872,64): Yield
+SyntaxKind[CloseBracketToken](872,69): ]
+SyntaxKind[Terminal](872,71): `)`
+SyntaxKind[Terminal](872,75): `{`
+SyntaxKind[Identifier](872,79): GeneratorBody
+SyntaxKind[Terminal](872,93): `}`
+SyntaxKind[LineTerminatorToken](873,1): «line terminator»
+SyntaxKind[DedentToken](873,1): «dedent»
+SyntaxKind[LineTerminatorToken](874,1): «line terminator»
+SyntaxKind[Identifier](874,1): GeneratorBody
+SyntaxKind[ColonToken](874,15): :
+SyntaxKind[LineTerminatorToken](875,1): «line terminator»
+SyntaxKind[IndentToken](875,1): «indent»
+SyntaxKind[Identifier](875,2): FunctionBody
+SyntaxKind[OpenBracketToken](875,14): [
+SyntaxKind[Identifier](875,15): Yield
+SyntaxKind[CloseBracketToken](875,20): ]
+SyntaxKind[LineTerminatorToken](876,1): «line terminator»
+SyntaxKind[DedentToken](876,1): «dedent»
+SyntaxKind[LineTerminatorToken](877,1): «line terminator»
+SyntaxKind[Identifier](877,1): YieldExpression
+SyntaxKind[OpenBracketToken](877,16): [
+SyntaxKind[Identifier](877,17): In
+SyntaxKind[CloseBracketToken](877,19): ]
+SyntaxKind[ColonToken](877,21): :
+SyntaxKind[LineTerminatorToken](878,1): «line terminator»
+SyntaxKind[IndentToken](878,1): «indent»
+SyntaxKind[Terminal](878,2): `yield`
+SyntaxKind[LineTerminatorToken](879,1): «line terminator»
+SyntaxKind[Terminal](879,2): `yield`
+SyntaxKind[OpenBracketToken](879,10): [
+SyntaxKind[NoKeyword](879,11): no
+SyntaxKind[Identifier](879,14): LineTerminator
+SyntaxKind[HereKeyword](879,29): here
+SyntaxKind[CloseBracketToken](879,33): ]
+SyntaxKind[Identifier](879,35): AssignmentExpression
+SyntaxKind[OpenBracketToken](879,55): [
+SyntaxKind[QuestionToken](879,56): ?
+SyntaxKind[Identifier](879,57): In
+SyntaxKind[CommaToken](879,59): ,
+SyntaxKind[Identifier](879,61): Yield
+SyntaxKind[CloseBracketToken](879,66): ]
+SyntaxKind[LineTerminatorToken](880,1): «line terminator»
+SyntaxKind[Terminal](880,2): `yield`
+SyntaxKind[OpenBracketToken](880,10): [
+SyntaxKind[NoKeyword](880,11): no
+SyntaxKind[Identifier](880,14): LineTerminator
+SyntaxKind[HereKeyword](880,29): here
+SyntaxKind[CloseBracketToken](880,33): ]
+SyntaxKind[Terminal](880,35): `*`
+SyntaxKind[Identifier](880,39): AssignmentExpression
+SyntaxKind[OpenBracketToken](880,59): [
+SyntaxKind[QuestionToken](880,60): ?
+SyntaxKind[Identifier](880,61): In
+SyntaxKind[CommaToken](880,63): ,
+SyntaxKind[Identifier](880,65): Yield
+SyntaxKind[CloseBracketToken](880,70): ]
+SyntaxKind[LineTerminatorToken](881,1): «line terminator»
+SyntaxKind[DedentToken](881,1): «dedent»
+SyntaxKind[LineTerminatorToken](882,1): «line terminator»
+SyntaxKind[Identifier](882,1): ClassDeclaration
+SyntaxKind[OpenBracketToken](882,17): [
+SyntaxKind[Identifier](882,18): Yield
+SyntaxKind[CommaToken](882,23): ,
+SyntaxKind[Identifier](882,25): Default
+SyntaxKind[CloseBracketToken](882,32): ]
+SyntaxKind[ColonToken](882,34): :
+SyntaxKind[LineTerminatorToken](883,1): «line terminator»
+SyntaxKind[IndentToken](883,1): «indent»
+SyntaxKind[Terminal](883,2): `class`
+SyntaxKind[Identifier](883,10): BindingIdentifier
+SyntaxKind[OpenBracketToken](883,27): [
+SyntaxKind[QuestionToken](883,28): ?
+SyntaxKind[Identifier](883,29): Yield
+SyntaxKind[CloseBracketToken](883,34): ]
+SyntaxKind[Identifier](883,36): ClassTail
+SyntaxKind[OpenBracketToken](883,45): [
+SyntaxKind[QuestionToken](883,46): ?
+SyntaxKind[Identifier](883,47): Yield
+SyntaxKind[CloseBracketToken](883,52): ]
+SyntaxKind[LineTerminatorToken](884,1): «line terminator»
+SyntaxKind[OpenBracketToken](884,2): [
+SyntaxKind[PlusToken](884,3): +
+SyntaxKind[Identifier](884,4): Default
+SyntaxKind[CloseBracketToken](884,11): ]
+SyntaxKind[Terminal](884,13): `class`
+SyntaxKind[Identifier](884,21): ClassTail
+SyntaxKind[OpenBracketToken](884,30): [
+SyntaxKind[QuestionToken](884,31): ?
+SyntaxKind[Identifier](884,32): Yield
+SyntaxKind[CloseBracketToken](884,37): ]
+SyntaxKind[LineTerminatorToken](885,1): «line terminator»
+SyntaxKind[DedentToken](885,1): «dedent»
+SyntaxKind[LineTerminatorToken](886,1): «line terminator»
+SyntaxKind[Identifier](886,1): ClassExpression
+SyntaxKind[OpenBracketToken](886,16): [
+SyntaxKind[Identifier](886,17): Yield
+SyntaxKind[CloseBracketToken](886,22): ]
+SyntaxKind[ColonToken](886,24): :
+SyntaxKind[LineTerminatorToken](887,1): «line terminator»
+SyntaxKind[IndentToken](887,1): «indent»
+SyntaxKind[Terminal](887,2): `class`
+SyntaxKind[Identifier](887,10): BindingIdentifier
+SyntaxKind[OpenBracketToken](887,27): [
+SyntaxKind[QuestionToken](887,28): ?
+SyntaxKind[Identifier](887,29): Yield
+SyntaxKind[CloseBracketToken](887,34): ]
+SyntaxKind[QuestionToken](887,35): ?
+SyntaxKind[Identifier](887,37): ClassTail
+SyntaxKind[OpenBracketToken](887,46): [
+SyntaxKind[QuestionToken](887,47): ?
+SyntaxKind[Identifier](887,48): Yield
+SyntaxKind[CloseBracketToken](887,53): ]
+SyntaxKind[LineTerminatorToken](888,1): «line terminator»
+SyntaxKind[DedentToken](888,1): «dedent»
+SyntaxKind[LineTerminatorToken](889,1): «line terminator»
+SyntaxKind[Identifier](889,1): ClassTail
+SyntaxKind[OpenBracketToken](889,10): [
+SyntaxKind[Identifier](889,11): Yield
+SyntaxKind[CloseBracketToken](889,16): ]
+SyntaxKind[ColonToken](889,18): :
+SyntaxKind[LineTerminatorToken](890,1): «line terminator»
+SyntaxKind[IndentToken](890,1): «indent»
+SyntaxKind[Identifier](890,2): ClassHeritage
+SyntaxKind[OpenBracketToken](890,15): [
+SyntaxKind[QuestionToken](890,16): ?
+SyntaxKind[Identifier](890,17): Yield
+SyntaxKind[CloseBracketToken](890,22): ]
+SyntaxKind[QuestionToken](890,23): ?
+SyntaxKind[Terminal](890,25): `{`
+SyntaxKind[Identifier](890,29): ClassBody
+SyntaxKind[OpenBracketToken](890,38): [
+SyntaxKind[QuestionToken](890,39): ?
+SyntaxKind[Identifier](890,40): Yield
+SyntaxKind[CloseBracketToken](890,45): ]
+SyntaxKind[QuestionToken](890,46): ?
+SyntaxKind[Terminal](890,48): `}`
+SyntaxKind[LineTerminatorToken](891,1): «line terminator»
+SyntaxKind[DedentToken](891,1): «dedent»
+SyntaxKind[LineTerminatorToken](892,1): «line terminator»
+SyntaxKind[Identifier](892,1): ClassHeritage
+SyntaxKind[OpenBracketToken](892,14): [
+SyntaxKind[Identifier](892,15): Yield
+SyntaxKind[CloseBracketToken](892,20): ]
+SyntaxKind[ColonToken](892,22): :
+SyntaxKind[LineTerminatorToken](893,1): «line terminator»
+SyntaxKind[IndentToken](893,1): «indent»
+SyntaxKind[Terminal](893,2): `extends`
+SyntaxKind[Identifier](893,12): LeftHandSideExpression
+SyntaxKind[OpenBracketToken](893,34): [
+SyntaxKind[QuestionToken](893,35): ?
+SyntaxKind[Identifier](893,36): Yield
+SyntaxKind[CloseBracketToken](893,41): ]
+SyntaxKind[LineTerminatorToken](894,1): «line terminator»
+SyntaxKind[DedentToken](894,1): «dedent»
+SyntaxKind[LineTerminatorToken](895,1): «line terminator»
+SyntaxKind[Identifier](895,1): ClassBody
+SyntaxKind[OpenBracketToken](895,10): [
+SyntaxKind[Identifier](895,11): Yield
+SyntaxKind[CloseBracketToken](895,16): ]
+SyntaxKind[ColonToken](895,18): :
+SyntaxKind[LineTerminatorToken](896,1): «line terminator»
+SyntaxKind[IndentToken](896,1): «indent»
+SyntaxKind[Identifier](896,2): ClassElementList
+SyntaxKind[OpenBracketToken](896,18): [
+SyntaxKind[QuestionToken](896,19): ?
+SyntaxKind[Identifier](896,20): Yield
+SyntaxKind[CloseBracketToken](896,25): ]
+SyntaxKind[LineTerminatorToken](897,1): «line terminator»
+SyntaxKind[DedentToken](897,1): «dedent»
+SyntaxKind[LineTerminatorToken](898,1): «line terminator»
+SyntaxKind[Identifier](898,1): ClassElementList
+SyntaxKind[OpenBracketToken](898,17): [
+SyntaxKind[Identifier](898,18): Yield
+SyntaxKind[CloseBracketToken](898,23): ]
+SyntaxKind[ColonToken](898,25): :
+SyntaxKind[LineTerminatorToken](899,1): «line terminator»
+SyntaxKind[IndentToken](899,1): «indent»
+SyntaxKind[Identifier](899,2): ClassElement
+SyntaxKind[OpenBracketToken](899,14): [
+SyntaxKind[QuestionToken](899,15): ?
+SyntaxKind[Identifier](899,16): Yield
+SyntaxKind[CloseBracketToken](899,21): ]
+SyntaxKind[LineTerminatorToken](900,1): «line terminator»
+SyntaxKind[Identifier](900,2): ClassElementList
+SyntaxKind[OpenBracketToken](900,18): [
+SyntaxKind[QuestionToken](900,19): ?
+SyntaxKind[Identifier](900,20): Yield
+SyntaxKind[CloseBracketToken](900,25): ]
+SyntaxKind[Identifier](900,28): ClassElement
+SyntaxKind[OpenBracketToken](900,40): [
+SyntaxKind[QuestionToken](900,41): ?
+SyntaxKind[Identifier](900,42): Yield
+SyntaxKind[CloseBracketToken](900,47): ]
+SyntaxKind[LineTerminatorToken](901,1): «line terminator»
+SyntaxKind[DedentToken](901,1): «dedent»
+SyntaxKind[LineTerminatorToken](902,1): «line terminator»
+SyntaxKind[Identifier](902,1): ClassElement
+SyntaxKind[OpenBracketToken](902,13): [
+SyntaxKind[Identifier](902,14): Yield
+SyntaxKind[CloseBracketToken](902,19): ]
+SyntaxKind[ColonToken](902,21): :
+SyntaxKind[LineTerminatorToken](903,1): «line terminator»
+SyntaxKind[IndentToken](903,1): «indent»
+SyntaxKind[Identifier](903,2): MethodDefinition
+SyntaxKind[OpenBracketToken](903,18): [
+SyntaxKind[QuestionToken](903,19): ?
+SyntaxKind[Identifier](903,20): Yield
+SyntaxKind[CloseBracketToken](903,25): ]
+SyntaxKind[LineTerminatorToken](904,1): «line terminator»
+SyntaxKind[Terminal](904,2): `static`
+SyntaxKind[Identifier](904,11): MethodDefinition
+SyntaxKind[OpenBracketToken](904,27): [
+SyntaxKind[QuestionToken](904,28): ?
+SyntaxKind[Identifier](904,29): Yield
+SyntaxKind[CloseBracketToken](904,34): ]
+SyntaxKind[LineTerminatorToken](905,1): «line terminator»
+SyntaxKind[Terminal](905,2): `;`
+SyntaxKind[LineTerminatorToken](906,1): «line terminator»
+SyntaxKind[DedentToken](906,1): «dedent»
+SyntaxKind[LineTerminatorToken](907,1): «line terminator»
+SyntaxKind[LineTerminatorToken](908,1): «line terminator»
+SyntaxKind[Identifier](908,1): Script
+SyntaxKind[ColonToken](908,8): :
+SyntaxKind[LineTerminatorToken](909,1): «line terminator»
+SyntaxKind[IndentToken](909,1): «indent»
+SyntaxKind[Identifier](909,2): ScriptBody
+SyntaxKind[QuestionToken](909,12): ?
+SyntaxKind[LineTerminatorToken](910,1): «line terminator»
+SyntaxKind[DedentToken](910,1): «dedent»
+SyntaxKind[LineTerminatorToken](911,1): «line terminator»
+SyntaxKind[Identifier](911,1): ScriptBody
+SyntaxKind[ColonToken](911,12): :
+SyntaxKind[LineTerminatorToken](912,1): «line terminator»
+SyntaxKind[IndentToken](912,1): «indent»
+SyntaxKind[Identifier](912,2): StatementList
+SyntaxKind[LineTerminatorToken](913,1): «line terminator»
+SyntaxKind[DedentToken](913,1): «dedent»
+SyntaxKind[LineTerminatorToken](914,1): «line terminator»
+SyntaxKind[Identifier](914,1): Module
+SyntaxKind[ColonToken](914,8): :
+SyntaxKind[LineTerminatorToken](915,1): «line terminator»
+SyntaxKind[IndentToken](915,1): «indent»
+SyntaxKind[Identifier](915,2): ModuleBody
+SyntaxKind[QuestionToken](915,12): ?
+SyntaxKind[LineTerminatorToken](916,1): «line terminator»
+SyntaxKind[DedentToken](916,1): «dedent»
+SyntaxKind[LineTerminatorToken](917,1): «line terminator»
+SyntaxKind[Identifier](917,1): ModuleBody
+SyntaxKind[ColonToken](917,12): :
+SyntaxKind[LineTerminatorToken](918,1): «line terminator»
+SyntaxKind[IndentToken](918,1): «indent»
+SyntaxKind[Identifier](918,2): ModuleItemList
+SyntaxKind[LineTerminatorToken](919,1): «line terminator»
+SyntaxKind[DedentToken](919,1): «dedent»
+SyntaxKind[LineTerminatorToken](920,1): «line terminator»
+SyntaxKind[Identifier](920,1): ModuleItemList
+SyntaxKind[ColonToken](920,16): :
+SyntaxKind[LineTerminatorToken](921,1): «line terminator»
+SyntaxKind[IndentToken](921,1): «indent»
+SyntaxKind[Identifier](921,2): ModuleItem
+SyntaxKind[LineTerminatorToken](922,1): «line terminator»
+SyntaxKind[Identifier](922,2): ModuleItemList
+SyntaxKind[Identifier](922,18): ModuleItem
+SyntaxKind[LineTerminatorToken](923,1): «line terminator»
+SyntaxKind[DedentToken](923,1): «dedent»
+SyntaxKind[LineTerminatorToken](924,1): «line terminator»
+SyntaxKind[Identifier](924,1): ModuleItem
+SyntaxKind[ColonToken](924,12): :
+SyntaxKind[LineTerminatorToken](925,1): «line terminator»
+SyntaxKind[IndentToken](925,1): «indent»
+SyntaxKind[Identifier](925,2): ImportDeclaration
+SyntaxKind[LineTerminatorToken](926,1): «line terminator»
+SyntaxKind[Identifier](926,2): ExportDeclaration
+SyntaxKind[LineTerminatorToken](927,1): «line terminator»
+SyntaxKind[Identifier](927,2): StatementListItem
+SyntaxKind[LineTerminatorToken](928,1): «line terminator»
+SyntaxKind[DedentToken](928,1): «dedent»
+SyntaxKind[LineTerminatorToken](929,1): «line terminator»
+SyntaxKind[Identifier](929,1): ImportDeclaration
+SyntaxKind[ColonToken](929,19): :
+SyntaxKind[LineTerminatorToken](930,1): «line terminator»
+SyntaxKind[IndentToken](930,1): «indent»
+SyntaxKind[Terminal](930,2): `import`
+SyntaxKind[Identifier](930,12): ImportClause
+SyntaxKind[Identifier](930,25): FromClause
+SyntaxKind[Terminal](930,36): `;`
+SyntaxKind[LineTerminatorToken](931,1): «line terminator»
+SyntaxKind[Terminal](931,2): `import`
+SyntaxKind[Identifier](931,12): ModuleSpecifier
+SyntaxKind[Terminal](931,28): `;`
+SyntaxKind[LineTerminatorToken](932,1): «line terminator»
+SyntaxKind[DedentToken](932,1): «dedent»
+SyntaxKind[LineTerminatorToken](933,1): «line terminator»
+SyntaxKind[Identifier](933,1): ImportClause
+SyntaxKind[ColonToken](933,14): :
+SyntaxKind[LineTerminatorToken](934,1): «line terminator»
+SyntaxKind[IndentToken](934,1): «indent»
+SyntaxKind[Identifier](934,2): ImportedDefaultBinding
+SyntaxKind[LineTerminatorToken](935,1): «line terminator»
+SyntaxKind[Identifier](935,2): NameSpaceImport
+SyntaxKind[LineTerminatorToken](936,1): «line terminator»
+SyntaxKind[Identifier](936,2): NamedImports
+SyntaxKind[LineTerminatorToken](937,1): «line terminator»
+SyntaxKind[Identifier](937,2): ImportedDefaultBinding
+SyntaxKind[Terminal](937,25): `,`
+SyntaxKind[Identifier](937,29): NameSpaceImport
+SyntaxKind[LineTerminatorToken](938,1): «line terminator»
+SyntaxKind[Identifier](938,2): ImportedDefaultBinding
+SyntaxKind[Terminal](938,25): `,`
+SyntaxKind[Identifier](938,29): NamedImports
+SyntaxKind[LineTerminatorToken](939,1): «line terminator»
+SyntaxKind[DedentToken](939,1): «dedent»
+SyntaxKind[LineTerminatorToken](940,1): «line terminator»
+SyntaxKind[Identifier](940,1): ImportedDefaultBinding
+SyntaxKind[ColonToken](940,24): :
+SyntaxKind[LineTerminatorToken](941,1): «line terminator»
+SyntaxKind[IndentToken](941,1): «indent»
+SyntaxKind[Identifier](941,2): ImportedBinding
+SyntaxKind[LineTerminatorToken](942,1): «line terminator»
+SyntaxKind[DedentToken](942,1): «dedent»
+SyntaxKind[LineTerminatorToken](943,1): «line terminator»
+SyntaxKind[Identifier](943,1): NameSpaceImport
+SyntaxKind[ColonToken](943,17): :
+SyntaxKind[LineTerminatorToken](944,1): «line terminator»
+SyntaxKind[IndentToken](944,1): «indent»
+SyntaxKind[Terminal](944,2): `*`
+SyntaxKind[Terminal](944,6): `as`
+SyntaxKind[Identifier](944,11): ImportedBinding
+SyntaxKind[LineTerminatorToken](945,1): «line terminator»
+SyntaxKind[DedentToken](945,1): «dedent»
+SyntaxKind[LineTerminatorToken](946,1): «line terminator»
+SyntaxKind[Identifier](946,1): NamedImports
+SyntaxKind[ColonToken](946,14): :
+SyntaxKind[LineTerminatorToken](947,1): «line terminator»
+SyntaxKind[IndentToken](947,1): «indent»
+SyntaxKind[Terminal](947,2): `{`
+SyntaxKind[Terminal](947,6): `}`
+SyntaxKind[LineTerminatorToken](948,1): «line terminator»
+SyntaxKind[Terminal](948,2): `{`
+SyntaxKind[Identifier](948,6): ImportsList
+SyntaxKind[Terminal](948,18): `}`
+SyntaxKind[LineTerminatorToken](949,1): «line terminator»
+SyntaxKind[Terminal](949,2): `{`
+SyntaxKind[Identifier](949,6): ImportsList
+SyntaxKind[Terminal](949,18): `,`
+SyntaxKind[Terminal](949,22): `}`
+SyntaxKind[LineTerminatorToken](950,1): «line terminator»
+SyntaxKind[DedentToken](950,1): «dedent»
+SyntaxKind[LineTerminatorToken](951,1): «line terminator»
+SyntaxKind[Identifier](951,1): FromClause
+SyntaxKind[ColonToken](951,12): :
+SyntaxKind[LineTerminatorToken](952,1): «line terminator»
+SyntaxKind[IndentToken](952,1): «indent»
+SyntaxKind[Terminal](952,2): `from`
+SyntaxKind[Identifier](952,9): ModuleSpecifier
+SyntaxKind[LineTerminatorToken](953,1): «line terminator»
+SyntaxKind[DedentToken](953,1): «dedent»
+SyntaxKind[LineTerminatorToken](954,1): «line terminator»
+SyntaxKind[Identifier](954,1): ImportsList
+SyntaxKind[ColonToken](954,13): :
+SyntaxKind[LineTerminatorToken](955,1): «line terminator»
+SyntaxKind[IndentToken](955,1): «indent»
+SyntaxKind[Identifier](955,2): ImportSpecifier
+SyntaxKind[LineTerminatorToken](956,1): «line terminator»
+SyntaxKind[Identifier](956,2): ImportsList
+SyntaxKind[Terminal](956,14): `,`
+SyntaxKind[Identifier](956,18): ImportSpecifier
+SyntaxKind[LineTerminatorToken](957,1): «line terminator»
+SyntaxKind[DedentToken](957,1): «dedent»
+SyntaxKind[LineTerminatorToken](958,1): «line terminator»
+SyntaxKind[Identifier](958,1): ImportSpecifier
+SyntaxKind[ColonToken](958,17): :
+SyntaxKind[LineTerminatorToken](959,1): «line terminator»
+SyntaxKind[IndentToken](959,1): «indent»
+SyntaxKind[Identifier](959,2): ImportedBinding
+SyntaxKind[LineTerminatorToken](960,1): «line terminator»
+SyntaxKind[Identifier](960,2): IdentifierName
+SyntaxKind[Terminal](960,17): `as`
+SyntaxKind[Identifier](960,22): ImportedBinding
+SyntaxKind[LineTerminatorToken](961,1): «line terminator»
+SyntaxKind[DedentToken](961,1): «dedent»
+SyntaxKind[LineTerminatorToken](962,1): «line terminator»
+SyntaxKind[Identifier](962,1): ModuleSpecifier
+SyntaxKind[ColonToken](962,17): :
+SyntaxKind[LineTerminatorToken](963,1): «line terminator»
+SyntaxKind[IndentToken](963,1): «indent»
+SyntaxKind[Identifier](963,2): StringLiteral
+SyntaxKind[LineTerminatorToken](964,1): «line terminator»
+SyntaxKind[DedentToken](964,1): «dedent»
+SyntaxKind[LineTerminatorToken](965,1): «line terminator»
+SyntaxKind[Identifier](965,1): ImportedBinding
+SyntaxKind[ColonToken](965,17): :
+SyntaxKind[LineTerminatorToken](966,1): «line terminator»
+SyntaxKind[IndentToken](966,1): «indent»
+SyntaxKind[Identifier](966,2): BindingIdentifier
+SyntaxKind[LineTerminatorToken](967,1): «line terminator»
+SyntaxKind[DedentToken](967,1): «dedent»
+SyntaxKind[LineTerminatorToken](968,1): «line terminator»
+SyntaxKind[Identifier](968,1): ExportDeclaration
+SyntaxKind[ColonToken](968,19): :
+SyntaxKind[LineTerminatorToken](969,1): «line terminator»
+SyntaxKind[IndentToken](969,1): «indent»
+SyntaxKind[Terminal](969,2): `export`
+SyntaxKind[Terminal](969,11): `*`
+SyntaxKind[Identifier](969,15): FromClause
+SyntaxKind[Terminal](969,26): `;`
+SyntaxKind[LineTerminatorToken](970,1): «line terminator»
+SyntaxKind[Terminal](970,2): `export`
+SyntaxKind[Identifier](970,11): ExportClause
+SyntaxKind[Identifier](970,24): FromClause
+SyntaxKind[Terminal](970,35): `;`
+SyntaxKind[LineTerminatorToken](971,1): «line terminator»
+SyntaxKind[Terminal](971,2): `export`
+SyntaxKind[Identifier](971,11): ExportClause
+SyntaxKind[Terminal](971,24): `;`
+SyntaxKind[LineTerminatorToken](972,1): «line terminator»
+SyntaxKind[Terminal](972,2): `export`
+SyntaxKind[Identifier](972,11): VariableStatement
+SyntaxKind[LineTerminatorToken](973,1): «line terminator»
+SyntaxKind[Terminal](973,2): `export`
+SyntaxKind[Identifier](973,11): Declaration
+SyntaxKind[LineTerminatorToken](974,1): «line terminator»
+SyntaxKind[Terminal](974,2): `export`
+SyntaxKind[Terminal](974,11): `default`
+SyntaxKind[Identifier](974,21): HoistableDeclaration
+SyntaxKind[OpenBracketToken](974,41): [
+SyntaxKind[Identifier](974,42): Default
+SyntaxKind[CloseBracketToken](974,49): ]
+SyntaxKind[LineTerminatorToken](975,1): «line terminator»
+SyntaxKind[Terminal](975,2): `export`
+SyntaxKind[Terminal](975,11): `default`
+SyntaxKind[Identifier](975,21): ClassDeclaration
+SyntaxKind[OpenBracketToken](975,37): [
+SyntaxKind[Identifier](975,38): Default
+SyntaxKind[CloseBracketToken](975,45): ]
+SyntaxKind[LineTerminatorToken](976,1): «line terminator»
+SyntaxKind[Terminal](976,2): `export`
+SyntaxKind[Terminal](976,11): `default`
+SyntaxKind[OpenBracketToken](976,21): [
+SyntaxKind[LookaheadKeyword](976,22): lookahead
+SyntaxKind[LessThanExclamationToken](976,32):
+ any Unicode code point
+
+
+ <LF>
+ <CR>
+ <LS>
+ <PS>
+
+
+ IdentifierStart
+
+ IdentifierName
+ IdentifierPart
+
+
+
+ UnicodeIDStart
+ _
+
+
+ UnicodeIDContinue
+ _
+ <ZWNJ>
+ <ZWJ>
+
+
+ any Unicode code point with the Unicode property "ID_Start" or "Other_ID_Start"
+
+
+ any Unicode code point with the Unicode property "ID_Continue" or "Other_ID_Continue", or "Other_ID_Start"
+
+
+ Keyword
+
+
+ empty lookahead lexical goal no here one of or but not
+
+
+ 0 1 2 3 4 5 6 7 8 9
+
+
+ 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F
+
+
+
+ <
+ UnicodeCharacterLiteralChars
+ >
+
+
+
+
+ UnicodeCharacterLiteralChar
+ UnicodeCharacterLiteralChars
+
+
+
+ SourceCharacter but not one of < or > or LineTerminator
+
+
+ An increase in the indentation depth from the previous line.
+
+
+ A decrease in the indentation depth from the previous line.
+
+
+
+ `
+ `
+ `
+
+
+ `
+ TerminalChars
+ `
+
+
+
+
+ TerminalChar
+ TerminalChars
+
+
+
+ SourceCharacter but not one of ` or LineTerminator
+
+
+ ProseLines
+
+
+ ProseLine
+
+ ProseLine
+ LineTerminator
+ ProseLines
+
+
+
+
+ >
+ ProseChars
+
+
+
+
+ ProseChar
+ ProseChars
+
+
+
+ SourceCharacter but not LineTerminator
+
+
+ IdentifierName but not ReservedWord
+
+
+ Identifier
+
+
+
+ (
+ )
+
+
+ (
+ ArgumentList
+ )
+
+
+
+ Argument
+
+ ArgumentList
+ ,
+ Argument
+
+
+
+ Terminal
+ UnicodeCharacterLiteral
+ Nonterminal
+
+
+
+ Identifier
+ Arguments
+
+
+
+
+ PrimarySymbol
+ ?
+
+
+
+ PrimarySymbol
+
+ OrClause
+ or
+ PrimarySymbol
+
+
+
+ PrimarySymbol
+
+ one
+ of
+ OrClause
+
+
+
+ OneOfSymbol
+
+
+
+ UnarySymbol
+ but
+ not
+ UnarySymbol
+
+
+
+ ButNotSymbol
+ UnarySymbol
+
+
+ PrimarySymbol
+
+ SymbolList
+ ,
+ PrimarySymbol
+
+
+
+
+ {
+ SymbolList
+ }
+
+
+
+ empty
+
+
+
+ lookahead
+ ==
+ PrimarySymbol
+
+
+
+
+ lookahead
+ !=
+ PrimarySymbol
+
+
+
+
+ lookahead
+ <-
+ SymbolSet
+
+
+
+
+ lookahead
+ <!
+ SymbolSet
+
+
+
+ LookaheadEqualsAssertionClause
+ LookaheadNotEqualsAssertionClause
+ LookaheadInAssertionClause
+ LookaheadNotInAssertionClause
+
+
+
+ no
+ OrClause
+ here
+
+
+
+
+ lexical
+ goal
+ PrimarySymbol
+
+
+
+
+ ~
+ Identifier
+
+
+ +
+ Identifier
+
+
+
+ EmptyAssertionClause
+ LookaheadAssertionClause
+ NoSymbolAssertionClause
+ LexicalGoalAssertionClause
+ ParameterValueAssertionClause
+
+
+
+ [
+ AssertionClause
+ ]
+
+
+
+ Prose
+
+ ProseSpan
+ LineTerminator
+ Prose
+
+
+
+ Assertion
+ BinarySymbol
+
+
+ ProseSpan
+ SymbolSpanRest
+
+
+
+ Symbol
+ SymbolSpanRest
+
+
+
+
+ RightHandSide
+ RightHandSideList
+
+
+
+
+ SymbolSpan
+ LineTerminator
+
+
+
+
+ Terminal
+ Terminals
+
+
+
+ Terminals
+
+ TerminalList
+ LineTerminator
+ Terminals
+
+
+
+
+ one
+ of
+ Terminals
+
+
+ one
+ of
+ LineTerminator
+ Indent
+ TerminalList
+ Dedent
+
+
+
+ Identifier
+
+
+ Parameter
+
+ ParameterList
+ ,
+ Parameter
+
+
+
+
+ (
+ ParameterList
+ )
+
+
+
+
+ Identifier
+ Parameters
+ :
+ OneOfList
+
+
+ Identifier
+ Parameters
+ :
+ RightHandSide
+
+
+ Identifier
+ Parameters
+ :
+ LineTerminator
+ Indent
+ RightHandSideList
+ Dedent
+
+
+
+ empty
+ Production
+
+
+
+ SourceElement
+ SourceElements
+
+
+
+ SourceElements
+
\ No newline at end of file
diff --git a/tests/baselines/reference/grammarkdown.grammar.md b/tests/baselines/reference/grammarkdown.grammar.md
new file mode 100644
index 0000000..b00eae8
--- /dev/null
+++ b/tests/baselines/reference/grammarkdown.grammar.md
@@ -0,0 +1,234 @@
+ *SourceCharacter* **::**
+ any Unicode code point
+
+ *LineTerminator* **::**
+ <LF>
+ <CR>
+ <LS>
+ <PS>
+
+ *IdentifierName* **::**
+ *[IdentifierStart](#IdentifierStart)*
+ *[IdentifierName](#IdentifierName)* *[IdentifierPart](#IdentifierPart)*
+
+ *IdentifierStart* **::**
+ *[UnicodeIDStart](#UnicodeIDStart)*
+ `` _ ``
+
+ *IdentifierPart* **::**
+ *[UnicodeIDContinue](#UnicodeIDContinue)*
+ `` _ ``
+ <ZWNJ>
+ <ZWJ>
+
+ *UnicodeIDStart* **::**
+ any Unicode code point with the Unicode property "ID_Start" or "Other_ID_Start"
+
+ *UnicodeIDContinue* **::**
+ any Unicode code point with the Unicode property "ID_Continue" or "Other_ID_Continue", or "Other_ID_Start"
+
+ *ReservedWord* **::**
+ *[Keyword](#Keyword)*
+
+ *Keyword* **::** **one of**
+ empty
lookahead
lexical
goal
no
+ here
one
of
or
but
+ not
+
+ *DecimalDigit* **::** **one of**
+ 0
1
2
3
4
5
6
7
8
9
+
+ *HexDigit* **::** **one of**
+ 0
1
2
3
4
5
6
7
8
9
+ a
b
c
d
e
f
A
B
C
D
+ E
F
+
+ *UnicodeCharacterLiteral* **::**
+ `` < `` *[UnicodeCharacterLiteralChars](#UnicodeCharacterLiteralChars)* `` > ``
+
+ *UnicodeCharacterLiteralChars* **::**
+ *[UnicodeCharacterLiteralChar](#UnicodeCharacterLiteralChar)* *[UnicodeCharacterLiteralChars](#UnicodeCharacterLiteralChars)*opt
+
+ *UnicodeCharacterLiteralChar* **::**
+ *[SourceCharacter](#SourceCharacter)* **but not** **one of** `` < `` **or** `` > `` **or** *[LineTerminator](#LineTerminator)*
+
+ *Indent* **::**
+ An increase in the indentation depth from the previous line.
+
+ *Dedent* **::**
+ A decrease in the indentation depth from the previous line.
+
+ *Terminal* **::**
+ `` ` `` `` ` `` `` ` ``
+ `` ` `` *[TerminalChars](#TerminalChars)* `` ` ``
+
+ *TerminalChars* **::**
+ *[TerminalChar](#TerminalChar)* *[TerminalChars](#TerminalChars)*opt
+
+ *TerminalChar* **::**
+ *[SourceCharacter](#SourceCharacter)* **but not** **one of** `` ` `` **or** *[LineTerminator](#LineTerminator)*
+
+ *Prose* **::**
+ *[ProseLines](#ProseLines)*
+
+ *ProseLines* **::**
+ *[ProseLine](#ProseLine)*
+ *[ProseLine](#ProseLine)* *[LineTerminator](#LineTerminator)* *[ProseLines](#ProseLines)*
+
+ *ProseLine* **::**
+ `` > `` *[ProseChars](#ProseChars)*opt
+
+ *ProseChars* **::**
+ *[ProseChar](#ProseChar)* *[ProseChars](#ProseChars)*opt
+
+ *ProseChar* **::**
+ *[SourceCharacter](#SourceCharacter)* **but not** *[LineTerminator](#LineTerminator)*
+
+ *Identifier* **:**
+ *[IdentifierName](#IdentifierName)* **but not** *[ReservedWord](#ReservedWord)*
+
+ *Argument* **:**
+ *[Identifier](#Identifier)*
+
+ *Arguments* **:**
+ `` ( `` `` ) ``
+ `` ( `` *[ArgumentList](#ArgumentList)* `` ) ``
+
+ *ArgumentList* **:**
+ *[Argument](#Argument)*
+ *[ArgumentList](#ArgumentList)* `` , `` *[Argument](#Argument)*
+
+ *PrimarySymbol* **:**
+ *[Terminal](#Terminal)*
+ *[UnicodeCharacterLiteral](#UnicodeCharacterLiteral)*
+ *[Nonterminal](#Nonterminal)*
+
+ *Nonterminal* **:**
+ *[Identifier](#Identifier)* *[Arguments](#Arguments)*opt
+
+ *OptionalSymbol* **:**
+ *[PrimarySymbol](#PrimarySymbol)* `` ? ``opt
+
+ *OrClause* **:**
+ *[PrimarySymbol](#PrimarySymbol)*
+ *[OrClause](#OrClause)* `` or `` *[PrimarySymbol](#PrimarySymbol)*
+
+ *OneOfSymbol* **:**
+ *[PrimarySymbol](#PrimarySymbol)*
+ `` one `` `` of `` *[OrClause](#OrClause)*
+
+ *UnarySymbol* **:**
+ *[OneOfSymbol](#OneOfSymbol)*
+
+ *ButNotSymbol* **:**
+ *[UnarySymbol](#UnarySymbol)* `` but `` `` not `` *[UnarySymbol](#UnarySymbol)*
+
+ *BinarySymbol* **:**
+ *[ButNotSymbol](#ButNotSymbol)*
+ *[UnarySymbol](#UnarySymbol)*
+
+ *SymbolList* **:**
+ *[PrimarySymbol](#PrimarySymbol)*
+ *[SymbolList](#SymbolList)* `` , `` *[PrimarySymbol](#PrimarySymbol)*
+
+ *SymbolSet* **:**
+ `` { `` *[SymbolList](#SymbolList)* `` } ``
+
+ *EmptyAssertionClause* **:**
+ `` empty ``
+
+ *LookaheadEqualsAssertionClause* **:**
+ `` lookahead `` `` == `` *[PrimarySymbol](#PrimarySymbol)*
+
+ *LookaheadNotEqualsAssertionClause* **:**
+ `` lookahead `` `` != `` *[PrimarySymbol](#PrimarySymbol)*
+
+ *LookaheadInAssertionClause* **:**
+ `` lookahead `` `` <- `` *[SymbolSet](#SymbolSet)*
+
+ *LookaheadNotInAssertionClause* **:**
+ `` lookahead `` `` *LookaheadAssertionClause* **:**
+ *[LookaheadEqualsAssertionClause](#LookaheadEqualsAssertionClause)*
+ *[LookaheadNotEqualsAssertionClause](#LookaheadNotEqualsAssertionClause)*
+ *[LookaheadInAssertionClause](#LookaheadInAssertionClause)*
+ *[LookaheadNotInAssertionClause](#LookaheadNotInAssertionClause)*
+
+ *NoSymbolAssertionClause* **:**
+ `` no `` *[OrClause](#OrClause)* `` here ``
+
+ *LexicalGoalAssertionClause* **:**
+ `` lexical `` `` goal `` *[PrimarySymbol](#PrimarySymbol)*
+
+ *ParameterValueAssertionClause* **:**
+ `` ~ `` *[Identifier](#Identifier)*
+ `` + `` *[Identifier](#Identifier)*
+
+ *AssertionClause* **:**
+ *[EmptyAssertionClause](#EmptyAssertionClause)*
+ *[LookaheadAssertionClause](#LookaheadAssertionClause)*
+ *[NoSymbolAssertionClause](#NoSymbolAssertionClause)*
+ *[LexicalGoalAssertionClause](#LexicalGoalAssertionClause)*
+ *[ParameterValueAssertionClause](#ParameterValueAssertionClause)*
+
+ *Assertion* **:**
+ `` [ `` *[AssertionClause](#AssertionClause)* `` ] ``
+
+ *ProseSpan* **:**
+ *[Prose](#Prose)*
+ *[ProseSpan](#ProseSpan)* *[LineTerminator](#LineTerminator)* *[Prose](#Prose)*
+
+ *Symbol* **:**
+ *[Assertion](#Assertion)*
+ *[BinarySymbol](#BinarySymbol)*
+
+ *SymbolSpan* **:**
+ *[ProseSpan](#ProseSpan)*
+ *[SymbolSpanRest](#SymbolSpanRest)*
+
+ *SymbolSpanRest* **:**
+ *[Symbol](#Symbol)* *[SymbolSpanRest](#SymbolSpanRest)*opt
+
+ *RightHandSideList* **:**
+ *[RightHandSide](#RightHandSide)* *[RightHandSideList](#RightHandSideList)*opt
+
+ *RightHandSide* **:**
+ *[SymbolSpan](#SymbolSpan)* *[LineTerminator](#LineTerminator)*
+
+ *Terminals* **:**
+ *[Terminal](#Terminal)* *[Terminals](#Terminals)*opt
+
+ *TerminalList* **:**
+ *[Terminals](#Terminals)*
+ *[TerminalList](#TerminalList)* *[LineTerminator](#LineTerminator)* *[Terminals](#Terminals)*
+
+ *OneOfList* **:**
+ `` one `` `` of `` *[Terminals](#Terminals)*
+ `` one `` `` of `` *[LineTerminator](#LineTerminator)* *[Indent](#Indent)* *[TerminalList](#TerminalList)* *[Dedent](#Dedent)*
+
+ *Parameter* **:**
+ *[Identifier](#Identifier)*
+
+ *ParameterList* **:**
+ *[Parameter](#Parameter)*
+ *[ParameterList](#ParameterList)* `` , `` *[Parameter](#Parameter)*
+
+ *Parameters* **:**
+ `` ( `` *[ParameterList](#ParameterList)* `` ) ``
+
+ *Production* **:**
+ *[Identifier](#Identifier)* *[Parameters](#Parameters)*opt `` : `` *[OneOfList](#OneOfList)*
+ *[Identifier](#Identifier)* *[Parameters](#Parameters)*opt `` : `` *[RightHandSide](#RightHandSide)*
+ *[Identifier](#Identifier)* *[Parameters](#Parameters)*opt `` : `` *[LineTerminator](#LineTerminator)* *[Indent](#Indent)* *[RightHandSideList](#RightHandSideList)* *[Dedent](#Dedent)*
+
+ *SourceElement* **:**
+ [empty]
+ *[Production](#Production)*
+
+ *SourceElements* **:**
+ *[SourceElement](#SourceElement)* *[SourceElements](#SourceElements)*opt
+
+ *SourceFile* **:**
+ *[SourceElements](#SourceElements)*
+
\ No newline at end of file
diff --git a/tests/baselines/reference/grammarkdown.grammar.nodes b/tests/baselines/reference/grammarkdown.grammar.nodes
new file mode 100644
index 0000000..471ae16
--- /dev/null
+++ b/tests/baselines/reference/grammarkdown.grammar.nodes
@@ -0,0 +1,989 @@
+/// grammarkdown.grammar:
+(1,1)SyntaxKind[SourceFile](filename = "grammarkdown.grammar")
+ (4,1)SyntaxKind[Production]
+ (4,1)SyntaxKind[Identifier](text = "SourceCharacter")
+ (5,1)SyntaxKind[RightHandSideList]
+ (5,1)SyntaxKind[IndentToken]
+ (5,2)SyntaxKind[RightHandSide]
+ (5,2)SyntaxKind[SymbolSpan]
+ (5,2)SyntaxKind[Prose]
+ (5,2)SyntaxKind[GreaterThanToken]
+ (5,4)SyntaxKind[ProseFull](text = "any Unicode code point")
+ (6,1)SyntaxKind[DedentToken]
+ (7,1)SyntaxKind[Production]
+ (7,1)SyntaxKind[Identifier](text = "LineTerminator")
+ (8,1)SyntaxKind[RightHandSideList]
+ (8,1)SyntaxKind[IndentToken]
+ (8,2)SyntaxKind[RightHandSide]
+ (8,2)SyntaxKind[SymbolSpan]
+ (8,2)SyntaxKind[UnicodeCharacterLiteral](text = )
+ (9,2)SyntaxKind[RightHandSide]
+ (9,2)SyntaxKind[SymbolSpan]
+ (9,2)SyntaxKind[UnicodeCharacterLiteral](text = )
+ (10,2)SyntaxKind[RightHandSide]
+ (10,2)SyntaxKind[SymbolSpan]
+ (10,2)SyntaxKind[UnicodeCharacterLiteral](text = )
+ (11,2)SyntaxKind[RightHandSide]
+ (11,2)SyntaxKind[SymbolSpan]
+ (11,2)SyntaxKind[UnicodeCharacterLiteral](text = )
+ (12,1)SyntaxKind[DedentToken]
+ (13,1)SyntaxKind[Production]
+ (13,1)SyntaxKind[Identifier](text = "IdentifierName")
+ (14,1)SyntaxKind[RightHandSideList]
+ (14,1)SyntaxKind[IndentToken]
+ (14,2)SyntaxKind[RightHandSide]
+ (14,2)SyntaxKind[SymbolSpan]
+ (14,2)SyntaxKind[Nonterminal]
+ (14,2)SyntaxKind[Identifier](text = "IdentifierStart")
+ (15,2)SyntaxKind[RightHandSide]
+ (15,2)SyntaxKind[SymbolSpan]
+ (15,2)SyntaxKind[Nonterminal]
+ (15,2)SyntaxKind[Identifier](text = "IdentifierName")
+ (15,17)SyntaxKind[SymbolSpan]
+ (15,17)SyntaxKind[Nonterminal]
+ (15,17)SyntaxKind[Identifier](text = "IdentifierPart")
+ (16,1)SyntaxKind[DedentToken]
+ (17,1)SyntaxKind[Production]
+ (17,1)SyntaxKind[Identifier](text = "IdentifierStart")
+ (18,1)SyntaxKind[RightHandSideList]
+ (18,1)SyntaxKind[IndentToken]
+ (18,2)SyntaxKind[RightHandSide]
+ (18,2)SyntaxKind[SymbolSpan]
+ (18,2)SyntaxKind[Nonterminal]
+ (18,2)SyntaxKind[Identifier](text = "UnicodeIDStart")
+ (19,2)SyntaxKind[RightHandSide]
+ (19,2)SyntaxKind[SymbolSpan]
+ (19,2)SyntaxKind[Terminal](text = "_")
+ (20,1)SyntaxKind[DedentToken]
+ (21,1)SyntaxKind[Production]
+ (21,1)SyntaxKind[Identifier](text = "IdentifierPart")
+ (22,1)SyntaxKind[RightHandSideList]
+ (22,1)SyntaxKind[IndentToken]
+ (22,2)SyntaxKind[RightHandSide]
+ (22,2)SyntaxKind[SymbolSpan]
+ (22,2)SyntaxKind[Nonterminal]
+ (22,2)SyntaxKind[Identifier](text = "UnicodeIDContinue")
+ (23,2)SyntaxKind[RightHandSide]
+ (23,2)SyntaxKind[SymbolSpan]
+ (23,2)SyntaxKind[Terminal](text = "_")
+ (24,2)SyntaxKind[RightHandSide]
+ (24,2)SyntaxKind[SymbolSpan]
+ (24,2)SyntaxKind[UnicodeCharacterLiteral](text = )
+ (25,2)SyntaxKind[RightHandSide]
+ (25,2)SyntaxKind[SymbolSpan]
+ (25,2)SyntaxKind[UnicodeCharacterLiteral](text = )
+ (27,1)SyntaxKind[DedentToken]
+ (27,1)SyntaxKind[Production]
+ (27,1)SyntaxKind[Identifier](text = "UnicodeIDStart")
+ (28,1)SyntaxKind[RightHandSideList]
+ (28,1)SyntaxKind[IndentToken]
+ (28,2)SyntaxKind[RightHandSide]
+ (28,2)SyntaxKind[SymbolSpan]
+ (28,2)SyntaxKind[Prose]
+ (28,2)SyntaxKind[GreaterThanToken]
+ (28,4)SyntaxKind[ProseFull](text = "any Unicode code point with the Unicode property "ID_Start" or "Other_ID_Start"")
+ (29,1)SyntaxKind[DedentToken]
+ (30,1)SyntaxKind[Production]
+ (30,1)SyntaxKind[Identifier](text = "UnicodeIDContinue")
+ (31,1)SyntaxKind[RightHandSideList]
+ (31,1)SyntaxKind[IndentToken]
+ (31,2)SyntaxKind[RightHandSide]
+ (31,2)SyntaxKind[SymbolSpan]
+ (31,2)SyntaxKind[Prose]
+ (31,2)SyntaxKind[GreaterThanToken]
+ (31,4)SyntaxKind[ProseFull](text = "any Unicode code point with the Unicode property "ID_Continue" or "Other_ID_Continue", or "Other_ID_Start"")
+ (32,1)SyntaxKind[DedentToken]
+ (33,1)SyntaxKind[Production]
+ (33,1)SyntaxKind[Identifier](text = "ReservedWord")
+ (34,1)SyntaxKind[RightHandSideList]
+ (34,1)SyntaxKind[IndentToken]
+ (34,2)SyntaxKind[RightHandSide]
+ (34,2)SyntaxKind[SymbolSpan]
+ (34,2)SyntaxKind[Nonterminal]
+ (34,2)SyntaxKind[Identifier](text = "Keyword")
+ (36,1)SyntaxKind[DedentToken]
+ (36,1)SyntaxKind[Production]
+ (36,1)SyntaxKind[Identifier](text = "Keyword")
+ (36,12)SyntaxKind[OneOfList]
+ (36,12)SyntaxKind[OneKeyword]
+ (36,16)SyntaxKind[OfKeyword]
+ (37,1)SyntaxKind[IndentToken]
+ (37,2)SyntaxKind[Terminal](text = "empty")
+ (38,2)SyntaxKind[Terminal](text = "lookahead")
+ (39,2)SyntaxKind[Terminal](text = "lexical")
+ (40,2)SyntaxKind[Terminal](text = "goal")
+ (41,2)SyntaxKind[Terminal](text = "no")
+ (42,2)SyntaxKind[Terminal](text = "here")
+ (43,2)SyntaxKind[Terminal](text = "one")
+ (44,2)SyntaxKind[Terminal](text = "of")
+ (45,2)SyntaxKind[Terminal](text = "or")
+ (46,2)SyntaxKind[Terminal](text = "but")
+ (47,2)SyntaxKind[Terminal](text = "not")
+ (48,1)SyntaxKind[DedentToken]
+ (49,1)SyntaxKind[Production]
+ (49,1)SyntaxKind[Identifier](text = "DecimalDigit")
+ (49,17)SyntaxKind[OneOfList]
+ (49,17)SyntaxKind[OneKeyword]
+ (49,21)SyntaxKind[OfKeyword]
+ (50,1)SyntaxKind[IndentToken]
+ (50,2)SyntaxKind[Terminal](text = "0")
+ (50,6)SyntaxKind[Terminal](text = "1")
+ (50,10)SyntaxKind[Terminal](text = "2")
+ (50,14)SyntaxKind[Terminal](text = "3")
+ (50,18)SyntaxKind[Terminal](text = "4")
+ (50,22)SyntaxKind[Terminal](text = "5")
+ (50,26)SyntaxKind[Terminal](text = "6")
+ (50,30)SyntaxKind[Terminal](text = "7")
+ (50,34)SyntaxKind[Terminal](text = "8")
+ (50,38)SyntaxKind[Terminal](text = "9")
+ (51,1)SyntaxKind[DedentToken]
+ (52,1)SyntaxKind[Production]
+ (52,1)SyntaxKind[Identifier](text = "HexDigit")
+ (52,13)SyntaxKind[OneOfList]
+ (52,13)SyntaxKind[OneKeyword]
+ (52,17)SyntaxKind[OfKeyword]
+ (53,1)SyntaxKind[IndentToken]
+ (53,2)SyntaxKind[Terminal](text = "0")
+ (53,6)SyntaxKind[Terminal](text = "1")
+ (53,10)SyntaxKind[Terminal](text = "2")
+ (53,14)SyntaxKind[Terminal](text = "3")
+ (53,18)SyntaxKind[Terminal](text = "4")
+ (53,22)SyntaxKind[Terminal](text = "5")
+ (53,26)SyntaxKind[Terminal](text = "6")
+ (53,30)SyntaxKind[Terminal](text = "7")
+ (53,34)SyntaxKind[Terminal](text = "8")
+ (53,38)SyntaxKind[Terminal](text = "9")
+ (53,42)SyntaxKind[Terminal](text = "a")
+ (53,46)SyntaxKind[Terminal](text = "b")
+ (53,50)SyntaxKind[Terminal](text = "c")
+ (53,54)SyntaxKind[Terminal](text = "d")
+ (53,58)SyntaxKind[Terminal](text = "e")
+ (53,62)SyntaxKind[Terminal](text = "f")
+ (53,66)SyntaxKind[Terminal](text = "A")
+ (53,70)SyntaxKind[Terminal](text = "B")
+ (53,74)SyntaxKind[Terminal](text = "C")
+ (53,78)SyntaxKind[Terminal](text = "D")
+ (53,82)SyntaxKind[Terminal](text = "E")
+ (53,86)SyntaxKind[Terminal](text = "F")
+ (54,1)SyntaxKind[DedentToken]
+ (55,1)SyntaxKind[Production]
+ (55,1)SyntaxKind[Identifier](text = "UnicodeCharacterLiteral")
+ (56,1)SyntaxKind[RightHandSideList]
+ (56,1)SyntaxKind[IndentToken]
+ (56,2)SyntaxKind[RightHandSide]
+ (56,2)SyntaxKind[SymbolSpan]
+ (56,2)SyntaxKind[Terminal](text = "<")
+ (56,6)SyntaxKind[SymbolSpan]
+ (56,6)SyntaxKind[Nonterminal]
+ (56,6)SyntaxKind[Identifier](text = "UnicodeCharacterLiteralChars")
+ (56,35)SyntaxKind[SymbolSpan]
+ (56,35)SyntaxKind[Terminal](text = ">")
+ (57,1)SyntaxKind[DedentToken]
+ (58,1)SyntaxKind[Production]
+ (58,1)SyntaxKind[Identifier](text = "UnicodeCharacterLiteralChars")
+ (59,1)SyntaxKind[RightHandSideList]
+ (59,1)SyntaxKind[IndentToken]
+ (59,2)SyntaxKind[RightHandSide]
+ (59,2)SyntaxKind[SymbolSpan]
+ (59,2)SyntaxKind[Nonterminal]
+ (59,2)SyntaxKind[Identifier](text = "UnicodeCharacterLiteralChar")
+ (59,30)SyntaxKind[SymbolSpan]
+ (59,30)SyntaxKind[Nonterminal]?
+ (59,30)SyntaxKind[Identifier](text = "UnicodeCharacterLiteralChars")
+ (59,58)SyntaxKind[QuestionToken]
+ (60,1)SyntaxKind[DedentToken]
+ (61,1)SyntaxKind[Production]
+ (61,1)SyntaxKind[Identifier](text = "UnicodeCharacterLiteralChar")
+ (62,1)SyntaxKind[RightHandSideList]
+ (62,1)SyntaxKind[IndentToken]
+ (62,2)SyntaxKind[RightHandSide]
+ (62,2)SyntaxKind[SymbolSpan]
+ (62,2)SyntaxKind[ButNotSymbol]
+ (62,2)SyntaxKind[Nonterminal]
+ (62,2)SyntaxKind[Identifier](text = "SourceCharacter")
+ (62,18)SyntaxKind[ButKeyword]
+ (62,22)SyntaxKind[NotKeyword]
+ (62,26)SyntaxKind[OneOfSymbol]
+ (62,33)SyntaxKind[Terminal](text = "<")
+ (62,40)SyntaxKind[Terminal](text = ">")
+ (62,47)SyntaxKind[Nonterminal]
+ (62,47)SyntaxKind[Identifier](text = "LineTerminator")
+ (64,1)SyntaxKind[DedentToken]
+ (64,1)SyntaxKind[Production]
+ (64,1)SyntaxKind[Identifier](text = "Indent")
+ (65,1)SyntaxKind[RightHandSideList]
+ (65,1)SyntaxKind[IndentToken]
+ (65,2)SyntaxKind[RightHandSide]
+ (65,2)SyntaxKind[SymbolSpan]
+ (65,2)SyntaxKind[Prose]
+ (65,2)SyntaxKind[GreaterThanToken]
+ (65,4)SyntaxKind[ProseFull](text = "An increase in the indentation depth from the previous line.")
+ (67,1)SyntaxKind[DedentToken]
+ (67,1)SyntaxKind[Production]
+ (67,1)SyntaxKind[Identifier](text = "Dedent")
+ (68,1)SyntaxKind[RightHandSideList]
+ (68,1)SyntaxKind[IndentToken]
+ (68,2)SyntaxKind[RightHandSide]
+ (68,2)SyntaxKind[SymbolSpan]
+ (68,2)SyntaxKind[Prose]
+ (68,2)SyntaxKind[GreaterThanToken]
+ (68,4)SyntaxKind[ProseFull](text = "A decrease in the indentation depth from the previous line.")
+ (69,1)SyntaxKind[DedentToken]
+ (70,1)SyntaxKind[Production]
+ (70,1)SyntaxKind[Identifier](text = "Terminal")
+ (71,1)SyntaxKind[RightHandSideList]
+ (71,1)SyntaxKind[IndentToken]
+ (71,2)SyntaxKind[RightHandSide]
+ (71,2)SyntaxKind[SymbolSpan]
+ (71,2)SyntaxKind[Terminal](text = "`")
+ (71,6)SyntaxKind[SymbolSpan]
+ (71,6)SyntaxKind[Terminal](text = "`")
+ (71,10)SyntaxKind[SymbolSpan]
+ (71,10)SyntaxKind[Terminal](text = "`")
+ (72,2)SyntaxKind[RightHandSide]
+ (72,2)SyntaxKind[SymbolSpan]
+ (72,2)SyntaxKind[Terminal](text = "`")
+ (72,6)SyntaxKind[SymbolSpan]
+ (72,6)SyntaxKind[Nonterminal]
+ (72,6)SyntaxKind[Identifier](text = "TerminalChars")
+ (72,20)SyntaxKind[SymbolSpan]
+ (72,20)SyntaxKind[Terminal](text = "`")
+ (73,1)SyntaxKind[DedentToken]
+ (74,1)SyntaxKind[Production]
+ (74,1)SyntaxKind[Identifier](text = "TerminalChars")
+ (75,1)SyntaxKind[RightHandSideList]
+ (75,1)SyntaxKind[IndentToken]
+ (75,2)SyntaxKind[RightHandSide]
+ (75,2)SyntaxKind[SymbolSpan]
+ (75,2)SyntaxKind[Nonterminal]
+ (75,2)SyntaxKind[Identifier](text = "TerminalChar")
+ (75,15)SyntaxKind[SymbolSpan]
+ (75,15)SyntaxKind[Nonterminal]?
+ (75,15)SyntaxKind[Identifier](text = "TerminalChars")
+ (75,28)SyntaxKind[QuestionToken]
+ (76,1)SyntaxKind[DedentToken]
+ (77,1)SyntaxKind[Production]
+ (77,1)SyntaxKind[Identifier](text = "TerminalChar")
+ (78,1)SyntaxKind[RightHandSideList]
+ (78,1)SyntaxKind[IndentToken]
+ (78,2)SyntaxKind[RightHandSide]
+ (78,2)SyntaxKind[SymbolSpan]
+ (78,2)SyntaxKind[ButNotSymbol]
+ (78,2)SyntaxKind[Nonterminal]
+ (78,2)SyntaxKind[Identifier](text = "SourceCharacter")
+ (78,18)SyntaxKind[ButKeyword]
+ (78,22)SyntaxKind[NotKeyword]
+ (78,26)SyntaxKind[OneOfSymbol]
+ (78,33)SyntaxKind[Terminal](text = "`")
+ (78,40)SyntaxKind[Nonterminal]
+ (78,40)SyntaxKind[Identifier](text = "LineTerminator")
+ (79,1)SyntaxKind[DedentToken]
+ (80,1)SyntaxKind[Production]
+ (80,1)SyntaxKind[Identifier](text = "Prose")
+ (81,1)SyntaxKind[RightHandSideList]
+ (81,1)SyntaxKind[IndentToken]
+ (81,2)SyntaxKind[RightHandSide]
+ (81,2)SyntaxKind[SymbolSpan]
+ (81,2)SyntaxKind[Nonterminal]
+ (81,2)SyntaxKind[Identifier](text = "ProseLines")
+ (82,1)SyntaxKind[DedentToken]
+ (83,1)SyntaxKind[Production]
+ (83,1)SyntaxKind[Identifier](text = "ProseLines")
+ (84,1)SyntaxKind[RightHandSideList]
+ (84,1)SyntaxKind[IndentToken]
+ (84,2)SyntaxKind[RightHandSide]
+ (84,2)SyntaxKind[SymbolSpan]
+ (84,2)SyntaxKind[Nonterminal]
+ (84,2)SyntaxKind[Identifier](text = "ProseLine")
+ (85,2)SyntaxKind[RightHandSide]
+ (85,2)SyntaxKind[SymbolSpan]
+ (85,2)SyntaxKind[Nonterminal]
+ (85,2)SyntaxKind[Identifier](text = "ProseLine")
+ (85,12)SyntaxKind[SymbolSpan]
+ (85,12)SyntaxKind[Nonterminal]
+ (85,12)SyntaxKind[Identifier](text = "LineTerminator")
+ (85,27)SyntaxKind[SymbolSpan]
+ (85,27)SyntaxKind[Nonterminal]
+ (85,27)SyntaxKind[Identifier](text = "ProseLines")
+ (87,1)SyntaxKind[DedentToken]
+ (87,1)SyntaxKind[Production]
+ (87,1)SyntaxKind[Identifier](text = "ProseLine")
+ (88,1)SyntaxKind[RightHandSideList]
+ (88,1)SyntaxKind[IndentToken]
+ (88,2)SyntaxKind[RightHandSide]
+ (88,2)SyntaxKind[SymbolSpan]
+ (88,2)SyntaxKind[Terminal](text = ">")
+ (88,6)SyntaxKind[SymbolSpan]
+ (88,6)SyntaxKind[Nonterminal]?
+ (88,6)SyntaxKind[Identifier](text = "ProseChars")
+ (88,16)SyntaxKind[QuestionToken]
+ (89,1)SyntaxKind[DedentToken]
+ (90,1)SyntaxKind[Production]
+ (90,1)SyntaxKind[Identifier](text = "ProseChars")
+ (91,1)SyntaxKind[RightHandSideList]
+ (91,1)SyntaxKind[IndentToken]
+ (91,2)SyntaxKind[RightHandSide]
+ (91,2)SyntaxKind[SymbolSpan]
+ (91,2)SyntaxKind[Nonterminal]
+ (91,2)SyntaxKind[Identifier](text = "ProseChar")
+ (91,12)SyntaxKind[SymbolSpan]
+ (91,12)SyntaxKind[Nonterminal]?
+ (91,12)SyntaxKind[Identifier](text = "ProseChars")
+ (91,22)SyntaxKind[QuestionToken]
+ (92,1)SyntaxKind[DedentToken]
+ (93,1)SyntaxKind[Production]
+ (93,1)SyntaxKind[Identifier](text = "ProseChar")
+ (94,1)SyntaxKind[RightHandSideList]
+ (94,1)SyntaxKind[IndentToken]
+ (94,2)SyntaxKind[RightHandSide]
+ (94,2)SyntaxKind[SymbolSpan]
+ (94,2)SyntaxKind[ButNotSymbol]
+ (94,2)SyntaxKind[Nonterminal]
+ (94,2)SyntaxKind[Identifier](text = "SourceCharacter")
+ (94,18)SyntaxKind[ButKeyword]
+ (94,22)SyntaxKind[NotKeyword]
+ (94,26)SyntaxKind[Nonterminal]
+ (94,26)SyntaxKind[Identifier](text = "LineTerminator")
+ (95,1)SyntaxKind[DedentToken]
+ (99,1)SyntaxKind[Production]
+ (99,1)SyntaxKind[Identifier](text = "Identifier")
+ (100,1)SyntaxKind[RightHandSideList]
+ (100,1)SyntaxKind[IndentToken]
+ (100,2)SyntaxKind[RightHandSide]
+ (100,2)SyntaxKind[SymbolSpan]
+ (100,2)SyntaxKind[ButNotSymbol]
+ (100,2)SyntaxKind[Nonterminal]
+ (100,2)SyntaxKind[Identifier](text = "IdentifierName")
+ (100,17)SyntaxKind[ButKeyword]
+ (100,21)SyntaxKind[NotKeyword]
+ (100,25)SyntaxKind[Nonterminal]
+ (100,25)SyntaxKind[Identifier](text = "ReservedWord")
+ (101,1)SyntaxKind[DedentToken]
+ (102,1)SyntaxKind[Production]
+ (102,1)SyntaxKind[Identifier](text = "Argument")
+ (103,1)SyntaxKind[RightHandSideList]
+ (103,1)SyntaxKind[IndentToken]
+ (103,2)SyntaxKind[RightHandSide]
+ (103,2)SyntaxKind[SymbolSpan]
+ (103,2)SyntaxKind[Nonterminal]
+ (103,2)SyntaxKind[Identifier](text = "Identifier")
+ (104,1)SyntaxKind[DedentToken]
+ (105,1)SyntaxKind[Production]
+ (105,1)SyntaxKind[Identifier](text = "Arguments")
+ (106,1)SyntaxKind[RightHandSideList]
+ (106,1)SyntaxKind[IndentToken]
+ (106,2)SyntaxKind[RightHandSide]
+ (106,2)SyntaxKind[SymbolSpan]
+ (106,2)SyntaxKind[Terminal](text = "(")
+ (106,6)SyntaxKind[SymbolSpan]
+ (106,6)SyntaxKind[Terminal](text = ")")
+ (107,2)SyntaxKind[RightHandSide]
+ (107,2)SyntaxKind[SymbolSpan]
+ (107,2)SyntaxKind[Terminal](text = "(")
+ (107,6)SyntaxKind[SymbolSpan]
+ (107,6)SyntaxKind[Nonterminal]
+ (107,6)SyntaxKind[Identifier](text = "ArgumentList")
+ (107,19)SyntaxKind[SymbolSpan]
+ (107,19)SyntaxKind[Terminal](text = ")")
+ (108,1)SyntaxKind[DedentToken]
+ (109,1)SyntaxKind[Production]
+ (109,1)SyntaxKind[Identifier](text = "ArgumentList")
+ (110,1)SyntaxKind[RightHandSideList]
+ (110,1)SyntaxKind[IndentToken]
+ (110,2)SyntaxKind[RightHandSide]
+ (110,2)SyntaxKind[SymbolSpan]
+ (110,2)SyntaxKind[Nonterminal]
+ (110,2)SyntaxKind[Identifier](text = "Argument")
+ (111,2)SyntaxKind[RightHandSide]
+ (111,2)SyntaxKind[SymbolSpan]
+ (111,2)SyntaxKind[Nonterminal]
+ (111,2)SyntaxKind[Identifier](text = "ArgumentList")
+ (111,15)SyntaxKind[SymbolSpan]
+ (111,15)SyntaxKind[Terminal](text = ",")
+ (111,19)SyntaxKind[SymbolSpan]
+ (111,19)SyntaxKind[Nonterminal]
+ (111,19)SyntaxKind[Identifier](text = "Argument")
+ (112,1)SyntaxKind[DedentToken]
+ (113,1)SyntaxKind[Production]
+ (113,1)SyntaxKind[Identifier](text = "PrimarySymbol")
+ (114,1)SyntaxKind[RightHandSideList]
+ (114,1)SyntaxKind[IndentToken]
+ (114,2)SyntaxKind[RightHandSide]
+ (114,2)SyntaxKind[SymbolSpan]
+ (114,2)SyntaxKind[Nonterminal]
+ (114,2)SyntaxKind[Identifier](text = "Terminal")
+ (115,2)SyntaxKind[RightHandSide]
+ (115,2)SyntaxKind[SymbolSpan]
+ (115,2)SyntaxKind[Nonterminal]
+ (115,2)SyntaxKind[Identifier](text = "UnicodeCharacterLiteral")
+ (116,2)SyntaxKind[RightHandSide]
+ (116,2)SyntaxKind[SymbolSpan]
+ (116,2)SyntaxKind[Nonterminal]
+ (116,2)SyntaxKind[Identifier](text = "Nonterminal")
+ (118,1)SyntaxKind[DedentToken]
+ (118,1)SyntaxKind[Production]
+ (118,1)SyntaxKind[Identifier](text = "Nonterminal")
+ (119,1)SyntaxKind[RightHandSideList]
+ (119,1)SyntaxKind[IndentToken]
+ (119,2)SyntaxKind[RightHandSide]
+ (119,2)SyntaxKind[SymbolSpan]
+ (119,2)SyntaxKind[Nonterminal]
+ (119,2)SyntaxKind[Identifier](text = "Identifier")
+ (119,13)SyntaxKind[SymbolSpan]
+ (119,13)SyntaxKind[Nonterminal]?
+ (119,13)SyntaxKind[Identifier](text = "Arguments")
+ (119,22)SyntaxKind[QuestionToken]
+ (120,1)SyntaxKind[DedentToken]
+ (121,1)SyntaxKind[Production]
+ (121,1)SyntaxKind[Identifier](text = "OptionalSymbol")
+ (122,1)SyntaxKind[RightHandSideList]
+ (122,1)SyntaxKind[IndentToken]
+ (122,2)SyntaxKind[RightHandSide]
+ (122,2)SyntaxKind[SymbolSpan]
+ (122,2)SyntaxKind[Nonterminal]
+ (122,2)SyntaxKind[Identifier](text = "PrimarySymbol")
+ (122,16)SyntaxKind[SymbolSpan]
+ (122,16)SyntaxKind[Terminal](text = "?")?
+ (122,19)SyntaxKind[QuestionToken]
+ (123,1)SyntaxKind[DedentToken]
+ (124,1)SyntaxKind[Production]
+ (124,1)SyntaxKind[Identifier](text = "OrClause")
+ (125,1)SyntaxKind[RightHandSideList]
+ (125,1)SyntaxKind[IndentToken]
+ (125,2)SyntaxKind[RightHandSide]
+ (125,2)SyntaxKind[SymbolSpan]
+ (125,2)SyntaxKind[Nonterminal]
+ (125,2)SyntaxKind[Identifier](text = "PrimarySymbol")
+ (126,2)SyntaxKind[RightHandSide]
+ (126,2)SyntaxKind[SymbolSpan]
+ (126,2)SyntaxKind[Nonterminal]
+ (126,2)SyntaxKind[Identifier](text = "OrClause")
+ (126,11)SyntaxKind[SymbolSpan]
+ (126,11)SyntaxKind[Terminal](text = "or")
+ (126,16)SyntaxKind[SymbolSpan]
+ (126,16)SyntaxKind[Nonterminal]
+ (126,16)SyntaxKind[Identifier](text = "PrimarySymbol")
+ (127,1)SyntaxKind[DedentToken]
+ (128,1)SyntaxKind[Production]
+ (128,1)SyntaxKind[Identifier](text = "OneOfSymbol")
+ (129,1)SyntaxKind[RightHandSideList]
+ (129,1)SyntaxKind[IndentToken]
+ (129,2)SyntaxKind[RightHandSide]
+ (129,2)SyntaxKind[SymbolSpan]
+ (129,2)SyntaxKind[Nonterminal]
+ (129,2)SyntaxKind[Identifier](text = "PrimarySymbol")
+ (130,2)SyntaxKind[RightHandSide]
+ (130,2)SyntaxKind[SymbolSpan]
+ (130,2)SyntaxKind[Terminal](text = "one")
+ (130,8)SyntaxKind[SymbolSpan]
+ (130,8)SyntaxKind[Terminal](text = "of")
+ (130,13)SyntaxKind[SymbolSpan]
+ (130,13)SyntaxKind[Nonterminal]
+ (130,13)SyntaxKind[Identifier](text = "OrClause")
+ (131,1)SyntaxKind[DedentToken]
+ (132,1)SyntaxKind[Production]
+ (132,1)SyntaxKind[Identifier](text = "UnarySymbol")
+ (133,1)SyntaxKind[RightHandSideList]
+ (133,1)SyntaxKind[IndentToken]
+ (133,2)SyntaxKind[RightHandSide]
+ (133,2)SyntaxKind[SymbolSpan]
+ (133,2)SyntaxKind[Nonterminal]
+ (133,2)SyntaxKind[Identifier](text = "OneOfSymbol")
+ (134,1)SyntaxKind[DedentToken]
+ (135,1)SyntaxKind[Production]
+ (135,1)SyntaxKind[Identifier](text = "ButNotSymbol")
+ (136,1)SyntaxKind[RightHandSideList]
+ (136,1)SyntaxKind[IndentToken]
+ (136,2)SyntaxKind[RightHandSide]
+ (136,2)SyntaxKind[SymbolSpan]
+ (136,2)SyntaxKind[Nonterminal]
+ (136,2)SyntaxKind[Identifier](text = "UnarySymbol")
+ (136,14)SyntaxKind[SymbolSpan]
+ (136,14)SyntaxKind[Terminal](text = "but")
+ (136,20)SyntaxKind[SymbolSpan]
+ (136,20)SyntaxKind[Terminal](text = "not")
+ (136,26)SyntaxKind[SymbolSpan]
+ (136,26)SyntaxKind[Nonterminal]
+ (136,26)SyntaxKind[Identifier](text = "UnarySymbol")
+ (137,1)SyntaxKind[DedentToken]
+ (138,1)SyntaxKind[Production]
+ (138,1)SyntaxKind[Identifier](text = "BinarySymbol")
+ (139,1)SyntaxKind[RightHandSideList]
+ (139,1)SyntaxKind[IndentToken]
+ (139,2)SyntaxKind[RightHandSide]
+ (139,2)SyntaxKind[SymbolSpan]
+ (139,2)SyntaxKind[Nonterminal]
+ (139,2)SyntaxKind[Identifier](text = "ButNotSymbol")
+ (140,2)SyntaxKind[RightHandSide]
+ (140,2)SyntaxKind[SymbolSpan]
+ (140,2)SyntaxKind[Nonterminal]
+ (140,2)SyntaxKind[Identifier](text = "UnarySymbol")
+ (141,1)SyntaxKind[DedentToken]
+ (142,1)SyntaxKind[Production]
+ (142,1)SyntaxKind[Identifier](text = "SymbolList")
+ (143,1)SyntaxKind[RightHandSideList]
+ (143,1)SyntaxKind[IndentToken]
+ (143,2)SyntaxKind[RightHandSide]
+ (143,2)SyntaxKind[SymbolSpan]
+ (143,2)SyntaxKind[Nonterminal]
+ (143,2)SyntaxKind[Identifier](text = "PrimarySymbol")
+ (144,2)SyntaxKind[RightHandSide]
+ (144,2)SyntaxKind[SymbolSpan]
+ (144,2)SyntaxKind[Nonterminal]
+ (144,2)SyntaxKind[Identifier](text = "SymbolList")
+ (144,13)SyntaxKind[SymbolSpan]
+ (144,13)SyntaxKind[Terminal](text = ",")
+ (144,17)SyntaxKind[SymbolSpan]
+ (144,17)SyntaxKind[Nonterminal]
+ (144,17)SyntaxKind[Identifier](text = "PrimarySymbol")
+ (145,1)SyntaxKind[DedentToken]
+ (146,1)SyntaxKind[Production]
+ (146,1)SyntaxKind[Identifier](text = "SymbolSet")
+ (147,1)SyntaxKind[RightHandSideList]
+ (147,1)SyntaxKind[IndentToken]
+ (147,2)SyntaxKind[RightHandSide]
+ (147,2)SyntaxKind[SymbolSpan]
+ (147,2)SyntaxKind[Terminal](text = "{")
+ (147,6)SyntaxKind[SymbolSpan]
+ (147,6)SyntaxKind[Nonterminal]
+ (147,6)SyntaxKind[Identifier](text = "SymbolList")
+ (147,17)SyntaxKind[SymbolSpan]
+ (147,17)SyntaxKind[Terminal](text = "}")
+ (148,1)SyntaxKind[DedentToken]
+ (149,1)SyntaxKind[Production]
+ (149,1)SyntaxKind[Identifier](text = "EmptyAssertionClause")
+ (150,1)SyntaxKind[RightHandSideList]
+ (150,1)SyntaxKind[IndentToken]
+ (150,2)SyntaxKind[RightHandSide]
+ (150,2)SyntaxKind[SymbolSpan]
+ (150,2)SyntaxKind[Terminal](text = "empty")
+ (151,1)SyntaxKind[DedentToken]
+ (152,1)SyntaxKind[Production]
+ (152,1)SyntaxKind[Identifier](text = "LookaheadEqualsAssertionClause")
+ (153,1)SyntaxKind[RightHandSideList]
+ (153,1)SyntaxKind[IndentToken]
+ (153,2)SyntaxKind[RightHandSide]
+ (153,2)SyntaxKind[SymbolSpan]
+ (153,2)SyntaxKind[Terminal](text = "lookahead")
+ (153,14)SyntaxKind[SymbolSpan]
+ (153,14)SyntaxKind[Terminal](text = "==")
+ (153,19)SyntaxKind[SymbolSpan]
+ (153,19)SyntaxKind[Nonterminal]
+ (153,19)SyntaxKind[Identifier](text = "PrimarySymbol")
+ (154,1)SyntaxKind[DedentToken]
+ (155,1)SyntaxKind[Production]
+ (155,1)SyntaxKind[Identifier](text = "LookaheadNotEqualsAssertionClause")
+ (156,1)SyntaxKind[RightHandSideList]
+ (156,1)SyntaxKind[IndentToken]
+ (156,2)SyntaxKind[RightHandSide]
+ (156,2)SyntaxKind[SymbolSpan]
+ (156,2)SyntaxKind[Terminal](text = "lookahead")
+ (156,14)SyntaxKind[SymbolSpan]
+ (156,14)SyntaxKind[Terminal](text = "!=")
+ (156,19)SyntaxKind[SymbolSpan]
+ (156,19)SyntaxKind[Nonterminal]
+ (156,19)SyntaxKind[Identifier](text = "PrimarySymbol")
+ (157,1)SyntaxKind[DedentToken]
+ (158,1)SyntaxKind[Production]
+ (158,1)SyntaxKind[Identifier](text = "LookaheadInAssertionClause")
+ (159,1)SyntaxKind[RightHandSideList]
+ (159,1)SyntaxKind[IndentToken]
+ (159,2)SyntaxKind[RightHandSide]
+ (159,2)SyntaxKind[SymbolSpan]
+ (159,2)SyntaxKind[Terminal](text = "lookahead")
+ (159,14)SyntaxKind[SymbolSpan]
+ (159,14)SyntaxKind[Terminal](text = "<-")
+ (159,19)SyntaxKind[SymbolSpan]
+ (159,19)SyntaxKind[Nonterminal]
+ (159,19)SyntaxKind[Identifier](text = "SymbolSet")
+ (160,1)SyntaxKind[DedentToken]
+ (161,1)SyntaxKind[Production]
+ (161,1)SyntaxKind[Identifier](text = "LookaheadNotInAssertionClause")
+ (162,1)SyntaxKind[RightHandSideList]
+ (162,1)SyntaxKind[IndentToken]
+ (162,2)SyntaxKind[RightHandSide]
+ (162,2)SyntaxKind[SymbolSpan]
+ (162,2)SyntaxKind[Terminal](text = "lookahead")
+ (162,14)SyntaxKind[SymbolSpan]
+ (162,14)SyntaxKind[Terminal](text = "
+SyntaxKind[ProseFull](5,4): any Unicode code point
+SyntaxKind[LineTerminatorToken](6,1): «line terminator»
+SyntaxKind[DedentToken](6,1): «dedent»
+SyntaxKind[LineTerminatorToken](7,1): «line terminator»
+SyntaxKind[Identifier](7,1): LineTerminator
+SyntaxKind[ColonColonToken](7,16): ::
+SyntaxKind[LineTerminatorToken](8,1): «line terminator»
+SyntaxKind[IndentToken](8,1): «indent»
+SyntaxKind[UnicodeCharacterLiteral](8,2):
+SyntaxKind[LineTerminatorToken](9,1): «line terminator»
+SyntaxKind[UnicodeCharacterLiteral](9,2):
+SyntaxKind[LineTerminatorToken](10,1): «line terminator»
+SyntaxKind[UnicodeCharacterLiteral](10,2):
+SyntaxKind[LineTerminatorToken](11,1): «line terminator»
+SyntaxKind[UnicodeCharacterLiteral](11,2):
+SyntaxKind[LineTerminatorToken](12,1): «line terminator»
+SyntaxKind[DedentToken](12,1): «dedent»
+SyntaxKind[LineTerminatorToken](13,1): «line terminator»
+SyntaxKind[Identifier](13,1): IdentifierName
+SyntaxKind[ColonColonToken](13,16): ::
+SyntaxKind[LineTerminatorToken](14,1): «line terminator»
+SyntaxKind[IndentToken](14,1): «indent»
+SyntaxKind[Identifier](14,2): IdentifierStart
+SyntaxKind[LineTerminatorToken](15,1): «line terminator»
+SyntaxKind[Identifier](15,2): IdentifierName
+SyntaxKind[Identifier](15,17): IdentifierPart
+SyntaxKind[LineTerminatorToken](16,1): «line terminator»
+SyntaxKind[DedentToken](16,1): «dedent»
+SyntaxKind[LineTerminatorToken](17,1): «line terminator»
+SyntaxKind[Identifier](17,1): IdentifierStart
+SyntaxKind[ColonColonToken](17,17): ::
+SyntaxKind[LineTerminatorToken](18,1): «line terminator»
+SyntaxKind[IndentToken](18,1): «indent»
+SyntaxKind[Identifier](18,2): UnicodeIDStart
+SyntaxKind[LineTerminatorToken](19,1): «line terminator»
+SyntaxKind[Terminal](19,2): `_`
+SyntaxKind[LineTerminatorToken](20,1): «line terminator»
+SyntaxKind[DedentToken](20,1): «dedent»
+SyntaxKind[LineTerminatorToken](21,1): «line terminator»
+SyntaxKind[Identifier](21,1): IdentifierPart
+SyntaxKind[ColonColonToken](21,16): ::
+SyntaxKind[LineTerminatorToken](22,1): «line terminator»
+SyntaxKind[IndentToken](22,1): «indent»
+SyntaxKind[Identifier](22,2): UnicodeIDContinue
+SyntaxKind[LineTerminatorToken](23,1): «line terminator»
+SyntaxKind[Terminal](23,2): `_`
+SyntaxKind[LineTerminatorToken](24,1): «line terminator»
+SyntaxKind[UnicodeCharacterLiteral](24,2):
+SyntaxKind[LineTerminatorToken](25,1): «line terminator»
+SyntaxKind[UnicodeCharacterLiteral](25,2):
+SyntaxKind[LineTerminatorToken](26,1): «line terminator»
+SyntaxKind[LineTerminatorToken](27,1): «line terminator»
+SyntaxKind[DedentToken](27,1): «dedent»
+SyntaxKind[Identifier](27,1): UnicodeIDStart
+SyntaxKind[ColonColonToken](27,16): ::
+SyntaxKind[LineTerminatorToken](28,1): «line terminator»
+SyntaxKind[IndentToken](28,1): «indent»
+SyntaxKind[GreaterThanToken](28,2): >
+SyntaxKind[ProseFull](28,4): any Unicode code point with the Unicode property "ID_Start" or "Other_ID_Start"
+SyntaxKind[LineTerminatorToken](29,1): «line terminator»
+SyntaxKind[DedentToken](29,1): «dedent»
+SyntaxKind[LineTerminatorToken](30,1): «line terminator»
+SyntaxKind[Identifier](30,1): UnicodeIDContinue
+SyntaxKind[ColonColonToken](30,19): ::
+SyntaxKind[LineTerminatorToken](31,1): «line terminator»
+SyntaxKind[IndentToken](31,1): «indent»
+SyntaxKind[GreaterThanToken](31,2): >
+SyntaxKind[ProseFull](31,4): any Unicode code point with the Unicode property "ID_Continue" or "Other_ID_Continue", or "Other_ID_Start"
+SyntaxKind[LineTerminatorToken](32,1): «line terminator»
+SyntaxKind[DedentToken](32,1): «dedent»
+SyntaxKind[LineTerminatorToken](33,1): «line terminator»
+SyntaxKind[Identifier](33,1): ReservedWord
+SyntaxKind[ColonColonToken](33,14): ::
+SyntaxKind[LineTerminatorToken](34,1): «line terminator»
+SyntaxKind[IndentToken](34,1): «indent»
+SyntaxKind[Identifier](34,2): Keyword
+SyntaxKind[LineTerminatorToken](35,1): «line terminator»
+SyntaxKind[LineTerminatorToken](36,1): «line terminator»
+SyntaxKind[DedentToken](36,1): «dedent»
+SyntaxKind[Identifier](36,1): Keyword
+SyntaxKind[ColonColonToken](36,9): ::
+SyntaxKind[OneKeyword](36,12): one
+SyntaxKind[OfKeyword](36,16): of
+SyntaxKind[LineTerminatorToken](37,1): «line terminator»
+SyntaxKind[IndentToken](37,1): «indent»
+SyntaxKind[Terminal](37,2): `empty`
+SyntaxKind[LineTerminatorToken](38,1): «line terminator»
+SyntaxKind[Terminal](38,2): `lookahead`
+SyntaxKind[LineTerminatorToken](39,1): «line terminator»
+SyntaxKind[Terminal](39,2): `lexical`
+SyntaxKind[LineTerminatorToken](40,1): «line terminator»
+SyntaxKind[Terminal](40,2): `goal`
+SyntaxKind[LineTerminatorToken](41,1): «line terminator»
+SyntaxKind[Terminal](41,2): `no`
+SyntaxKind[LineTerminatorToken](42,1): «line terminator»
+SyntaxKind[Terminal](42,2): `here`
+SyntaxKind[LineTerminatorToken](43,1): «line terminator»
+SyntaxKind[Terminal](43,2): `one`
+SyntaxKind[LineTerminatorToken](44,1): «line terminator»
+SyntaxKind[Terminal](44,2): `of`
+SyntaxKind[LineTerminatorToken](45,1): «line terminator»
+SyntaxKind[Terminal](45,2): `or`
+SyntaxKind[LineTerminatorToken](46,1): «line terminator»
+SyntaxKind[Terminal](46,2): `but`
+SyntaxKind[LineTerminatorToken](47,1): «line terminator»
+SyntaxKind[Terminal](47,2): `not`
+SyntaxKind[LineTerminatorToken](48,1): «line terminator»
+SyntaxKind[DedentToken](48,1): «dedent»
+SyntaxKind[LineTerminatorToken](49,1): «line terminator»
+SyntaxKind[Identifier](49,1): DecimalDigit
+SyntaxKind[ColonColonToken](49,14): ::
+SyntaxKind[OneKeyword](49,17): one
+SyntaxKind[OfKeyword](49,21): of
+SyntaxKind[LineTerminatorToken](50,1): «line terminator»
+SyntaxKind[IndentToken](50,1): «indent»
+SyntaxKind[Terminal](50,2): `0`
+SyntaxKind[Terminal](50,6): `1`
+SyntaxKind[Terminal](50,10): `2`
+SyntaxKind[Terminal](50,14): `3`
+SyntaxKind[Terminal](50,18): `4`
+SyntaxKind[Terminal](50,22): `5`
+SyntaxKind[Terminal](50,26): `6`
+SyntaxKind[Terminal](50,30): `7`
+SyntaxKind[Terminal](50,34): `8`
+SyntaxKind[Terminal](50,38): `9`
+SyntaxKind[LineTerminatorToken](51,1): «line terminator»
+SyntaxKind[DedentToken](51,1): «dedent»
+SyntaxKind[LineTerminatorToken](52,1): «line terminator»
+SyntaxKind[Identifier](52,1): HexDigit
+SyntaxKind[ColonColonToken](52,10): ::
+SyntaxKind[OneKeyword](52,13): one
+SyntaxKind[OfKeyword](52,17): of
+SyntaxKind[LineTerminatorToken](53,1): «line terminator»
+SyntaxKind[IndentToken](53,1): «indent»
+SyntaxKind[Terminal](53,2): `0`
+SyntaxKind[Terminal](53,6): `1`
+SyntaxKind[Terminal](53,10): `2`
+SyntaxKind[Terminal](53,14): `3`
+SyntaxKind[Terminal](53,18): `4`
+SyntaxKind[Terminal](53,22): `5`
+SyntaxKind[Terminal](53,26): `6`
+SyntaxKind[Terminal](53,30): `7`
+SyntaxKind[Terminal](53,34): `8`
+SyntaxKind[Terminal](53,38): `9`
+SyntaxKind[Terminal](53,42): `a`
+SyntaxKind[Terminal](53,46): `b`
+SyntaxKind[Terminal](53,50): `c`
+SyntaxKind[Terminal](53,54): `d`
+SyntaxKind[Terminal](53,58): `e`
+SyntaxKind[Terminal](53,62): `f`
+SyntaxKind[Terminal](53,66): `A`
+SyntaxKind[Terminal](53,70): `B`
+SyntaxKind[Terminal](53,74): `C`
+SyntaxKind[Terminal](53,78): `D`
+SyntaxKind[Terminal](53,82): `E`
+SyntaxKind[Terminal](53,86): `F`
+SyntaxKind[LineTerminatorToken](54,1): «line terminator»
+SyntaxKind[DedentToken](54,1): «dedent»
+SyntaxKind[LineTerminatorToken](55,1): «line terminator»
+SyntaxKind[Identifier](55,1): UnicodeCharacterLiteral
+SyntaxKind[ColonColonToken](55,25): ::
+SyntaxKind[LineTerminatorToken](56,1): «line terminator»
+SyntaxKind[IndentToken](56,1): «indent»
+SyntaxKind[Terminal](56,2): `<`
+SyntaxKind[Identifier](56,6): UnicodeCharacterLiteralChars
+SyntaxKind[Terminal](56,35): `>`
+SyntaxKind[LineTerminatorToken](57,1): «line terminator»
+SyntaxKind[DedentToken](57,1): «dedent»
+SyntaxKind[LineTerminatorToken](58,1): «line terminator»
+SyntaxKind[Identifier](58,1): UnicodeCharacterLiteralChars
+SyntaxKind[ColonColonToken](58,30): ::
+SyntaxKind[LineTerminatorToken](59,1): «line terminator»
+SyntaxKind[IndentToken](59,1): «indent»
+SyntaxKind[Identifier](59,2): UnicodeCharacterLiteralChar
+SyntaxKind[Identifier](59,30): UnicodeCharacterLiteralChars
+SyntaxKind[QuestionToken](59,58): ?
+SyntaxKind[LineTerminatorToken](60,1): «line terminator»
+SyntaxKind[DedentToken](60,1): «dedent»
+SyntaxKind[LineTerminatorToken](61,1): «line terminator»
+SyntaxKind[Identifier](61,1): UnicodeCharacterLiteralChar
+SyntaxKind[ColonColonToken](61,29): ::
+SyntaxKind[LineTerminatorToken](62,1): «line terminator»
+SyntaxKind[IndentToken](62,1): «indent»
+SyntaxKind[Identifier](62,2): SourceCharacter
+SyntaxKind[ButKeyword](62,18): but
+SyntaxKind[NotKeyword](62,22): not
+SyntaxKind[OneKeyword](62,26): one
+SyntaxKind[OfKeyword](62,30): of
+SyntaxKind[Terminal](62,33): `<`
+SyntaxKind[OrKeyword](62,37): or
+SyntaxKind[Terminal](62,40): `>`
+SyntaxKind[OrKeyword](62,44): or
+SyntaxKind[Identifier](62,47): LineTerminator
+SyntaxKind[LineTerminatorToken](63,1): «line terminator»
+SyntaxKind[LineTerminatorToken](64,1): «line terminator»
+SyntaxKind[DedentToken](64,1): «dedent»
+SyntaxKind[Identifier](64,1): Indent
+SyntaxKind[ColonColonToken](64,8): ::
+SyntaxKind[LineTerminatorToken](65,1): «line terminator»
+SyntaxKind[IndentToken](65,1): «indent»
+SyntaxKind[GreaterThanToken](65,2): >
+SyntaxKind[ProseFull](65,4): An increase in the indentation depth from the previous line.
+SyntaxKind[LineTerminatorToken](66,1): «line terminator»
+SyntaxKind[LineTerminatorToken](67,1): «line terminator»
+SyntaxKind[DedentToken](67,1): «dedent»
+SyntaxKind[Identifier](67,1): Dedent
+SyntaxKind[ColonColonToken](67,8): ::
+SyntaxKind[LineTerminatorToken](68,1): «line terminator»
+SyntaxKind[IndentToken](68,1): «indent»
+SyntaxKind[GreaterThanToken](68,2): >
+SyntaxKind[ProseFull](68,4): A decrease in the indentation depth from the previous line.
+SyntaxKind[LineTerminatorToken](69,1): «line terminator»
+SyntaxKind[DedentToken](69,1): «dedent»
+SyntaxKind[LineTerminatorToken](70,1): «line terminator»
+SyntaxKind[Identifier](70,1): Terminal
+SyntaxKind[ColonColonToken](70,10): ::
+SyntaxKind[LineTerminatorToken](71,1): «line terminator»
+SyntaxKind[IndentToken](71,1): «indent»
+SyntaxKind[Terminal](71,2): ```
+SyntaxKind[Terminal](71,6): ```
+SyntaxKind[Terminal](71,10): ```
+SyntaxKind[LineTerminatorToken](72,1): «line terminator»
+SyntaxKind[Terminal](72,2): ```
+SyntaxKind[Identifier](72,6): TerminalChars
+SyntaxKind[Terminal](72,20): ```
+SyntaxKind[LineTerminatorToken](73,1): «line terminator»
+SyntaxKind[DedentToken](73,1): «dedent»
+SyntaxKind[LineTerminatorToken](74,1): «line terminator»
+SyntaxKind[Identifier](74,1): TerminalChars
+SyntaxKind[ColonColonToken](74,15): ::
+SyntaxKind[LineTerminatorToken](75,1): «line terminator»
+SyntaxKind[IndentToken](75,1): «indent»
+SyntaxKind[Identifier](75,2): TerminalChar
+SyntaxKind[Identifier](75,15): TerminalChars
+SyntaxKind[QuestionToken](75,28): ?
+SyntaxKind[LineTerminatorToken](76,1): «line terminator»
+SyntaxKind[DedentToken](76,1): «dedent»
+SyntaxKind[LineTerminatorToken](77,1): «line terminator»
+SyntaxKind[Identifier](77,1): TerminalChar
+SyntaxKind[ColonColonToken](77,14): ::
+SyntaxKind[LineTerminatorToken](78,1): «line terminator»
+SyntaxKind[IndentToken](78,1): «indent»
+SyntaxKind[Identifier](78,2): SourceCharacter
+SyntaxKind[ButKeyword](78,18): but
+SyntaxKind[NotKeyword](78,22): not
+SyntaxKind[OneKeyword](78,26): one
+SyntaxKind[OfKeyword](78,30): of
+SyntaxKind[Terminal](78,33): ```
+SyntaxKind[OrKeyword](78,37): or
+SyntaxKind[Identifier](78,40): LineTerminator
+SyntaxKind[LineTerminatorToken](79,1): «line terminator»
+SyntaxKind[DedentToken](79,1): «dedent»
+SyntaxKind[LineTerminatorToken](80,1): «line terminator»
+SyntaxKind[Identifier](80,1): Prose
+SyntaxKind[ColonColonToken](80,7): ::
+SyntaxKind[LineTerminatorToken](81,1): «line terminator»
+SyntaxKind[IndentToken](81,1): «indent»
+SyntaxKind[Identifier](81,2): ProseLines
+SyntaxKind[LineTerminatorToken](82,1): «line terminator»
+SyntaxKind[DedentToken](82,1): «dedent»
+SyntaxKind[LineTerminatorToken](83,1): «line terminator»
+SyntaxKind[Identifier](83,1): ProseLines
+SyntaxKind[ColonColonToken](83,12): ::
+SyntaxKind[LineTerminatorToken](84,1): «line terminator»
+SyntaxKind[IndentToken](84,1): «indent»
+SyntaxKind[Identifier](84,2): ProseLine
+SyntaxKind[LineTerminatorToken](85,1): «line terminator»
+SyntaxKind[Identifier](85,2): ProseLine
+SyntaxKind[Identifier](85,12): LineTerminator
+SyntaxKind[Identifier](85,27): ProseLines
+SyntaxKind[LineTerminatorToken](86,1): «line terminator»
+SyntaxKind[LineTerminatorToken](87,1): «line terminator»
+SyntaxKind[DedentToken](87,1): «dedent»
+SyntaxKind[Identifier](87,1): ProseLine
+SyntaxKind[ColonColonToken](87,11): ::
+SyntaxKind[LineTerminatorToken](88,1): «line terminator»
+SyntaxKind[IndentToken](88,1): «indent»
+SyntaxKind[Terminal](88,2): `>`
+SyntaxKind[Identifier](88,6): ProseChars
+SyntaxKind[QuestionToken](88,16): ?
+SyntaxKind[LineTerminatorToken](89,1): «line terminator»
+SyntaxKind[DedentToken](89,1): «dedent»
+SyntaxKind[LineTerminatorToken](90,1): «line terminator»
+SyntaxKind[Identifier](90,1): ProseChars
+SyntaxKind[ColonColonToken](90,12): ::
+SyntaxKind[LineTerminatorToken](91,1): «line terminator»
+SyntaxKind[IndentToken](91,1): «indent»
+SyntaxKind[Identifier](91,2): ProseChar
+SyntaxKind[Identifier](91,12): ProseChars
+SyntaxKind[QuestionToken](91,22): ?
+SyntaxKind[LineTerminatorToken](92,1): «line terminator»
+SyntaxKind[DedentToken](92,1): «dedent»
+SyntaxKind[LineTerminatorToken](93,1): «line terminator»
+SyntaxKind[Identifier](93,1): ProseChar
+SyntaxKind[ColonColonToken](93,11): ::
+SyntaxKind[LineTerminatorToken](94,1): «line terminator»
+SyntaxKind[IndentToken](94,1): «indent»
+SyntaxKind[Identifier](94,2): SourceCharacter
+SyntaxKind[ButKeyword](94,18): but
+SyntaxKind[NotKeyword](94,22): not
+SyntaxKind[Identifier](94,26): LineTerminator
+SyntaxKind[LineTerminatorToken](95,1): «line terminator»
+SyntaxKind[DedentToken](95,1): «dedent»
+SyntaxKind[LineTerminatorToken](96,1): «line terminator»
+SyntaxKind[LineTerminatorToken](97,1): «line terminator»
+SyntaxKind[LineTerminatorToken](98,1): «line terminator»
+SyntaxKind[LineTerminatorToken](99,1): «line terminator»
+SyntaxKind[Identifier](99,1): Identifier
+SyntaxKind[ColonToken](99,12): :
+SyntaxKind[LineTerminatorToken](100,1): «line terminator»
+SyntaxKind[IndentToken](100,1): «indent»
+SyntaxKind[Identifier](100,2): IdentifierName
+SyntaxKind[ButKeyword](100,17): but
+SyntaxKind[NotKeyword](100,21): not
+SyntaxKind[Identifier](100,25): ReservedWord
+SyntaxKind[LineTerminatorToken](101,1): «line terminator»
+SyntaxKind[DedentToken](101,1): «dedent»
+SyntaxKind[LineTerminatorToken](102,1): «line terminator»
+SyntaxKind[Identifier](102,1): Argument
+SyntaxKind[ColonToken](102,10): :
+SyntaxKind[LineTerminatorToken](103,1): «line terminator»
+SyntaxKind[IndentToken](103,1): «indent»
+SyntaxKind[Identifier](103,2): Identifier
+SyntaxKind[LineTerminatorToken](104,1): «line terminator»
+SyntaxKind[DedentToken](104,1): «dedent»
+SyntaxKind[LineTerminatorToken](105,1): «line terminator»
+SyntaxKind[Identifier](105,1): Arguments
+SyntaxKind[ColonToken](105,11): :
+SyntaxKind[LineTerminatorToken](106,1): «line terminator»
+SyntaxKind[IndentToken](106,1): «indent»
+SyntaxKind[Terminal](106,2): `(`
+SyntaxKind[Terminal](106,6): `)`
+SyntaxKind[LineTerminatorToken](107,1): «line terminator»
+SyntaxKind[Terminal](107,2): `(`
+SyntaxKind[Identifier](107,6): ArgumentList
+SyntaxKind[Terminal](107,19): `)`
+SyntaxKind[LineTerminatorToken](108,1): «line terminator»
+SyntaxKind[DedentToken](108,1): «dedent»
+SyntaxKind[LineTerminatorToken](109,1): «line terminator»
+SyntaxKind[Identifier](109,1): ArgumentList
+SyntaxKind[ColonToken](109,14): :
+SyntaxKind[LineTerminatorToken](110,1): «line terminator»
+SyntaxKind[IndentToken](110,1): «indent»
+SyntaxKind[Identifier](110,2): Argument
+SyntaxKind[LineTerminatorToken](111,1): «line terminator»
+SyntaxKind[Identifier](111,2): ArgumentList
+SyntaxKind[Terminal](111,15): `,`
+SyntaxKind[Identifier](111,19): Argument
+SyntaxKind[LineTerminatorToken](112,1): «line terminator»
+SyntaxKind[DedentToken](112,1): «dedent»
+SyntaxKind[LineTerminatorToken](113,1): «line terminator»
+SyntaxKind[Identifier](113,1): PrimarySymbol
+SyntaxKind[ColonToken](113,15): :
+SyntaxKind[LineTerminatorToken](114,1): «line terminator»
+SyntaxKind[IndentToken](114,1): «indent»
+SyntaxKind[Identifier](114,2): Terminal
+SyntaxKind[LineTerminatorToken](115,1): «line terminator»
+SyntaxKind[Identifier](115,2): UnicodeCharacterLiteral
+SyntaxKind[LineTerminatorToken](116,1): «line terminator»
+SyntaxKind[Identifier](116,2): Nonterminal
+SyntaxKind[LineTerminatorToken](117,1): «line terminator»
+SyntaxKind[LineTerminatorToken](118,1): «line terminator»
+SyntaxKind[DedentToken](118,1): «dedent»
+SyntaxKind[Identifier](118,1): Nonterminal
+SyntaxKind[ColonToken](118,13): :
+SyntaxKind[LineTerminatorToken](119,1): «line terminator»
+SyntaxKind[IndentToken](119,1): «indent»
+SyntaxKind[Identifier](119,2): Identifier
+SyntaxKind[Identifier](119,13): Arguments
+SyntaxKind[QuestionToken](119,22): ?
+SyntaxKind[LineTerminatorToken](120,1): «line terminator»
+SyntaxKind[DedentToken](120,1): «dedent»
+SyntaxKind[LineTerminatorToken](121,1): «line terminator»
+SyntaxKind[Identifier](121,1): OptionalSymbol
+SyntaxKind[ColonToken](121,16): :
+SyntaxKind[LineTerminatorToken](122,1): «line terminator»
+SyntaxKind[IndentToken](122,1): «indent»
+SyntaxKind[Identifier](122,2): PrimarySymbol
+SyntaxKind[Terminal](122,16): `?`
+SyntaxKind[QuestionToken](122,19): ?
+SyntaxKind[LineTerminatorToken](123,1): «line terminator»
+SyntaxKind[DedentToken](123,1): «dedent»
+SyntaxKind[LineTerminatorToken](124,1): «line terminator»
+SyntaxKind[Identifier](124,1): OrClause
+SyntaxKind[ColonToken](124,10): :
+SyntaxKind[LineTerminatorToken](125,1): «line terminator»
+SyntaxKind[IndentToken](125,1): «indent»
+SyntaxKind[Identifier](125,2): PrimarySymbol
+SyntaxKind[LineTerminatorToken](126,1): «line terminator»
+SyntaxKind[Identifier](126,2): OrClause
+SyntaxKind[Terminal](126,11): `or`
+SyntaxKind[Identifier](126,16): PrimarySymbol
+SyntaxKind[LineTerminatorToken](127,1): «line terminator»
+SyntaxKind[DedentToken](127,1): «dedent»
+SyntaxKind[LineTerminatorToken](128,1): «line terminator»
+SyntaxKind[Identifier](128,1): OneOfSymbol
+SyntaxKind[ColonToken](128,13): :
+SyntaxKind[LineTerminatorToken](129,1): «line terminator»
+SyntaxKind[IndentToken](129,1): «indent»
+SyntaxKind[Identifier](129,2): PrimarySymbol
+SyntaxKind[LineTerminatorToken](130,1): «line terminator»
+SyntaxKind[Terminal](130,2): `one`
+SyntaxKind[Terminal](130,8): `of`
+SyntaxKind[Identifier](130,13): OrClause
+SyntaxKind[LineTerminatorToken](131,1): «line terminator»
+SyntaxKind[DedentToken](131,1): «dedent»
+SyntaxKind[LineTerminatorToken](132,1): «line terminator»
+SyntaxKind[Identifier](132,1): UnarySymbol
+SyntaxKind[ColonToken](132,13): :
+SyntaxKind[LineTerminatorToken](133,1): «line terminator»
+SyntaxKind[IndentToken](133,1): «indent»
+SyntaxKind[Identifier](133,2): OneOfSymbol
+SyntaxKind[LineTerminatorToken](134,1): «line terminator»
+SyntaxKind[DedentToken](134,1): «dedent»
+SyntaxKind[LineTerminatorToken](135,1): «line terminator»
+SyntaxKind[Identifier](135,1): ButNotSymbol
+SyntaxKind[ColonToken](135,14): :
+SyntaxKind[LineTerminatorToken](136,1): «line terminator»
+SyntaxKind[IndentToken](136,1): «indent»
+SyntaxKind[Identifier](136,2): UnarySymbol
+SyntaxKind[Terminal](136,14): `but`
+SyntaxKind[Terminal](136,20): `not`
+SyntaxKind[Identifier](136,26): UnarySymbol
+SyntaxKind[LineTerminatorToken](137,1): «line terminator»
+SyntaxKind[DedentToken](137,1): «dedent»
+SyntaxKind[LineTerminatorToken](138,1): «line terminator»
+SyntaxKind[Identifier](138,1): BinarySymbol
+SyntaxKind[ColonToken](138,14): :
+SyntaxKind[LineTerminatorToken](139,1): «line terminator»
+SyntaxKind[IndentToken](139,1): «indent»
+SyntaxKind[Identifier](139,2): ButNotSymbol
+SyntaxKind[LineTerminatorToken](140,1): «line terminator»
+SyntaxKind[Identifier](140,2): UnarySymbol
+SyntaxKind[LineTerminatorToken](141,1): «line terminator»
+SyntaxKind[DedentToken](141,1): «dedent»
+SyntaxKind[LineTerminatorToken](142,1): «line terminator»
+SyntaxKind[Identifier](142,1): SymbolList
+SyntaxKind[ColonToken](142,12): :
+SyntaxKind[LineTerminatorToken](143,1): «line terminator»
+SyntaxKind[IndentToken](143,1): «indent»
+SyntaxKind[Identifier](143,2): PrimarySymbol
+SyntaxKind[LineTerminatorToken](144,1): «line terminator»
+SyntaxKind[Identifier](144,2): SymbolList
+SyntaxKind[Terminal](144,13): `,`
+SyntaxKind[Identifier](144,17): PrimarySymbol
+SyntaxKind[LineTerminatorToken](145,1): «line terminator»
+SyntaxKind[DedentToken](145,1): «dedent»
+SyntaxKind[LineTerminatorToken](146,1): «line terminator»
+SyntaxKind[Identifier](146,1): SymbolSet
+SyntaxKind[ColonToken](146,11): :
+SyntaxKind[LineTerminatorToken](147,1): «line terminator»
+SyntaxKind[IndentToken](147,1): «indent»
+SyntaxKind[Terminal](147,2): `{`
+SyntaxKind[Identifier](147,6): SymbolList
+SyntaxKind[Terminal](147,17): `}`
+SyntaxKind[LineTerminatorToken](148,1): «line terminator»
+SyntaxKind[DedentToken](148,1): «dedent»
+SyntaxKind[LineTerminatorToken](149,1): «line terminator»
+SyntaxKind[Identifier](149,1): EmptyAssertionClause
+SyntaxKind[ColonToken](149,22): :
+SyntaxKind[LineTerminatorToken](150,1): «line terminator»
+SyntaxKind[IndentToken](150,1): «indent»
+SyntaxKind[Terminal](150,2): `empty`
+SyntaxKind[LineTerminatorToken](151,1): «line terminator»
+SyntaxKind[DedentToken](151,1): «dedent»
+SyntaxKind[LineTerminatorToken](152,1): «line terminator»
+SyntaxKind[Identifier](152,1): LookaheadEqualsAssertionClause
+SyntaxKind[ColonToken](152,32): :
+SyntaxKind[LineTerminatorToken](153,1): «line terminator»
+SyntaxKind[IndentToken](153,1): «indent»
+SyntaxKind[Terminal](153,2): `lookahead`
+SyntaxKind[Terminal](153,14): `==`
+SyntaxKind[Identifier](153,19): PrimarySymbol
+SyntaxKind[LineTerminatorToken](154,1): «line terminator»
+SyntaxKind[DedentToken](154,1): «dedent»
+SyntaxKind[LineTerminatorToken](155,1): «line terminator»
+SyntaxKind[Identifier](155,1): LookaheadNotEqualsAssertionClause
+SyntaxKind[ColonToken](155,35): :
+SyntaxKind[LineTerminatorToken](156,1): «line terminator»
+SyntaxKind[IndentToken](156,1): «indent»
+SyntaxKind[Terminal](156,2): `lookahead`
+SyntaxKind[Terminal](156,14): `!=`
+SyntaxKind[Identifier](156,19): PrimarySymbol
+SyntaxKind[LineTerminatorToken](157,1): «line terminator»
+SyntaxKind[DedentToken](157,1): «dedent»
+SyntaxKind[LineTerminatorToken](158,1): «line terminator»
+SyntaxKind[Identifier](158,1): LookaheadInAssertionClause
+SyntaxKind[ColonToken](158,28): :
+SyntaxKind[LineTerminatorToken](159,1): «line terminator»
+SyntaxKind[IndentToken](159,1): «indent»
+SyntaxKind[Terminal](159,2): `lookahead`
+SyntaxKind[Terminal](159,14): `<-`
+SyntaxKind[Identifier](159,19): SymbolSet
+SyntaxKind[LineTerminatorToken](160,1): «line terminator»
+SyntaxKind[DedentToken](160,1): «dedent»
+SyntaxKind[LineTerminatorToken](161,1): «line terminator»
+SyntaxKind[Identifier](161,1): LookaheadNotInAssertionClause
+SyntaxKind[ColonToken](161,31): :
+SyntaxKind[LineTerminatorToken](162,1): «line terminator»
+SyntaxKind[IndentToken](162,1): «indent»
+SyntaxKind[Terminal](162,2): `lookahead`
+SyntaxKind[Terminal](162,14): `
+
+ A
+ @
+ A
+
+
+
+ A but not one of " or \ or U+0000 through U+001F
+
+
+
+ A
+ full prose span
+
+
+
+
+ A
+ head terminal middle B tail
+
+
+
+ A
+
+
+ A
+
+
+ A
+
+
+ E
+ E
+ E
+ E
+ E
+ E
+ E
+
\ No newline at end of file
diff --git a/tests/baselines/reference/test.grammar.md b/tests/baselines/reference/test.grammar.md
new file mode 100644
index 0000000..8fef425
--- /dev/null
+++ b/tests/baselines/reference/test.grammar.md
@@ -0,0 +1,23 @@
+ *A* **:** *[A](#A)* @ *[A](#A)*
+
+ *B* **:** *[A](#A)* **but not** **one of** `` " `` **or** `` \ `` **or** U+0000 **through** U+001F
+
+ *C* **:** *[A](#A)* full prose span
+
+ *C* **:** *[A](#A)* head `` terminal `` middle *[B](#B)* tail
+
+ *D*[A] **:** *[A](#A)*
+
+ *D*[B] **:** *[A](#A)*
+
+ *E*[A] **:** *[A](#A)*
+
+ *F*[A] **:**
+ *[E](#E)*
+ *[E](#E)*[A]
+ *[E](#E)*[A, B]
+ *[E](#E)*[?B]
+ *[E](#E)*[+A]
+ *[E](#E)*[~A]
+ *[E](#E)*[?A]
+
\ No newline at end of file
diff --git a/tests/baselines/reference/test.grammar.nodes b/tests/baselines/reference/test.grammar.nodes
new file mode 100644
index 0000000..e89bbe1
--- /dev/null
+++ b/tests/baselines/reference/test.grammar.nodes
@@ -0,0 +1,163 @@
+/// test.grammar:
+(1,1)SyntaxKind[SourceFile](filename = "test.grammar")
+ (1,1)SyntaxKind[Production]
+ (1,1)SyntaxKind[Identifier](text = "A")
+ (1,5)SyntaxKind[RightHandSide]
+ (1,5)SyntaxKind[SymbolSpan]
+ (1,5)SyntaxKind[Nonterminal]
+ (1,5)SyntaxKind[Identifier](text = "A")
+ (1,7)SyntaxKind[SymbolSpan]
+ (1,7)SyntaxKind[AtToken]
+ (1,9)SyntaxKind[SymbolSpan]
+ (1,9)SyntaxKind[Nonterminal]
+ (1,9)SyntaxKind[Identifier](text = "A")
+ (2,1)SyntaxKind[Production]
+ (2,1)SyntaxKind[Identifier](text = "B")
+ (2,5)SyntaxKind[RightHandSide]
+ (2,5)SyntaxKind[SymbolSpan]
+ (2,5)SyntaxKind[ButNotSymbol]
+ (2,5)SyntaxKind[Nonterminal]
+ (2,5)SyntaxKind[Identifier](text = "A")
+ (2,9)SyntaxKind[ButKeyword]
+ (2,13)SyntaxKind[NotKeyword]
+ (2,17)SyntaxKind[OneOfSymbol]
+ (2,24)SyntaxKind[Terminal](text = """)
+ (2,31)SyntaxKind[Terminal](text = "\")
+ (2,38)SyntaxKind[UnicodeCharacterRange]
+ (2,38)SyntaxKind[UnicodeCharacterLiteral](text = U+0000)
+ (2,45)SyntaxKind[ThroughKeyword]
+ (2,53)SyntaxKind[UnicodeCharacterLiteral](text = U+001F)
+ (4,1)SyntaxKind[Production]
+ (4,1)SyntaxKind[Identifier](text = "C")
+ (4,5)SyntaxKind[RightHandSide]
+ (4,5)SyntaxKind[SymbolSpan]
+ (4,5)SyntaxKind[Nonterminal]
+ (4,5)SyntaxKind[Identifier](text = "A")
+ (4,7)SyntaxKind[SymbolSpan]
+ (4,7)SyntaxKind[ProseAssertion]
+ (4,7)SyntaxKind[OpenBracketGreaterThanToken]
+ (4,9)SyntaxKind[ProseFull](text = "full prose span")
+ (4,24)SyntaxKind[CloseBracketToken]
+ (5,1)SyntaxKind[Production]
+ (5,1)SyntaxKind[Identifier](text = "C")
+ (5,5)SyntaxKind[RightHandSide]
+ (5,5)SyntaxKind[SymbolSpan]
+ (5,5)SyntaxKind[Nonterminal]
+ (5,5)SyntaxKind[Identifier](text = "A")
+ (5,7)SyntaxKind[SymbolSpan]
+ (5,7)SyntaxKind[ProseAssertion]
+ (5,7)SyntaxKind[OpenBracketGreaterThanToken]
+ (5,9)SyntaxKind[ProseHead](text = "head ")
+ (5,14)SyntaxKind[Terminal](text = "terminal")
+ (5,24)SyntaxKind[ProseMiddle](text = " middle ")
+ (5,32)SyntaxKind[Nonterminal]
+ (5,32)SyntaxKind[Identifier](text = "B")
+ (5,35)SyntaxKind[ProseTail](text = " tail")
+ (5,40)SyntaxKind[CloseBracketToken]
+ (7,1)SyntaxKind[Production]
+ (7,1)SyntaxKind[Identifier](text = "D")
+ (7,2)SyntaxKind[ParameterList]
+ (7,2)SyntaxKind[OpenBracketToken]
+ (7,3)SyntaxKind[Parameter]
+ (7,3)SyntaxKind[Identifier](text = "A")
+ (7,4)SyntaxKind[CloseBracketToken]
+ (7,8)SyntaxKind[RightHandSide]
+ (7,8)SyntaxKind[SymbolSpan]
+ (7,8)SyntaxKind[Nonterminal]
+ (7,8)SyntaxKind[Identifier](text = "A")
+ (8,1)SyntaxKind[Production]
+ (8,1)SyntaxKind[Identifier](text = "D")
+ (8,2)SyntaxKind[ParameterList]
+ (8,2)SyntaxKind[OpenBracketToken]
+ (8,3)SyntaxKind[Parameter]
+ (8,3)SyntaxKind[Identifier](text = "B")
+ (8,4)SyntaxKind[CloseBracketToken]
+ (8,8)SyntaxKind[RightHandSide]
+ (8,8)SyntaxKind[SymbolSpan]
+ (8,8)SyntaxKind[Nonterminal]
+ (8,8)SyntaxKind[Identifier](text = "A")
+ (10,1)SyntaxKind[Production]
+ (10,1)SyntaxKind[Identifier](text = "E")
+ (10,2)SyntaxKind[ParameterList]
+ (10,2)SyntaxKind[OpenBracketToken]
+ (10,3)SyntaxKind[Parameter]
+ (10,3)SyntaxKind[Identifier](text = "A")
+ (10,4)SyntaxKind[CloseBracketToken]
+ (10,8)SyntaxKind[RightHandSide]
+ (10,8)SyntaxKind[SymbolSpan]
+ (10,8)SyntaxKind[Nonterminal]
+ (10,8)SyntaxKind[Identifier](text = "A")
+ (11,1)SyntaxKind[Production]
+ (11,1)SyntaxKind[Identifier](text = "F")
+ (11,2)SyntaxKind[ParameterList]
+ (11,2)SyntaxKind[OpenBracketToken]
+ (11,3)SyntaxKind[Parameter]
+ (11,3)SyntaxKind[Identifier](text = "A")
+ (11,4)SyntaxKind[CloseBracketToken]
+ (12,1)SyntaxKind[RightHandSideList]
+ (12,1)SyntaxKind[IndentToken]
+ (12,5)SyntaxKind[RightHandSide]
+ (12,5)SyntaxKind[SymbolSpan]
+ (12,5)SyntaxKind[Nonterminal]
+ (12,5)SyntaxKind[Identifier](text = "E")
+ (13,5)SyntaxKind[RightHandSide]
+ (13,5)SyntaxKind[SymbolSpan]
+ (13,5)SyntaxKind[Nonterminal]
+ (13,5)SyntaxKind[Identifier](text = "E")
+ (13,6)SyntaxKind[ArgumentList]
+ (13,6)SyntaxKind[OpenBracketToken]
+ (13,7)SyntaxKind[Argument]
+ (13,7)SyntaxKind[Identifier](text = "A")
+ (13,8)SyntaxKind[CloseBracketToken]
+ (14,5)SyntaxKind[RightHandSide]
+ (14,5)SyntaxKind[SymbolSpan]
+ (14,5)SyntaxKind[Nonterminal]
+ (14,5)SyntaxKind[Identifier](text = "E")
+ (14,6)SyntaxKind[ArgumentList]
+ (14,6)SyntaxKind[OpenBracketToken]
+ (14,7)SyntaxKind[Argument]
+ (14,7)SyntaxKind[Identifier](text = "A")
+ (14,10)SyntaxKind[Argument]
+ (14,10)SyntaxKind[Identifier](text = "B")
+ (14,11)SyntaxKind[CloseBracketToken]
+ (15,5)SyntaxKind[RightHandSide]
+ (15,5)SyntaxKind[SymbolSpan]
+ (15,5)SyntaxKind[Nonterminal]
+ (15,5)SyntaxKind[Identifier](text = "E")
+ (15,6)SyntaxKind[ArgumentList]
+ (15,6)SyntaxKind[OpenBracketToken]
+ (15,7)SyntaxKind[Argument]?
+ (15,7)SyntaxKind[QuestionToken]
+ (15,8)SyntaxKind[Identifier](text = "B")
+ (15,9)SyntaxKind[CloseBracketToken]
+ (16,5)SyntaxKind[RightHandSide]
+ (16,5)SyntaxKind[SymbolSpan]
+ (16,5)SyntaxKind[Nonterminal]
+ (16,5)SyntaxKind[Identifier](text = "E")
+ (16,6)SyntaxKind[ArgumentList]
+ (16,6)SyntaxKind[OpenBracketToken]
+ (16,7)SyntaxKind[Argument]+
+ (16,7)SyntaxKind[PlusToken]
+ (16,8)SyntaxKind[Identifier](text = "A")
+ (16,9)SyntaxKind[CloseBracketToken]
+ (17,5)SyntaxKind[RightHandSide]
+ (17,5)SyntaxKind[SymbolSpan]
+ (17,5)SyntaxKind[Nonterminal]
+ (17,5)SyntaxKind[Identifier](text = "E")
+ (17,6)SyntaxKind[ArgumentList]
+ (17,6)SyntaxKind[OpenBracketToken]
+ (17,7)SyntaxKind[Argument]~
+ (17,7)SyntaxKind[TildeToken]
+ (17,8)SyntaxKind[Identifier](text = "A")
+ (17,9)SyntaxKind[CloseBracketToken]
+ (18,5)SyntaxKind[RightHandSide]
+ (18,5)SyntaxKind[SymbolSpan]
+ (18,5)SyntaxKind[Nonterminal]
+ (18,5)SyntaxKind[Identifier](text = "E")
+ (18,6)SyntaxKind[ArgumentList]
+ (18,6)SyntaxKind[OpenBracketToken]
+ (18,7)SyntaxKind[Argument]?
+ (18,7)SyntaxKind[QuestionToken]
+ (18,8)SyntaxKind[Identifier](text = "A")
+ (18,9)SyntaxKind[CloseBracketToken]
+ (19,1)SyntaxKind[DedentToken]
diff --git a/tests/baselines/reference/test.grammar.tokens b/tests/baselines/reference/test.grammar.tokens
new file mode 100644
index 0000000..2911e41
--- /dev/null
+++ b/tests/baselines/reference/test.grammar.tokens
@@ -0,0 +1,111 @@
+/// test.grammar:
+SyntaxKind[Identifier](1,1): A
+SyntaxKind[ColonToken](1,3): :
+SyntaxKind[Identifier](1,5): A
+SyntaxKind[AtToken](1,7): @
+SyntaxKind[Identifier](1,9): A
+SyntaxKind[LineTerminatorToken](2,1): «line terminator»
+SyntaxKind[Identifier](2,1): B
+SyntaxKind[ColonToken](2,3): :
+SyntaxKind[Identifier](2,5): A
+SyntaxKind[ButKeyword](2,9): but
+SyntaxKind[NotKeyword](2,13): not
+SyntaxKind[OneKeyword](2,17): one
+SyntaxKind[OfKeyword](2,21): of
+SyntaxKind[Terminal](2,24): `"`
+SyntaxKind[OrKeyword](2,28): or
+SyntaxKind[Terminal](2,31): `\`
+SyntaxKind[OrKeyword](2,35): or
+SyntaxKind[UnicodeCharacterLiteral](2,38): U+0000
+SyntaxKind[ThroughKeyword](2,45): through
+SyntaxKind[UnicodeCharacterLiteral](2,53): U+001F
+SyntaxKind[LineTerminatorToken](3,1): «line terminator»
+SyntaxKind[LineTerminatorToken](4,1): «line terminator»
+SyntaxKind[Identifier](4,1): C
+SyntaxKind[ColonToken](4,3): :
+SyntaxKind[Identifier](4,5): A
+SyntaxKind[OpenBracketGreaterThanToken](4,7): [>
+SyntaxKind[ProseFull](4,9): full prose span
+SyntaxKind[CloseBracketToken](4,24): ]
+SyntaxKind[LineTerminatorToken](5,1): «line terminator»
+SyntaxKind[Identifier](5,1): C
+SyntaxKind[ColonToken](5,3): :
+SyntaxKind[Identifier](5,5): A
+SyntaxKind[OpenBracketGreaterThanToken](5,7): [>
+SyntaxKind[ProseHead](5,9): head
+SyntaxKind[Terminal](5,14): `terminal`
+SyntaxKind[ProseMiddle](5,24): middle
+SyntaxKind[Identifier](5,32): B
+SyntaxKind[ProseTail](5,35): tail
+SyntaxKind[CloseBracketToken](5,40): ]
+SyntaxKind[LineTerminatorToken](6,1): «line terminator»
+SyntaxKind[LineTerminatorToken](7,1): «line terminator»
+SyntaxKind[Identifier](7,1): D
+SyntaxKind[OpenBracketToken](7,2): [
+SyntaxKind[Identifier](7,3): A
+SyntaxKind[CloseBracketToken](7,4): ]
+SyntaxKind[ColonToken](7,6): :
+SyntaxKind[Identifier](7,8): A
+SyntaxKind[LineTerminatorToken](8,1): «line terminator»
+SyntaxKind[Identifier](8,1): D
+SyntaxKind[OpenBracketToken](8,2): [
+SyntaxKind[Identifier](8,3): B
+SyntaxKind[CloseBracketToken](8,4): ]
+SyntaxKind[ColonToken](8,6): :
+SyntaxKind[Identifier](8,8): A
+SyntaxKind[LineTerminatorToken](9,1): «line terminator»
+SyntaxKind[LineTerminatorToken](10,1): «line terminator»
+SyntaxKind[Identifier](10,1): E
+SyntaxKind[OpenBracketToken](10,2): [
+SyntaxKind[Identifier](10,3): A
+SyntaxKind[CloseBracketToken](10,4): ]
+SyntaxKind[ColonToken](10,6): :
+SyntaxKind[Identifier](10,8): A
+SyntaxKind[LineTerminatorToken](11,1): «line terminator»
+SyntaxKind[Identifier](11,1): F
+SyntaxKind[OpenBracketToken](11,2): [
+SyntaxKind[Identifier](11,3): A
+SyntaxKind[CloseBracketToken](11,4): ]
+SyntaxKind[ColonToken](11,6): :
+SyntaxKind[LineTerminatorToken](12,1): «line terminator»
+SyntaxKind[IndentToken](12,1): «indent»
+SyntaxKind[Identifier](12,5): E
+SyntaxKind[LineTerminatorToken](13,1): «line terminator»
+SyntaxKind[Identifier](13,5): E
+SyntaxKind[OpenBracketToken](13,6): [
+SyntaxKind[Identifier](13,7): A
+SyntaxKind[CloseBracketToken](13,8): ]
+SyntaxKind[LineTerminatorToken](14,1): «line terminator»
+SyntaxKind[Identifier](14,5): E
+SyntaxKind[OpenBracketToken](14,6): [
+SyntaxKind[Identifier](14,7): A
+SyntaxKind[CommaToken](14,8): ,
+SyntaxKind[Identifier](14,10): B
+SyntaxKind[CloseBracketToken](14,11): ]
+SyntaxKind[LineTerminatorToken](15,1): «line terminator»
+SyntaxKind[Identifier](15,5): E
+SyntaxKind[OpenBracketToken](15,6): [
+SyntaxKind[QuestionToken](15,7): ?
+SyntaxKind[Identifier](15,8): B
+SyntaxKind[CloseBracketToken](15,9): ]
+SyntaxKind[LineTerminatorToken](16,1): «line terminator»
+SyntaxKind[Identifier](16,5): E
+SyntaxKind[OpenBracketToken](16,6): [
+SyntaxKind[PlusToken](16,7): +
+SyntaxKind[Identifier](16,8): A
+SyntaxKind[CloseBracketToken](16,9): ]
+SyntaxKind[LineTerminatorToken](17,1): «line terminator»
+SyntaxKind[Identifier](17,5): E
+SyntaxKind[OpenBracketToken](17,6): [
+SyntaxKind[TildeToken](17,7): ~
+SyntaxKind[Identifier](17,8): A
+SyntaxKind[CloseBracketToken](17,9): ]
+SyntaxKind[LineTerminatorToken](18,1): «line terminator»
+SyntaxKind[Identifier](18,5): E
+SyntaxKind[OpenBracketToken](18,6): [
+SyntaxKind[QuestionToken](18,7): ?
+SyntaxKind[Identifier](18,8): A
+SyntaxKind[CloseBracketToken](18,9): ]
+SyntaxKind[LineTerminatorToken](19,1): «line terminator»
+SyntaxKind[DedentToken](19,1): «dedent»
+SyntaxKind[EndOfFileToken](19,1): «EndOfFileToken»
diff --git a/tests/baselines/reference/typescript.grammar.emu.html b/tests/baselines/reference/typescript.grammar.emu.html
new file mode 100644
index 0000000..8d707f3
--- /dev/null
+++ b/tests/baselines/reference/typescript.grammar.emu.html
@@ -0,0 +1,1164 @@
+
+
+ <
+ TypeParameterList
+ >
+
+
+
+ TypeParameter
+
+ TypeParameterList
+ ,
+ TypeParameter
+
+
+
+
+ Identifier
+ Constraint
+
+
+
+
+ extends
+ Type
+
+
+
+
+ <
+ TypeArgumentList
+ >
+
+
+
+ TypeArgument
+
+ TypeArgumentList
+ ,
+ TypeArgument
+
+
+
+ Type
+
+
+ PrimaryOrUnionType
+ FunctionType
+ ConstructorType
+
+
+ PrimaryType
+ UnionType
+
+
+ ParenthesizedType
+ PredefinedType
+ TypeReference
+ ObjectType
+ ArrayType
+ TupleType
+ TypeQuery
+
+
+
+ (
+ Type
+ )
+
+
+
+ any
+ number
+ boolean
+ string
+ void
+
+
+
+ TypeName
+ no LineTerminator here
+ TypeArguments
+
+
+
+ Identifier
+
+ ModuleName
+ .
+ Identifier
+
+
+
+ Identifier
+
+ ModuleName
+ .
+ Identifier
+
+
+
+
+ {
+ TypeBody
+ }
+
+
+
+
+ TypeMemberList
+ ;
+
+
+
+ TypeMember
+
+ TypeMemberList
+ ;
+ TypeMember
+
+
+
+ PropertySignature
+ CallSignature
+ ConstructSignature
+ IndexSignature
+ MethodSignature
+
+
+
+ PrimaryType
+ no LineTerminator here
+ [
+ ]
+
+
+
+
+ [
+ TupleElementTypes
+ ]
+
+
+
+ TupleElementType
+
+ TupleElementTypes
+ ,
+ TupleElementType
+
+
+
+ Type
+
+
+
+ PrimaryOrUnionType
+ |
+ PrimaryType
+
+
+
+
+ TypeParameters
+ (
+ ParameterList
+ )
+ =>
+ Type
+
+
+
+
+ new
+ TypeParameters
+ (
+ ParameterList
+ )
+ =>
+ Type
+
+
+
+
+ typeof
+ TypeQueryExpression
+
+
+
+ Identifier
+
+ TypeQueryExpression
+ .
+ IdentifierName
+
+
+
+
+ PropertyName
+ ?
+ TypeAnnotation
+
+
+
+ IdentifierName
+ StringLiteral
+ NumericLiteral
+
+
+
+ TypeParameters
+ (
+ ParameterList
+ )
+ TypeAnnotation
+
+
+
+ RequiredParameterList
+ OptionalParameterList
+ RestParameter
+
+ RequiredParameterList
+ ,
+ OptionalParameterList
+
+
+ RequiredParameterList
+ ,
+ RestParameter
+
+
+ OptionalParameterList
+ ,
+ RestParameter
+
+
+ RequiredParameterList
+ ,
+ OptionalParameterList
+ ,
+ RestParameter
+
+
+
+ RequiredParameter
+
+ RequiredParameterList
+ ,
+ RequiredParameter
+
+
+
+
+ AccessibilityModifier
+ Identifier
+ TypeAnnotation
+
+
+ Identifier
+ :
+ StringLiteral
+
+
+
+ public
+ private
+ protected
+
+
+ OptionalParameter
+
+ OptionalParameterList
+ ,
+ OptionalParameter
+
+
+
+
+ AccessibilityModifier
+ Identifier
+ ?
+ TypeAnnotation
+
+
+ AccessibilityModifier
+ Identifier
+ TypeAnnotation
+ Initializer
+
+
+ Identifier
+ ?
+ :
+ StringLiteral
+
+
+
+
+ ...
+ Identifier
+ TypeAnnotation
+
+
+
+
+ new
+ TypeParameters
+ (
+ ParameterList
+ )
+ TypeAnnotation
+
+
+
+
+ [
+ Identifier
+ :
+ string
+ ]
+ TypeAnnotation
+
+
+ [
+ Identifier
+ :
+ number
+ ]
+ TypeAnnotation
+
+
+
+
+ PropertyName
+ ?
+ CallSignature
+
+
+
+
+ type
+ Identifier
+ =
+ Type
+ ;
+
+
+
+
+ PropertyName
+ :
+ AssignmentExpression
+
+
+ PropertyName
+ CallSignature
+ {
+ FunctionBody
+ }
+
+ GetAccessor
+ SetAccessor
+
+
+
+ get
+ PropertyName
+ (
+ )
+ TypeAnnotation
+ {
+ FunctionBody
+ }
+
+
+
+
+ set
+ PropertyName
+ (
+ Identifier
+ TypeAnnotation
+ )
+ {
+ FunctionBody
+ }
+
+
+
+
+ Elision
+ AssignmentExpression
+
+
+ Elision
+ SpreadElement
+
+
+ ElementList
+ ,
+ Elision
+ AssignmentExpression
+
+
+ ElementList
+ ,
+ Elision
+ SpreadElement
+
+
+
+
+ ...
+ AssignmentExpression
+
+
+
+
+ super
+ (
+ ArgumentList
+ )
+
+
+ super
+ .
+ IdentifierName
+
+
+
+
+ function
+ Identifier
+ CallSignature
+ {
+ FunctionBody
+ }
+
+
+
+ ArrowFunctionExpression
+
+
+
+ ArrowFormalParameters
+ =>
+ Block
+
+
+ ArrowFormalParameters
+ =>
+ AssignmentExpression
+
+
+
+ CallSignature
+ Identifier
+
+
+
+ TypeArguments
+ (
+ ArgumentList
+ )
+
+
+
+
+ <
+ Type
+ >
+ UnaryExpression
+
+
+
+ SimpleVariableDeclaration
+ DestructuringVariableDeclaration
+
+
+
+ Identifier
+ TypeAnnotation
+ Initializer
+
+
+
+
+ :
+ Type
+
+
+
+
+ BindingPattern
+ TypeAnnotation
+ Initializer
+
+
+
+ ObjectBindingPattern
+ ArrayBindingPattern
+
+
+
+ {
+ }
+
+
+ {
+ BindingPropertyList
+ ,
+ }
+
+
+
+ BindingProperty
+
+ BindingPropertyList
+ ,
+ BindingProperty
+
+
+
+
+ Identifier
+ Initializer
+
+
+ PropertyName
+ :
+ Identifier
+ Initializer
+
+
+ PropertyName
+ :
+ BindingPattern
+ Initializer
+
+
+
+
+ [
+ Elision
+ BindingRestElement
+ ]
+
+
+ [
+ BindingElementList
+ ]
+
+
+ [
+ BindingElementList
+ ,
+ Elision
+ BindingRestElement
+ ]
+
+
+
+
+ Elision
+ BindingElement
+
+
+ BindingElementList
+ ,
+ Elision
+ BindingElement
+
+
+
+
+ Identifier
+ Initializer
+
+
+ BindingPattern
+ Initializer
+
+
+
+
+ ...
+ Identifier
+
+
+
+
+ FunctionOverloads
+ FunctionImplementation
+
+
+
+ FunctionOverload
+
+ FunctionOverloads
+ FunctionOverload
+
+
+
+
+ function
+ Identifier
+ CallSignature
+ ;
+
+
+
+
+ function
+ Identifier
+ CallSignature
+ {
+ FunctionBody
+ }
+
+
+
+
+ interface
+ Identifier
+ TypeParameters
+ InterfaceExtendsClause
+ ObjectType
+
+
+
+
+ extends
+ ClassOrInterfaceTypeList
+
+
+
+ ClassOrInterfaceType
+
+ ClassOrInterfaceTypeList
+ ,
+ ClassOrInterfaceType
+
+
+
+ TypeReference
+
+
+
+ class
+ Identifier
+ TypeParameters
+ ClassHeritage
+ {
+ ClassBody
+ }
+
+
+
+
+ ClassExtendsClause
+ ImplementsClause
+
+
+
+
+ extends
+ ClassType
+
+
+
+ TypeReference
+
+
+
+ implements
+ ClassOrInterfaceTypeList
+
+
+
+ ClassElements
+
+
+ ClassElement
+
+ ClassElements
+ ClassElement
+
+
+
+ ConstructorDeclaration
+ PropertyMemberDeclaration
+ IndexMemberDeclaration
+
+
+
+ ConstructorOverloads
+ ConstructorImplementation
+
+
+
+ ConstructorOverload
+
+ ConstructorOverloads
+ ConstructorOverload
+
+
+
+
+ AccessibilityModifier
+ constructor
+ (
+ ParameterList
+ )
+ ;
+
+
+
+
+ AccessibilityModifier
+ constructor
+ (
+ ParameterList
+ )
+ {
+ FunctionBody
+ }
+
+
+
+ MemberVariableDeclaration
+ MemberFunctionDeclaration
+ MemberAccessorDeclaration
+
+
+
+ AccessibilityModifier
+ static
+ PropertyName
+ TypeAnnotation
+ Initializer
+ ;
+
+
+
+
+ MemberFunctionOverloads
+ MemberFunctionImplementation
+
+
+
+ MemberFunctionOverload
+
+ MemberFunctionOverloads
+ MemberFunctionOverload
+
+
+
+
+ AccessibilityModifier
+ static
+ PropertyName
+ CallSignature
+ ;
+
+
+
+
+ AccessibilityModifier
+ static
+ PropertyName
+ CallSignature
+ {
+ FunctionBody
+ }
+
+
+
+
+ AccessibilityModifier
+ static
+ GetAccessor
+
+
+ AccessibilityModifier
+ static
+ SetAccessor
+
+
+
+
+ IndexSignature
+ ;
+
+
+
+
+ const
+ enum
+ Identifier
+ {
+ EnumBody
+ }
+
+
+
+
+ EnumMemberList
+ ,
+
+
+
+ EnumMember
+
+ EnumMemberList
+ ,
+ EnumMember
+
+
+
+ PropertyName
+
+ PropertyName
+ =
+ EnumValue
+
+
+
+ AssignmentExpression
+
+
+
+ module
+ IdentifierPath
+ {
+ ModuleBody
+ }
+
+
+
+ Identifier
+
+ IdentifierPath
+ .
+ Identifier
+
+
+
+ ModuleElements
+
+
+ ModuleElement
+
+ ModuleElements
+ ModuleElement
+
+
+
+ Statement
+
+ export
+ VariableDeclaration
+
+
+ export
+ FunctionDeclaration
+
+
+ export
+ ClassDeclaration
+
+
+ export
+ InterfaceDeclaration
+
+
+ export
+ TypeAliasDeclaration
+
+
+ export
+ EnumDeclaration
+
+
+ export
+ ModuleDeclaration
+
+
+ export
+ ImportDeclaration
+
+
+ export
+ AmbientDeclaration
+
+
+
+
+ import
+ Identifier
+ =
+ EntityName
+ ;
+
+
+
+ ModuleName
+
+ ModuleName
+ .
+ Identifier
+
+
+
+ ImplementationSourceFile
+ DeclarationSourceFile
+
+
+ ImplementationElements
+
+
+ ImplementationElement
+
+ ImplementationElements
+ ImplementationElement
+
+
+
+ ModuleElement
+ ExportAssignment
+ AmbientExternalModuleDeclaration
+
+ export
+ ExternalImportDeclaration
+
+
+
+ DeclarationElements
+
+
+ DeclarationElement
+
+ DeclarationElements
+ DeclarationElement
+
+
+
+ ExportAssignment
+ AmbientExternalModuleDeclaration
+
+ export
+ InterfaceDeclaration
+
+
+ export
+ TypeAliasDeclaration
+
+
+ export
+ ImportDeclaration
+
+
+ export
+ AmbientDeclaration
+
+
+ export
+ ExternalImportDeclaration
+
+
+
+
+ import
+ Identifier
+ =
+ ExternalModuleReference
+ ;
+
+
+
+
+ require
+ (
+ StringLiteral
+ )
+
+
+
+
+ export
+ =
+ Identifier
+ ;
+
+
+
+
+ declare
+ AmbientVariableDeclaration
+
+
+ declare
+ AmbientFunctionDeclaration
+
+
+ declare
+ AmbientClassDeclaration
+
+
+ declare
+ AmbientEnumDeclaration
+
+
+ declare
+ AmbientModuleDeclaration
+
+
+
+
+ var
+ Identifier
+ TypeAnnotation
+ ;
+
+
+
+
+ function
+ Identifier
+ CallSignature
+ ;
+
+
+
+
+ class
+ Identifier
+ TypeParameters
+ ClassHeritage
+ {
+ AmbientClassBody
+ }
+
+
+
+ AmbientClassBodyElements
+
+
+ AmbientClassBodyElement
+
+ AmbientClassBodyElements
+ AmbientClassBodyElement
+
+
+
+ AmbientConstructorDeclaration
+ AmbientPropertyMemberDeclaration
+ IndexSignature
+
+
+
+ constructor
+ (
+ ParameterList
+ )
+ ;
+
+
+
+
+ AccessibilityModifier
+ static
+ PropertyName
+ TypeAnnotation
+ ;
+
+
+ AccessibilityModifier
+ static
+ PropertyName
+ CallSignature
+ ;
+
+
+
+ EnumDeclaration
+
+
+
+ module
+ IdentifierPath
+ {
+ AmbientModuleBody
+ }
+
+
+
+ AmbientModuleElements
+
+
+ AmbientModuleElement
+
+ AmbientModuleElements
+ AmbientModuleElement
+
+
+
+
+ export
+ AmbientVariableDeclaration
+
+
+ export
+ AmbientFunctionDeclaration
+
+
+ export
+ AmbientClassDeclaration
+
+
+ export
+ InterfaceDeclaration
+
+
+ export
+ AmbientEnumDeclaration
+
+
+ export
+ AmbientModuleDeclaration
+
+
+ export
+ ImportDeclaration
+
+
+
+
+ declare
+ module
+ StringLiteral
+ {
+ AmbientExternalModuleBody
+ }
+
+
+
+ AmbientExternalModuleElements
+
+
+ AmbientExternalModuleElement
+
+ AmbientExternalModuleElements
+ AmbientExternalModuleElement
+
+
+
+ AmbientModuleElement
+ ExportAssignment
+
+ export
+ ExternalImportDeclaration
+
+
\ No newline at end of file
diff --git a/tests/baselines/reference/typescript.grammar.md b/tests/baselines/reference/typescript.grammar.md
new file mode 100644
index 0000000..8ba63bd
--- /dev/null
+++ b/tests/baselines/reference/typescript.grammar.md
@@ -0,0 +1,515 @@
+ *TypeParameters* **:**
+ `` < `` *[TypeParameterList](#TypeParameterList)* `` > ``
+
+ *TypeParameterList* **:**
+ *[TypeParameter](#TypeParameter)*
+ *[TypeParameterList](#TypeParameterList)* `` , `` *[TypeParameter](#TypeParameter)*
+
+ *TypeParameter* **:**
+ *[Identifier](#Identifier)* *[Constraint](#Constraint)*opt
+
+ *Constraint* **:**
+ `` extends `` *[Type](#Type)*
+
+ *TypeArguments* **:**
+ `` < `` *[TypeArgumentList](#TypeArgumentList)* `` > ``
+
+ *TypeArgumentList* **:**
+ *[TypeArgument](#TypeArgument)*
+ *[TypeArgumentList](#TypeArgumentList)* `` , `` *[TypeArgument](#TypeArgument)*
+
+ *TypeArgument* **:**
+ *[Type](#Type)*
+
+ *Type* **:**
+ *[PrimaryOrUnionType](#PrimaryOrUnionType)*
+ *[FunctionType](#FunctionType)*
+ *[ConstructorType](#ConstructorType)*
+
+ *PrimaryOrUnionType* **:**
+ *[PrimaryType](#PrimaryType)*
+ *[UnionType](#UnionType)*
+
+ *PrimaryType* **:**
+ *[ParenthesizedType](#ParenthesizedType)*
+ *[PredefinedType](#PredefinedType)*
+ *[TypeReference](#TypeReference)*
+ *[ObjectType](#ObjectType)*
+ *[ArrayType](#ArrayType)*
+ *[TupleType](#TupleType)*
+ *[TypeQuery](#TypeQuery)*
+
+ *ParenthesizedType* **:**
+ `` ( `` *[Type](#Type)* `` ) ``
+
+ *PredefinedType* **:**
+ `` any ``
+ `` number ``
+ `` boolean ``
+ `` string ``
+ `` void ``
+
+ *TypeReference* **:**
+ *[TypeName](#TypeName)* [no *[LineTerminator](#LineTerminator)* here] *[TypeArguments](#TypeArguments)*opt
+
+ *TypeName* **:**
+ *[Identifier](#Identifier)*
+ *[ModuleName](#ModuleName)* `` . `` *[Identifier](#Identifier)*
+
+ *ModuleName* **:**
+ *[Identifier](#Identifier)*
+ *[ModuleName](#ModuleName)* `` . `` *[Identifier](#Identifier)*
+
+ *ObjectType* **:**
+ `` { `` *[TypeBody](#TypeBody)*opt `` } ``
+
+ *TypeBody* **:**
+ *[TypeMemberList](#TypeMemberList)* `` ; ``opt
+
+ *TypeMemberList* **:**
+ *[TypeMember](#TypeMember)*
+ *[TypeMemberList](#TypeMemberList)* `` ; `` *[TypeMember](#TypeMember)*
+
+ *TypeMember* **:**
+ *[PropertySignature](#PropertySignature)*
+ *[CallSignature](#CallSignature)*
+ *[ConstructSignature](#ConstructSignature)*
+ *[IndexSignature](#IndexSignature)*
+ *[MethodSignature](#MethodSignature)*
+
+ *ArrayType* **:**
+ *[PrimaryType](#PrimaryType)* [no *[LineTerminator](#LineTerminator)* here] `` [ `` `` ] ``
+
+ *TupleType* **:**
+ `` [ `` *[TupleElementTypes](#TupleElementTypes)* `` ] ``
+
+ *TupleElementTypes* **:**
+ *[TupleElementType](#TupleElementType)*
+ *[TupleElementTypes](#TupleElementTypes)* `` , `` *[TupleElementType](#TupleElementType)*
+
+ *TupleElementType* **:**
+ *[Type](#Type)*
+
+ *UnionType* **:**
+ *[PrimaryOrUnionType](#PrimaryOrUnionType)* `` | `` *[PrimaryType](#PrimaryType)*
+
+ *FunctionType* **:**
+ *[TypeParameters](#TypeParameters)*opt `` ( `` *[ParameterList](#ParameterList)*opt `` ) `` `` => `` *[Type](#Type)*
+
+ *ConstructorType* **:**
+ `` new `` *[TypeParameters](#TypeParameters)*opt `` ( `` *[ParameterList](#ParameterList)*opt `` ) `` `` => `` *[Type](#Type)*
+
+ *TypeQuery* **:**
+ `` typeof `` *[TypeQueryExpression](#TypeQueryExpression)*
+
+ *TypeQueryExpression* **:**
+ *[Identifier](#Identifier)*
+ *[TypeQueryExpression](#TypeQueryExpression)* `` . `` *[IdentifierName](#IdentifierName)*
+
+ *PropertySignature* **:**
+ *[PropertyName](#PropertyName)* `` ? ``opt *[TypeAnnotation](#TypeAnnotation)*opt
+
+ *PropertyName* **:**
+ *[IdentifierName](#IdentifierName)*
+ *[StringLiteral](#StringLiteral)*
+ *[NumericLiteral](#NumericLiteral)*
+
+ *CallSignature* **:**
+ *[TypeParameters](#TypeParameters)*opt `` ( `` *[ParameterList](#ParameterList)*opt `` ) `` *[TypeAnnotation](#TypeAnnotation)*opt
+
+ *ParameterList* **:**
+ *[RequiredParameterList](#RequiredParameterList)*
+ *[OptionalParameterList](#OptionalParameterList)*
+ *[RestParameter](#RestParameter)*
+ *[RequiredParameterList](#RequiredParameterList)* `` , `` *[OptionalParameterList](#OptionalParameterList)*
+ *[RequiredParameterList](#RequiredParameterList)* `` , `` *[RestParameter](#RestParameter)*
+ *[OptionalParameterList](#OptionalParameterList)* `` , `` *[RestParameter](#RestParameter)*
+ *[RequiredParameterList](#RequiredParameterList)* `` , `` *[OptionalParameterList](#OptionalParameterList)* `` , `` *[RestParameter](#RestParameter)*
+
+ *RequiredParameterList* **:**
+ *[RequiredParameter](#RequiredParameter)*
+ *[RequiredParameterList](#RequiredParameterList)* `` , `` *[RequiredParameter](#RequiredParameter)*
+
+ *RequiredParameter* **:**
+ *[AccessibilityModifier](#AccessibilityModifier)*opt *[Identifier](#Identifier)* *[TypeAnnotation](#TypeAnnotation)*opt
+ *[Identifier](#Identifier)* `` : `` *[StringLiteral](#StringLiteral)*
+
+ *AccessibilityModifier* **:**
+ `` public ``
+ `` private ``
+ `` protected ``
+
+ *OptionalParameterList* **:**
+ *[OptionalParameter](#OptionalParameter)*
+ *[OptionalParameterList](#OptionalParameterList)* `` , `` *[OptionalParameter](#OptionalParameter)*
+
+ *OptionalParameter* **:**
+ *[AccessibilityModifier](#AccessibilityModifier)*opt *[Identifier](#Identifier)* `` ? `` *[TypeAnnotation](#TypeAnnotation)*opt
+ *[AccessibilityModifier](#AccessibilityModifier)*opt *[Identifier](#Identifier)* *[TypeAnnotation](#TypeAnnotation)*opt *[Initializer](#Initializer)*
+ *[Identifier](#Identifier)* `` ? `` `` : `` *[StringLiteral](#StringLiteral)*
+
+ *RestParameter* **:**
+ `` ... `` *[Identifier](#Identifier)* *[TypeAnnotation](#TypeAnnotation)*opt
+
+ *ConstructSignature* **:**
+ `` new `` *[TypeParameters](#TypeParameters)*opt `` ( `` *[ParameterList](#ParameterList)*opt `` ) `` *[TypeAnnotation](#TypeAnnotation)*opt
+
+ *IndexSignature* **:**
+ `` [ `` *[Identifier](#Identifier)* `` : `` `` string `` `` ] `` *[TypeAnnotation](#TypeAnnotation)*
+ `` [ `` *[Identifier](#Identifier)* `` : `` `` number `` `` ] `` *[TypeAnnotation](#TypeAnnotation)*
+
+ *MethodSignature* **:**
+ *[PropertyName](#PropertyName)* `` ? ``opt *[CallSignature](#CallSignature)*
+
+ *TypeAliasDeclaration* **:**
+ `` type `` *[Identifier](#Identifier)* `` = `` *[Type](#Type)* `` ; ``
+
+ *PropertyAssignment* **:**
+ *[PropertyName](#PropertyName)* `` : `` *[AssignmentExpression](#AssignmentExpression)*
+ *[PropertyName](#PropertyName)* *[CallSignature](#CallSignature)* `` { `` *[FunctionBody](#FunctionBody)* `` } ``
+ *[GetAccessor](#GetAccessor)*
+ *[SetAccessor](#SetAccessor)*
+
+ *GetAccessor* **:**
+ `` get `` *[PropertyName](#PropertyName)* `` ( `` `` ) `` *[TypeAnnotation](#TypeAnnotation)*opt `` { `` *[FunctionBody](#FunctionBody)* `` } ``
+
+ *SetAccessor* **:**
+ `` set `` *[PropertyName](#PropertyName)* `` ( `` *[Identifier](#Identifier)* *[TypeAnnotation](#TypeAnnotation)*opt `` ) `` `` { `` *[FunctionBody](#FunctionBody)* `` } ``
+
+ *ElementList* **:**
+ *[Elision](#Elision)*opt *[AssignmentExpression](#AssignmentExpression)*
+ *[Elision](#Elision)*opt *[SpreadElement](#SpreadElement)*
+ *[ElementList](#ElementList)* `` , `` *[Elision](#Elision)*opt *[AssignmentExpression](#AssignmentExpression)*
+ *[ElementList](#ElementList)* `` , `` *[Elision](#Elision)*opt *[SpreadElement](#SpreadElement)*
+
+ *SpreadElement* **:**
+ `` ... `` *[AssignmentExpression](#AssignmentExpression)*
+
+ *CallExpression* **:**
+ `` super `` `` ( `` *[ArgumentList](#ArgumentList)*opt `` ) ``
+ `` super `` `` . `` *[IdentifierName](#IdentifierName)*
+
+ *FunctionExpression* **:**
+ `` function `` *[Identifier](#Identifier)*opt *[CallSignature](#CallSignature)* `` { `` *[FunctionBody](#FunctionBody)* `` } ``
+
+ *AssignmentExpression* **:**
+ *[ArrowFunctionExpression](#ArrowFunctionExpression)*
+
+ *ArrowFunctionExpression* **:**
+ *[ArrowFormalParameters](#ArrowFormalParameters)* `` => `` *[Block](#Block)*
+ *[ArrowFormalParameters](#ArrowFormalParameters)* `` => `` *[AssignmentExpression](#AssignmentExpression)*
+
+ *ArrowFormalParameters* **:**
+ *[CallSignature](#CallSignature)*
+ *[Identifier](#Identifier)*
+
+ *Arguments* **:**
+ *[TypeArguments](#TypeArguments)*opt `` ( `` *[ArgumentList](#ArgumentList)*opt `` ) ``
+
+ *UnaryExpression* **:**
+ `` < `` *[Type](#Type)* `` > `` *[UnaryExpression](#UnaryExpression)*
+
+ *VariableDeclaration* **:**
+ *[SimpleVariableDeclaration](#SimpleVariableDeclaration)*
+ *[DestructuringVariableDeclaration](#DestructuringVariableDeclaration)*
+
+ *SimpleVariableDeclaration* **:**
+ *[Identifier](#Identifier)* *[TypeAnnotation](#TypeAnnotation)*opt *[Initializer](#Initializer)*opt
+
+ *TypeAnnotation* **:**
+ `` : `` *[Type](#Type)*
+
+ *DestructuringVariableDeclaration* **:**
+ *[BindingPattern](#BindingPattern)* *[TypeAnnotation](#TypeAnnotation)*opt *[Initializer](#Initializer)*
+
+ *BindingPattern* **:**
+ *[ObjectBindingPattern](#ObjectBindingPattern)*
+ *[ArrayBindingPattern](#ArrayBindingPattern)*
+
+ *ObjectBindingPattern* **:**
+ `` { `` `` } ``
+ `` { `` *[BindingPropertyList](#BindingPropertyList)* `` , ``opt `` } ``
+
+ *BindingPropertyList* **:**
+ *[BindingProperty](#BindingProperty)*
+ *[BindingPropertyList](#BindingPropertyList)* `` , `` *[BindingProperty](#BindingProperty)*
+
+ *BindingProperty* **:**
+ *[Identifier](#Identifier)* *[Initializer](#Initializer)*opt
+ *[PropertyName](#PropertyName)* `` : `` *[Identifier](#Identifier)* *[Initializer](#Initializer)*opt
+ *[PropertyName](#PropertyName)* `` : `` *[BindingPattern](#BindingPattern)* *[Initializer](#Initializer)*opt
+
+ *ArrayBindingPattern* **:**
+ `` [ `` *[Elision](#Elision)*opt *[BindingRestElement](#BindingRestElement)*opt `` ] ``
+ `` [ `` *[BindingElementList](#BindingElementList)* `` ] ``
+ `` [ `` *[BindingElementList](#BindingElementList)* `` , `` *[Elision](#Elision)*opt *[BindingRestElement](#BindingRestElement)*opt `` ] ``
+
+ *BindingElementList* **:**
+ *[Elision](#Elision)*opt *[BindingElement](#BindingElement)*
+ *[BindingElementList](#BindingElementList)* `` , `` *[Elision](#Elision)*opt *[BindingElement](#BindingElement)*
+
+ *BindingElement* **:**
+ *[Identifier](#Identifier)* *[Initializer](#Initializer)*opt
+ *[BindingPattern](#BindingPattern)* *[Initializer](#Initializer)*opt
+
+ *BindingRestElement* **:**
+ `` ... `` *[Identifier](#Identifier)*
+
+ *FunctionDeclaration* **:**
+ *[FunctionOverloads](#FunctionOverloads)*opt *[FunctionImplementation](#FunctionImplementation)*
+
+ *FunctionOverloads* **:**
+ *[FunctionOverload](#FunctionOverload)*
+ *[FunctionOverloads](#FunctionOverloads)* *[FunctionOverload](#FunctionOverload)*
+
+ *FunctionOverload* **:**
+ `` function `` *[Identifier](#Identifier)* *[CallSignature](#CallSignature)* `` ; ``
+
+ *FunctionImplementation* **:**
+ `` function `` *[Identifier](#Identifier)* *[CallSignature](#CallSignature)* `` { `` *[FunctionBody](#FunctionBody)* `` } ``
+
+ *InterfaceDeclaration* **:**
+ `` interface `` *[Identifier](#Identifier)* *[TypeParameters](#TypeParameters)*opt *[InterfaceExtendsClause](#InterfaceExtendsClause)*opt *[ObjectType](#ObjectType)*
+
+ *InterfaceExtendsClause* **:**
+ `` extends `` *[ClassOrInterfaceTypeList](#ClassOrInterfaceTypeList)*
+
+ *ClassOrInterfaceTypeList* **:**
+ *[ClassOrInterfaceType](#ClassOrInterfaceType)*
+ *[ClassOrInterfaceTypeList](#ClassOrInterfaceTypeList)* `` , `` *[ClassOrInterfaceType](#ClassOrInterfaceType)*
+
+ *ClassOrInterfaceType* **:**
+ *[TypeReference](#TypeReference)*
+
+ *ClassDeclaration* **:**
+ `` class `` *[Identifier](#Identifier)* *[TypeParameters](#TypeParameters)*opt *[ClassHeritage](#ClassHeritage)* `` { `` *[ClassBody](#ClassBody)* `` } ``
+
+ *ClassHeritage* **:**
+ *[ClassExtendsClause](#ClassExtendsClause)*opt *[ImplementsClause](#ImplementsClause)*opt
+
+ *ClassExtendsClause* **:**
+ `` extends `` *[ClassType](#ClassType)*
+
+ *ClassType* **:**
+ *[TypeReference](#TypeReference)*
+
+ *ImplementsClause* **:**
+ `` implements `` *[ClassOrInterfaceTypeList](#ClassOrInterfaceTypeList)*
+
+ *ClassBody* **:**
+ *[ClassElements](#ClassElements)*opt
+
+ *ClassElements* **:**
+ *[ClassElement](#ClassElement)*
+ *[ClassElements](#ClassElements)* *[ClassElement](#ClassElement)*
+
+ *ClassElement* **:**
+ *[ConstructorDeclaration](#ConstructorDeclaration)*
+ *[PropertyMemberDeclaration](#PropertyMemberDeclaration)*
+ *[IndexMemberDeclaration](#IndexMemberDeclaration)*
+
+ *ConstructorDeclaration* **:**
+ *[ConstructorOverloads](#ConstructorOverloads)*opt *[ConstructorImplementation](#ConstructorImplementation)*
+
+ *ConstructorOverloads* **:**
+ *[ConstructorOverload](#ConstructorOverload)*
+ *[ConstructorOverloads](#ConstructorOverloads)* *[ConstructorOverload](#ConstructorOverload)*
+
+ *ConstructorOverload* **:**
+ *[AccessibilityModifier](#AccessibilityModifier)*opt `` constructor `` `` ( `` *[ParameterList](#ParameterList)*opt `` ) `` `` ; ``
+
+ *ConstructorImplementation* **:**
+ *[AccessibilityModifier](#AccessibilityModifier)*opt `` constructor `` `` ( `` *[ParameterList](#ParameterList)*opt `` ) `` `` { `` *[FunctionBody](#FunctionBody)* `` } ``
+
+ *PropertyMemberDeclaration* **:**
+ *[MemberVariableDeclaration](#MemberVariableDeclaration)*
+ *[MemberFunctionDeclaration](#MemberFunctionDeclaration)*
+ *[MemberAccessorDeclaration](#MemberAccessorDeclaration)*
+
+ *MemberVariableDeclaration* **:**
+ *[AccessibilityModifier](#AccessibilityModifier)*opt `` static ``opt *[PropertyName](#PropertyName)* *[TypeAnnotation](#TypeAnnotation)*opt *[Initializer](#Initializer)*opt `` ; ``
+
+ *MemberFunctionDeclaration* **:**
+ *[MemberFunctionOverloads](#MemberFunctionOverloads)*opt *[MemberFunctionImplementation](#MemberFunctionImplementation)*
+
+ *MemberFunctionOverloads* **:**
+ *[MemberFunctionOverload](#MemberFunctionOverload)*
+ *[MemberFunctionOverloads](#MemberFunctionOverloads)* *[MemberFunctionOverload](#MemberFunctionOverload)*
+
+ *MemberFunctionOverload* **:**
+ *[AccessibilityModifier](#AccessibilityModifier)*opt `` static ``opt *[PropertyName](#PropertyName)* *[CallSignature](#CallSignature)* `` ; ``
+
+ *MemberFunctionImplementation* **:**
+ *[AccessibilityModifier](#AccessibilityModifier)*opt `` static ``opt *[PropertyName](#PropertyName)* *[CallSignature](#CallSignature)* `` { `` *[FunctionBody](#FunctionBody)* `` } ``
+
+ *MemberAccessorDeclaration* **:**
+ *[AccessibilityModifier](#AccessibilityModifier)*opt `` static ``opt *[GetAccessor](#GetAccessor)*
+ *[AccessibilityModifier](#AccessibilityModifier)*opt `` static ``opt *[SetAccessor](#SetAccessor)*
+
+ *IndexMemberDeclaration* **:**
+ *[IndexSignature](#IndexSignature)* `` ; ``
+
+ *EnumDeclaration* **:**
+ `` const ``opt `` enum `` *[Identifier](#Identifier)* `` { `` *[EnumBody](#EnumBody)*opt `` } ``
+
+ *EnumBody* **:**
+ *[EnumMemberList](#EnumMemberList)* `` , ``opt
+
+ *EnumMemberList* **:**
+ *[EnumMember](#EnumMember)*
+ *[EnumMemberList](#EnumMemberList)* `` , `` *[EnumMember](#EnumMember)*
+
+ *EnumMember* **:**
+ *[PropertyName](#PropertyName)*
+ *[PropertyName](#PropertyName)* `` = `` *[EnumValue](#EnumValue)*
+
+ *EnumValue* **:**
+ *[AssignmentExpression](#AssignmentExpression)*
+
+ *ModuleDeclaration* **:**
+ `` module `` *[IdentifierPath](#IdentifierPath)* `` { `` *[ModuleBody](#ModuleBody)* `` } ``
+
+ *IdentifierPath* **:**
+ *[Identifier](#Identifier)*
+ *[IdentifierPath](#IdentifierPath)* `` . `` *[Identifier](#Identifier)*
+
+ *ModuleBody* **:**
+ *[ModuleElements](#ModuleElements)*opt
+
+ *ModuleElements* **:**
+ *[ModuleElement](#ModuleElement)*
+ *[ModuleElements](#ModuleElements)* *[ModuleElement](#ModuleElement)*
+
+ *ModuleElement* **:**
+ *[Statement](#Statement)*
+ `` export ``opt *[VariableDeclaration](#VariableDeclaration)*
+ `` export ``opt *[FunctionDeclaration](#FunctionDeclaration)*
+ `` export ``opt *[ClassDeclaration](#ClassDeclaration)*
+ `` export ``opt *[InterfaceDeclaration](#InterfaceDeclaration)*
+ `` export ``opt *[TypeAliasDeclaration](#TypeAliasDeclaration)*
+ `` export ``opt *[EnumDeclaration](#EnumDeclaration)*
+ `` export ``opt *[ModuleDeclaration](#ModuleDeclaration)*
+ `` export ``opt *[ImportDeclaration](#ImportDeclaration)*
+ `` export ``opt *[AmbientDeclaration](#AmbientDeclaration)*
+
+ *ImportDeclaration* **:**
+ `` import `` *[Identifier](#Identifier)* `` = `` *[EntityName](#EntityName)* `` ; ``
+
+ *EntityName* **:**
+ *[ModuleName](#ModuleName)*
+ *[ModuleName](#ModuleName)* `` . `` *[Identifier](#Identifier)*
+
+ *SourceFile* **:**
+ *[ImplementationSourceFile](#ImplementationSourceFile)*
+ *[DeclarationSourceFile](#DeclarationSourceFile)*
+
+ *ImplementationSourceFile* **:**
+ *[ImplementationElements](#ImplementationElements)*opt
+
+ *ImplementationElements* **:**
+ *[ImplementationElement](#ImplementationElement)*
+ *[ImplementationElements](#ImplementationElements)* *[ImplementationElement](#ImplementationElement)*
+
+ *ImplementationElement* **:**
+ *[ModuleElement](#ModuleElement)*
+ *[ExportAssignment](#ExportAssignment)*
+ *[AmbientExternalModuleDeclaration](#AmbientExternalModuleDeclaration)*
+ `` export ``opt *[ExternalImportDeclaration](#ExternalImportDeclaration)*
+
+ *DeclarationSourceFile* **:**
+ *[DeclarationElements](#DeclarationElements)*opt
+
+ *DeclarationElements* **:**
+ *[DeclarationElement](#DeclarationElement)*
+ *[DeclarationElements](#DeclarationElements)* *[DeclarationElement](#DeclarationElement)*
+
+ *DeclarationElement* **:**
+ *[ExportAssignment](#ExportAssignment)*
+ *[AmbientExternalModuleDeclaration](#AmbientExternalModuleDeclaration)*
+ `` export ``opt *[InterfaceDeclaration](#InterfaceDeclaration)*
+ `` export ``opt *[TypeAliasDeclaration](#TypeAliasDeclaration)*
+ `` export ``opt *[ImportDeclaration](#ImportDeclaration)*
+ `` export ``opt *[AmbientDeclaration](#AmbientDeclaration)*
+ `` export ``opt *[ExternalImportDeclaration](#ExternalImportDeclaration)*
+
+ *ExternalImportDeclaration* **:**
+ `` import `` *[Identifier](#Identifier)* `` = `` *[ExternalModuleReference](#ExternalModuleReference)* `` ; ``
+
+ *ExternalModuleReference* **:**
+ `` require `` `` ( `` *[StringLiteral](#StringLiteral)* `` ) ``
+
+ *ExportAssignment* **:**
+ `` export `` `` = `` *[Identifier](#Identifier)* `` ; ``
+
+ *AmbientDeclaration* **:**
+ `` declare `` *[AmbientVariableDeclaration](#AmbientVariableDeclaration)*
+ `` declare `` *[AmbientFunctionDeclaration](#AmbientFunctionDeclaration)*
+ `` declare `` *[AmbientClassDeclaration](#AmbientClassDeclaration)*
+ `` declare `` *[AmbientEnumDeclaration](#AmbientEnumDeclaration)*
+ `` declare `` *[AmbientModuleDeclaration](#AmbientModuleDeclaration)*
+
+ *AmbientVariableDeclaration* **:**
+ `` var `` *[Identifier](#Identifier)* *[TypeAnnotation](#TypeAnnotation)*opt `` ; ``
+
+ *AmbientFunctionDeclaration* **:**
+ `` function `` *[Identifier](#Identifier)* *[CallSignature](#CallSignature)* `` ; ``
+
+ *AmbientClassDeclaration* **:**
+ `` class `` *[Identifier](#Identifier)* *[TypeParameters](#TypeParameters)*opt *[ClassHeritage](#ClassHeritage)* `` { `` *[AmbientClassBody](#AmbientClassBody)* `` } ``
+
+ *AmbientClassBody* **:**
+ *[AmbientClassBodyElements](#AmbientClassBodyElements)*opt
+
+ *AmbientClassBodyElements* **:**
+ *[AmbientClassBodyElement](#AmbientClassBodyElement)*
+ *[AmbientClassBodyElements](#AmbientClassBodyElements)* *[AmbientClassBodyElement](#AmbientClassBodyElement)*
+
+ *AmbientClassBodyElement* **:**
+ *[AmbientConstructorDeclaration](#AmbientConstructorDeclaration)*
+ *[AmbientPropertyMemberDeclaration](#AmbientPropertyMemberDeclaration)*
+ *[IndexSignature](#IndexSignature)*
+
+ *AmbientConstructorDeclaration* **:**
+ `` constructor `` `` ( `` *[ParameterList](#ParameterList)*opt `` ) `` `` ; ``
+
+ *AmbientPropertyMemberDeclaration* **:**
+ *[AccessibilityModifier](#AccessibilityModifier)*opt `` static ``opt *[PropertyName](#PropertyName)* *[TypeAnnotation](#TypeAnnotation)*opt `` ; ``
+ *[AccessibilityModifier](#AccessibilityModifier)*opt `` static ``opt *[PropertyName](#PropertyName)* *[CallSignature](#CallSignature)* `` ; ``
+
+ *AmbientEnumDeclaration* **:**
+ *[EnumDeclaration](#EnumDeclaration)*
+
+ *AmbientModuleDeclaration* **:**
+ `` module `` *[IdentifierPath](#IdentifierPath)* `` { `` *[AmbientModuleBody](#AmbientModuleBody)* `` } ``
+
+ *AmbientModuleBody* **:**
+ *[AmbientModuleElements](#AmbientModuleElements)*opt
+
+ *AmbientModuleElements* **:**
+ *[AmbientModuleElement](#AmbientModuleElement)*
+ *[AmbientModuleElements](#AmbientModuleElements)* *[AmbientModuleElement](#AmbientModuleElement)*
+
+ *AmbientModuleElement* **:**
+ `` export ``opt *[AmbientVariableDeclaration](#AmbientVariableDeclaration)*
+ `` export ``opt *[AmbientFunctionDeclaration](#AmbientFunctionDeclaration)*
+ `` export ``opt *[AmbientClassDeclaration](#AmbientClassDeclaration)*
+ `` export ``opt *[InterfaceDeclaration](#InterfaceDeclaration)*
+ `` export ``opt *[AmbientEnumDeclaration](#AmbientEnumDeclaration)*
+ `` export ``opt *[AmbientModuleDeclaration](#AmbientModuleDeclaration)*
+ `` export ``opt *[ImportDeclaration](#ImportDeclaration)*
+
+ *AmbientExternalModuleDeclaration* **:**
+ `` declare `` `` module `` *[StringLiteral](#StringLiteral)* `` { `` *[AmbientExternalModuleBody](#AmbientExternalModuleBody)* `` } ``
+
+ *AmbientExternalModuleBody* **:**
+ *[AmbientExternalModuleElements](#AmbientExternalModuleElements)*opt
+
+ *AmbientExternalModuleElements* **:**
+ *[AmbientExternalModuleElement](#AmbientExternalModuleElement)*
+ *[AmbientExternalModuleElements](#AmbientExternalModuleElements)* *[AmbientExternalModuleElement](#AmbientExternalModuleElement)*
+
+ *AmbientExternalModuleElement* **:**
+ *[AmbientModuleElement](#AmbientModuleElement)*
+ *[ExportAssignment](#ExportAssignment)*
+ `` export ``opt *[ExternalImportDeclaration](#ExternalImportDeclaration)*
+
\ No newline at end of file
diff --git a/tests/baselines/reference/typescript.grammar.nodes b/tests/baselines/reference/typescript.grammar.nodes
new file mode 100644
index 0000000..e964680
--- /dev/null
+++ b/tests/baselines/reference/typescript.grammar.nodes
@@ -0,0 +1,2614 @@
+/// typescript.grammar:
+(1,1)SyntaxKind[SourceFile](filename = "typescript.grammar")
+ (1,1)SyntaxKind[Define]
+ (2,1)SyntaxKind[Import]
+ (2,1)SyntaxKind[AtToken]
+ (2,2)SyntaxKind[ImportKeyword]
+ (2,9)SyntaxKind[StringLiteral]
+ (5,1)SyntaxKind[Production]
+ (5,1)SyntaxKind[Identifier](text = "TypeParameters")
+ (6,1)SyntaxKind[RightHandSideList]
+ (6,1)SyntaxKind[IndentToken]
+ (6,2)SyntaxKind[RightHandSide]
+ (6,2)SyntaxKind[SymbolSpan]
+ (6,2)SyntaxKind[Terminal](text = "<")
+ (6,6)SyntaxKind[SymbolSpan]
+ (6,6)SyntaxKind[Nonterminal]
+ (6,6)SyntaxKind[Identifier](text = "TypeParameterList")
+ (6,24)SyntaxKind[SymbolSpan]
+ (6,24)SyntaxKind[Terminal](text = ">")
+ (7,1)SyntaxKind[DedentToken]
+ (8,1)SyntaxKind[Production]
+ (8,1)SyntaxKind[Identifier](text = "TypeParameterList")
+ (9,1)SyntaxKind[RightHandSideList]
+ (9,1)SyntaxKind[IndentToken]
+ (9,2)SyntaxKind[RightHandSide]
+ (9,2)SyntaxKind[SymbolSpan]
+ (9,2)SyntaxKind[Nonterminal]
+ (9,2)SyntaxKind[Identifier](text = "TypeParameter")
+ (10,2)SyntaxKind[RightHandSide]
+ (10,2)SyntaxKind[SymbolSpan]
+ (10,2)SyntaxKind[Nonterminal]
+ (10,2)SyntaxKind[Identifier](text = "TypeParameterList")
+ (10,20)SyntaxKind[SymbolSpan]
+ (10,20)SyntaxKind[Terminal](text = ",")
+ (10,24)SyntaxKind[SymbolSpan]
+ (10,24)SyntaxKind[Nonterminal]
+ (10,24)SyntaxKind[Identifier](text = "TypeParameter")
+ (11,1)SyntaxKind[DedentToken]
+ (12,1)SyntaxKind[Production]
+ (12,1)SyntaxKind[Identifier](text = "TypeParameter")
+ (13,1)SyntaxKind[RightHandSideList]
+ (13,1)SyntaxKind[IndentToken]
+ (13,2)SyntaxKind[RightHandSide]
+ (13,2)SyntaxKind[SymbolSpan]
+ (13,2)SyntaxKind[Nonterminal]
+ (13,2)SyntaxKind[Identifier](text = "Identifier")
+ (13,13)SyntaxKind[SymbolSpan]
+ (13,13)SyntaxKind[Nonterminal]?
+ (13,13)SyntaxKind[Identifier](text = "Constraint")
+ (13,23)SyntaxKind[QuestionToken]
+ (14,1)SyntaxKind[DedentToken]
+ (15,1)SyntaxKind[Production]
+ (15,1)SyntaxKind[Identifier](text = "Constraint")
+ (16,1)SyntaxKind[RightHandSideList]
+ (16,1)SyntaxKind[IndentToken]
+ (16,2)SyntaxKind[RightHandSide]
+ (16,2)SyntaxKind[SymbolSpan]
+ (16,2)SyntaxKind[Terminal](text = "extends")
+ (16,12)SyntaxKind[SymbolSpan]
+ (16,12)SyntaxKind[Nonterminal]
+ (16,12)SyntaxKind[Identifier](text = "Type")
+ (17,1)SyntaxKind[DedentToken]
+ (18,1)SyntaxKind[Production]
+ (18,1)SyntaxKind[Identifier](text = "TypeArguments")
+ (19,1)SyntaxKind[RightHandSideList]
+ (19,1)SyntaxKind[IndentToken]
+ (19,2)SyntaxKind[RightHandSide]
+ (19,2)SyntaxKind[SymbolSpan]
+ (19,2)SyntaxKind[Terminal](text = "<")
+ (19,6)SyntaxKind[SymbolSpan]
+ (19,6)SyntaxKind[Nonterminal]
+ (19,6)SyntaxKind[Identifier](text = "TypeArgumentList")
+ (19,23)SyntaxKind[SymbolSpan]
+ (19,23)SyntaxKind[Terminal](text = ">")
+ (20,1)SyntaxKind[DedentToken]
+ (21,1)SyntaxKind[Production]
+ (21,1)SyntaxKind[Identifier](text = "TypeArgumentList")
+ (22,1)SyntaxKind[RightHandSideList]
+ (22,1)SyntaxKind[IndentToken]
+ (22,2)SyntaxKind[RightHandSide]
+ (22,2)SyntaxKind[SymbolSpan]
+ (22,2)SyntaxKind[Nonterminal]
+ (22,2)SyntaxKind[Identifier](text = "TypeArgument")
+ (23,2)SyntaxKind[RightHandSide]
+ (23,2)SyntaxKind[SymbolSpan]
+ (23,2)SyntaxKind[Nonterminal]
+ (23,2)SyntaxKind[Identifier](text = "TypeArgumentList")
+ (23,19)SyntaxKind[SymbolSpan]
+ (23,19)SyntaxKind[Terminal](text = ",")
+ (23,23)SyntaxKind[SymbolSpan]
+ (23,23)SyntaxKind[Nonterminal]
+ (23,23)SyntaxKind[Identifier](text = "TypeArgument")
+ (24,1)SyntaxKind[DedentToken]
+ (25,1)SyntaxKind[Production]
+ (25,1)SyntaxKind[Identifier](text = "TypeArgument")
+ (26,1)SyntaxKind[RightHandSideList]
+ (26,1)SyntaxKind[IndentToken]
+ (26,2)SyntaxKind[RightHandSide]
+ (26,2)SyntaxKind[SymbolSpan]
+ (26,2)SyntaxKind[Nonterminal]
+ (26,2)SyntaxKind[Identifier](text = "Type")
+ (27,1)SyntaxKind[DedentToken]
+ (28,1)SyntaxKind[Production]
+ (28,1)SyntaxKind[Identifier](text = "Type")
+ (29,1)SyntaxKind[RightHandSideList]
+ (29,1)SyntaxKind[IndentToken]
+ (29,2)SyntaxKind[RightHandSide]
+ (29,2)SyntaxKind[SymbolSpan]
+ (29,2)SyntaxKind[Nonterminal]
+ (29,2)SyntaxKind[Identifier](text = "PrimaryOrUnionType")
+ (30,2)SyntaxKind[RightHandSide]
+ (30,2)SyntaxKind[SymbolSpan]
+ (30,2)SyntaxKind[Nonterminal]
+ (30,2)SyntaxKind[Identifier](text = "FunctionType")
+ (31,2)SyntaxKind[RightHandSide]
+ (31,2)SyntaxKind[SymbolSpan]
+ (31,2)SyntaxKind[Nonterminal]
+ (31,2)SyntaxKind[Identifier](text = "ConstructorType")
+ (32,1)SyntaxKind[DedentToken]
+ (33,1)SyntaxKind[Production]
+ (33,1)SyntaxKind[Identifier](text = "PrimaryOrUnionType")
+ (34,1)SyntaxKind[RightHandSideList]
+ (34,1)SyntaxKind[IndentToken]
+ (34,2)SyntaxKind[RightHandSide]
+ (34,2)SyntaxKind[SymbolSpan]
+ (34,2)SyntaxKind[Nonterminal]
+ (34,2)SyntaxKind[Identifier](text = "PrimaryType")
+ (35,2)SyntaxKind[RightHandSide]
+ (35,2)SyntaxKind[SymbolSpan]
+ (35,2)SyntaxKind[Nonterminal]
+ (35,2)SyntaxKind[Identifier](text = "UnionType")
+ (36,1)SyntaxKind[DedentToken]
+ (37,1)SyntaxKind[Production]
+ (37,1)SyntaxKind[Identifier](text = "PrimaryType")
+ (38,1)SyntaxKind[RightHandSideList]
+ (38,1)SyntaxKind[IndentToken]
+ (38,2)SyntaxKind[RightHandSide]
+ (38,2)SyntaxKind[SymbolSpan]
+ (38,2)SyntaxKind[Nonterminal]
+ (38,2)SyntaxKind[Identifier](text = "ParenthesizedType")
+ (39,2)SyntaxKind[RightHandSide]
+ (39,2)SyntaxKind[SymbolSpan]
+ (39,2)SyntaxKind[Nonterminal]
+ (39,2)SyntaxKind[Identifier](text = "PredefinedType")
+ (40,2)SyntaxKind[RightHandSide]
+ (40,2)SyntaxKind[SymbolSpan]
+ (40,2)SyntaxKind[Nonterminal]
+ (40,2)SyntaxKind[Identifier](text = "TypeReference")
+ (41,2)SyntaxKind[RightHandSide]
+ (41,2)SyntaxKind[SymbolSpan]
+ (41,2)SyntaxKind[Nonterminal]
+ (41,2)SyntaxKind[Identifier](text = "ObjectType")
+ (42,2)SyntaxKind[RightHandSide]
+ (42,2)SyntaxKind[SymbolSpan]
+ (42,2)SyntaxKind[Nonterminal]
+ (42,2)SyntaxKind[Identifier](text = "ArrayType")
+ (43,2)SyntaxKind[RightHandSide]
+ (43,2)SyntaxKind[SymbolSpan]
+ (43,2)SyntaxKind[Nonterminal]
+ (43,2)SyntaxKind[Identifier](text = "TupleType")
+ (44,2)SyntaxKind[RightHandSide]
+ (44,2)SyntaxKind[SymbolSpan]
+ (44,2)SyntaxKind[Nonterminal]
+ (44,2)SyntaxKind[Identifier](text = "TypeQuery")
+ (45,1)SyntaxKind[DedentToken]
+ (46,1)SyntaxKind[Production]
+ (46,1)SyntaxKind[Identifier](text = "ParenthesizedType")
+ (47,1)SyntaxKind[RightHandSideList]
+ (47,1)SyntaxKind[IndentToken]
+ (47,2)SyntaxKind[RightHandSide]
+ (47,2)SyntaxKind[SymbolSpan]
+ (47,2)SyntaxKind[Terminal](text = "(")
+ (47,6)SyntaxKind[SymbolSpan]
+ (47,6)SyntaxKind[Nonterminal]
+ (47,6)SyntaxKind[Identifier](text = "Type")
+ (47,11)SyntaxKind[SymbolSpan]
+ (47,11)SyntaxKind[Terminal](text = ")")
+ (48,1)SyntaxKind[DedentToken]
+ (49,1)SyntaxKind[Production]
+ (49,1)SyntaxKind[Identifier](text = "PredefinedType")
+ (50,1)SyntaxKind[RightHandSideList]
+ (50,1)SyntaxKind[IndentToken]
+ (50,2)SyntaxKind[RightHandSide]
+ (50,2)SyntaxKind[SymbolSpan]
+ (50,2)SyntaxKind[Terminal](text = "any")
+ (51,2)SyntaxKind[RightHandSide]
+ (51,2)SyntaxKind[SymbolSpan]
+ (51,2)SyntaxKind[Terminal](text = "number")
+ (52,2)SyntaxKind[RightHandSide]
+ (52,2)SyntaxKind[SymbolSpan]
+ (52,2)SyntaxKind[Terminal](text = "boolean")
+ (53,2)SyntaxKind[RightHandSide]
+ (53,2)SyntaxKind[SymbolSpan]
+ (53,2)SyntaxKind[Terminal](text = "string")
+ (54,2)SyntaxKind[RightHandSide]
+ (54,2)SyntaxKind[SymbolSpan]
+ (54,2)SyntaxKind[Terminal](text = "void")
+ (55,1)SyntaxKind[DedentToken]
+ (56,1)SyntaxKind[Production]
+ (56,1)SyntaxKind[Identifier](text = "TypeReference")
+ (57,1)SyntaxKind[RightHandSideList]
+ (57,1)SyntaxKind[IndentToken]
+ (57,2)SyntaxKind[RightHandSide]
+ (57,2)SyntaxKind[SymbolSpan]
+ (57,2)SyntaxKind[Nonterminal]
+ (57,2)SyntaxKind[Identifier](text = "TypeName")
+ (57,11)SyntaxKind[SymbolSpan]
+ (57,11)SyntaxKind[NoSymbolHereAssertion]
+ (57,11)SyntaxKind[OpenBracketToken]
+ (57,12)SyntaxKind[NoKeyword]
+ (57,15)SyntaxKind[Nonterminal]
+ (57,15)SyntaxKind[Identifier](text = "LineTerminator")
+ (57,30)SyntaxKind[HereKeyword]
+ (57,34)SyntaxKind[CloseBracketToken]
+ (57,36)SyntaxKind[SymbolSpan]
+ (57,36)SyntaxKind[Nonterminal]?
+ (57,36)SyntaxKind[Identifier](text = "TypeArguments")
+ (57,49)SyntaxKind[QuestionToken]
+ (58,1)SyntaxKind[DedentToken]
+ (59,1)SyntaxKind[Production]
+ (59,1)SyntaxKind[Identifier](text = "TypeName")
+ (60,1)SyntaxKind[RightHandSideList]
+ (60,1)SyntaxKind[IndentToken]
+ (60,2)SyntaxKind[RightHandSide]
+ (60,2)SyntaxKind[SymbolSpan]
+ (60,2)SyntaxKind[Nonterminal]
+ (60,2)SyntaxKind[Identifier](text = "Identifier")
+ (61,2)SyntaxKind[RightHandSide]
+ (61,2)SyntaxKind[SymbolSpan]
+ (61,2)SyntaxKind[Nonterminal]
+ (61,2)SyntaxKind[Identifier](text = "ModuleName")
+ (61,13)SyntaxKind[SymbolSpan]
+ (61,13)SyntaxKind[Terminal](text = ".")
+ (61,17)SyntaxKind[SymbolSpan]
+ (61,17)SyntaxKind[Nonterminal]
+ (61,17)SyntaxKind[Identifier](text = "Identifier")
+ (62,1)SyntaxKind[DedentToken]
+ (63,1)SyntaxKind[Production]
+ (63,1)SyntaxKind[Identifier](text = "ModuleName")
+ (64,1)SyntaxKind[RightHandSideList]
+ (64,1)SyntaxKind[IndentToken]
+ (64,2)SyntaxKind[RightHandSide]
+ (64,2)SyntaxKind[SymbolSpan]
+ (64,2)SyntaxKind[Nonterminal]
+ (64,2)SyntaxKind[Identifier](text = "Identifier")
+ (65,2)SyntaxKind[RightHandSide]
+ (65,2)SyntaxKind[SymbolSpan]
+ (65,2)SyntaxKind[Nonterminal]
+ (65,2)SyntaxKind[Identifier](text = "ModuleName")
+ (65,13)SyntaxKind[SymbolSpan]
+ (65,13)SyntaxKind[Terminal](text = ".")
+ (65,17)SyntaxKind[SymbolSpan]
+ (65,17)SyntaxKind[Nonterminal]
+ (65,17)SyntaxKind[Identifier](text = "Identifier")
+ (66,1)SyntaxKind[DedentToken]
+ (67,1)SyntaxKind[Production]
+ (67,1)SyntaxKind[Identifier](text = "ObjectType")
+ (68,1)SyntaxKind[RightHandSideList]
+ (68,1)SyntaxKind[IndentToken]
+ (68,2)SyntaxKind[RightHandSide]
+ (68,2)SyntaxKind[SymbolSpan]
+ (68,2)SyntaxKind[Terminal](text = "{")
+ (68,8)SyntaxKind[SymbolSpan]
+ (68,8)SyntaxKind[Nonterminal]?
+ (68,8)SyntaxKind[Identifier](text = "TypeBody")
+ (68,16)SyntaxKind[QuestionToken]
+ (68,20)SyntaxKind[SymbolSpan]
+ (68,20)SyntaxKind[Terminal](text = "}")
+ (69,1)SyntaxKind[DedentToken]
+ (70,1)SyntaxKind[Production]
+ (70,1)SyntaxKind[Identifier](text = "TypeBody")
+ (71,1)SyntaxKind[RightHandSideList]
+ (71,1)SyntaxKind[IndentToken]
+ (71,2)SyntaxKind[RightHandSide]
+ (71,2)SyntaxKind[SymbolSpan]
+ (71,2)SyntaxKind[Nonterminal]
+ (71,2)SyntaxKind[Identifier](text = "TypeMemberList")
+ (71,17)SyntaxKind[SymbolSpan]
+ (71,17)SyntaxKind[Terminal](text = ";")?
+ (71,20)SyntaxKind[QuestionToken]
+ (72,1)SyntaxKind[DedentToken]
+ (73,1)SyntaxKind[Production]
+ (73,1)SyntaxKind[Identifier](text = "TypeMemberList")
+ (74,1)SyntaxKind[RightHandSideList]
+ (74,1)SyntaxKind[IndentToken]
+ (74,2)SyntaxKind[RightHandSide]
+ (74,2)SyntaxKind[SymbolSpan]
+ (74,2)SyntaxKind[Nonterminal]
+ (74,2)SyntaxKind[Identifier](text = "TypeMember")
+ (75,2)SyntaxKind[RightHandSide]
+ (75,2)SyntaxKind[SymbolSpan]
+ (75,2)SyntaxKind[Nonterminal]
+ (75,2)SyntaxKind[Identifier](text = "TypeMemberList")
+ (75,17)SyntaxKind[SymbolSpan]
+ (75,17)SyntaxKind[Terminal](text = ";")
+ (75,21)SyntaxKind[SymbolSpan]
+ (75,21)SyntaxKind[Nonterminal]
+ (75,21)SyntaxKind[Identifier](text = "TypeMember")
+ (76,1)SyntaxKind[DedentToken]
+ (77,1)SyntaxKind[Production]
+ (77,1)SyntaxKind[Identifier](text = "TypeMember")
+ (78,1)SyntaxKind[RightHandSideList]
+ (78,1)SyntaxKind[IndentToken]
+ (78,2)SyntaxKind[RightHandSide]
+ (78,2)SyntaxKind[SymbolSpan]
+ (78,2)SyntaxKind[Nonterminal]
+ (78,2)SyntaxKind[Identifier](text = "PropertySignature")
+ (79,2)SyntaxKind[RightHandSide]
+ (79,2)SyntaxKind[SymbolSpan]
+ (79,2)SyntaxKind[Nonterminal]
+ (79,2)SyntaxKind[Identifier](text = "CallSignature")
+ (80,2)SyntaxKind[RightHandSide]
+ (80,2)SyntaxKind[SymbolSpan]
+ (80,2)SyntaxKind[Nonterminal]
+ (80,2)SyntaxKind[Identifier](text = "ConstructSignature")
+ (81,2)SyntaxKind[RightHandSide]
+ (81,2)SyntaxKind[SymbolSpan]
+ (81,2)SyntaxKind[Nonterminal]
+ (81,2)SyntaxKind[Identifier](text = "IndexSignature")
+ (82,2)SyntaxKind[RightHandSide]
+ (82,2)SyntaxKind[SymbolSpan]
+ (82,2)SyntaxKind[Nonterminal]
+ (82,2)SyntaxKind[Identifier](text = "MethodSignature")
+ (83,1)SyntaxKind[DedentToken]
+ (84,1)SyntaxKind[Production]
+ (84,1)SyntaxKind[Identifier](text = "ArrayType")
+ (85,1)SyntaxKind[RightHandSideList]
+ (85,1)SyntaxKind[IndentToken]
+ (85,2)SyntaxKind[RightHandSide]
+ (85,2)SyntaxKind[SymbolSpan]
+ (85,2)SyntaxKind[Nonterminal]
+ (85,2)SyntaxKind[Identifier](text = "PrimaryType")
+ (85,14)SyntaxKind[SymbolSpan]
+ (85,14)SyntaxKind[NoSymbolHereAssertion]
+ (85,14)SyntaxKind[OpenBracketToken]
+ (85,15)SyntaxKind[NoKeyword]
+ (85,18)SyntaxKind[Nonterminal]
+ (85,18)SyntaxKind[Identifier](text = "LineTerminator")
+ (85,33)SyntaxKind[HereKeyword]
+ (85,37)SyntaxKind[CloseBracketToken]
+ (85,39)SyntaxKind[SymbolSpan]
+ (85,39)SyntaxKind[Terminal](text = "[")
+ (85,43)SyntaxKind[SymbolSpan]
+ (85,43)SyntaxKind[Terminal](text = "]")
+ (86,1)SyntaxKind[DedentToken]
+ (87,1)SyntaxKind[Production]
+ (87,1)SyntaxKind[Identifier](text = "TupleType")
+ (88,1)SyntaxKind[RightHandSideList]
+ (88,1)SyntaxKind[IndentToken]
+ (88,2)SyntaxKind[RightHandSide]
+ (88,2)SyntaxKind[SymbolSpan]
+ (88,2)SyntaxKind[Terminal](text = "[")
+ (88,6)SyntaxKind[SymbolSpan]
+ (88,6)SyntaxKind[Nonterminal]
+ (88,6)SyntaxKind[Identifier](text = "TupleElementTypes")
+ (88,24)SyntaxKind[SymbolSpan]
+ (88,24)SyntaxKind[Terminal](text = "]")
+ (89,1)SyntaxKind[DedentToken]
+ (90,1)SyntaxKind[Production]
+ (90,1)SyntaxKind[Identifier](text = "TupleElementTypes")
+ (91,1)SyntaxKind[RightHandSideList]
+ (91,1)SyntaxKind[IndentToken]
+ (91,2)SyntaxKind[RightHandSide]
+ (91,2)SyntaxKind[SymbolSpan]
+ (91,2)SyntaxKind[Nonterminal]
+ (91,2)SyntaxKind[Identifier](text = "TupleElementType")
+ (92,2)SyntaxKind[RightHandSide]
+ (92,2)SyntaxKind[SymbolSpan]
+ (92,2)SyntaxKind[Nonterminal]
+ (92,2)SyntaxKind[Identifier](text = "TupleElementTypes")
+ (92,20)SyntaxKind[SymbolSpan]
+ (92,20)SyntaxKind[Terminal](text = ",")
+ (92,24)SyntaxKind[SymbolSpan]
+ (92,24)SyntaxKind[Nonterminal]
+ (92,24)SyntaxKind[Identifier](text = "TupleElementType")
+ (93,1)SyntaxKind[DedentToken]
+ (94,1)SyntaxKind[Production]
+ (94,1)SyntaxKind[Identifier](text = "TupleElementType")
+ (95,1)SyntaxKind[RightHandSideList]
+ (95,1)SyntaxKind[IndentToken]
+ (95,2)SyntaxKind[RightHandSide]
+ (95,2)SyntaxKind[SymbolSpan]
+ (95,2)SyntaxKind[Nonterminal]
+ (95,2)SyntaxKind[Identifier](text = "Type")
+ (96,1)SyntaxKind[DedentToken]
+ (97,1)SyntaxKind[Production]
+ (97,1)SyntaxKind[Identifier](text = "UnionType")
+ (98,1)SyntaxKind[RightHandSideList]
+ (98,1)SyntaxKind[IndentToken]
+ (98,2)SyntaxKind[RightHandSide]
+ (98,2)SyntaxKind[SymbolSpan]
+ (98,2)SyntaxKind[Nonterminal]
+ (98,2)SyntaxKind[Identifier](text = "PrimaryOrUnionType")
+ (98,21)SyntaxKind[SymbolSpan]
+ (98,21)SyntaxKind[Terminal](text = "|")
+ (98,25)SyntaxKind[SymbolSpan]
+ (98,25)SyntaxKind[Nonterminal]
+ (98,25)SyntaxKind[Identifier](text = "PrimaryType")
+ (99,1)SyntaxKind[DedentToken]
+ (100,1)SyntaxKind[Production]
+ (100,1)SyntaxKind[Identifier](text = "FunctionType")
+ (101,1)SyntaxKind[RightHandSideList]
+ (101,1)SyntaxKind[IndentToken]
+ (101,2)SyntaxKind[RightHandSide]
+ (101,2)SyntaxKind[SymbolSpan]
+ (101,2)SyntaxKind[Nonterminal]?
+ (101,2)SyntaxKind[Identifier](text = "TypeParameters")
+ (101,16)SyntaxKind[QuestionToken]
+ (101,18)SyntaxKind[SymbolSpan]
+ (101,18)SyntaxKind[Terminal](text = "(")
+ (101,22)SyntaxKind[SymbolSpan]
+ (101,22)SyntaxKind[Nonterminal]?
+ (101,22)SyntaxKind[Identifier](text = "ParameterList")
+ (101,35)SyntaxKind[QuestionToken]
+ (101,37)SyntaxKind[SymbolSpan]
+ (101,37)SyntaxKind[Terminal](text = ")")
+ (101,41)SyntaxKind[SymbolSpan]
+ (101,41)SyntaxKind[Terminal](text = "=>")
+ (101,46)SyntaxKind[SymbolSpan]
+ (101,46)SyntaxKind[Nonterminal]
+ (101,46)SyntaxKind[Identifier](text = "Type")
+ (102,1)SyntaxKind[DedentToken]
+ (103,1)SyntaxKind[Production]
+ (103,1)SyntaxKind[Identifier](text = "ConstructorType")
+ (104,1)SyntaxKind[RightHandSideList]
+ (104,1)SyntaxKind[IndentToken]
+ (104,2)SyntaxKind[RightHandSide]
+ (104,2)SyntaxKind[SymbolSpan]
+ (104,2)SyntaxKind[Terminal](text = "new")
+ (104,8)SyntaxKind[SymbolSpan]
+ (104,8)SyntaxKind[Nonterminal]?
+ (104,8)SyntaxKind[Identifier](text = "TypeParameters")
+ (104,22)SyntaxKind[QuestionToken]
+ (104,24)SyntaxKind[SymbolSpan]
+ (104,24)SyntaxKind[Terminal](text = "(")
+ (104,28)SyntaxKind[SymbolSpan]
+ (104,28)SyntaxKind[Nonterminal]?
+ (104,28)SyntaxKind[Identifier](text = "ParameterList")
+ (104,41)SyntaxKind[QuestionToken]
+ (104,43)SyntaxKind[SymbolSpan]
+ (104,43)SyntaxKind[Terminal](text = ")")
+ (104,47)SyntaxKind[SymbolSpan]
+ (104,47)SyntaxKind[Terminal](text = "=>")
+ (104,52)SyntaxKind[SymbolSpan]
+ (104,52)SyntaxKind[Nonterminal]
+ (104,52)SyntaxKind[Identifier](text = "Type")
+ (105,1)SyntaxKind[DedentToken]
+ (106,1)SyntaxKind[Production]
+ (106,1)SyntaxKind[Identifier](text = "TypeQuery")
+ (107,1)SyntaxKind[RightHandSideList]
+ (107,1)SyntaxKind[IndentToken]
+ (107,2)SyntaxKind[RightHandSide]
+ (107,2)SyntaxKind[SymbolSpan]
+ (107,2)SyntaxKind[Terminal](text = "typeof")
+ (107,11)SyntaxKind[SymbolSpan]
+ (107,11)SyntaxKind[Nonterminal]
+ (107,11)SyntaxKind[Identifier](text = "TypeQueryExpression")
+ (108,1)SyntaxKind[DedentToken]
+ (109,1)SyntaxKind[Production]
+ (109,1)SyntaxKind[Identifier](text = "TypeQueryExpression")
+ (110,1)SyntaxKind[RightHandSideList]
+ (110,1)SyntaxKind[IndentToken]
+ (110,2)SyntaxKind[RightHandSide]
+ (110,2)SyntaxKind[SymbolSpan]
+ (110,2)SyntaxKind[Nonterminal]
+ (110,2)SyntaxKind[Identifier](text = "Identifier")
+ (111,2)SyntaxKind[RightHandSide]
+ (111,2)SyntaxKind[SymbolSpan]
+ (111,2)SyntaxKind[Nonterminal]
+ (111,2)SyntaxKind[Identifier](text = "TypeQueryExpression")
+ (111,22)SyntaxKind[SymbolSpan]
+ (111,22)SyntaxKind[Terminal](text = ".")
+ (111,26)SyntaxKind[SymbolSpan]
+ (111,26)SyntaxKind[Nonterminal]
+ (111,26)SyntaxKind[Identifier](text = "IdentifierName")
+ (112,1)SyntaxKind[DedentToken]
+ (113,1)SyntaxKind[Production]
+ (113,1)SyntaxKind[Identifier](text = "PropertySignature")
+ (114,1)SyntaxKind[RightHandSideList]
+ (114,1)SyntaxKind[IndentToken]
+ (114,2)SyntaxKind[RightHandSide]
+ (114,2)SyntaxKind[SymbolSpan]
+ (114,2)SyntaxKind[Nonterminal]
+ (114,2)SyntaxKind[Identifier](text = "PropertyName")
+ (114,15)SyntaxKind[SymbolSpan]
+ (114,15)SyntaxKind[Terminal](text = "?")?
+ (114,18)SyntaxKind[QuestionToken]
+ (114,20)SyntaxKind[SymbolSpan]
+ (114,20)SyntaxKind[Nonterminal]?
+ (114,20)SyntaxKind[Identifier](text = "TypeAnnotation")
+ (114,34)SyntaxKind[QuestionToken]
+ (115,1)SyntaxKind[DedentToken]
+ (116,1)SyntaxKind[Production]
+ (116,1)SyntaxKind[Identifier](text = "PropertyName")
+ (117,1)SyntaxKind[RightHandSideList]
+ (117,1)SyntaxKind[IndentToken]
+ (117,2)SyntaxKind[RightHandSide]
+ (117,2)SyntaxKind[SymbolSpan]
+ (117,2)SyntaxKind[Nonterminal]
+ (117,2)SyntaxKind[Identifier](text = "IdentifierName")
+ (118,2)SyntaxKind[RightHandSide]
+ (118,2)SyntaxKind[SymbolSpan]
+ (118,2)SyntaxKind[Nonterminal]
+ (118,2)SyntaxKind[Identifier](text = "StringLiteral")
+ (119,2)SyntaxKind[RightHandSide]
+ (119,2)SyntaxKind[SymbolSpan]
+ (119,2)SyntaxKind[Nonterminal]
+ (119,2)SyntaxKind[Identifier](text = "NumericLiteral")
+ (120,1)SyntaxKind[DedentToken]
+ (121,1)SyntaxKind[Production]
+ (121,1)SyntaxKind[Identifier](text = "CallSignature")
+ (122,1)SyntaxKind[RightHandSideList]
+ (122,1)SyntaxKind[IndentToken]
+ (122,2)SyntaxKind[RightHandSide]
+ (122,2)SyntaxKind[SymbolSpan]
+ (122,2)SyntaxKind[Nonterminal]?
+ (122,2)SyntaxKind[Identifier](text = "TypeParameters")
+ (122,16)SyntaxKind[QuestionToken]
+ (122,18)SyntaxKind[SymbolSpan]
+ (122,18)SyntaxKind[Terminal](text = "(")
+ (122,22)SyntaxKind[SymbolSpan]
+ (122,22)SyntaxKind[Nonterminal]?
+ (122,22)SyntaxKind[Identifier](text = "ParameterList")
+ (122,35)SyntaxKind[QuestionToken]
+ (122,37)SyntaxKind[SymbolSpan]
+ (122,37)SyntaxKind[Terminal](text = ")")
+ (122,41)SyntaxKind[SymbolSpan]
+ (122,41)SyntaxKind[Nonterminal]?
+ (122,41)SyntaxKind[Identifier](text = "TypeAnnotation")
+ (122,55)SyntaxKind[QuestionToken]
+ (123,1)SyntaxKind[DedentToken]
+ (124,1)SyntaxKind[Production]
+ (124,1)SyntaxKind[Identifier](text = "ParameterList")
+ (125,1)SyntaxKind[RightHandSideList]
+ (125,1)SyntaxKind[IndentToken]
+ (125,2)SyntaxKind[RightHandSide]
+ (125,2)SyntaxKind[SymbolSpan]
+ (125,2)SyntaxKind[Nonterminal]
+ (125,2)SyntaxKind[Identifier](text = "RequiredParameterList")
+ (126,2)SyntaxKind[RightHandSide]
+ (126,2)SyntaxKind[SymbolSpan]
+ (126,2)SyntaxKind[Nonterminal]
+ (126,2)SyntaxKind[Identifier](text = "OptionalParameterList")
+ (127,2)SyntaxKind[RightHandSide]
+ (127,2)SyntaxKind[SymbolSpan]
+ (127,2)SyntaxKind[Nonterminal]
+ (127,2)SyntaxKind[Identifier](text = "RestParameter")
+ (128,2)SyntaxKind[RightHandSide]
+ (128,2)SyntaxKind[SymbolSpan]
+ (128,2)SyntaxKind[Nonterminal]
+ (128,2)SyntaxKind[Identifier](text = "RequiredParameterList")
+ (128,24)SyntaxKind[SymbolSpan]
+ (128,24)SyntaxKind[Terminal](text = ",")
+ (128,28)SyntaxKind[SymbolSpan]
+ (128,28)SyntaxKind[Nonterminal]
+ (128,28)SyntaxKind[Identifier](text = "OptionalParameterList")
+ (129,2)SyntaxKind[RightHandSide]
+ (129,2)SyntaxKind[SymbolSpan]
+ (129,2)SyntaxKind[Nonterminal]
+ (129,2)SyntaxKind[Identifier](text = "RequiredParameterList")
+ (129,24)SyntaxKind[SymbolSpan]
+ (129,24)SyntaxKind[Terminal](text = ",")
+ (129,28)SyntaxKind[SymbolSpan]
+ (129,28)SyntaxKind[Nonterminal]
+ (129,28)SyntaxKind[Identifier](text = "RestParameter")
+ (130,2)SyntaxKind[RightHandSide]
+ (130,2)SyntaxKind[SymbolSpan]
+ (130,2)SyntaxKind[Nonterminal]
+ (130,2)SyntaxKind[Identifier](text = "OptionalParameterList")
+ (130,24)SyntaxKind[SymbolSpan]
+ (130,24)SyntaxKind[Terminal](text = ",")
+ (130,28)SyntaxKind[SymbolSpan]
+ (130,28)SyntaxKind[Nonterminal]
+ (130,28)SyntaxKind[Identifier](text = "RestParameter")
+ (131,2)SyntaxKind[RightHandSide]
+ (131,2)SyntaxKind[SymbolSpan]
+ (131,2)SyntaxKind[Nonterminal]
+ (131,2)SyntaxKind[Identifier](text = "RequiredParameterList")
+ (131,24)SyntaxKind[SymbolSpan]
+ (131,24)SyntaxKind[Terminal](text = ",")
+ (131,28)SyntaxKind[SymbolSpan]
+ (131,28)SyntaxKind[Nonterminal]
+ (131,28)SyntaxKind[Identifier](text = "OptionalParameterList")
+ (131,50)SyntaxKind[SymbolSpan]
+ (131,50)SyntaxKind[Terminal](text = ",")
+ (131,54)SyntaxKind[SymbolSpan]
+ (131,54)SyntaxKind[Nonterminal]
+ (131,54)SyntaxKind[Identifier](text = "RestParameter")
+ (132,1)SyntaxKind[DedentToken]
+ (133,1)SyntaxKind[Production]
+ (133,1)SyntaxKind[Identifier](text = "RequiredParameterList")
+ (134,1)SyntaxKind[RightHandSideList]
+ (134,1)SyntaxKind[IndentToken]
+ (134,2)SyntaxKind[RightHandSide]
+ (134,2)SyntaxKind[SymbolSpan]
+ (134,2)SyntaxKind[Nonterminal]
+ (134,2)SyntaxKind[Identifier](text = "RequiredParameter")
+ (135,2)SyntaxKind[RightHandSide]
+ (135,2)SyntaxKind[SymbolSpan]
+ (135,2)SyntaxKind[Nonterminal]
+ (135,2)SyntaxKind[Identifier](text = "RequiredParameterList")
+ (135,24)SyntaxKind[SymbolSpan]
+ (135,24)SyntaxKind[Terminal](text = ",")
+ (135,28)SyntaxKind[SymbolSpan]
+ (135,28)SyntaxKind[Nonterminal]
+ (135,28)SyntaxKind[Identifier](text = "RequiredParameter")
+ (136,1)SyntaxKind[DedentToken]
+ (137,1)SyntaxKind[Production]
+ (137,1)SyntaxKind[Identifier](text = "RequiredParameter")
+ (138,1)SyntaxKind[RightHandSideList]
+ (138,1)SyntaxKind[IndentToken]
+ (138,2)SyntaxKind[RightHandSide]
+ (138,2)SyntaxKind[SymbolSpan]
+ (138,2)SyntaxKind[Nonterminal]?
+ (138,2)SyntaxKind[Identifier](text = "AccessibilityModifier")
+ (138,23)SyntaxKind[QuestionToken]
+ (138,25)SyntaxKind[SymbolSpan]
+ (138,25)SyntaxKind[Nonterminal]
+ (138,25)SyntaxKind[Identifier](text = "Identifier")
+ (138,36)SyntaxKind[SymbolSpan]
+ (138,36)SyntaxKind[Nonterminal]?
+ (138,36)SyntaxKind[Identifier](text = "TypeAnnotation")
+ (138,50)SyntaxKind[QuestionToken]
+ (139,2)SyntaxKind[RightHandSide]
+ (139,2)SyntaxKind[SymbolSpan]
+ (139,2)SyntaxKind[Nonterminal]
+ (139,2)SyntaxKind[Identifier](text = "Identifier")
+ (139,13)SyntaxKind[SymbolSpan]
+ (139,13)SyntaxKind[Terminal](text = ":")
+ (139,17)SyntaxKind[SymbolSpan]
+ (139,17)SyntaxKind[Nonterminal]
+ (139,17)SyntaxKind[Identifier](text = "StringLiteral")
+ (140,1)SyntaxKind[DedentToken]
+ (141,1)SyntaxKind[Production]
+ (141,1)SyntaxKind[Identifier](text = "AccessibilityModifier")
+ (142,1)SyntaxKind[RightHandSideList]
+ (142,1)SyntaxKind[IndentToken]
+ (142,2)SyntaxKind[RightHandSide]
+ (142,2)SyntaxKind[SymbolSpan]
+ (142,2)SyntaxKind[Terminal](text = "public")
+ (143,2)SyntaxKind[RightHandSide]
+ (143,2)SyntaxKind[SymbolSpan]
+ (143,2)SyntaxKind[Terminal](text = "private")
+ (144,2)SyntaxKind[RightHandSide]
+ (144,2)SyntaxKind[SymbolSpan]
+ (144,2)SyntaxKind[Terminal](text = "protected")
+ (145,1)SyntaxKind[DedentToken]
+ (146,1)SyntaxKind[Production]
+ (146,1)SyntaxKind[Identifier](text = "OptionalParameterList")
+ (147,1)SyntaxKind[RightHandSideList]
+ (147,1)SyntaxKind[IndentToken]
+ (147,2)SyntaxKind[RightHandSide]
+ (147,2)SyntaxKind[SymbolSpan]
+ (147,2)SyntaxKind[Nonterminal]
+ (147,2)SyntaxKind[Identifier](text = "OptionalParameter")
+ (148,2)SyntaxKind[RightHandSide]
+ (148,2)SyntaxKind[SymbolSpan]
+ (148,2)SyntaxKind[Nonterminal]
+ (148,2)SyntaxKind[Identifier](text = "OptionalParameterList")
+ (148,24)SyntaxKind[SymbolSpan]
+ (148,24)SyntaxKind[Terminal](text = ",")
+ (148,28)SyntaxKind[SymbolSpan]
+ (148,28)SyntaxKind[Nonterminal]
+ (148,28)SyntaxKind[Identifier](text = "OptionalParameter")
+ (149,1)SyntaxKind[DedentToken]
+ (150,1)SyntaxKind[Production]
+ (150,1)SyntaxKind[Identifier](text = "OptionalParameter")
+ (151,1)SyntaxKind[RightHandSideList]
+ (151,1)SyntaxKind[IndentToken]
+ (151,2)SyntaxKind[RightHandSide]
+ (151,2)SyntaxKind[SymbolSpan]
+ (151,2)SyntaxKind[Nonterminal]?
+ (151,2)SyntaxKind[Identifier](text = "AccessibilityModifier")
+ (151,23)SyntaxKind[QuestionToken]
+ (151,25)SyntaxKind[SymbolSpan]
+ (151,25)SyntaxKind[Nonterminal]
+ (151,25)SyntaxKind[Identifier](text = "Identifier")
+ (151,36)SyntaxKind[SymbolSpan]
+ (151,36)SyntaxKind[Terminal](text = "?")
+ (151,40)SyntaxKind[SymbolSpan]
+ (151,40)SyntaxKind[Nonterminal]?
+ (151,40)SyntaxKind[Identifier](text = "TypeAnnotation")
+ (151,54)SyntaxKind[QuestionToken]
+ (152,2)SyntaxKind[RightHandSide]
+ (152,2)SyntaxKind[SymbolSpan]
+ (152,2)SyntaxKind[Nonterminal]?
+ (152,2)SyntaxKind[Identifier](text = "AccessibilityModifier")
+ (152,23)SyntaxKind[QuestionToken]
+ (152,25)SyntaxKind[SymbolSpan]
+ (152,25)SyntaxKind[Nonterminal]
+ (152,25)SyntaxKind[Identifier](text = "Identifier")
+ (152,36)SyntaxKind[SymbolSpan]
+ (152,36)SyntaxKind[Nonterminal]?
+ (152,36)SyntaxKind[Identifier](text = "TypeAnnotation")
+ (152,50)SyntaxKind[QuestionToken]
+ (152,52)SyntaxKind[SymbolSpan]
+ (152,52)SyntaxKind[Nonterminal]
+ (152,52)SyntaxKind[Identifier](text = "Initializer")
+ (153,2)SyntaxKind[RightHandSide]
+ (153,2)SyntaxKind[SymbolSpan]
+ (153,2)SyntaxKind[Nonterminal]
+ (153,2)SyntaxKind[Identifier](text = "Identifier")
+ (153,13)SyntaxKind[SymbolSpan]
+ (153,13)SyntaxKind[Terminal](text = "?")
+ (153,17)SyntaxKind[SymbolSpan]
+ (153,17)SyntaxKind[Terminal](text = ":")
+ (153,21)SyntaxKind[SymbolSpan]
+ (153,21)SyntaxKind[Nonterminal]
+ (153,21)SyntaxKind[Identifier](text = "StringLiteral")
+ (154,1)SyntaxKind[DedentToken]
+ (155,1)SyntaxKind[Production]
+ (155,1)SyntaxKind[Identifier](text = "RestParameter")
+ (156,1)SyntaxKind[RightHandSideList]
+ (156,1)SyntaxKind[IndentToken]
+ (156,2)SyntaxKind[RightHandSide]
+ (156,2)SyntaxKind[SymbolSpan]
+ (156,2)SyntaxKind[Terminal](text = "...")
+ (156,8)SyntaxKind[SymbolSpan]
+ (156,8)SyntaxKind[Nonterminal]
+ (156,8)SyntaxKind[Identifier](text = "Identifier")
+ (156,19)SyntaxKind[SymbolSpan]
+ (156,19)SyntaxKind[Nonterminal]?
+ (156,19)SyntaxKind[Identifier](text = "TypeAnnotation")
+ (156,33)SyntaxKind[QuestionToken]
+ (157,1)SyntaxKind[DedentToken]
+ (158,1)SyntaxKind[Production]
+ (158,1)SyntaxKind[Identifier](text = "ConstructSignature")
+ (159,1)SyntaxKind[RightHandSideList]
+ (159,1)SyntaxKind[IndentToken]
+ (159,2)SyntaxKind[RightHandSide]
+ (159,2)SyntaxKind[SymbolSpan]
+ (159,2)SyntaxKind[Terminal](text = "new")
+ (159,8)SyntaxKind[SymbolSpan]
+ (159,8)SyntaxKind[Nonterminal]?
+ (159,8)SyntaxKind[Identifier](text = "TypeParameters")
+ (159,22)SyntaxKind[QuestionToken]
+ (159,24)SyntaxKind[SymbolSpan]
+ (159,24)SyntaxKind[Terminal](text = "(")
+ (159,28)SyntaxKind[SymbolSpan]
+ (159,28)SyntaxKind[Nonterminal]?
+ (159,28)SyntaxKind[Identifier](text = "ParameterList")
+ (159,41)SyntaxKind[QuestionToken]
+ (159,43)SyntaxKind[SymbolSpan]
+ (159,43)SyntaxKind[Terminal](text = ")")
+ (159,47)SyntaxKind[SymbolSpan]
+ (159,47)SyntaxKind[Nonterminal]?
+ (159,47)SyntaxKind[Identifier](text = "TypeAnnotation")
+ (159,61)SyntaxKind[QuestionToken]
+ (160,1)SyntaxKind[DedentToken]
+ (161,1)SyntaxKind[Production]
+ (161,1)SyntaxKind[Identifier](text = "IndexSignature")
+ (162,1)SyntaxKind[RightHandSideList]
+ (162,1)SyntaxKind[IndentToken]
+ (162,2)SyntaxKind[RightHandSide]
+ (162,2)SyntaxKind[SymbolSpan]
+ (162,2)SyntaxKind[Terminal](text = "[")
+ (162,6)SyntaxKind[SymbolSpan]
+ (162,6)SyntaxKind[Nonterminal]
+ (162,6)SyntaxKind[Identifier](text = "Identifier")
+ (162,17)SyntaxKind[SymbolSpan]
+ (162,17)SyntaxKind[Terminal](text = ":")
+ (162,21)SyntaxKind[SymbolSpan]
+ (162,21)SyntaxKind[Terminal](text = "string")
+ (162,30)SyntaxKind[SymbolSpan]
+ (162,30)SyntaxKind[Terminal](text = "]")
+ (162,34)SyntaxKind[SymbolSpan]
+ (162,34)SyntaxKind[Nonterminal]
+ (162,34)SyntaxKind[Identifier](text = "TypeAnnotation")
+ (163,2)SyntaxKind[RightHandSide]
+ (163,2)SyntaxKind[SymbolSpan]
+ (163,2)SyntaxKind[Terminal](text = "[")
+ (163,6)SyntaxKind[SymbolSpan]
+ (163,6)SyntaxKind[Nonterminal]
+ (163,6)SyntaxKind[Identifier](text = "Identifier")
+ (163,17)SyntaxKind[SymbolSpan]
+ (163,17)SyntaxKind[Terminal](text = ":")
+ (163,21)SyntaxKind[SymbolSpan]
+ (163,21)SyntaxKind[Terminal](text = "number")
+ (163,30)SyntaxKind[SymbolSpan]
+ (163,30)SyntaxKind[Terminal](text = "]")
+ (163,34)SyntaxKind[SymbolSpan]
+ (163,34)SyntaxKind[Nonterminal]
+ (163,34)SyntaxKind[Identifier](text = "TypeAnnotation")
+ (164,1)SyntaxKind[DedentToken]
+ (165,1)SyntaxKind[Production]
+ (165,1)SyntaxKind[Identifier](text = "MethodSignature")
+ (166,1)SyntaxKind[RightHandSideList]
+ (166,1)SyntaxKind[IndentToken]
+ (166,2)SyntaxKind[RightHandSide]
+ (166,2)SyntaxKind[SymbolSpan]
+ (166,2)SyntaxKind[Nonterminal]
+ (166,2)SyntaxKind[Identifier](text = "PropertyName")
+ (166,17)SyntaxKind[SymbolSpan]
+ (166,17)SyntaxKind[Terminal](text = "?")?
+ (166,20)SyntaxKind[QuestionToken]
+ (166,24)SyntaxKind[SymbolSpan]
+ (166,24)SyntaxKind[Nonterminal]
+ (166,24)SyntaxKind[Identifier](text = "CallSignature")
+ (167,1)SyntaxKind[DedentToken]
+ (168,1)SyntaxKind[Production]
+ (168,1)SyntaxKind[Identifier](text = "TypeAliasDeclaration")
+ (169,1)SyntaxKind[RightHandSideList]
+ (169,1)SyntaxKind[IndentToken]
+ (169,2)SyntaxKind[RightHandSide]
+ (169,2)SyntaxKind[SymbolSpan]
+ (169,2)SyntaxKind[Terminal](text = "type")
+ (169,9)SyntaxKind[SymbolSpan]
+ (169,9)SyntaxKind[Nonterminal]
+ (169,9)SyntaxKind[Identifier](text = "Identifier")
+ (169,20)SyntaxKind[SymbolSpan]
+ (169,20)SyntaxKind[Terminal](text = "=")
+ (169,24)SyntaxKind[SymbolSpan]
+ (169,24)SyntaxKind[Nonterminal]
+ (169,24)SyntaxKind[Identifier](text = "Type")
+ (169,29)SyntaxKind[SymbolSpan]
+ (169,29)SyntaxKind[Terminal](text = ";")
+ (170,1)SyntaxKind[DedentToken]
+ (173,1)SyntaxKind[Production]
+ (173,1)SyntaxKind[Identifier](text = "PropertyAssignment")
+ (174,1)SyntaxKind[RightHandSideList]
+ (174,1)SyntaxKind[IndentToken]
+ (174,2)SyntaxKind[RightHandSide]
+ (174,2)SyntaxKind[SymbolSpan]
+ (174,2)SyntaxKind[Nonterminal]
+ (174,2)SyntaxKind[Identifier](text = "PropertyName")
+ (174,15)SyntaxKind[SymbolSpan]
+ (174,15)SyntaxKind[Terminal](text = ":")
+ (174,19)SyntaxKind[SymbolSpan]
+ (174,19)SyntaxKind[Nonterminal]
+ (174,19)SyntaxKind[Identifier](text = "AssignmentExpression")
+ (175,2)SyntaxKind[RightHandSide]
+ (175,2)SyntaxKind[SymbolSpan]
+ (175,2)SyntaxKind[Nonterminal]
+ (175,2)SyntaxKind[Identifier](text = "PropertyName")
+ (175,15)SyntaxKind[SymbolSpan]
+ (175,15)SyntaxKind[Nonterminal]
+ (175,15)SyntaxKind[Identifier](text = "CallSignature")
+ (175,29)SyntaxKind[SymbolSpan]
+ (175,29)SyntaxKind[Terminal](text = "{")
+ (175,33)SyntaxKind[SymbolSpan]
+ (175,33)SyntaxKind[Nonterminal]
+ (175,33)SyntaxKind[Identifier](text = "FunctionBody")
+ (175,46)SyntaxKind[SymbolSpan]
+ (175,46)SyntaxKind[Terminal](text = "}")
+ (176,2)SyntaxKind[RightHandSide]
+ (176,2)SyntaxKind[SymbolSpan]
+ (176,2)SyntaxKind[Nonterminal]
+ (176,2)SyntaxKind[Identifier](text = "GetAccessor")
+ (177,2)SyntaxKind[RightHandSide]
+ (177,2)SyntaxKind[SymbolSpan]
+ (177,2)SyntaxKind[Nonterminal]
+ (177,2)SyntaxKind[Identifier](text = "SetAccessor")
+ (178,1)SyntaxKind[DedentToken]
+ (179,1)SyntaxKind[Production]
+ (179,1)SyntaxKind[Identifier](text = "GetAccessor")
+ (180,1)SyntaxKind[RightHandSideList]
+ (180,1)SyntaxKind[IndentToken]
+ (180,2)SyntaxKind[RightHandSide]
+ (180,2)SyntaxKind[SymbolSpan]
+ (180,2)SyntaxKind[Terminal](text = "get")
+ (180,8)SyntaxKind[SymbolSpan]
+ (180,8)SyntaxKind[Nonterminal]
+ (180,8)SyntaxKind[Identifier](text = "PropertyName")
+ (180,21)SyntaxKind[SymbolSpan]
+ (180,21)SyntaxKind[Terminal](text = "(")
+ (180,25)SyntaxKind[SymbolSpan]
+ (180,25)SyntaxKind[Terminal](text = ")")
+ (180,29)SyntaxKind[SymbolSpan]
+ (180,29)SyntaxKind[Nonterminal]?
+ (180,29)SyntaxKind[Identifier](text = "TypeAnnotation")
+ (180,43)SyntaxKind[QuestionToken]
+ (180,45)SyntaxKind[SymbolSpan]
+ (180,45)SyntaxKind[Terminal](text = "{")
+ (180,49)SyntaxKind[SymbolSpan]
+ (180,49)SyntaxKind[Nonterminal]
+ (180,49)SyntaxKind[Identifier](text = "FunctionBody")
+ (180,62)SyntaxKind[SymbolSpan]
+ (180,62)SyntaxKind[Terminal](text = "}")
+ (181,1)SyntaxKind[DedentToken]
+ (182,1)SyntaxKind[Production]
+ (182,1)SyntaxKind[Identifier](text = "SetAccessor")
+ (183,1)SyntaxKind[RightHandSideList]
+ (183,1)SyntaxKind[IndentToken]
+ (183,2)SyntaxKind[RightHandSide]
+ (183,2)SyntaxKind[SymbolSpan]
+ (183,2)SyntaxKind[Terminal](text = "set")
+ (183,8)SyntaxKind[SymbolSpan]
+ (183,8)SyntaxKind[Nonterminal]
+ (183,8)SyntaxKind[Identifier](text = "PropertyName")
+ (183,21)SyntaxKind[SymbolSpan]
+ (183,21)SyntaxKind[Terminal](text = "(")
+ (183,25)SyntaxKind[SymbolSpan]
+ (183,25)SyntaxKind[Nonterminal]
+ (183,25)SyntaxKind[Identifier](text = "Identifier")
+ (183,36)SyntaxKind[SymbolSpan]
+ (183,36)SyntaxKind[Nonterminal]?
+ (183,36)SyntaxKind[Identifier](text = "TypeAnnotation")
+ (183,50)SyntaxKind[QuestionToken]
+ (183,52)SyntaxKind[SymbolSpan]
+ (183,52)SyntaxKind[Terminal](text = ")")
+ (183,56)SyntaxKind[SymbolSpan]
+ (183,56)SyntaxKind[Terminal](text = "{")
+ (183,60)SyntaxKind[SymbolSpan]
+ (183,60)SyntaxKind[Nonterminal]
+ (183,60)SyntaxKind[Identifier](text = "FunctionBody")
+ (183,73)SyntaxKind[SymbolSpan]
+ (183,73)SyntaxKind[Terminal](text = "}")
+ (184,1)SyntaxKind[DedentToken]
+ (185,1)SyntaxKind[Production]
+ (185,1)SyntaxKind[Identifier](text = "ElementList")
+ (186,1)SyntaxKind[RightHandSideList]
+ (186,1)SyntaxKind[IndentToken]
+ (186,2)SyntaxKind[RightHandSide]
+ (186,2)SyntaxKind[SymbolSpan]
+ (186,2)SyntaxKind[Nonterminal]?
+ (186,2)SyntaxKind[Identifier](text = "Elision")
+ (186,9)SyntaxKind[QuestionToken]
+ (186,12)SyntaxKind[SymbolSpan]
+ (186,12)SyntaxKind[Nonterminal]
+ (186,12)SyntaxKind[Identifier](text = "AssignmentExpression")
+ (187,2)SyntaxKind[RightHandSide]
+ (187,2)SyntaxKind[SymbolSpan]
+ (187,2)SyntaxKind[Nonterminal]?
+ (187,2)SyntaxKind[Identifier](text = "Elision")
+ (187,9)SyntaxKind[QuestionToken]
+ (187,12)SyntaxKind[SymbolSpan]
+ (187,12)SyntaxKind[Nonterminal]
+ (187,12)SyntaxKind[Identifier](text = "SpreadElement")
+ (188,2)SyntaxKind[RightHandSide]
+ (188,2)SyntaxKind[SymbolSpan]
+ (188,2)SyntaxKind[Nonterminal]
+ (188,2)SyntaxKind[Identifier](text = "ElementList")
+ (188,14)SyntaxKind[SymbolSpan]
+ (188,14)SyntaxKind[Terminal](text = ",")
+ (188,18)SyntaxKind[SymbolSpan]
+ (188,18)SyntaxKind[Nonterminal]?
+ (188,18)SyntaxKind[Identifier](text = "Elision")
+ (188,25)SyntaxKind[QuestionToken]
+ (188,27)SyntaxKind[SymbolSpan]
+ (188,27)SyntaxKind[Nonterminal]
+ (188,27)SyntaxKind[Identifier](text = "AssignmentExpression")
+ (189,2)SyntaxKind[RightHandSide]
+ (189,2)SyntaxKind[SymbolSpan]
+ (189,2)SyntaxKind[Nonterminal]
+ (189,2)SyntaxKind[Identifier](text = "ElementList")
+ (189,14)SyntaxKind[SymbolSpan]
+ (189,14)SyntaxKind[Terminal](text = ",")
+ (189,18)SyntaxKind[SymbolSpan]
+ (189,18)SyntaxKind[Nonterminal]?
+ (189,18)SyntaxKind[Identifier](text = "Elision")
+ (189,25)SyntaxKind[QuestionToken]
+ (189,27)SyntaxKind[SymbolSpan]
+ (189,27)SyntaxKind[Nonterminal]
+ (189,27)SyntaxKind[Identifier](text = "SpreadElement")
+ (190,1)SyntaxKind[DedentToken]
+ (191,1)SyntaxKind[Production]
+ (191,1)SyntaxKind[Identifier](text = "SpreadElement")
+ (192,1)SyntaxKind[RightHandSideList]
+ (192,1)SyntaxKind[IndentToken]
+ (192,2)SyntaxKind[RightHandSide]
+ (192,2)SyntaxKind[SymbolSpan]
+ (192,2)SyntaxKind[Terminal](text = "...")
+ (192,8)SyntaxKind[SymbolSpan]
+ (192,8)SyntaxKind[Nonterminal]
+ (192,8)SyntaxKind[Identifier](text = "AssignmentExpression")
+ (193,1)SyntaxKind[DedentToken]
+ (194,1)SyntaxKind[Production]
+ (194,1)SyntaxKind[Identifier](text = "CallExpression")
+ (195,1)SyntaxKind[RightHandSideList]
+ (195,1)SyntaxKind[IndentToken]
+ (195,2)SyntaxKind[RightHandSide]
+ (195,2)SyntaxKind[SymbolSpan]
+ (195,2)SyntaxKind[Terminal](text = "super")
+ (195,10)SyntaxKind[SymbolSpan]
+ (195,10)SyntaxKind[Terminal](text = "(")
+ (195,14)SyntaxKind[SymbolSpan]
+ (195,14)SyntaxKind[Nonterminal]?
+ (195,14)SyntaxKind[Identifier](text = "ArgumentList")
+ (195,26)SyntaxKind[QuestionToken]
+ (195,28)SyntaxKind[SymbolSpan]
+ (195,28)SyntaxKind[Terminal](text = ")")
+ (196,2)SyntaxKind[RightHandSide]
+ (196,2)SyntaxKind[SymbolSpan]
+ (196,2)SyntaxKind[Terminal](text = "super")
+ (196,10)SyntaxKind[SymbolSpan]
+ (196,10)SyntaxKind[Terminal](text = ".")
+ (196,14)SyntaxKind[SymbolSpan]
+ (196,14)SyntaxKind[Nonterminal]
+ (196,14)SyntaxKind[Identifier](text = "IdentifierName")
+ (197,1)SyntaxKind[DedentToken]
+ (198,1)SyntaxKind[Production]
+ (198,1)SyntaxKind[Identifier](text = "FunctionExpression")
+ (199,1)SyntaxKind[RightHandSideList]
+ (199,1)SyntaxKind[IndentToken]
+ (199,2)SyntaxKind[RightHandSide]
+ (199,2)SyntaxKind[SymbolSpan]
+ (199,2)SyntaxKind[Terminal](text = "function")
+ (199,13)SyntaxKind[SymbolSpan]
+ (199,13)SyntaxKind[Nonterminal]?
+ (199,13)SyntaxKind[Identifier](text = "Identifier")
+ (199,23)SyntaxKind[QuestionToken]
+ (199,25)SyntaxKind[SymbolSpan]
+ (199,25)SyntaxKind[Nonterminal]
+ (199,25)SyntaxKind[Identifier](text = "CallSignature")
+ (199,39)SyntaxKind[SymbolSpan]
+ (199,39)SyntaxKind[Terminal](text = "{")
+ (199,43)SyntaxKind[SymbolSpan]
+ (199,43)SyntaxKind[Nonterminal]
+ (199,43)SyntaxKind[Identifier](text = "FunctionBody")
+ (199,56)SyntaxKind[SymbolSpan]
+ (199,56)SyntaxKind[Terminal](text = "}")
+ (200,1)SyntaxKind[DedentToken]
+ (201,1)SyntaxKind[Production]
+ (201,1)SyntaxKind[Identifier](text = "AssignmentExpression")
+ (202,1)SyntaxKind[RightHandSideList]
+ (202,1)SyntaxKind[IndentToken]
+ (202,2)SyntaxKind[RightHandSide]
+ (202,2)SyntaxKind[SymbolSpan]
+ (202,2)SyntaxKind[Nonterminal]
+ (202,2)SyntaxKind[Identifier](text = "ArrowFunctionExpression")
+ (203,1)SyntaxKind[DedentToken]
+ (204,1)SyntaxKind[Production]
+ (204,1)SyntaxKind[Identifier](text = "ArrowFunctionExpression")
+ (205,1)SyntaxKind[RightHandSideList]
+ (205,1)SyntaxKind[IndentToken]
+ (205,2)SyntaxKind[RightHandSide]
+ (205,2)SyntaxKind[SymbolSpan]
+ (205,2)SyntaxKind[Nonterminal]
+ (205,2)SyntaxKind[Identifier](text = "ArrowFormalParameters")
+ (205,24)SyntaxKind[SymbolSpan]
+ (205,24)SyntaxKind[Terminal](text = "=>")
+ (205,29)SyntaxKind[SymbolSpan]
+ (205,29)SyntaxKind[Nonterminal]
+ (205,29)SyntaxKind[Identifier](text = "Block")
+ (206,2)SyntaxKind[RightHandSide]
+ (206,2)SyntaxKind[SymbolSpan]
+ (206,2)SyntaxKind[Nonterminal]
+ (206,2)SyntaxKind[Identifier](text = "ArrowFormalParameters")
+ (206,24)SyntaxKind[SymbolSpan]
+ (206,24)SyntaxKind[Terminal](text = "=>")
+ (206,29)SyntaxKind[SymbolSpan]
+ (206,29)SyntaxKind[Nonterminal]
+ (206,29)SyntaxKind[Identifier](text = "AssignmentExpression")
+ (207,1)SyntaxKind[DedentToken]
+ (208,1)SyntaxKind[Production]
+ (208,1)SyntaxKind[Identifier](text = "ArrowFormalParameters")
+ (209,1)SyntaxKind[RightHandSideList]
+ (209,1)SyntaxKind[IndentToken]
+ (209,2)SyntaxKind[RightHandSide]
+ (209,2)SyntaxKind[SymbolSpan]
+ (209,2)SyntaxKind[Nonterminal]
+ (209,2)SyntaxKind[Identifier](text = "CallSignature")
+ (210,2)SyntaxKind[RightHandSide]
+ (210,2)SyntaxKind[SymbolSpan]
+ (210,2)SyntaxKind[Nonterminal]
+ (210,2)SyntaxKind[Identifier](text = "Identifier")
+ (211,1)SyntaxKind[DedentToken]
+ (212,1)SyntaxKind[Production]
+ (212,1)SyntaxKind[Identifier](text = "Arguments")
+ (213,1)SyntaxKind[RightHandSideList]
+ (213,1)SyntaxKind[IndentToken]
+ (213,2)SyntaxKind[RightHandSide]
+ (213,2)SyntaxKind[SymbolSpan]
+ (213,2)SyntaxKind[Nonterminal]?
+ (213,2)SyntaxKind[Identifier](text = "TypeArguments")
+ (213,15)SyntaxKind[QuestionToken]
+ (213,17)SyntaxKind[SymbolSpan]
+ (213,17)SyntaxKind[Terminal](text = "(")
+ (213,21)SyntaxKind[SymbolSpan]
+ (213,21)SyntaxKind[Nonterminal]?
+ (213,21)SyntaxKind[Identifier](text = "ArgumentList")
+ (213,33)SyntaxKind[QuestionToken]
+ (213,35)SyntaxKind[SymbolSpan]
+ (213,35)SyntaxKind[Terminal](text = ")")
+ (214,1)SyntaxKind[DedentToken]
+ (215,1)SyntaxKind[Production]
+ (215,1)SyntaxKind[Identifier](text = "UnaryExpression")
+ (216,1)SyntaxKind[RightHandSideList]
+ (216,1)SyntaxKind[IndentToken]
+ (216,2)SyntaxKind[RightHandSide]
+ (216,2)SyntaxKind[SymbolSpan]
+ (216,2)SyntaxKind[Terminal](text = "<")
+ (216,6)SyntaxKind[SymbolSpan]
+ (216,6)SyntaxKind[Nonterminal]
+ (216,6)SyntaxKind[Identifier](text = "Type")
+ (216,11)SyntaxKind[SymbolSpan]
+ (216,11)SyntaxKind[Terminal](text = ">")
+ (216,15)SyntaxKind[SymbolSpan]
+ (216,15)SyntaxKind[Nonterminal]
+ (216,15)SyntaxKind[Identifier](text = "UnaryExpression")
+ (217,1)SyntaxKind[DedentToken]
+ (220,1)SyntaxKind[Production]
+ (220,1)SyntaxKind[Identifier](text = "VariableDeclaration")
+ (221,1)SyntaxKind[RightHandSideList]
+ (221,1)SyntaxKind[IndentToken]
+ (221,2)SyntaxKind[RightHandSide]
+ (221,2)SyntaxKind[SymbolSpan]
+ (221,2)SyntaxKind[Nonterminal]
+ (221,2)SyntaxKind[Identifier](text = "SimpleVariableDeclaration")
+ (222,2)SyntaxKind[RightHandSide]
+ (222,2)SyntaxKind[SymbolSpan]
+ (222,2)SyntaxKind[Nonterminal]
+ (222,2)SyntaxKind[Identifier](text = "DestructuringVariableDeclaration")
+ (223,1)SyntaxKind[DedentToken]
+ (224,1)SyntaxKind[Production]
+ (224,1)SyntaxKind[Identifier](text = "SimpleVariableDeclaration")
+ (225,1)SyntaxKind[RightHandSideList]
+ (225,1)SyntaxKind[IndentToken]
+ (225,2)SyntaxKind[RightHandSide]
+ (225,2)SyntaxKind[SymbolSpan]
+ (225,2)SyntaxKind[Nonterminal]
+ (225,2)SyntaxKind[Identifier](text = "Identifier")
+ (225,13)SyntaxKind[SymbolSpan]
+ (225,13)SyntaxKind[Nonterminal]?
+ (225,13)SyntaxKind[Identifier](text = "TypeAnnotation")
+ (225,27)SyntaxKind[QuestionToken]
+ (225,29)SyntaxKind[SymbolSpan]
+ (225,29)SyntaxKind[Nonterminal]?
+ (225,29)SyntaxKind[Identifier](text = "Initializer")
+ (225,40)SyntaxKind[QuestionToken]
+ (226,1)SyntaxKind[DedentToken]
+ (227,1)SyntaxKind[Production]
+ (227,1)SyntaxKind[Identifier](text = "TypeAnnotation")
+ (228,1)SyntaxKind[RightHandSideList]
+ (228,1)SyntaxKind[IndentToken]
+ (228,2)SyntaxKind[RightHandSide]
+ (228,2)SyntaxKind[SymbolSpan]
+ (228,2)SyntaxKind[Terminal](text = ":")
+ (228,6)SyntaxKind[SymbolSpan]
+ (228,6)SyntaxKind[Nonterminal]
+ (228,6)SyntaxKind[Identifier](text = "Type")
+ (229,1)SyntaxKind[DedentToken]
+ (230,1)SyntaxKind[Production]
+ (230,1)SyntaxKind[Identifier](text = "DestructuringVariableDeclaration")
+ (231,1)SyntaxKind[RightHandSideList]
+ (231,1)SyntaxKind[IndentToken]
+ (231,2)SyntaxKind[RightHandSide]
+ (231,2)SyntaxKind[SymbolSpan]
+ (231,2)SyntaxKind[Nonterminal]
+ (231,2)SyntaxKind[Identifier](text = "BindingPattern")
+ (231,17)SyntaxKind[SymbolSpan]
+ (231,17)SyntaxKind[Nonterminal]?
+ (231,17)SyntaxKind[Identifier](text = "TypeAnnotation")
+ (231,31)SyntaxKind[QuestionToken]
+ (231,33)SyntaxKind[SymbolSpan]
+ (231,33)SyntaxKind[Nonterminal]
+ (231,33)SyntaxKind[Identifier](text = "Initializer")
+ (232,1)SyntaxKind[DedentToken]
+ (233,1)SyntaxKind[Production]
+ (233,1)SyntaxKind[Identifier](text = "BindingPattern")
+ (234,1)SyntaxKind[RightHandSideList]
+ (234,1)SyntaxKind[IndentToken]
+ (234,2)SyntaxKind[RightHandSide]
+ (234,2)SyntaxKind[SymbolSpan]
+ (234,2)SyntaxKind[Nonterminal]
+ (234,2)SyntaxKind[Identifier](text = "ObjectBindingPattern")
+ (235,2)SyntaxKind[RightHandSide]
+ (235,2)SyntaxKind[SymbolSpan]
+ (235,2)SyntaxKind[Nonterminal]
+ (235,2)SyntaxKind[Identifier](text = "ArrayBindingPattern")
+ (236,1)SyntaxKind[DedentToken]
+ (237,1)SyntaxKind[Production]
+ (237,1)SyntaxKind[Identifier](text = "ObjectBindingPattern")
+ (238,1)SyntaxKind[RightHandSideList]
+ (238,1)SyntaxKind[IndentToken]
+ (238,2)SyntaxKind[RightHandSide]
+ (238,2)SyntaxKind[SymbolSpan]
+ (238,2)SyntaxKind[Terminal](text = "{")
+ (238,6)SyntaxKind[SymbolSpan]
+ (238,6)SyntaxKind[Terminal](text = "}")
+ (239,2)SyntaxKind[RightHandSide]
+ (239,2)SyntaxKind[SymbolSpan]
+ (239,2)SyntaxKind[Terminal](text = "{")
+ (239,6)SyntaxKind[SymbolSpan]
+ (239,6)SyntaxKind[Nonterminal]
+ (239,6)SyntaxKind[Identifier](text = "BindingPropertyList")
+ (239,26)SyntaxKind[SymbolSpan]
+ (239,26)SyntaxKind[Terminal](text = ",")?
+ (239,29)SyntaxKind[QuestionToken]
+ (239,31)SyntaxKind[SymbolSpan]
+ (239,31)SyntaxKind[Terminal](text = "}")
+ (240,1)SyntaxKind[DedentToken]
+ (241,1)SyntaxKind[Production]
+ (241,1)SyntaxKind[Identifier](text = "BindingPropertyList")
+ (242,1)SyntaxKind[RightHandSideList]
+ (242,1)SyntaxKind[IndentToken]
+ (242,2)SyntaxKind[RightHandSide]
+ (242,2)SyntaxKind[SymbolSpan]
+ (242,2)SyntaxKind[Nonterminal]
+ (242,2)SyntaxKind[Identifier](text = "BindingProperty")
+ (243,2)SyntaxKind[RightHandSide]
+ (243,2)SyntaxKind[SymbolSpan]
+ (243,2)SyntaxKind[Nonterminal]
+ (243,2)SyntaxKind[Identifier](text = "BindingPropertyList")
+ (243,22)SyntaxKind[SymbolSpan]
+ (243,22)SyntaxKind[Terminal](text = ",")
+ (243,26)SyntaxKind[SymbolSpan]
+ (243,26)SyntaxKind[Nonterminal]
+ (243,26)SyntaxKind[Identifier](text = "BindingProperty")
+ (244,1)SyntaxKind[DedentToken]
+ (245,1)SyntaxKind[Production]
+ (245,1)SyntaxKind[Identifier](text = "BindingProperty")
+ (246,1)SyntaxKind[RightHandSideList]
+ (246,1)SyntaxKind[IndentToken]
+ (246,2)SyntaxKind[RightHandSide]
+ (246,2)SyntaxKind[SymbolSpan]
+ (246,2)SyntaxKind[Nonterminal]
+ (246,2)SyntaxKind[Identifier](text = "Identifier")
+ (246,13)SyntaxKind[SymbolSpan]
+ (246,13)SyntaxKind[Nonterminal]?
+ (246,13)SyntaxKind[Identifier](text = "Initializer")
+ (246,24)SyntaxKind[QuestionToken]
+ (247,2)SyntaxKind[RightHandSide]
+ (247,2)SyntaxKind[SymbolSpan]
+ (247,2)SyntaxKind[Nonterminal]
+ (247,2)SyntaxKind[Identifier](text = "PropertyName")
+ (247,15)SyntaxKind[SymbolSpan]
+ (247,15)SyntaxKind[Terminal](text = ":")
+ (247,19)SyntaxKind[SymbolSpan]
+ (247,19)SyntaxKind[Nonterminal]
+ (247,19)SyntaxKind[Identifier](text = "Identifier")
+ (247,30)SyntaxKind[SymbolSpan]
+ (247,30)SyntaxKind[Nonterminal]?
+ (247,30)SyntaxKind[Identifier](text = "Initializer")
+ (247,41)SyntaxKind[QuestionToken]
+ (248,2)SyntaxKind[RightHandSide]
+ (248,2)SyntaxKind[SymbolSpan]
+ (248,2)SyntaxKind[Nonterminal]
+ (248,2)SyntaxKind[Identifier](text = "PropertyName")
+ (248,15)SyntaxKind[SymbolSpan]
+ (248,15)SyntaxKind[Terminal](text = ":")
+ (248,19)SyntaxKind[SymbolSpan]
+ (248,19)SyntaxKind[Nonterminal]
+ (248,19)SyntaxKind[Identifier](text = "BindingPattern")
+ (248,34)SyntaxKind[SymbolSpan]
+ (248,34)SyntaxKind[Nonterminal]?
+ (248,34)SyntaxKind[Identifier](text = "Initializer")
+ (248,45)SyntaxKind[QuestionToken]
+ (249,1)SyntaxKind[DedentToken]
+ (250,1)SyntaxKind[Production]
+ (250,1)SyntaxKind[Identifier](text = "ArrayBindingPattern")
+ (251,1)SyntaxKind[RightHandSideList]
+ (251,1)SyntaxKind[IndentToken]
+ (251,2)SyntaxKind[RightHandSide]
+ (251,2)SyntaxKind[SymbolSpan]
+ (251,2)SyntaxKind[Terminal](text = "[")
+ (251,6)SyntaxKind[SymbolSpan]
+ (251,6)SyntaxKind[Nonterminal]?
+ (251,6)SyntaxKind[Identifier](text = "Elision")
+ (251,13)SyntaxKind[QuestionToken]
+ (251,15)SyntaxKind[SymbolSpan]
+ (251,15)SyntaxKind[Nonterminal]?
+ (251,15)SyntaxKind[Identifier](text = "BindingRestElement")
+ (251,33)SyntaxKind[QuestionToken]
+ (251,35)SyntaxKind[SymbolSpan]
+ (251,35)SyntaxKind[Terminal](text = "]")
+ (252,2)SyntaxKind[RightHandSide]
+ (252,2)SyntaxKind[SymbolSpan]
+ (252,2)SyntaxKind[Terminal](text = "[")
+ (252,6)SyntaxKind[SymbolSpan]
+ (252,6)SyntaxKind[Nonterminal]
+ (252,6)SyntaxKind[Identifier](text = "BindingElementList")
+ (252,25)SyntaxKind[SymbolSpan]
+ (252,25)SyntaxKind[Terminal](text = "]")
+ (253,2)SyntaxKind[RightHandSide]
+ (253,2)SyntaxKind[SymbolSpan]
+ (253,2)SyntaxKind[Terminal](text = "[")
+ (253,6)SyntaxKind[SymbolSpan]
+ (253,6)SyntaxKind[Nonterminal]
+ (253,6)SyntaxKind[Identifier](text = "BindingElementList")
+ (253,25)SyntaxKind[SymbolSpan]
+ (253,25)SyntaxKind[Terminal](text = ",")
+ (253,29)SyntaxKind[SymbolSpan]
+ (253,29)SyntaxKind[Nonterminal]?
+ (253,29)SyntaxKind[Identifier](text = "Elision")
+ (253,36)SyntaxKind[QuestionToken]
+ (253,38)SyntaxKind[SymbolSpan]
+ (253,38)SyntaxKind[Nonterminal]?
+ (253,38)SyntaxKind[Identifier](text = "BindingRestElement")
+ (253,56)SyntaxKind[QuestionToken]
+ (253,58)SyntaxKind[SymbolSpan]
+ (253,58)SyntaxKind[Terminal](text = "]")
+ (254,1)SyntaxKind[DedentToken]
+ (255,1)SyntaxKind[Production]
+ (255,1)SyntaxKind[Identifier](text = "BindingElementList")
+ (256,1)SyntaxKind[RightHandSideList]
+ (256,1)SyntaxKind[IndentToken]
+ (256,2)SyntaxKind[RightHandSide]
+ (256,2)SyntaxKind[SymbolSpan]
+ (256,2)SyntaxKind[Nonterminal]?
+ (256,2)SyntaxKind[Identifier](text = "Elision")
+ (256,9)SyntaxKind[QuestionToken]
+ (256,11)SyntaxKind[SymbolSpan]
+ (256,11)SyntaxKind[Nonterminal]
+ (256,11)SyntaxKind[Identifier](text = "BindingElement")
+ (257,2)SyntaxKind[RightHandSide]
+ (257,2)SyntaxKind[SymbolSpan]
+ (257,2)SyntaxKind[Nonterminal]
+ (257,2)SyntaxKind[Identifier](text = "BindingElementList")
+ (257,21)SyntaxKind[SymbolSpan]
+ (257,21)SyntaxKind[Terminal](text = ",")
+ (257,25)SyntaxKind[SymbolSpan]
+ (257,25)SyntaxKind[Nonterminal]?
+ (257,25)SyntaxKind[Identifier](text = "Elision")
+ (257,32)SyntaxKind[QuestionToken]
+ (257,34)SyntaxKind[SymbolSpan]
+ (257,34)SyntaxKind[Nonterminal]
+ (257,34)SyntaxKind[Identifier](text = "BindingElement")
+ (258,1)SyntaxKind[DedentToken]
+ (259,1)SyntaxKind[Production]
+ (259,1)SyntaxKind[Identifier](text = "BindingElement")
+ (260,1)SyntaxKind[RightHandSideList]
+ (260,1)SyntaxKind[IndentToken]
+ (260,2)SyntaxKind[RightHandSide]
+ (260,2)SyntaxKind[SymbolSpan]
+ (260,2)SyntaxKind[Nonterminal]
+ (260,2)SyntaxKind[Identifier](text = "Identifier")
+ (260,13)SyntaxKind[SymbolSpan]
+ (260,13)SyntaxKind[Nonterminal]?
+ (260,13)SyntaxKind[Identifier](text = "Initializer")
+ (260,24)SyntaxKind[QuestionToken]
+ (261,2)SyntaxKind[RightHandSide]
+ (261,2)SyntaxKind[SymbolSpan]
+ (261,2)SyntaxKind[Nonterminal]
+ (261,2)SyntaxKind[Identifier](text = "BindingPattern")
+ (261,17)SyntaxKind[SymbolSpan]
+ (261,17)SyntaxKind[Nonterminal]?
+ (261,17)SyntaxKind[Identifier](text = "Initializer")
+ (261,28)SyntaxKind[QuestionToken]
+ (262,1)SyntaxKind[DedentToken]
+ (263,1)SyntaxKind[Production]
+ (263,1)SyntaxKind[Identifier](text = "BindingRestElement")
+ (264,1)SyntaxKind[RightHandSideList]
+ (264,1)SyntaxKind[IndentToken]
+ (264,2)SyntaxKind[RightHandSide]
+ (264,2)SyntaxKind[SymbolSpan]
+ (264,2)SyntaxKind[Terminal](text = "...")
+ (264,8)SyntaxKind[SymbolSpan]
+ (264,8)SyntaxKind[Nonterminal]
+ (264,8)SyntaxKind[Identifier](text = "Identifier")
+ (265,1)SyntaxKind[DedentToken]
+ (267,1)SyntaxKind[Production]
+ (267,1)SyntaxKind[Identifier](text = "FunctionDeclaration")
+ (268,1)SyntaxKind[RightHandSideList]
+ (268,1)SyntaxKind[IndentToken]
+ (268,2)SyntaxKind[RightHandSide]
+ (268,2)SyntaxKind[SymbolSpan]
+ (268,2)SyntaxKind[Nonterminal]?
+ (268,2)SyntaxKind[Identifier](text = "FunctionOverloads")
+ (268,19)SyntaxKind[QuestionToken]
+ (268,21)SyntaxKind[SymbolSpan]
+ (268,21)SyntaxKind[Nonterminal]
+ (268,21)SyntaxKind[Identifier](text = "FunctionImplementation")
+ (269,1)SyntaxKind[DedentToken]
+ (270,1)SyntaxKind[Production]
+ (270,1)SyntaxKind[Identifier](text = "FunctionOverloads")
+ (271,1)SyntaxKind[RightHandSideList]
+ (271,1)SyntaxKind[IndentToken]
+ (271,2)SyntaxKind[RightHandSide]
+ (271,2)SyntaxKind[SymbolSpan]
+ (271,2)SyntaxKind[Nonterminal]
+ (271,2)SyntaxKind[Identifier](text = "FunctionOverload")
+ (272,2)SyntaxKind[RightHandSide]
+ (272,2)SyntaxKind[SymbolSpan]
+ (272,2)SyntaxKind[Nonterminal]
+ (272,2)SyntaxKind[Identifier](text = "FunctionOverloads")
+ (272,20)SyntaxKind[SymbolSpan]
+ (272,20)SyntaxKind[Nonterminal]
+ (272,20)SyntaxKind[Identifier](text = "FunctionOverload")
+ (273,1)SyntaxKind[DedentToken]
+ (274,1)SyntaxKind[Production]
+ (274,1)SyntaxKind[Identifier](text = "FunctionOverload")
+ (275,1)SyntaxKind[RightHandSideList]
+ (275,1)SyntaxKind[IndentToken]
+ (275,2)SyntaxKind[RightHandSide]
+ (275,2)SyntaxKind[SymbolSpan]
+ (275,2)SyntaxKind[Terminal](text = "function")
+ (275,13)SyntaxKind[SymbolSpan]
+ (275,13)SyntaxKind[Nonterminal]
+ (275,13)SyntaxKind[Identifier](text = "Identifier")
+ (275,24)SyntaxKind[SymbolSpan]
+ (275,24)SyntaxKind[Nonterminal]
+ (275,24)SyntaxKind[Identifier](text = "CallSignature")
+ (275,38)SyntaxKind[SymbolSpan]
+ (275,38)SyntaxKind[Terminal](text = ";")
+ (276,1)SyntaxKind[DedentToken]
+ (277,1)SyntaxKind[Production]
+ (277,1)SyntaxKind[Identifier](text = "FunctionImplementation")
+ (278,1)SyntaxKind[RightHandSideList]
+ (278,1)SyntaxKind[IndentToken]
+ (278,2)SyntaxKind[RightHandSide]
+ (278,2)SyntaxKind[SymbolSpan]
+ (278,2)SyntaxKind[Terminal](text = "function")
+ (278,13)SyntaxKind[SymbolSpan]
+ (278,13)SyntaxKind[Nonterminal]
+ (278,13)SyntaxKind[Identifier](text = "Identifier")
+ (278,24)SyntaxKind[SymbolSpan]
+ (278,24)SyntaxKind[Nonterminal]
+ (278,24)SyntaxKind[Identifier](text = "CallSignature")
+ (278,38)SyntaxKind[SymbolSpan]
+ (278,38)SyntaxKind[Terminal](text = "{")
+ (278,42)SyntaxKind[SymbolSpan]
+ (278,42)SyntaxKind[Nonterminal]
+ (278,42)SyntaxKind[Identifier](text = "FunctionBody")
+ (278,55)SyntaxKind[SymbolSpan]
+ (278,55)SyntaxKind[Terminal](text = "}")
+ (279,1)SyntaxKind[DedentToken]
+ (281,1)SyntaxKind[Production]
+ (281,1)SyntaxKind[Identifier](text = "InterfaceDeclaration")
+ (282,1)SyntaxKind[RightHandSideList]
+ (282,1)SyntaxKind[IndentToken]
+ (282,2)SyntaxKind[RightHandSide]
+ (282,2)SyntaxKind[SymbolSpan]
+ (282,2)SyntaxKind[Terminal](text = "interface")
+ (282,14)SyntaxKind[SymbolSpan]
+ (282,14)SyntaxKind[Nonterminal]
+ (282,14)SyntaxKind[Identifier](text = "Identifier")
+ (282,25)SyntaxKind[SymbolSpan]
+ (282,25)SyntaxKind[Nonterminal]?
+ (282,25)SyntaxKind[Identifier](text = "TypeParameters")
+ (282,39)SyntaxKind[QuestionToken]
+ (282,41)SyntaxKind[SymbolSpan]
+ (282,41)SyntaxKind[Nonterminal]?
+ (282,41)SyntaxKind[Identifier](text = "InterfaceExtendsClause")
+ (282,63)SyntaxKind[QuestionToken]
+ (282,65)SyntaxKind[SymbolSpan]
+ (282,65)SyntaxKind[Nonterminal]
+ (282,65)SyntaxKind[Identifier](text = "ObjectType")
+ (283,1)SyntaxKind[DedentToken]
+ (284,1)SyntaxKind[Production]
+ (284,1)SyntaxKind[Identifier](text = "InterfaceExtendsClause")
+ (285,1)SyntaxKind[RightHandSideList]
+ (285,1)SyntaxKind[IndentToken]
+ (285,2)SyntaxKind[RightHandSide]
+ (285,2)SyntaxKind[SymbolSpan]
+ (285,2)SyntaxKind[Terminal](text = "extends")
+ (285,12)SyntaxKind[SymbolSpan]
+ (285,12)SyntaxKind[Nonterminal]
+ (285,12)SyntaxKind[Identifier](text = "ClassOrInterfaceTypeList")
+ (286,1)SyntaxKind[DedentToken]
+ (287,1)SyntaxKind[Production]
+ (287,1)SyntaxKind[Identifier](text = "ClassOrInterfaceTypeList")
+ (288,1)SyntaxKind[RightHandSideList]
+ (288,1)SyntaxKind[IndentToken]
+ (288,2)SyntaxKind[RightHandSide]
+ (288,2)SyntaxKind[SymbolSpan]
+ (288,2)SyntaxKind[Nonterminal]
+ (288,2)SyntaxKind[Identifier](text = "ClassOrInterfaceType")
+ (289,2)SyntaxKind[RightHandSide]
+ (289,2)SyntaxKind[SymbolSpan]
+ (289,2)SyntaxKind[Nonterminal]
+ (289,2)SyntaxKind[Identifier](text = "ClassOrInterfaceTypeList")
+ (289,27)SyntaxKind[SymbolSpan]
+ (289,27)SyntaxKind[Terminal](text = ",")
+ (289,31)SyntaxKind[SymbolSpan]
+ (289,31)SyntaxKind[Nonterminal]
+ (289,31)SyntaxKind[Identifier](text = "ClassOrInterfaceType")
+ (290,1)SyntaxKind[DedentToken]
+ (291,1)SyntaxKind[Production]
+ (291,1)SyntaxKind[Identifier](text = "ClassOrInterfaceType")
+ (292,1)SyntaxKind[RightHandSideList]
+ (292,1)SyntaxKind[IndentToken]
+ (292,2)SyntaxKind[RightHandSide]
+ (292,2)SyntaxKind[SymbolSpan]
+ (292,2)SyntaxKind[Nonterminal]
+ (292,2)SyntaxKind[Identifier](text = "TypeReference")
+ (293,1)SyntaxKind[DedentToken]
+ (295,1)SyntaxKind[Production]
+ (295,1)SyntaxKind[Identifier](text = "ClassDeclaration")
+ (296,1)SyntaxKind[RightHandSideList]
+ (296,1)SyntaxKind[IndentToken]
+ (296,2)SyntaxKind[RightHandSide]
+ (296,2)SyntaxKind[SymbolSpan]
+ (296,2)SyntaxKind[Terminal](text = "class")
+ (296,10)SyntaxKind[SymbolSpan]
+ (296,10)SyntaxKind[Nonterminal]
+ (296,10)SyntaxKind[Identifier](text = "Identifier")
+ (296,21)SyntaxKind[SymbolSpan]
+ (296,21)SyntaxKind[Nonterminal]?
+ (296,21)SyntaxKind[Identifier](text = "TypeParameters")
+ (296,35)SyntaxKind[QuestionToken]
+ (296,37)SyntaxKind[SymbolSpan]
+ (296,37)SyntaxKind[Nonterminal]
+ (296,37)SyntaxKind[Identifier](text = "ClassHeritage")
+ (296,51)SyntaxKind[SymbolSpan]
+ (296,51)SyntaxKind[Terminal](text = "{")
+ (296,55)SyntaxKind[SymbolSpan]
+ (296,55)SyntaxKind[Nonterminal]
+ (296,55)SyntaxKind[Identifier](text = "ClassBody")
+ (296,65)SyntaxKind[SymbolSpan]
+ (296,65)SyntaxKind[Terminal](text = "}")
+ (297,1)SyntaxKind[DedentToken]
+ (298,1)SyntaxKind[Production]
+ (298,1)SyntaxKind[Identifier](text = "ClassHeritage")
+ (299,1)SyntaxKind[RightHandSideList]
+ (299,1)SyntaxKind[IndentToken]
+ (299,2)SyntaxKind[RightHandSide]
+ (299,2)SyntaxKind[SymbolSpan]
+ (299,2)SyntaxKind[Nonterminal]?
+ (299,2)SyntaxKind[Identifier](text = "ClassExtendsClause")
+ (299,20)SyntaxKind[QuestionToken]
+ (299,22)SyntaxKind[SymbolSpan]
+ (299,22)SyntaxKind[Nonterminal]?
+ (299,22)SyntaxKind[Identifier](text = "ImplementsClause")
+ (299,38)SyntaxKind[QuestionToken]
+ (300,1)SyntaxKind[DedentToken]
+ (301,1)SyntaxKind[Production]
+ (301,1)SyntaxKind[Identifier](text = "ClassExtendsClause")
+ (302,1)SyntaxKind[RightHandSideList]
+ (302,1)SyntaxKind[IndentToken]
+ (302,2)SyntaxKind[RightHandSide]
+ (302,2)SyntaxKind[SymbolSpan]
+ (302,2)SyntaxKind[Terminal](text = "extends")
+ (302,13)SyntaxKind[SymbolSpan]
+ (302,13)SyntaxKind[Nonterminal]
+ (302,13)SyntaxKind[Identifier](text = "ClassType")
+ (303,1)SyntaxKind[DedentToken]
+ (304,1)SyntaxKind[Production]
+ (304,1)SyntaxKind[Identifier](text = "ClassType")
+ (305,1)SyntaxKind[RightHandSideList]
+ (305,1)SyntaxKind[IndentToken]
+ (305,2)SyntaxKind[RightHandSide]
+ (305,2)SyntaxKind[SymbolSpan]
+ (305,2)SyntaxKind[Nonterminal]
+ (305,2)SyntaxKind[Identifier](text = "TypeReference")
+ (306,1)SyntaxKind[DedentToken]
+ (307,1)SyntaxKind[Production]
+ (307,1)SyntaxKind[Identifier](text = "ImplementsClause")
+ (308,1)SyntaxKind[RightHandSideList]
+ (308,1)SyntaxKind[IndentToken]
+ (308,2)SyntaxKind[RightHandSide]
+ (308,2)SyntaxKind[SymbolSpan]
+ (308,2)SyntaxKind[Terminal](text = "implements")
+ (308,15)SyntaxKind[SymbolSpan]
+ (308,15)SyntaxKind[Nonterminal]
+ (308,15)SyntaxKind[Identifier](text = "ClassOrInterfaceTypeList")
+ (309,1)SyntaxKind[DedentToken]
+ (310,1)SyntaxKind[Production]
+ (310,1)SyntaxKind[Identifier](text = "ClassBody")
+ (311,1)SyntaxKind[RightHandSideList]
+ (311,1)SyntaxKind[IndentToken]
+ (311,2)SyntaxKind[RightHandSide]
+ (311,2)SyntaxKind[SymbolSpan]
+ (311,2)SyntaxKind[Nonterminal]?
+ (311,2)SyntaxKind[Identifier](text = "ClassElements")
+ (311,15)SyntaxKind[QuestionToken]
+ (312,1)SyntaxKind[DedentToken]
+ (313,1)SyntaxKind[Production]
+ (313,1)SyntaxKind[Identifier](text = "ClassElements")
+ (314,1)SyntaxKind[RightHandSideList]
+ (314,1)SyntaxKind[IndentToken]
+ (314,2)SyntaxKind[RightHandSide]
+ (314,2)SyntaxKind[SymbolSpan]
+ (314,2)SyntaxKind[Nonterminal]
+ (314,2)SyntaxKind[Identifier](text = "ClassElement")
+ (315,2)SyntaxKind[RightHandSide]
+ (315,2)SyntaxKind[SymbolSpan]
+ (315,2)SyntaxKind[Nonterminal]
+ (315,2)SyntaxKind[Identifier](text = "ClassElements")
+ (315,16)SyntaxKind[SymbolSpan]
+ (315,16)SyntaxKind[Nonterminal]
+ (315,16)SyntaxKind[Identifier](text = "ClassElement")
+ (316,1)SyntaxKind[DedentToken]
+ (317,1)SyntaxKind[Production]
+ (317,1)SyntaxKind[Identifier](text = "ClassElement")
+ (318,1)SyntaxKind[RightHandSideList]
+ (318,1)SyntaxKind[IndentToken]
+ (318,2)SyntaxKind[RightHandSide]
+ (318,2)SyntaxKind[SymbolSpan]
+ (318,2)SyntaxKind[Nonterminal]
+ (318,2)SyntaxKind[Identifier](text = "ConstructorDeclaration")
+ (319,2)SyntaxKind[RightHandSide]
+ (319,2)SyntaxKind[SymbolSpan]
+ (319,2)SyntaxKind[Nonterminal]
+ (319,2)SyntaxKind[Identifier](text = "PropertyMemberDeclaration")
+ (320,2)SyntaxKind[RightHandSide]
+ (320,2)SyntaxKind[SymbolSpan]
+ (320,2)SyntaxKind[Nonterminal]
+ (320,2)SyntaxKind[Identifier](text = "IndexMemberDeclaration")
+ (321,1)SyntaxKind[DedentToken]
+ (322,1)SyntaxKind[Production]
+ (322,1)SyntaxKind[Identifier](text = "ConstructorDeclaration")
+ (323,1)SyntaxKind[RightHandSideList]
+ (323,1)SyntaxKind[IndentToken]
+ (323,2)SyntaxKind[RightHandSide]
+ (323,2)SyntaxKind[SymbolSpan]
+ (323,2)SyntaxKind[Nonterminal]?
+ (323,2)SyntaxKind[Identifier](text = "ConstructorOverloads")
+ (323,22)SyntaxKind[QuestionToken]
+ (323,24)SyntaxKind[SymbolSpan]
+ (323,24)SyntaxKind[Nonterminal]
+ (323,24)SyntaxKind[Identifier](text = "ConstructorImplementation")
+ (324,1)SyntaxKind[DedentToken]
+ (325,1)SyntaxKind[Production]
+ (325,1)SyntaxKind[Identifier](text = "ConstructorOverloads")
+ (326,1)SyntaxKind[RightHandSideList]
+ (326,1)SyntaxKind[IndentToken]
+ (326,2)SyntaxKind[RightHandSide]
+ (326,2)SyntaxKind[SymbolSpan]
+ (326,2)SyntaxKind[Nonterminal]
+ (326,2)SyntaxKind[Identifier](text = "ConstructorOverload")
+ (327,2)SyntaxKind[RightHandSide]
+ (327,2)SyntaxKind[SymbolSpan]
+ (327,2)SyntaxKind[Nonterminal]
+ (327,2)SyntaxKind[Identifier](text = "ConstructorOverloads")
+ (327,23)SyntaxKind[SymbolSpan]
+ (327,23)SyntaxKind[Nonterminal]
+ (327,23)SyntaxKind[Identifier](text = "ConstructorOverload")
+ (328,1)SyntaxKind[DedentToken]
+ (329,1)SyntaxKind[Production]
+ (329,1)SyntaxKind[Identifier](text = "ConstructorOverload")
+ (330,1)SyntaxKind[RightHandSideList]
+ (330,1)SyntaxKind[IndentToken]
+ (330,2)SyntaxKind[RightHandSide]
+ (330,2)SyntaxKind[SymbolSpan]
+ (330,2)SyntaxKind[Nonterminal]?
+ (330,2)SyntaxKind[Identifier](text = "AccessibilityModifier")
+ (330,23)SyntaxKind[QuestionToken]
+ (330,25)SyntaxKind[SymbolSpan]
+ (330,25)SyntaxKind[Terminal](text = "constructor")
+ (330,39)SyntaxKind[SymbolSpan]
+ (330,39)SyntaxKind[Terminal](text = "(")
+ (330,43)SyntaxKind[SymbolSpan]
+ (330,43)SyntaxKind[Nonterminal]?
+ (330,43)SyntaxKind[Identifier](text = "ParameterList")
+ (330,56)SyntaxKind[QuestionToken]
+ (330,58)SyntaxKind[SymbolSpan]
+ (330,58)SyntaxKind[Terminal](text = ")")
+ (330,62)SyntaxKind[SymbolSpan]
+ (330,62)SyntaxKind[Terminal](text = ";")
+ (331,1)SyntaxKind[DedentToken]
+ (332,1)SyntaxKind[Production]
+ (332,1)SyntaxKind[Identifier](text = "ConstructorImplementation")
+ (333,1)SyntaxKind[RightHandSideList]
+ (333,1)SyntaxKind[IndentToken]
+ (333,2)SyntaxKind[RightHandSide]
+ (333,2)SyntaxKind[SymbolSpan]
+ (333,2)SyntaxKind[Nonterminal]?
+ (333,2)SyntaxKind[Identifier](text = "AccessibilityModifier")
+ (333,23)SyntaxKind[QuestionToken]
+ (333,25)SyntaxKind[SymbolSpan]
+ (333,25)SyntaxKind[Terminal](text = "constructor")
+ (333,39)SyntaxKind[SymbolSpan]
+ (333,39)SyntaxKind[Terminal](text = "(")
+ (333,43)SyntaxKind[SymbolSpan]
+ (333,43)SyntaxKind[Nonterminal]?
+ (333,43)SyntaxKind[Identifier](text = "ParameterList")
+ (333,56)SyntaxKind[QuestionToken]
+ (333,58)SyntaxKind[SymbolSpan]
+ (333,58)SyntaxKind[Terminal](text = ")")
+ (333,62)SyntaxKind[SymbolSpan]
+ (333,62)SyntaxKind[Terminal](text = "{")
+ (333,66)SyntaxKind[SymbolSpan]
+ (333,66)SyntaxKind[Nonterminal]
+ (333,66)SyntaxKind[Identifier](text = "FunctionBody")
+ (333,79)SyntaxKind[SymbolSpan]
+ (333,79)SyntaxKind[Terminal](text = "}")
+ (334,1)SyntaxKind[DedentToken]
+ (335,1)SyntaxKind[Production]
+ (335,1)SyntaxKind[Identifier](text = "PropertyMemberDeclaration")
+ (336,1)SyntaxKind[RightHandSideList]
+ (336,1)SyntaxKind[IndentToken]
+ (336,2)SyntaxKind[RightHandSide]
+ (336,2)SyntaxKind[SymbolSpan]
+ (336,2)SyntaxKind[Nonterminal]
+ (336,2)SyntaxKind[Identifier](text = "MemberVariableDeclaration")
+ (337,2)SyntaxKind[RightHandSide]
+ (337,2)SyntaxKind[SymbolSpan]
+ (337,2)SyntaxKind[Nonterminal]
+ (337,2)SyntaxKind[Identifier](text = "MemberFunctionDeclaration")
+ (338,2)SyntaxKind[RightHandSide]
+ (338,2)SyntaxKind[SymbolSpan]
+ (338,2)SyntaxKind[Nonterminal]
+ (338,2)SyntaxKind[Identifier](text = "MemberAccessorDeclaration")
+ (339,1)SyntaxKind[DedentToken]
+ (340,1)SyntaxKind[Production]
+ (340,1)SyntaxKind[Identifier](text = "MemberVariableDeclaration")
+ (341,1)SyntaxKind[RightHandSideList]
+ (341,1)SyntaxKind[IndentToken]
+ (341,2)SyntaxKind[RightHandSide]
+ (341,2)SyntaxKind[SymbolSpan]
+ (341,2)SyntaxKind[Nonterminal]?
+ (341,2)SyntaxKind[Identifier](text = "AccessibilityModifier")
+ (341,23)SyntaxKind[QuestionToken]
+ (341,25)SyntaxKind[SymbolSpan]
+ (341,25)SyntaxKind[Terminal](text = "static")?
+ (341,33)SyntaxKind[QuestionToken]
+ (341,35)SyntaxKind[SymbolSpan]
+ (341,35)SyntaxKind[Nonterminal]
+ (341,35)SyntaxKind[Identifier](text = "PropertyName")
+ (341,48)SyntaxKind[SymbolSpan]
+ (341,48)SyntaxKind[Nonterminal]?
+ (341,48)SyntaxKind[Identifier](text = "TypeAnnotation")
+ (341,62)SyntaxKind[QuestionToken]
+ (341,64)SyntaxKind[SymbolSpan]
+ (341,64)SyntaxKind[Nonterminal]?
+ (341,64)SyntaxKind[Identifier](text = "Initializer")
+ (341,75)SyntaxKind[QuestionToken]
+ (341,77)SyntaxKind[SymbolSpan]
+ (341,77)SyntaxKind[Terminal](text = ";")
+ (342,1)SyntaxKind[DedentToken]
+ (343,1)SyntaxKind[Production]
+ (343,1)SyntaxKind[Identifier](text = "MemberFunctionDeclaration")
+ (344,1)SyntaxKind[RightHandSideList]
+ (344,1)SyntaxKind[IndentToken]
+ (344,2)SyntaxKind[RightHandSide]
+ (344,2)SyntaxKind[SymbolSpan]
+ (344,2)SyntaxKind[Nonterminal]?
+ (344,2)SyntaxKind[Identifier](text = "MemberFunctionOverloads")
+ (344,25)SyntaxKind[QuestionToken]
+ (344,27)SyntaxKind[SymbolSpan]
+ (344,27)SyntaxKind[Nonterminal]
+ (344,27)SyntaxKind[Identifier](text = "MemberFunctionImplementation")
+ (345,1)SyntaxKind[DedentToken]
+ (346,1)SyntaxKind[Production]
+ (346,1)SyntaxKind[Identifier](text = "MemberFunctionOverloads")
+ (347,1)SyntaxKind[RightHandSideList]
+ (347,1)SyntaxKind[IndentToken]
+ (347,2)SyntaxKind[RightHandSide]
+ (347,2)SyntaxKind[SymbolSpan]
+ (347,2)SyntaxKind[Nonterminal]
+ (347,2)SyntaxKind[Identifier](text = "MemberFunctionOverload")
+ (348,2)SyntaxKind[RightHandSide]
+ (348,2)SyntaxKind[SymbolSpan]
+ (348,2)SyntaxKind[Nonterminal]
+ (348,2)SyntaxKind[Identifier](text = "MemberFunctionOverloads")
+ (348,26)SyntaxKind[SymbolSpan]
+ (348,26)SyntaxKind[Nonterminal]
+ (348,26)SyntaxKind[Identifier](text = "MemberFunctionOverload")
+ (349,1)SyntaxKind[DedentToken]
+ (350,1)SyntaxKind[Production]
+ (350,1)SyntaxKind[Identifier](text = "MemberFunctionOverload")
+ (351,1)SyntaxKind[RightHandSideList]
+ (351,1)SyntaxKind[IndentToken]
+ (351,2)SyntaxKind[RightHandSide]
+ (351,2)SyntaxKind[SymbolSpan]
+ (351,2)SyntaxKind[Nonterminal]?
+ (351,2)SyntaxKind[Identifier](text = "AccessibilityModifier")
+ (351,23)SyntaxKind[QuestionToken]
+ (351,25)SyntaxKind[SymbolSpan]
+ (351,25)SyntaxKind[Terminal](text = "static")?
+ (351,33)SyntaxKind[QuestionToken]
+ (351,35)SyntaxKind[SymbolSpan]
+ (351,35)SyntaxKind[Nonterminal]
+ (351,35)SyntaxKind[Identifier](text = "PropertyName")
+ (351,48)SyntaxKind[SymbolSpan]
+ (351,48)SyntaxKind[Nonterminal]
+ (351,48)SyntaxKind[Identifier](text = "CallSignature")
+ (351,62)SyntaxKind[SymbolSpan]
+ (351,62)SyntaxKind[Terminal](text = ";")
+ (352,1)SyntaxKind[DedentToken]
+ (353,1)SyntaxKind[Production]
+ (353,1)SyntaxKind[Identifier](text = "MemberFunctionImplementation")
+ (354,1)SyntaxKind[RightHandSideList]
+ (354,1)SyntaxKind[IndentToken]
+ (354,2)SyntaxKind[RightHandSide]
+ (354,2)SyntaxKind[SymbolSpan]
+ (354,2)SyntaxKind[Nonterminal]?
+ (354,2)SyntaxKind[Identifier](text = "AccessibilityModifier")
+ (354,23)SyntaxKind[QuestionToken]
+ (354,25)SyntaxKind[SymbolSpan]
+ (354,25)SyntaxKind[Terminal](text = "static")?
+ (354,33)SyntaxKind[QuestionToken]
+ (354,35)SyntaxKind[SymbolSpan]
+ (354,35)SyntaxKind[Nonterminal]
+ (354,35)SyntaxKind[Identifier](text = "PropertyName")
+ (354,48)SyntaxKind[SymbolSpan]
+ (354,48)SyntaxKind[Nonterminal]
+ (354,48)SyntaxKind[Identifier](text = "CallSignature")
+ (354,62)SyntaxKind[SymbolSpan]
+ (354,62)SyntaxKind[Terminal](text = "{")
+ (354,66)SyntaxKind[SymbolSpan]
+ (354,66)SyntaxKind[Nonterminal]
+ (354,66)SyntaxKind[Identifier](text = "FunctionBody")
+ (354,79)SyntaxKind[SymbolSpan]
+ (354,79)SyntaxKind[Terminal](text = "}")
+ (355,1)SyntaxKind[DedentToken]
+ (356,1)SyntaxKind[Production]
+ (356,1)SyntaxKind[Identifier](text = "MemberAccessorDeclaration")
+ (357,1)SyntaxKind[RightHandSideList]
+ (357,1)SyntaxKind[IndentToken]
+ (357,2)SyntaxKind[RightHandSide]
+ (357,2)SyntaxKind[SymbolSpan]
+ (357,2)SyntaxKind[Nonterminal]?
+ (357,2)SyntaxKind[Identifier](text = "AccessibilityModifier")
+ (357,23)SyntaxKind[QuestionToken]
+ (357,25)SyntaxKind[SymbolSpan]
+ (357,25)SyntaxKind[Terminal](text = "static")?
+ (357,33)SyntaxKind[QuestionToken]
+ (357,35)SyntaxKind[SymbolSpan]
+ (357,35)SyntaxKind[Nonterminal]
+ (357,35)SyntaxKind[Identifier](text = "GetAccessor")
+ (358,2)SyntaxKind[RightHandSide]
+ (358,2)SyntaxKind[SymbolSpan]
+ (358,2)SyntaxKind[Nonterminal]?
+ (358,2)SyntaxKind[Identifier](text = "AccessibilityModifier")
+ (358,23)SyntaxKind[QuestionToken]
+ (358,25)SyntaxKind[SymbolSpan]
+ (358,25)SyntaxKind[Terminal](text = "static")?
+ (358,33)SyntaxKind[QuestionToken]
+ (358,35)SyntaxKind[SymbolSpan]
+ (358,35)SyntaxKind[Nonterminal]
+ (358,35)SyntaxKind[Identifier](text = "SetAccessor")
+ (359,1)SyntaxKind[DedentToken]
+ (360,1)SyntaxKind[Production]
+ (360,1)SyntaxKind[Identifier](text = "IndexMemberDeclaration")
+ (361,1)SyntaxKind[RightHandSideList]
+ (361,1)SyntaxKind[IndentToken]
+ (361,2)SyntaxKind[RightHandSide]
+ (361,2)SyntaxKind[SymbolSpan]
+ (361,2)SyntaxKind[Nonterminal]
+ (361,2)SyntaxKind[Identifier](text = "IndexSignature")
+ (361,17)SyntaxKind[SymbolSpan]
+ (361,17)SyntaxKind[Terminal](text = ";")
+ (362,1)SyntaxKind[DedentToken]
+ (364,1)SyntaxKind[Production]
+ (364,1)SyntaxKind[Identifier](text = "EnumDeclaration")
+ (365,1)SyntaxKind[RightHandSideList]
+ (365,1)SyntaxKind[IndentToken]
+ (365,2)SyntaxKind[RightHandSide]
+ (365,2)SyntaxKind[SymbolSpan]
+ (365,2)SyntaxKind[Terminal](text = "const")?
+ (365,9)SyntaxKind[QuestionToken]
+ (365,11)SyntaxKind[SymbolSpan]
+ (365,11)SyntaxKind[Terminal](text = "enum")
+ (365,18)SyntaxKind[SymbolSpan]
+ (365,18)SyntaxKind[Nonterminal]
+ (365,18)SyntaxKind[Identifier](text = "Identifier")
+ (365,29)SyntaxKind[SymbolSpan]
+ (365,29)SyntaxKind[Terminal](text = "{")
+ (365,33)SyntaxKind[SymbolSpan]
+ (365,33)SyntaxKind[Nonterminal]?
+ (365,33)SyntaxKind[Identifier](text = "EnumBody")
+ (365,41)SyntaxKind[QuestionToken]
+ (365,43)SyntaxKind[SymbolSpan]
+ (365,43)SyntaxKind[Terminal](text = "}")
+ (366,1)SyntaxKind[DedentToken]
+ (367,1)SyntaxKind[Production]
+ (367,1)SyntaxKind[Identifier](text = "EnumBody")
+ (368,1)SyntaxKind[RightHandSideList]
+ (368,1)SyntaxKind[IndentToken]
+ (368,2)SyntaxKind[RightHandSide]
+ (368,2)SyntaxKind[SymbolSpan]
+ (368,2)SyntaxKind[Nonterminal]
+ (368,2)SyntaxKind[Identifier](text = "EnumMemberList")
+ (368,17)SyntaxKind[SymbolSpan]
+ (368,17)SyntaxKind[Terminal](text = ",")?
+ (368,20)SyntaxKind[QuestionToken]
+ (369,1)SyntaxKind[DedentToken]
+ (370,1)SyntaxKind[Production]
+ (370,1)SyntaxKind[Identifier](text = "EnumMemberList")
+ (371,1)SyntaxKind[RightHandSideList]
+ (371,1)SyntaxKind[IndentToken]
+ (371,2)SyntaxKind[RightHandSide]
+ (371,2)SyntaxKind[SymbolSpan]
+ (371,2)SyntaxKind[Nonterminal]
+ (371,2)SyntaxKind[Identifier](text = "EnumMember")
+ (372,2)SyntaxKind[RightHandSide]
+ (372,2)SyntaxKind[SymbolSpan]
+ (372,2)SyntaxKind[Nonterminal]
+ (372,2)SyntaxKind[Identifier](text = "EnumMemberList")
+ (372,17)SyntaxKind[SymbolSpan]
+ (372,17)SyntaxKind[Terminal](text = ",")
+ (372,21)SyntaxKind[SymbolSpan]
+ (372,21)SyntaxKind[Nonterminal]
+ (372,21)SyntaxKind[Identifier](text = "EnumMember")
+ (373,1)SyntaxKind[DedentToken]
+ (374,1)SyntaxKind[Production]
+ (374,1)SyntaxKind[Identifier](text = "EnumMember")
+ (375,1)SyntaxKind[RightHandSideList]
+ (375,1)SyntaxKind[IndentToken]
+ (375,2)SyntaxKind[RightHandSide]
+ (375,2)SyntaxKind[SymbolSpan]
+ (375,2)SyntaxKind[Nonterminal]
+ (375,2)SyntaxKind[Identifier](text = "PropertyName")
+ (376,2)SyntaxKind[RightHandSide]
+ (376,2)SyntaxKind[SymbolSpan]
+ (376,2)SyntaxKind[Nonterminal]
+ (376,2)SyntaxKind[Identifier](text = "PropertyName")
+ (376,15)SyntaxKind[SymbolSpan]
+ (376,15)SyntaxKind[Terminal](text = "=")
+ (376,19)SyntaxKind[SymbolSpan]
+ (376,19)SyntaxKind[Nonterminal]
+ (376,19)SyntaxKind[Identifier](text = "EnumValue")
+ (377,1)SyntaxKind[DedentToken]
+ (378,1)SyntaxKind[Production]
+ (378,1)SyntaxKind[Identifier](text = "EnumValue")
+ (379,1)SyntaxKind[RightHandSideList]
+ (379,1)SyntaxKind[IndentToken]
+ (379,2)SyntaxKind[RightHandSide]
+ (379,2)SyntaxKind[SymbolSpan]
+ (379,2)SyntaxKind[Nonterminal]
+ (379,2)SyntaxKind[Identifier](text = "AssignmentExpression")
+ (380,1)SyntaxKind[DedentToken]
+ (382,1)SyntaxKind[Production]
+ (382,1)SyntaxKind[Identifier](text = "ModuleDeclaration")
+ (383,1)SyntaxKind[RightHandSideList]
+ (383,1)SyntaxKind[IndentToken]
+ (383,2)SyntaxKind[RightHandSide]
+ (383,2)SyntaxKind[SymbolSpan]
+ (383,2)SyntaxKind[Terminal](text = "module")
+ (383,11)SyntaxKind[SymbolSpan]
+ (383,11)SyntaxKind[Nonterminal]
+ (383,11)SyntaxKind[Identifier](text = "IdentifierPath")
+ (383,26)SyntaxKind[SymbolSpan]
+ (383,26)SyntaxKind[Terminal](text = "{")
+ (383,30)SyntaxKind[SymbolSpan]
+ (383,30)SyntaxKind[Nonterminal]
+ (383,30)SyntaxKind[Identifier](text = "ModuleBody")
+ (383,41)SyntaxKind[SymbolSpan]
+ (383,41)SyntaxKind[Terminal](text = "}")
+ (384,1)SyntaxKind[DedentToken]
+ (385,1)SyntaxKind[Production]
+ (385,1)SyntaxKind[Identifier](text = "IdentifierPath")
+ (386,1)SyntaxKind[RightHandSideList]
+ (386,1)SyntaxKind[IndentToken]
+ (386,2)SyntaxKind[RightHandSide]
+ (386,2)SyntaxKind[SymbolSpan]
+ (386,2)SyntaxKind[Nonterminal]
+ (386,2)SyntaxKind[Identifier](text = "Identifier")
+ (387,2)SyntaxKind[RightHandSide]
+ (387,2)SyntaxKind[SymbolSpan]
+ (387,2)SyntaxKind[Nonterminal]
+ (387,2)SyntaxKind[Identifier](text = "IdentifierPath")
+ (387,17)SyntaxKind[SymbolSpan]
+ (387,17)SyntaxKind[Terminal](text = ".")
+ (387,21)SyntaxKind[SymbolSpan]
+ (387,21)SyntaxKind[Nonterminal]
+ (387,21)SyntaxKind[Identifier](text = "Identifier")
+ (388,1)SyntaxKind[DedentToken]
+ (389,1)SyntaxKind[Production]
+ (389,1)SyntaxKind[Identifier](text = "ModuleBody")
+ (390,1)SyntaxKind[RightHandSideList]
+ (390,1)SyntaxKind[IndentToken]
+ (390,2)SyntaxKind[RightHandSide]
+ (390,2)SyntaxKind[SymbolSpan]
+ (390,2)SyntaxKind[Nonterminal]?
+ (390,2)SyntaxKind[Identifier](text = "ModuleElements")
+ (390,16)SyntaxKind[QuestionToken]
+ (391,1)SyntaxKind[DedentToken]
+ (392,1)SyntaxKind[Production]
+ (392,1)SyntaxKind[Identifier](text = "ModuleElements")
+ (393,1)SyntaxKind[RightHandSideList]
+ (393,1)SyntaxKind[IndentToken]
+ (393,2)SyntaxKind[RightHandSide]
+ (393,2)SyntaxKind[SymbolSpan]
+ (393,2)SyntaxKind[Nonterminal]
+ (393,2)SyntaxKind[Identifier](text = "ModuleElement")
+ (394,2)SyntaxKind[RightHandSide]
+ (394,2)SyntaxKind[SymbolSpan]
+ (394,2)SyntaxKind[Nonterminal]
+ (394,2)SyntaxKind[Identifier](text = "ModuleElements")
+ (394,17)SyntaxKind[SymbolSpan]
+ (394,17)SyntaxKind[Nonterminal]
+ (394,17)SyntaxKind[Identifier](text = "ModuleElement")
+ (395,1)SyntaxKind[DedentToken]
+ (396,1)SyntaxKind[Production]
+ (396,1)SyntaxKind[Identifier](text = "ModuleElement")
+ (397,1)SyntaxKind[RightHandSideList]
+ (397,1)SyntaxKind[IndentToken]
+ (397,2)SyntaxKind[RightHandSide]
+ (397,2)SyntaxKind[SymbolSpan]
+ (397,2)SyntaxKind[Nonterminal]
+ (397,2)SyntaxKind[Identifier](text = "Statement")
+ (398,2)SyntaxKind[RightHandSide]
+ (398,2)SyntaxKind[SymbolSpan]
+ (398,2)SyntaxKind[Terminal](text = "export")?
+ (398,10)SyntaxKind[QuestionToken]
+ (398,12)SyntaxKind[SymbolSpan]
+ (398,12)SyntaxKind[Nonterminal]
+ (398,12)SyntaxKind[Identifier](text = "VariableDeclaration")
+ (399,2)SyntaxKind[RightHandSide]
+ (399,2)SyntaxKind[SymbolSpan]
+ (399,2)SyntaxKind[Terminal](text = "export")?
+ (399,10)SyntaxKind[QuestionToken]
+ (399,12)SyntaxKind[SymbolSpan]
+ (399,12)SyntaxKind[Nonterminal]
+ (399,12)SyntaxKind[Identifier](text = "FunctionDeclaration")
+ (400,2)SyntaxKind[RightHandSide]
+ (400,2)SyntaxKind[SymbolSpan]
+ (400,2)SyntaxKind[Terminal](text = "export")?
+ (400,10)SyntaxKind[QuestionToken]
+ (400,12)SyntaxKind[SymbolSpan]
+ (400,12)SyntaxKind[Nonterminal]
+ (400,12)SyntaxKind[Identifier](text = "ClassDeclaration")
+ (401,2)SyntaxKind[RightHandSide]
+ (401,2)SyntaxKind[SymbolSpan]
+ (401,2)SyntaxKind[Terminal](text = "export")?
+ (401,10)SyntaxKind[QuestionToken]
+ (401,12)SyntaxKind[SymbolSpan]
+ (401,12)SyntaxKind[Nonterminal]
+ (401,12)SyntaxKind[Identifier](text = "InterfaceDeclaration")
+ (402,2)SyntaxKind[RightHandSide]
+ (402,2)SyntaxKind[SymbolSpan]
+ (402,2)SyntaxKind[Terminal](text = "export")?
+ (402,10)SyntaxKind[QuestionToken]
+ (402,12)SyntaxKind[SymbolSpan]
+ (402,12)SyntaxKind[Nonterminal]
+ (402,12)SyntaxKind[Identifier](text = "TypeAliasDeclaration")
+ (403,2)SyntaxKind[RightHandSide]
+ (403,2)SyntaxKind[SymbolSpan]
+ (403,2)SyntaxKind[Terminal](text = "export")?
+ (403,10)SyntaxKind[QuestionToken]
+ (403,12)SyntaxKind[SymbolSpan]
+ (403,12)SyntaxKind[Nonterminal]
+ (403,12)SyntaxKind[Identifier](text = "EnumDeclaration")
+ (404,2)SyntaxKind[RightHandSide]
+ (404,2)SyntaxKind[SymbolSpan]
+ (404,2)SyntaxKind[Terminal](text = "export")?
+ (404,10)SyntaxKind[QuestionToken]
+ (404,12)SyntaxKind[SymbolSpan]
+ (404,12)SyntaxKind[Nonterminal]
+ (404,12)SyntaxKind[Identifier](text = "ModuleDeclaration")
+ (405,2)SyntaxKind[RightHandSide]
+ (405,2)SyntaxKind[SymbolSpan]
+ (405,2)SyntaxKind[Terminal](text = "export")?
+ (405,10)SyntaxKind[QuestionToken]
+ (405,12)SyntaxKind[SymbolSpan]
+ (405,12)SyntaxKind[Nonterminal]
+ (405,12)SyntaxKind[Identifier](text = "ImportDeclaration")
+ (406,2)SyntaxKind[RightHandSide]
+ (406,2)SyntaxKind[SymbolSpan]
+ (406,2)SyntaxKind[Terminal](text = "export")?
+ (406,10)SyntaxKind[QuestionToken]
+ (406,12)SyntaxKind[SymbolSpan]
+ (406,12)SyntaxKind[Nonterminal]
+ (406,12)SyntaxKind[Identifier](text = "AmbientDeclaration")
+ (407,1)SyntaxKind[DedentToken]
+ (408,1)SyntaxKind[Production]
+ (408,1)SyntaxKind[Identifier](text = "ImportDeclaration")
+ (409,1)SyntaxKind[RightHandSideList]
+ (409,1)SyntaxKind[IndentToken]
+ (409,2)SyntaxKind[RightHandSide]
+ (409,2)SyntaxKind[SymbolSpan]
+ (409,2)SyntaxKind[Terminal](text = "import")
+ (409,11)SyntaxKind[SymbolSpan]
+ (409,11)SyntaxKind[Nonterminal]
+ (409,11)SyntaxKind[Identifier](text = "Identifier")
+ (409,22)SyntaxKind[SymbolSpan]
+ (409,22)SyntaxKind[Terminal](text = "=")
+ (409,26)SyntaxKind[SymbolSpan]
+ (409,26)SyntaxKind[Nonterminal]
+ (409,26)SyntaxKind[Identifier](text = "EntityName")
+ (409,37)SyntaxKind[SymbolSpan]
+ (409,37)SyntaxKind[Terminal](text = ";")
+ (410,1)SyntaxKind[DedentToken]
+ (411,1)SyntaxKind[Production]
+ (411,1)SyntaxKind[Identifier](text = "EntityName")
+ (412,1)SyntaxKind[RightHandSideList]
+ (412,1)SyntaxKind[IndentToken]
+ (412,2)SyntaxKind[RightHandSide]
+ (412,2)SyntaxKind[SymbolSpan]
+ (412,2)SyntaxKind[Nonterminal]
+ (412,2)SyntaxKind[Identifier](text = "ModuleName")
+ (413,2)SyntaxKind[RightHandSide]
+ (413,2)SyntaxKind[SymbolSpan]
+ (413,2)SyntaxKind[Nonterminal]
+ (413,2)SyntaxKind[Identifier](text = "ModuleName")
+ (413,13)SyntaxKind[SymbolSpan]
+ (413,13)SyntaxKind[Terminal](text = ".")
+ (413,17)SyntaxKind[SymbolSpan]
+ (413,17)SyntaxKind[Nonterminal]
+ (413,17)SyntaxKind[Identifier](text = "Identifier")
+ (414,1)SyntaxKind[DedentToken]
+ (416,1)SyntaxKind[Production]
+ (416,1)SyntaxKind[Identifier](text = "SourceFile")
+ (417,1)SyntaxKind[RightHandSideList]
+ (417,1)SyntaxKind[IndentToken]
+ (417,2)SyntaxKind[RightHandSide]
+ (417,2)SyntaxKind[SymbolSpan]
+ (417,2)SyntaxKind[Nonterminal]
+ (417,2)SyntaxKind[Identifier](text = "ImplementationSourceFile")
+ (418,2)SyntaxKind[RightHandSide]
+ (418,2)SyntaxKind[SymbolSpan]
+ (418,2)SyntaxKind[Nonterminal]
+ (418,2)SyntaxKind[Identifier](text = "DeclarationSourceFile")
+ (419,1)SyntaxKind[DedentToken]
+ (420,1)SyntaxKind[Production]
+ (420,1)SyntaxKind[Identifier](text = "ImplementationSourceFile")
+ (421,1)SyntaxKind[RightHandSideList]
+ (421,1)SyntaxKind[IndentToken]
+ (421,2)SyntaxKind[RightHandSide]
+ (421,2)SyntaxKind[SymbolSpan]
+ (421,2)SyntaxKind[Nonterminal]?
+ (421,2)SyntaxKind[Identifier](text = "ImplementationElements")
+ (421,24)SyntaxKind[QuestionToken]
+ (422,1)SyntaxKind[DedentToken]
+ (423,1)SyntaxKind[Production]
+ (423,1)SyntaxKind[Identifier](text = "ImplementationElements")
+ (424,1)SyntaxKind[RightHandSideList]
+ (424,1)SyntaxKind[IndentToken]
+ (424,2)SyntaxKind[RightHandSide]
+ (424,2)SyntaxKind[SymbolSpan]
+ (424,2)SyntaxKind[Nonterminal]
+ (424,2)SyntaxKind[Identifier](text = "ImplementationElement")
+ (425,2)SyntaxKind[RightHandSide]
+ (425,2)SyntaxKind[SymbolSpan]
+ (425,2)SyntaxKind[Nonterminal]
+ (425,2)SyntaxKind[Identifier](text = "ImplementationElements")
+ (425,25)SyntaxKind[SymbolSpan]
+ (425,25)SyntaxKind[Nonterminal]
+ (425,25)SyntaxKind[Identifier](text = "ImplementationElement")
+ (426,1)SyntaxKind[DedentToken]
+ (427,1)SyntaxKind[Production]
+ (427,1)SyntaxKind[Identifier](text = "ImplementationElement")
+ (428,1)SyntaxKind[RightHandSideList]
+ (428,1)SyntaxKind[IndentToken]
+ (428,2)SyntaxKind[RightHandSide]
+ (428,2)SyntaxKind[SymbolSpan]
+ (428,2)SyntaxKind[Nonterminal]
+ (428,2)SyntaxKind[Identifier](text = "ModuleElement")
+ (429,2)SyntaxKind[RightHandSide]
+ (429,2)SyntaxKind[SymbolSpan]
+ (429,2)SyntaxKind[Nonterminal]
+ (429,2)SyntaxKind[Identifier](text = "ExportAssignment")
+ (430,2)SyntaxKind[RightHandSide]
+ (430,2)SyntaxKind[SymbolSpan]
+ (430,2)SyntaxKind[Nonterminal]
+ (430,2)SyntaxKind[Identifier](text = "AmbientExternalModuleDeclaration")
+ (431,2)SyntaxKind[RightHandSide]
+ (431,2)SyntaxKind[SymbolSpan]
+ (431,2)SyntaxKind[Terminal](text = "export")?
+ (431,10)SyntaxKind[QuestionToken]
+ (431,12)SyntaxKind[SymbolSpan]
+ (431,12)SyntaxKind[Nonterminal]
+ (431,12)SyntaxKind[Identifier](text = "ExternalImportDeclaration")
+ (432,1)SyntaxKind[DedentToken]
+ (433,1)SyntaxKind[Production]
+ (433,1)SyntaxKind[Identifier](text = "DeclarationSourceFile")
+ (434,1)SyntaxKind[RightHandSideList]
+ (434,1)SyntaxKind[IndentToken]
+ (434,2)SyntaxKind[RightHandSide]
+ (434,2)SyntaxKind[SymbolSpan]
+ (434,2)SyntaxKind[Nonterminal]?
+ (434,2)SyntaxKind[Identifier](text = "DeclarationElements")
+ (434,21)SyntaxKind[QuestionToken]
+ (435,1)SyntaxKind[DedentToken]
+ (436,1)SyntaxKind[Production]
+ (436,1)SyntaxKind[Identifier](text = "DeclarationElements")
+ (437,1)SyntaxKind[RightHandSideList]
+ (437,1)SyntaxKind[IndentToken]
+ (437,2)SyntaxKind[RightHandSide]
+ (437,2)SyntaxKind[SymbolSpan]
+ (437,2)SyntaxKind[Nonterminal]
+ (437,2)SyntaxKind[Identifier](text = "DeclarationElement")
+ (438,2)SyntaxKind[RightHandSide]
+ (438,2)SyntaxKind[SymbolSpan]
+ (438,2)SyntaxKind[Nonterminal]
+ (438,2)SyntaxKind[Identifier](text = "DeclarationElements")
+ (438,22)SyntaxKind[SymbolSpan]
+ (438,22)SyntaxKind[Nonterminal]
+ (438,22)SyntaxKind[Identifier](text = "DeclarationElement")
+ (439,1)SyntaxKind[DedentToken]
+ (440,1)SyntaxKind[Production]
+ (440,1)SyntaxKind[Identifier](text = "DeclarationElement")
+ (441,1)SyntaxKind[RightHandSideList]
+ (441,1)SyntaxKind[IndentToken]
+ (441,2)SyntaxKind[RightHandSide]
+ (441,2)SyntaxKind[SymbolSpan]
+ (441,2)SyntaxKind[Nonterminal]
+ (441,2)SyntaxKind[Identifier](text = "ExportAssignment")
+ (442,2)SyntaxKind[RightHandSide]
+ (442,2)SyntaxKind[SymbolSpan]
+ (442,2)SyntaxKind[Nonterminal]
+ (442,2)SyntaxKind[Identifier](text = "AmbientExternalModuleDeclaration")
+ (443,2)SyntaxKind[RightHandSide]
+ (443,2)SyntaxKind[SymbolSpan]
+ (443,2)SyntaxKind[Terminal](text = "export")?
+ (443,10)SyntaxKind[QuestionToken]
+ (443,12)SyntaxKind[SymbolSpan]
+ (443,12)SyntaxKind[Nonterminal]
+ (443,12)SyntaxKind[Identifier](text = "InterfaceDeclaration")
+ (444,2)SyntaxKind[RightHandSide]
+ (444,2)SyntaxKind[SymbolSpan]
+ (444,2)SyntaxKind[Terminal](text = "export")?
+ (444,10)SyntaxKind[QuestionToken]
+ (444,12)SyntaxKind[SymbolSpan]
+ (444,12)SyntaxKind[Nonterminal]
+ (444,12)SyntaxKind[Identifier](text = "TypeAliasDeclaration")
+ (445,2)SyntaxKind[RightHandSide]
+ (445,2)SyntaxKind[SymbolSpan]
+ (445,2)SyntaxKind[Terminal](text = "export")?
+ (445,10)SyntaxKind[QuestionToken]
+ (445,12)SyntaxKind[SymbolSpan]
+ (445,12)SyntaxKind[Nonterminal]
+ (445,12)SyntaxKind[Identifier](text = "ImportDeclaration")
+ (446,2)SyntaxKind[RightHandSide]
+ (446,2)SyntaxKind[SymbolSpan]
+ (446,2)SyntaxKind[Terminal](text = "export")?
+ (446,10)SyntaxKind[QuestionToken]
+ (446,12)SyntaxKind[SymbolSpan]
+ (446,12)SyntaxKind[Nonterminal]
+ (446,12)SyntaxKind[Identifier](text = "AmbientDeclaration")
+ (447,2)SyntaxKind[RightHandSide]
+ (447,2)SyntaxKind[SymbolSpan]
+ (447,2)SyntaxKind[Terminal](text = "export")?
+ (447,10)SyntaxKind[QuestionToken]
+ (447,12)SyntaxKind[SymbolSpan]
+ (447,12)SyntaxKind[Nonterminal]
+ (447,12)SyntaxKind[Identifier](text = "ExternalImportDeclaration")
+ (448,1)SyntaxKind[DedentToken]
+ (449,1)SyntaxKind[Production]
+ (449,1)SyntaxKind[Identifier](text = "ExternalImportDeclaration")
+ (450,1)SyntaxKind[RightHandSideList]
+ (450,1)SyntaxKind[IndentToken]
+ (450,2)SyntaxKind[RightHandSide]
+ (450,2)SyntaxKind[SymbolSpan]
+ (450,2)SyntaxKind[Terminal](text = "import")
+ (450,11)SyntaxKind[SymbolSpan]
+ (450,11)SyntaxKind[Nonterminal]
+ (450,11)SyntaxKind[Identifier](text = "Identifier")
+ (450,22)SyntaxKind[SymbolSpan]
+ (450,22)SyntaxKind[Terminal](text = "=")
+ (450,26)SyntaxKind[SymbolSpan]
+ (450,26)SyntaxKind[Nonterminal]
+ (450,26)SyntaxKind[Identifier](text = "ExternalModuleReference")
+ (450,50)SyntaxKind[SymbolSpan]
+ (450,50)SyntaxKind[Terminal](text = ";")
+ (451,1)SyntaxKind[DedentToken]
+ (452,1)SyntaxKind[Production]
+ (452,1)SyntaxKind[Identifier](text = "ExternalModuleReference")
+ (453,1)SyntaxKind[RightHandSideList]
+ (453,1)SyntaxKind[IndentToken]
+ (453,2)SyntaxKind[RightHandSide]
+ (453,2)SyntaxKind[SymbolSpan]
+ (453,2)SyntaxKind[Terminal](text = "require")
+ (453,12)SyntaxKind[SymbolSpan]
+ (453,12)SyntaxKind[Terminal](text = "(")
+ (453,16)SyntaxKind[SymbolSpan]
+ (453,16)SyntaxKind[Nonterminal]
+ (453,16)SyntaxKind[Identifier](text = "StringLiteral")
+ (453,30)SyntaxKind[SymbolSpan]
+ (453,30)SyntaxKind[Terminal](text = ")")
+ (454,1)SyntaxKind[DedentToken]
+ (455,1)SyntaxKind[Production]
+ (455,1)SyntaxKind[Identifier](text = "ExportAssignment")
+ (456,1)SyntaxKind[RightHandSideList]
+ (456,1)SyntaxKind[IndentToken]
+ (456,2)SyntaxKind[RightHandSide]
+ (456,2)SyntaxKind[SymbolSpan]
+ (456,2)SyntaxKind[Terminal](text = "export")
+ (456,11)SyntaxKind[SymbolSpan]
+ (456,11)SyntaxKind[Terminal](text = "=")
+ (456,15)SyntaxKind[SymbolSpan]
+ (456,15)SyntaxKind[Nonterminal]
+ (456,15)SyntaxKind[Identifier](text = "Identifier")
+ (456,26)SyntaxKind[SymbolSpan]
+ (456,26)SyntaxKind[Terminal](text = ";")
+ (457,1)SyntaxKind[DedentToken]
+ (459,1)SyntaxKind[Production]
+ (459,1)SyntaxKind[Identifier](text = "AmbientDeclaration")
+ (460,1)SyntaxKind[RightHandSideList]
+ (460,1)SyntaxKind[IndentToken]
+ (460,2)SyntaxKind[RightHandSide]
+ (460,2)SyntaxKind[SymbolSpan]
+ (460,2)SyntaxKind[Terminal](text = "declare")
+ (460,12)SyntaxKind[SymbolSpan]
+ (460,12)SyntaxKind[Nonterminal]
+ (460,12)SyntaxKind[Identifier](text = "AmbientVariableDeclaration")
+ (461,2)SyntaxKind[RightHandSide]
+ (461,2)SyntaxKind[SymbolSpan]
+ (461,2)SyntaxKind[Terminal](text = "declare")
+ (461,12)SyntaxKind[SymbolSpan]
+ (461,12)SyntaxKind[Nonterminal]
+ (461,12)SyntaxKind[Identifier](text = "AmbientFunctionDeclaration")
+ (462,2)SyntaxKind[RightHandSide]
+ (462,2)SyntaxKind[SymbolSpan]
+ (462,2)SyntaxKind[Terminal](text = "declare")
+ (462,12)SyntaxKind[SymbolSpan]
+ (462,12)SyntaxKind[Nonterminal]
+ (462,12)SyntaxKind[Identifier](text = "AmbientClassDeclaration")
+ (463,2)SyntaxKind[RightHandSide]
+ (463,2)SyntaxKind[SymbolSpan]
+ (463,2)SyntaxKind[Terminal](text = "declare")
+ (463,12)SyntaxKind[SymbolSpan]
+ (463,12)SyntaxKind[Nonterminal]
+ (463,12)SyntaxKind[Identifier](text = "AmbientEnumDeclaration")
+ (464,2)SyntaxKind[RightHandSide]
+ (464,2)SyntaxKind[SymbolSpan]
+ (464,2)SyntaxKind[Terminal](text = "declare")
+ (464,12)SyntaxKind[SymbolSpan]
+ (464,12)SyntaxKind[Nonterminal]
+ (464,12)SyntaxKind[Identifier](text = "AmbientModuleDeclaration")
+ (465,1)SyntaxKind[DedentToken]
+ (466,1)SyntaxKind[Production]
+ (466,1)SyntaxKind[Identifier](text = "AmbientVariableDeclaration")
+ (467,1)SyntaxKind[RightHandSideList]
+ (467,1)SyntaxKind[IndentToken]
+ (467,2)SyntaxKind[RightHandSide]
+ (467,2)SyntaxKind[SymbolSpan]
+ (467,2)SyntaxKind[Terminal](text = "var")
+ (467,8)SyntaxKind[SymbolSpan]
+ (467,8)SyntaxKind[Nonterminal]
+ (467,8)SyntaxKind[Identifier](text = "Identifier")
+ (467,19)SyntaxKind[SymbolSpan]
+ (467,19)SyntaxKind[Nonterminal]?
+ (467,19)SyntaxKind[Identifier](text = "TypeAnnotation")
+ (467,33)SyntaxKind[QuestionToken]
+ (467,35)SyntaxKind[SymbolSpan]
+ (467,35)SyntaxKind[Terminal](text = ";")
+ (468,1)SyntaxKind[DedentToken]
+ (469,1)SyntaxKind[Production]
+ (469,1)SyntaxKind[Identifier](text = "AmbientFunctionDeclaration")
+ (470,1)SyntaxKind[RightHandSideList]
+ (470,1)SyntaxKind[IndentToken]
+ (470,2)SyntaxKind[RightHandSide]
+ (470,2)SyntaxKind[SymbolSpan]
+ (470,2)SyntaxKind[Terminal](text = "function")
+ (470,13)SyntaxKind[SymbolSpan]
+ (470,13)SyntaxKind[Nonterminal]
+ (470,13)SyntaxKind[Identifier](text = "Identifier")
+ (470,24)SyntaxKind[SymbolSpan]
+ (470,24)SyntaxKind[Nonterminal]
+ (470,24)SyntaxKind[Identifier](text = "CallSignature")
+ (470,38)SyntaxKind[SymbolSpan]
+ (470,38)SyntaxKind[Terminal](text = ";")
+ (471,1)SyntaxKind[DedentToken]
+ (472,1)SyntaxKind[Production]
+ (472,1)SyntaxKind[Identifier](text = "AmbientClassDeclaration")
+ (473,1)SyntaxKind[RightHandSideList]
+ (473,1)SyntaxKind[IndentToken]
+ (473,2)SyntaxKind[RightHandSide]
+ (473,2)SyntaxKind[SymbolSpan]
+ (473,2)SyntaxKind[Terminal](text = "class")
+ (473,10)SyntaxKind[SymbolSpan]
+ (473,10)SyntaxKind[Nonterminal]
+ (473,10)SyntaxKind[Identifier](text = "Identifier")
+ (473,21)SyntaxKind[SymbolSpan]
+ (473,21)SyntaxKind[Nonterminal]?
+ (473,21)SyntaxKind[Identifier](text = "TypeParameters")
+ (473,35)SyntaxKind[QuestionToken]
+ (473,37)SyntaxKind[SymbolSpan]
+ (473,37)SyntaxKind[Nonterminal]
+ (473,37)SyntaxKind[Identifier](text = "ClassHeritage")
+ (473,51)SyntaxKind[SymbolSpan]
+ (473,51)SyntaxKind[Terminal](text = "{")
+ (473,55)SyntaxKind[SymbolSpan]
+ (473,55)SyntaxKind[Nonterminal]
+ (473,55)SyntaxKind[Identifier](text = "AmbientClassBody")
+ (473,72)SyntaxKind[SymbolSpan]
+ (473,72)SyntaxKind[Terminal](text = "}")
+ (474,1)SyntaxKind[DedentToken]
+ (475,1)SyntaxKind[Production]
+ (475,1)SyntaxKind[Identifier](text = "AmbientClassBody")
+ (476,1)SyntaxKind[RightHandSideList]
+ (476,1)SyntaxKind[IndentToken]
+ (476,2)SyntaxKind[RightHandSide]
+ (476,2)SyntaxKind[SymbolSpan]
+ (476,2)SyntaxKind[Nonterminal]?
+ (476,2)SyntaxKind[Identifier](text = "AmbientClassBodyElements")
+ (476,26)SyntaxKind[QuestionToken]
+ (477,1)SyntaxKind[DedentToken]
+ (478,1)SyntaxKind[Production]
+ (478,1)SyntaxKind[Identifier](text = "AmbientClassBodyElements")
+ (479,1)SyntaxKind[RightHandSideList]
+ (479,1)SyntaxKind[IndentToken]
+ (479,2)SyntaxKind[RightHandSide]
+ (479,2)SyntaxKind[SymbolSpan]
+ (479,2)SyntaxKind[Nonterminal]
+ (479,2)SyntaxKind[Identifier](text = "AmbientClassBodyElement")
+ (480,2)SyntaxKind[RightHandSide]
+ (480,2)SyntaxKind[SymbolSpan]
+ (480,2)SyntaxKind[Nonterminal]
+ (480,2)SyntaxKind[Identifier](text = "AmbientClassBodyElements")
+ (480,27)SyntaxKind[SymbolSpan]
+ (480,27)SyntaxKind[Nonterminal]
+ (480,27)SyntaxKind[Identifier](text = "AmbientClassBodyElement")
+ (481,1)SyntaxKind[DedentToken]
+ (482,1)SyntaxKind[Production]
+ (482,1)SyntaxKind[Identifier](text = "AmbientClassBodyElement")
+ (483,1)SyntaxKind[RightHandSideList]
+ (483,1)SyntaxKind[IndentToken]
+ (483,2)SyntaxKind[RightHandSide]
+ (483,2)SyntaxKind[SymbolSpan]
+ (483,2)SyntaxKind[Nonterminal]
+ (483,2)SyntaxKind[Identifier](text = "AmbientConstructorDeclaration")
+ (484,2)SyntaxKind[RightHandSide]
+ (484,2)SyntaxKind[SymbolSpan]
+ (484,2)SyntaxKind[Nonterminal]
+ (484,2)SyntaxKind[Identifier](text = "AmbientPropertyMemberDeclaration")
+ (485,2)SyntaxKind[RightHandSide]
+ (485,2)SyntaxKind[SymbolSpan]
+ (485,2)SyntaxKind[Nonterminal]
+ (485,2)SyntaxKind[Identifier](text = "IndexSignature")
+ (486,1)SyntaxKind[DedentToken]
+ (487,1)SyntaxKind[Production]
+ (487,1)SyntaxKind[Identifier](text = "AmbientConstructorDeclaration")
+ (488,1)SyntaxKind[RightHandSideList]
+ (488,1)SyntaxKind[IndentToken]
+ (488,2)SyntaxKind[RightHandSide]
+ (488,2)SyntaxKind[SymbolSpan]
+ (488,2)SyntaxKind[Terminal](text = "constructor")
+ (488,16)SyntaxKind[SymbolSpan]
+ (488,16)SyntaxKind[Terminal](text = "(")
+ (488,20)SyntaxKind[SymbolSpan]
+ (488,20)SyntaxKind[Nonterminal]?
+ (488,20)SyntaxKind[Identifier](text = "ParameterList")
+ (488,33)SyntaxKind[QuestionToken]
+ (488,35)SyntaxKind[SymbolSpan]
+ (488,35)SyntaxKind[Terminal](text = ")")
+ (488,39)SyntaxKind[SymbolSpan]
+ (488,39)SyntaxKind[Terminal](text = ";")
+ (489,1)SyntaxKind[DedentToken]
+ (490,1)SyntaxKind[Production]
+ (490,1)SyntaxKind[Identifier](text = "AmbientPropertyMemberDeclaration")
+ (491,1)SyntaxKind[RightHandSideList]
+ (491,1)SyntaxKind[IndentToken]
+ (491,2)SyntaxKind[RightHandSide]
+ (491,2)SyntaxKind[SymbolSpan]
+ (491,2)SyntaxKind[Nonterminal]?
+ (491,2)SyntaxKind[Identifier](text = "AccessibilityModifier")
+ (491,23)SyntaxKind[QuestionToken]
+ (491,25)SyntaxKind[SymbolSpan]
+ (491,25)SyntaxKind[Terminal](text = "static")?
+ (491,33)SyntaxKind[QuestionToken]
+ (491,35)SyntaxKind[SymbolSpan]
+ (491,35)SyntaxKind[Nonterminal]
+ (491,35)SyntaxKind[Identifier](text = "PropertyName")
+ (491,48)SyntaxKind[SymbolSpan]
+ (491,48)SyntaxKind[Nonterminal]?
+ (491,48)SyntaxKind[Identifier](text = "TypeAnnotation")
+ (491,62)SyntaxKind[QuestionToken]
+ (491,64)SyntaxKind[SymbolSpan]
+ (491,64)SyntaxKind[Terminal](text = ";")
+ (492,2)SyntaxKind[RightHandSide]
+ (492,2)SyntaxKind[SymbolSpan]
+ (492,2)SyntaxKind[Nonterminal]?
+ (492,2)SyntaxKind[Identifier](text = "AccessibilityModifier")
+ (492,23)SyntaxKind[QuestionToken]
+ (492,25)SyntaxKind[SymbolSpan]
+ (492,25)SyntaxKind[Terminal](text = "static")?
+ (492,33)SyntaxKind[QuestionToken]
+ (492,35)SyntaxKind[SymbolSpan]
+ (492,35)SyntaxKind[Nonterminal]
+ (492,35)SyntaxKind[Identifier](text = "PropertyName")
+ (492,48)SyntaxKind[SymbolSpan]
+ (492,48)SyntaxKind[Nonterminal]
+ (492,48)SyntaxKind[Identifier](text = "CallSignature")
+ (492,62)SyntaxKind[SymbolSpan]
+ (492,62)SyntaxKind[Terminal](text = ";")
+ (493,1)SyntaxKind[DedentToken]
+ (494,1)SyntaxKind[Production]
+ (494,1)SyntaxKind[Identifier](text = "AmbientEnumDeclaration")
+ (495,1)SyntaxKind[RightHandSideList]
+ (495,1)SyntaxKind[IndentToken]
+ (495,2)SyntaxKind[RightHandSide]
+ (495,2)SyntaxKind[SymbolSpan]
+ (495,2)SyntaxKind[Nonterminal]
+ (495,2)SyntaxKind[Identifier](text = "EnumDeclaration")
+ (496,1)SyntaxKind[DedentToken]
+ (497,1)SyntaxKind[Production]
+ (497,1)SyntaxKind[Identifier](text = "AmbientModuleDeclaration")
+ (498,1)SyntaxKind[RightHandSideList]
+ (498,1)SyntaxKind[IndentToken]
+ (498,2)SyntaxKind[RightHandSide]
+ (498,2)SyntaxKind[SymbolSpan]
+ (498,2)SyntaxKind[Terminal](text = "module")
+ (498,11)SyntaxKind[SymbolSpan]
+ (498,11)SyntaxKind[Nonterminal]
+ (498,11)SyntaxKind[Identifier](text = "IdentifierPath")
+ (498,26)SyntaxKind[SymbolSpan]
+ (498,26)SyntaxKind[Terminal](text = "{")
+ (498,30)SyntaxKind[SymbolSpan]
+ (498,30)SyntaxKind[Nonterminal]
+ (498,30)SyntaxKind[Identifier](text = "AmbientModuleBody")
+ (498,48)SyntaxKind[SymbolSpan]
+ (498,48)SyntaxKind[Terminal](text = "}")
+ (499,1)SyntaxKind[DedentToken]
+ (500,1)SyntaxKind[Production]
+ (500,1)SyntaxKind[Identifier](text = "AmbientModuleBody")
+ (501,1)SyntaxKind[RightHandSideList]
+ (501,1)SyntaxKind[IndentToken]
+ (501,2)SyntaxKind[RightHandSide]
+ (501,2)SyntaxKind[SymbolSpan]
+ (501,2)SyntaxKind[Nonterminal]?
+ (501,2)SyntaxKind[Identifier](text = "AmbientModuleElements")
+ (501,23)SyntaxKind[QuestionToken]
+ (502,1)SyntaxKind[DedentToken]
+ (503,1)SyntaxKind[Production]
+ (503,1)SyntaxKind[Identifier](text = "AmbientModuleElements")
+ (504,1)SyntaxKind[RightHandSideList]
+ (504,1)SyntaxKind[IndentToken]
+ (504,2)SyntaxKind[RightHandSide]
+ (504,2)SyntaxKind[SymbolSpan]
+ (504,2)SyntaxKind[Nonterminal]
+ (504,2)SyntaxKind[Identifier](text = "AmbientModuleElement")
+ (505,2)SyntaxKind[RightHandSide]
+ (505,2)SyntaxKind[SymbolSpan]
+ (505,2)SyntaxKind[Nonterminal]
+ (505,2)SyntaxKind[Identifier](text = "AmbientModuleElements")
+ (505,24)SyntaxKind[SymbolSpan]
+ (505,24)SyntaxKind[Nonterminal]
+ (505,24)SyntaxKind[Identifier](text = "AmbientModuleElement")
+ (506,1)SyntaxKind[DedentToken]
+ (507,1)SyntaxKind[Production]
+ (507,1)SyntaxKind[Identifier](text = "AmbientModuleElement")
+ (508,1)SyntaxKind[RightHandSideList]
+ (508,1)SyntaxKind[IndentToken]
+ (508,2)SyntaxKind[RightHandSide]
+ (508,2)SyntaxKind[SymbolSpan]
+ (508,2)SyntaxKind[Terminal](text = "export")?
+ (508,10)SyntaxKind[QuestionToken]
+ (508,12)SyntaxKind[SymbolSpan]
+ (508,12)SyntaxKind[Nonterminal]
+ (508,12)SyntaxKind[Identifier](text = "AmbientVariableDeclaration")
+ (509,2)SyntaxKind[RightHandSide]
+ (509,2)SyntaxKind[SymbolSpan]
+ (509,2)SyntaxKind[Terminal](text = "export")?
+ (509,10)SyntaxKind[QuestionToken]
+ (509,12)SyntaxKind[SymbolSpan]
+ (509,12)SyntaxKind[Nonterminal]
+ (509,12)SyntaxKind[Identifier](text = "AmbientFunctionDeclaration")
+ (510,2)SyntaxKind[RightHandSide]
+ (510,2)SyntaxKind[SymbolSpan]
+ (510,2)SyntaxKind[Terminal](text = "export")?
+ (510,10)SyntaxKind[QuestionToken]
+ (510,12)SyntaxKind[SymbolSpan]
+ (510,12)SyntaxKind[Nonterminal]
+ (510,12)SyntaxKind[Identifier](text = "AmbientClassDeclaration")
+ (511,2)SyntaxKind[RightHandSide]
+ (511,2)SyntaxKind[SymbolSpan]
+ (511,2)SyntaxKind[Terminal](text = "export")?
+ (511,10)SyntaxKind[QuestionToken]
+ (511,12)SyntaxKind[SymbolSpan]
+ (511,12)SyntaxKind[Nonterminal]
+ (511,12)SyntaxKind[Identifier](text = "InterfaceDeclaration")
+ (512,2)SyntaxKind[RightHandSide]
+ (512,2)SyntaxKind[SymbolSpan]
+ (512,2)SyntaxKind[Terminal](text = "export")?
+ (512,10)SyntaxKind[QuestionToken]
+ (512,12)SyntaxKind[SymbolSpan]
+ (512,12)SyntaxKind[Nonterminal]
+ (512,12)SyntaxKind[Identifier](text = "AmbientEnumDeclaration")
+ (513,2)SyntaxKind[RightHandSide]
+ (513,2)SyntaxKind[SymbolSpan]
+ (513,2)SyntaxKind[Terminal](text = "export")?
+ (513,10)SyntaxKind[QuestionToken]
+ (513,12)SyntaxKind[SymbolSpan]
+ (513,12)SyntaxKind[Nonterminal]
+ (513,12)SyntaxKind[Identifier](text = "AmbientModuleDeclaration")
+ (514,2)SyntaxKind[RightHandSide]
+ (514,2)SyntaxKind[SymbolSpan]
+ (514,2)SyntaxKind[Terminal](text = "export")?
+ (514,10)SyntaxKind[QuestionToken]
+ (514,12)SyntaxKind[SymbolSpan]
+ (514,12)SyntaxKind[Nonterminal]
+ (514,12)SyntaxKind[Identifier](text = "ImportDeclaration")
+ (515,1)SyntaxKind[DedentToken]
+ (516,1)SyntaxKind[Production]
+ (516,1)SyntaxKind[Identifier](text = "AmbientExternalModuleDeclaration")
+ (517,1)SyntaxKind[RightHandSideList]
+ (517,1)SyntaxKind[IndentToken]
+ (517,2)SyntaxKind[RightHandSide]
+ (517,2)SyntaxKind[SymbolSpan]
+ (517,2)SyntaxKind[Terminal](text = "declare")
+ (517,12)SyntaxKind[SymbolSpan]
+ (517,12)SyntaxKind[Terminal](text = "module")
+ (517,21)SyntaxKind[SymbolSpan]
+ (517,21)SyntaxKind[Nonterminal]
+ (517,21)SyntaxKind[Identifier](text = "StringLiteral")
+ (517,35)SyntaxKind[SymbolSpan]
+ (517,35)SyntaxKind[Terminal](text = "{")
+ (517,39)SyntaxKind[SymbolSpan]
+ (517,39)SyntaxKind[Nonterminal]
+ (517,39)SyntaxKind[Identifier](text = "AmbientExternalModuleBody")
+ (517,65)SyntaxKind[SymbolSpan]
+ (517,65)SyntaxKind[Terminal](text = "}")
+ (518,1)SyntaxKind[DedentToken]
+ (519,1)SyntaxKind[Production]
+ (519,1)SyntaxKind[Identifier](text = "AmbientExternalModuleBody")
+ (520,1)SyntaxKind[RightHandSideList]
+ (520,1)SyntaxKind[IndentToken]
+ (520,2)SyntaxKind[RightHandSide]
+ (520,2)SyntaxKind[SymbolSpan]
+ (520,2)SyntaxKind[Nonterminal]?
+ (520,2)SyntaxKind[Identifier](text = "AmbientExternalModuleElements")
+ (520,31)SyntaxKind[QuestionToken]
+ (521,1)SyntaxKind[DedentToken]
+ (522,1)SyntaxKind[Production]
+ (522,1)SyntaxKind[Identifier](text = "AmbientExternalModuleElements")
+ (523,1)SyntaxKind[RightHandSideList]
+ (523,1)SyntaxKind[IndentToken]
+ (523,2)SyntaxKind[RightHandSide]
+ (523,2)SyntaxKind[SymbolSpan]
+ (523,2)SyntaxKind[Nonterminal]
+ (523,2)SyntaxKind[Identifier](text = "AmbientExternalModuleElement")
+ (524,2)SyntaxKind[RightHandSide]
+ (524,2)SyntaxKind[SymbolSpan]
+ (524,2)SyntaxKind[Nonterminal]
+ (524,2)SyntaxKind[Identifier](text = "AmbientExternalModuleElements")
+ (524,32)SyntaxKind[SymbolSpan]
+ (524,32)SyntaxKind[Nonterminal]
+ (524,32)SyntaxKind[Identifier](text = "AmbientExternalModuleElement")
+ (525,1)SyntaxKind[DedentToken]
+ (526,1)SyntaxKind[Production]
+ (526,1)SyntaxKind[Identifier](text = "AmbientExternalModuleElement")
+ (527,1)SyntaxKind[RightHandSideList]
+ (527,1)SyntaxKind[IndentToken]
+ (527,2)SyntaxKind[RightHandSide]
+ (527,2)SyntaxKind[SymbolSpan]
+ (527,2)SyntaxKind[Nonterminal]
+ (527,2)SyntaxKind[Identifier](text = "AmbientModuleElement")
+ (528,2)SyntaxKind[RightHandSide]
+ (528,2)SyntaxKind[SymbolSpan]
+ (528,2)SyntaxKind[Nonterminal]
+ (528,2)SyntaxKind[Identifier](text = "ExportAssignment")
+ (529,2)SyntaxKind[RightHandSide]
+ (529,2)SyntaxKind[SymbolSpan]
+ (529,2)SyntaxKind[Terminal](text = "export")?
+ (529,10)SyntaxKind[QuestionToken]
+ (529,12)SyntaxKind[SymbolSpan]
+ (529,12)SyntaxKind[Nonterminal]
+ (529,12)SyntaxKind[Identifier](text = "ExternalImportDeclaration")
+ (530,1)SyntaxKind[DedentToken]
diff --git a/tests/baselines/reference/typescript.grammar.tokens b/tests/baselines/reference/typescript.grammar.tokens
new file mode 100644
index 0000000..58046a0
--- /dev/null
+++ b/tests/baselines/reference/typescript.grammar.tokens
@@ -0,0 +1,1792 @@
+/// typescript.grammar:
+SyntaxKind[AtToken](1,1): @
+SyntaxKind[DefineKeyword](1,2): define
+SyntaxKind[Identifier](1,9): noStrictParametricProductions
+SyntaxKind[TrueKeyword](1,39): true
+SyntaxKind[LineTerminatorToken](2,1): «line terminator»
+SyntaxKind[AtToken](2,1): @
+SyntaxKind[ImportKeyword](2,2): import
+SyntaxKind[StringLiteral](2,9): «StringLiteral»
+SyntaxKind[LineTerminatorToken](3,1): «line terminator»
+SyntaxKind[LineTerminatorToken](4,1): «line terminator»
+SyntaxKind[LineTerminatorToken](5,1): «line terminator»
+SyntaxKind[Identifier](5,1): TypeParameters
+SyntaxKind[ColonToken](5,16): :
+SyntaxKind[LineTerminatorToken](6,1): «line terminator»
+SyntaxKind[IndentToken](6,1): «indent»
+SyntaxKind[Terminal](6,2): `<`
+SyntaxKind[Identifier](6,6): TypeParameterList
+SyntaxKind[Terminal](6,24): `>`
+SyntaxKind[LineTerminatorToken](7,1): «line terminator»
+SyntaxKind[DedentToken](7,1): «dedent»
+SyntaxKind[LineTerminatorToken](8,1): «line terminator»
+SyntaxKind[Identifier](8,1): TypeParameterList
+SyntaxKind[ColonToken](8,19): :
+SyntaxKind[LineTerminatorToken](9,1): «line terminator»
+SyntaxKind[IndentToken](9,1): «indent»
+SyntaxKind[Identifier](9,2): TypeParameter
+SyntaxKind[LineTerminatorToken](10,1): «line terminator»
+SyntaxKind[Identifier](10,2): TypeParameterList
+SyntaxKind[Terminal](10,20): `,`
+SyntaxKind[Identifier](10,24): TypeParameter
+SyntaxKind[LineTerminatorToken](11,1): «line terminator»
+SyntaxKind[DedentToken](11,1): «dedent»
+SyntaxKind[LineTerminatorToken](12,1): «line terminator»
+SyntaxKind[Identifier](12,1): TypeParameter
+SyntaxKind[ColonToken](12,15): :
+SyntaxKind[LineTerminatorToken](13,1): «line terminator»
+SyntaxKind[IndentToken](13,1): «indent»
+SyntaxKind[Identifier](13,2): Identifier
+SyntaxKind[Identifier](13,13): Constraint
+SyntaxKind[QuestionToken](13,23): ?
+SyntaxKind[LineTerminatorToken](14,1): «line terminator»
+SyntaxKind[DedentToken](14,1): «dedent»
+SyntaxKind[LineTerminatorToken](15,1): «line terminator»
+SyntaxKind[Identifier](15,1): Constraint
+SyntaxKind[ColonToken](15,12): :
+SyntaxKind[LineTerminatorToken](16,1): «line terminator»
+SyntaxKind[IndentToken](16,1): «indent»
+SyntaxKind[Terminal](16,2): `extends`
+SyntaxKind[Identifier](16,12): Type
+SyntaxKind[LineTerminatorToken](17,1): «line terminator»
+SyntaxKind[DedentToken](17,1): «dedent»
+SyntaxKind[LineTerminatorToken](18,1): «line terminator»
+SyntaxKind[Identifier](18,1): TypeArguments
+SyntaxKind[ColonToken](18,15): :
+SyntaxKind[LineTerminatorToken](19,1): «line terminator»
+SyntaxKind[IndentToken](19,1): «indent»
+SyntaxKind[Terminal](19,2): `<`
+SyntaxKind[Identifier](19,6): TypeArgumentList
+SyntaxKind[Terminal](19,23): `>`
+SyntaxKind[LineTerminatorToken](20,1): «line terminator»
+SyntaxKind[DedentToken](20,1): «dedent»
+SyntaxKind[LineTerminatorToken](21,1): «line terminator»
+SyntaxKind[Identifier](21,1): TypeArgumentList
+SyntaxKind[ColonToken](21,18): :
+SyntaxKind[LineTerminatorToken](22,1): «line terminator»
+SyntaxKind[IndentToken](22,1): «indent»
+SyntaxKind[Identifier](22,2): TypeArgument
+SyntaxKind[LineTerminatorToken](23,1): «line terminator»
+SyntaxKind[Identifier](23,2): TypeArgumentList
+SyntaxKind[Terminal](23,19): `,`
+SyntaxKind[Identifier](23,23): TypeArgument
+SyntaxKind[LineTerminatorToken](24,1): «line terminator»
+SyntaxKind[DedentToken](24,1): «dedent»
+SyntaxKind[LineTerminatorToken](25,1): «line terminator»
+SyntaxKind[Identifier](25,1): TypeArgument
+SyntaxKind[ColonToken](25,14): :
+SyntaxKind[LineTerminatorToken](26,1): «line terminator»
+SyntaxKind[IndentToken](26,1): «indent»
+SyntaxKind[Identifier](26,2): Type
+SyntaxKind[LineTerminatorToken](27,1): «line terminator»
+SyntaxKind[DedentToken](27,1): «dedent»
+SyntaxKind[LineTerminatorToken](28,1): «line terminator»
+SyntaxKind[Identifier](28,1): Type
+SyntaxKind[ColonToken](28,6): :
+SyntaxKind[LineTerminatorToken](29,1): «line terminator»
+SyntaxKind[IndentToken](29,1): «indent»
+SyntaxKind[Identifier](29,2): PrimaryOrUnionType
+SyntaxKind[LineTerminatorToken](30,1): «line terminator»
+SyntaxKind[Identifier](30,2): FunctionType
+SyntaxKind[LineTerminatorToken](31,1): «line terminator»
+SyntaxKind[Identifier](31,2): ConstructorType
+SyntaxKind[LineTerminatorToken](32,1): «line terminator»
+SyntaxKind[DedentToken](32,1): «dedent»
+SyntaxKind[LineTerminatorToken](33,1): «line terminator»
+SyntaxKind[Identifier](33,1): PrimaryOrUnionType
+SyntaxKind[ColonToken](33,20): :
+SyntaxKind[LineTerminatorToken](34,1): «line terminator»
+SyntaxKind[IndentToken](34,1): «indent»
+SyntaxKind[Identifier](34,2): PrimaryType
+SyntaxKind[LineTerminatorToken](35,1): «line terminator»
+SyntaxKind[Identifier](35,2): UnionType
+SyntaxKind[LineTerminatorToken](36,1): «line terminator»
+SyntaxKind[DedentToken](36,1): «dedent»
+SyntaxKind[LineTerminatorToken](37,1): «line terminator»
+SyntaxKind[Identifier](37,1): PrimaryType
+SyntaxKind[ColonToken](37,13): :
+SyntaxKind[LineTerminatorToken](38,1): «line terminator»
+SyntaxKind[IndentToken](38,1): «indent»
+SyntaxKind[Identifier](38,2): ParenthesizedType
+SyntaxKind[LineTerminatorToken](39,1): «line terminator»
+SyntaxKind[Identifier](39,2): PredefinedType
+SyntaxKind[LineTerminatorToken](40,1): «line terminator»
+SyntaxKind[Identifier](40,2): TypeReference
+SyntaxKind[LineTerminatorToken](41,1): «line terminator»
+SyntaxKind[Identifier](41,2): ObjectType
+SyntaxKind[LineTerminatorToken](42,1): «line terminator»
+SyntaxKind[Identifier](42,2): ArrayType
+SyntaxKind[LineTerminatorToken](43,1): «line terminator»
+SyntaxKind[Identifier](43,2): TupleType
+SyntaxKind[LineTerminatorToken](44,1): «line terminator»
+SyntaxKind[Identifier](44,2): TypeQuery
+SyntaxKind[LineTerminatorToken](45,1): «line terminator»
+SyntaxKind[DedentToken](45,1): «dedent»
+SyntaxKind[LineTerminatorToken](46,1): «line terminator»
+SyntaxKind[Identifier](46,1): ParenthesizedType
+SyntaxKind[ColonToken](46,19): :
+SyntaxKind[LineTerminatorToken](47,1): «line terminator»
+SyntaxKind[IndentToken](47,1): «indent»
+SyntaxKind[Terminal](47,2): `(`
+SyntaxKind[Identifier](47,6): Type
+SyntaxKind[Terminal](47,11): `)`
+SyntaxKind[LineTerminatorToken](48,1): «line terminator»
+SyntaxKind[DedentToken](48,1): «dedent»
+SyntaxKind[LineTerminatorToken](49,1): «line terminator»
+SyntaxKind[Identifier](49,1): PredefinedType
+SyntaxKind[ColonToken](49,16): :
+SyntaxKind[LineTerminatorToken](50,1): «line terminator»
+SyntaxKind[IndentToken](50,1): «indent»
+SyntaxKind[Terminal](50,2): `any`
+SyntaxKind[LineTerminatorToken](51,1): «line terminator»
+SyntaxKind[Terminal](51,2): `number`
+SyntaxKind[LineTerminatorToken](52,1): «line terminator»
+SyntaxKind[Terminal](52,2): `boolean`
+SyntaxKind[LineTerminatorToken](53,1): «line terminator»
+SyntaxKind[Terminal](53,2): `string`
+SyntaxKind[LineTerminatorToken](54,1): «line terminator»
+SyntaxKind[Terminal](54,2): `void`
+SyntaxKind[LineTerminatorToken](55,1): «line terminator»
+SyntaxKind[DedentToken](55,1): «dedent»
+SyntaxKind[LineTerminatorToken](56,1): «line terminator»
+SyntaxKind[Identifier](56,1): TypeReference
+SyntaxKind[ColonToken](56,15): :
+SyntaxKind[LineTerminatorToken](57,1): «line terminator»
+SyntaxKind[IndentToken](57,1): «indent»
+SyntaxKind[Identifier](57,2): TypeName
+SyntaxKind[OpenBracketToken](57,11): [
+SyntaxKind[NoKeyword](57,12): no
+SyntaxKind[Identifier](57,15): LineTerminator
+SyntaxKind[HereKeyword](57,30): here
+SyntaxKind[CloseBracketToken](57,34): ]
+SyntaxKind[Identifier](57,36): TypeArguments
+SyntaxKind[QuestionToken](57,49): ?
+SyntaxKind[LineTerminatorToken](58,1): «line terminator»
+SyntaxKind[DedentToken](58,1): «dedent»
+SyntaxKind[LineTerminatorToken](59,1): «line terminator»
+SyntaxKind[Identifier](59,1): TypeName
+SyntaxKind[ColonToken](59,10): :
+SyntaxKind[LineTerminatorToken](60,1): «line terminator»
+SyntaxKind[IndentToken](60,1): «indent»
+SyntaxKind[Identifier](60,2): Identifier
+SyntaxKind[LineTerminatorToken](61,1): «line terminator»
+SyntaxKind[Identifier](61,2): ModuleName
+SyntaxKind[Terminal](61,13): `.`
+SyntaxKind[Identifier](61,17): Identifier
+SyntaxKind[LineTerminatorToken](62,1): «line terminator»
+SyntaxKind[DedentToken](62,1): «dedent»
+SyntaxKind[LineTerminatorToken](63,1): «line terminator»
+SyntaxKind[Identifier](63,1): ModuleName
+SyntaxKind[ColonToken](63,12): :
+SyntaxKind[LineTerminatorToken](64,1): «line terminator»
+SyntaxKind[IndentToken](64,1): «indent»
+SyntaxKind[Identifier](64,2): Identifier
+SyntaxKind[LineTerminatorToken](65,1): «line terminator»
+SyntaxKind[Identifier](65,2): ModuleName
+SyntaxKind[Terminal](65,13): `.`
+SyntaxKind[Identifier](65,17): Identifier
+SyntaxKind[LineTerminatorToken](66,1): «line terminator»
+SyntaxKind[DedentToken](66,1): «dedent»
+SyntaxKind[LineTerminatorToken](67,1): «line terminator»
+SyntaxKind[Identifier](67,1): ObjectType
+SyntaxKind[ColonToken](67,12): :
+SyntaxKind[LineTerminatorToken](68,1): «line terminator»
+SyntaxKind[IndentToken](68,1): «indent»
+SyntaxKind[Terminal](68,2): `{`
+SyntaxKind[Identifier](68,8): TypeBody
+SyntaxKind[QuestionToken](68,16): ?
+SyntaxKind[Terminal](68,20): `}`
+SyntaxKind[LineTerminatorToken](69,1): «line terminator»
+SyntaxKind[DedentToken](69,1): «dedent»
+SyntaxKind[LineTerminatorToken](70,1): «line terminator»
+SyntaxKind[Identifier](70,1): TypeBody
+SyntaxKind[ColonToken](70,10): :
+SyntaxKind[LineTerminatorToken](71,1): «line terminator»
+SyntaxKind[IndentToken](71,1): «indent»
+SyntaxKind[Identifier](71,2): TypeMemberList
+SyntaxKind[Terminal](71,17): `;`
+SyntaxKind[QuestionToken](71,20): ?
+SyntaxKind[LineTerminatorToken](72,1): «line terminator»
+SyntaxKind[DedentToken](72,1): «dedent»
+SyntaxKind[LineTerminatorToken](73,1): «line terminator»
+SyntaxKind[Identifier](73,1): TypeMemberList
+SyntaxKind[ColonToken](73,16): :
+SyntaxKind[LineTerminatorToken](74,1): «line terminator»
+SyntaxKind[IndentToken](74,1): «indent»
+SyntaxKind[Identifier](74,2): TypeMember
+SyntaxKind[LineTerminatorToken](75,1): «line terminator»
+SyntaxKind[Identifier](75,2): TypeMemberList
+SyntaxKind[Terminal](75,17): `;`
+SyntaxKind[Identifier](75,21): TypeMember
+SyntaxKind[LineTerminatorToken](76,1): «line terminator»
+SyntaxKind[DedentToken](76,1): «dedent»
+SyntaxKind[LineTerminatorToken](77,1): «line terminator»
+SyntaxKind[Identifier](77,1): TypeMember
+SyntaxKind[ColonToken](77,12): :
+SyntaxKind[LineTerminatorToken](78,1): «line terminator»
+SyntaxKind[IndentToken](78,1): «indent»
+SyntaxKind[Identifier](78,2): PropertySignature
+SyntaxKind[LineTerminatorToken](79,1): «line terminator»
+SyntaxKind[Identifier](79,2): CallSignature
+SyntaxKind[LineTerminatorToken](80,1): «line terminator»
+SyntaxKind[Identifier](80,2): ConstructSignature
+SyntaxKind[LineTerminatorToken](81,1): «line terminator»
+SyntaxKind[Identifier](81,2): IndexSignature
+SyntaxKind[LineTerminatorToken](82,1): «line terminator»
+SyntaxKind[Identifier](82,2): MethodSignature
+SyntaxKind[LineTerminatorToken](83,1): «line terminator»
+SyntaxKind[DedentToken](83,1): «dedent»
+SyntaxKind[LineTerminatorToken](84,1): «line terminator»
+SyntaxKind[Identifier](84,1): ArrayType
+SyntaxKind[ColonToken](84,11): :
+SyntaxKind[LineTerminatorToken](85,1): «line terminator»
+SyntaxKind[IndentToken](85,1): «indent»
+SyntaxKind[Identifier](85,2): PrimaryType
+SyntaxKind[OpenBracketToken](85,14): [
+SyntaxKind[NoKeyword](85,15): no
+SyntaxKind[Identifier](85,18): LineTerminator
+SyntaxKind[HereKeyword](85,33): here
+SyntaxKind[CloseBracketToken](85,37): ]
+SyntaxKind[Terminal](85,39): `[`
+SyntaxKind[Terminal](85,43): `]`
+SyntaxKind[LineTerminatorToken](86,1): «line terminator»
+SyntaxKind[DedentToken](86,1): «dedent»
+SyntaxKind[LineTerminatorToken](87,1): «line terminator»
+SyntaxKind[Identifier](87,1): TupleType
+SyntaxKind[ColonToken](87,11): :
+SyntaxKind[LineTerminatorToken](88,1): «line terminator»
+SyntaxKind[IndentToken](88,1): «indent»
+SyntaxKind[Terminal](88,2): `[`
+SyntaxKind[Identifier](88,6): TupleElementTypes
+SyntaxKind[Terminal](88,24): `]`
+SyntaxKind[LineTerminatorToken](89,1): «line terminator»
+SyntaxKind[DedentToken](89,1): «dedent»
+SyntaxKind[LineTerminatorToken](90,1): «line terminator»
+SyntaxKind[Identifier](90,1): TupleElementTypes
+SyntaxKind[ColonToken](90,19): :
+SyntaxKind[LineTerminatorToken](91,1): «line terminator»
+SyntaxKind[IndentToken](91,1): «indent»
+SyntaxKind[Identifier](91,2): TupleElementType
+SyntaxKind[LineTerminatorToken](92,1): «line terminator»
+SyntaxKind[Identifier](92,2): TupleElementTypes
+SyntaxKind[Terminal](92,20): `,`
+SyntaxKind[Identifier](92,24): TupleElementType
+SyntaxKind[LineTerminatorToken](93,1): «line terminator»
+SyntaxKind[DedentToken](93,1): «dedent»
+SyntaxKind[LineTerminatorToken](94,1): «line terminator»
+SyntaxKind[Identifier](94,1): TupleElementType
+SyntaxKind[ColonToken](94,18): :
+SyntaxKind[LineTerminatorToken](95,1): «line terminator»
+SyntaxKind[IndentToken](95,1): «indent»
+SyntaxKind[Identifier](95,2): Type
+SyntaxKind[LineTerminatorToken](96,1): «line terminator»
+SyntaxKind[DedentToken](96,1): «dedent»
+SyntaxKind[LineTerminatorToken](97,1): «line terminator»
+SyntaxKind[Identifier](97,1): UnionType
+SyntaxKind[ColonToken](97,11): :
+SyntaxKind[LineTerminatorToken](98,1): «line terminator»
+SyntaxKind[IndentToken](98,1): «indent»
+SyntaxKind[Identifier](98,2): PrimaryOrUnionType
+SyntaxKind[Terminal](98,21): `|`
+SyntaxKind[Identifier](98,25): PrimaryType
+SyntaxKind[LineTerminatorToken](99,1): «line terminator»
+SyntaxKind[DedentToken](99,1): «dedent»
+SyntaxKind[LineTerminatorToken](100,1): «line terminator»
+SyntaxKind[Identifier](100,1): FunctionType
+SyntaxKind[ColonToken](100,14): :
+SyntaxKind[LineTerminatorToken](101,1): «line terminator»
+SyntaxKind[IndentToken](101,1): «indent»
+SyntaxKind[Identifier](101,2): TypeParameters
+SyntaxKind[QuestionToken](101,16): ?
+SyntaxKind[Terminal](101,18): `(`
+SyntaxKind[Identifier](101,22): ParameterList
+SyntaxKind[QuestionToken](101,35): ?
+SyntaxKind[Terminal](101,37): `)`
+SyntaxKind[Terminal](101,41): `=>`
+SyntaxKind[Identifier](101,46): Type
+SyntaxKind[LineTerminatorToken](102,1): «line terminator»
+SyntaxKind[DedentToken](102,1): «dedent»
+SyntaxKind[LineTerminatorToken](103,1): «line terminator»
+SyntaxKind[Identifier](103,1): ConstructorType
+SyntaxKind[ColonToken](103,17): :
+SyntaxKind[LineTerminatorToken](104,1): «line terminator»
+SyntaxKind[IndentToken](104,1): «indent»
+SyntaxKind[Terminal](104,2): `new`
+SyntaxKind[Identifier](104,8): TypeParameters
+SyntaxKind[QuestionToken](104,22): ?
+SyntaxKind[Terminal](104,24): `(`
+SyntaxKind[Identifier](104,28): ParameterList
+SyntaxKind[QuestionToken](104,41): ?
+SyntaxKind[Terminal](104,43): `)`
+SyntaxKind[Terminal](104,47): `=>`
+SyntaxKind[Identifier](104,52): Type
+SyntaxKind[LineTerminatorToken](105,1): «line terminator»
+SyntaxKind[DedentToken](105,1): «dedent»
+SyntaxKind[LineTerminatorToken](106,1): «line terminator»
+SyntaxKind[Identifier](106,1): TypeQuery
+SyntaxKind[ColonToken](106,11): :
+SyntaxKind[LineTerminatorToken](107,1): «line terminator»
+SyntaxKind[IndentToken](107,1): «indent»
+SyntaxKind[Terminal](107,2): `typeof`
+SyntaxKind[Identifier](107,11): TypeQueryExpression
+SyntaxKind[LineTerminatorToken](108,1): «line terminator»
+SyntaxKind[DedentToken](108,1): «dedent»
+SyntaxKind[LineTerminatorToken](109,1): «line terminator»
+SyntaxKind[Identifier](109,1): TypeQueryExpression
+SyntaxKind[ColonToken](109,21): :
+SyntaxKind[LineTerminatorToken](110,1): «line terminator»
+SyntaxKind[IndentToken](110,1): «indent»
+SyntaxKind[Identifier](110,2): Identifier
+SyntaxKind[LineTerminatorToken](111,1): «line terminator»
+SyntaxKind[Identifier](111,2): TypeQueryExpression
+SyntaxKind[Terminal](111,22): `.`
+SyntaxKind[Identifier](111,26): IdentifierName
+SyntaxKind[LineTerminatorToken](112,1): «line terminator»
+SyntaxKind[DedentToken](112,1): «dedent»
+SyntaxKind[LineTerminatorToken](113,1): «line terminator»
+SyntaxKind[Identifier](113,1): PropertySignature
+SyntaxKind[ColonToken](113,19): :
+SyntaxKind[LineTerminatorToken](114,1): «line terminator»
+SyntaxKind[IndentToken](114,1): «indent»
+SyntaxKind[Identifier](114,2): PropertyName
+SyntaxKind[Terminal](114,15): `?`
+SyntaxKind[QuestionToken](114,18): ?
+SyntaxKind[Identifier](114,20): TypeAnnotation
+SyntaxKind[QuestionToken](114,34): ?
+SyntaxKind[LineTerminatorToken](115,1): «line terminator»
+SyntaxKind[DedentToken](115,1): «dedent»
+SyntaxKind[LineTerminatorToken](116,1): «line terminator»
+SyntaxKind[Identifier](116,1): PropertyName
+SyntaxKind[ColonToken](116,14): :
+SyntaxKind[LineTerminatorToken](117,1): «line terminator»
+SyntaxKind[IndentToken](117,1): «indent»
+SyntaxKind[Identifier](117,2): IdentifierName
+SyntaxKind[LineTerminatorToken](118,1): «line terminator»
+SyntaxKind[Identifier](118,2): StringLiteral
+SyntaxKind[LineTerminatorToken](119,1): «line terminator»
+SyntaxKind[Identifier](119,2): NumericLiteral
+SyntaxKind[LineTerminatorToken](120,1): «line terminator»
+SyntaxKind[DedentToken](120,1): «dedent»
+SyntaxKind[LineTerminatorToken](121,1): «line terminator»
+SyntaxKind[Identifier](121,1): CallSignature
+SyntaxKind[ColonToken](121,15): :
+SyntaxKind[LineTerminatorToken](122,1): «line terminator»
+SyntaxKind[IndentToken](122,1): «indent»
+SyntaxKind[Identifier](122,2): TypeParameters
+SyntaxKind[QuestionToken](122,16): ?
+SyntaxKind[Terminal](122,18): `(`
+SyntaxKind[Identifier](122,22): ParameterList
+SyntaxKind[QuestionToken](122,35): ?
+SyntaxKind[Terminal](122,37): `)`
+SyntaxKind[Identifier](122,41): TypeAnnotation
+SyntaxKind[QuestionToken](122,55): ?
+SyntaxKind[LineTerminatorToken](123,1): «line terminator»
+SyntaxKind[DedentToken](123,1): «dedent»
+SyntaxKind[LineTerminatorToken](124,1): «line terminator»
+SyntaxKind[Identifier](124,1): ParameterList
+SyntaxKind[ColonToken](124,15): :
+SyntaxKind[LineTerminatorToken](125,1): «line terminator»
+SyntaxKind[IndentToken](125,1): «indent»
+SyntaxKind[Identifier](125,2): RequiredParameterList
+SyntaxKind[LineTerminatorToken](126,1): «line terminator»
+SyntaxKind[Identifier](126,2): OptionalParameterList
+SyntaxKind[LineTerminatorToken](127,1): «line terminator»
+SyntaxKind[Identifier](127,2): RestParameter
+SyntaxKind[LineTerminatorToken](128,1): «line terminator»
+SyntaxKind[Identifier](128,2): RequiredParameterList
+SyntaxKind[Terminal](128,24): `,`
+SyntaxKind[Identifier](128,28): OptionalParameterList
+SyntaxKind[LineTerminatorToken](129,1): «line terminator»
+SyntaxKind[Identifier](129,2): RequiredParameterList
+SyntaxKind[Terminal](129,24): `,`
+SyntaxKind[Identifier](129,28): RestParameter
+SyntaxKind[LineTerminatorToken](130,1): «line terminator»
+SyntaxKind[Identifier](130,2): OptionalParameterList
+SyntaxKind[Terminal](130,24): `,`
+SyntaxKind[Identifier](130,28): RestParameter
+SyntaxKind[LineTerminatorToken](131,1): «line terminator»
+SyntaxKind[Identifier](131,2): RequiredParameterList
+SyntaxKind[Terminal](131,24): `,`
+SyntaxKind[Identifier](131,28): OptionalParameterList
+SyntaxKind[Terminal](131,50): `,`
+SyntaxKind[Identifier](131,54): RestParameter
+SyntaxKind[LineTerminatorToken](132,1): «line terminator»
+SyntaxKind[DedentToken](132,1): «dedent»
+SyntaxKind[LineTerminatorToken](133,1): «line terminator»
+SyntaxKind[Identifier](133,1): RequiredParameterList
+SyntaxKind[ColonToken](133,23): :
+SyntaxKind[LineTerminatorToken](134,1): «line terminator»
+SyntaxKind[IndentToken](134,1): «indent»
+SyntaxKind[Identifier](134,2): RequiredParameter
+SyntaxKind[LineTerminatorToken](135,1): «line terminator»
+SyntaxKind[Identifier](135,2): RequiredParameterList
+SyntaxKind[Terminal](135,24): `,`
+SyntaxKind[Identifier](135,28): RequiredParameter
+SyntaxKind[LineTerminatorToken](136,1): «line terminator»
+SyntaxKind[DedentToken](136,1): «dedent»
+SyntaxKind[LineTerminatorToken](137,1): «line terminator»
+SyntaxKind[Identifier](137,1): RequiredParameter
+SyntaxKind[ColonToken](137,19): :
+SyntaxKind[LineTerminatorToken](138,1): «line terminator»
+SyntaxKind[IndentToken](138,1): «indent»
+SyntaxKind[Identifier](138,2): AccessibilityModifier
+SyntaxKind[QuestionToken](138,23): ?
+SyntaxKind[Identifier](138,25): Identifier
+SyntaxKind[Identifier](138,36): TypeAnnotation
+SyntaxKind[QuestionToken](138,50): ?
+SyntaxKind[LineTerminatorToken](139,1): «line terminator»
+SyntaxKind[Identifier](139,2): Identifier
+SyntaxKind[Terminal](139,13): `:`
+SyntaxKind[Identifier](139,17): StringLiteral
+SyntaxKind[LineTerminatorToken](140,1): «line terminator»
+SyntaxKind[DedentToken](140,1): «dedent»
+SyntaxKind[LineTerminatorToken](141,1): «line terminator»
+SyntaxKind[Identifier](141,1): AccessibilityModifier
+SyntaxKind[ColonToken](141,23): :
+SyntaxKind[LineTerminatorToken](142,1): «line terminator»
+SyntaxKind[IndentToken](142,1): «indent»
+SyntaxKind[Terminal](142,2): `public`
+SyntaxKind[LineTerminatorToken](143,1): «line terminator»
+SyntaxKind[Terminal](143,2): `private`
+SyntaxKind[LineTerminatorToken](144,1): «line terminator»
+SyntaxKind[Terminal](144,2): `protected`
+SyntaxKind[LineTerminatorToken](145,1): «line terminator»
+SyntaxKind[DedentToken](145,1): «dedent»
+SyntaxKind[LineTerminatorToken](146,1): «line terminator»
+SyntaxKind[Identifier](146,1): OptionalParameterList
+SyntaxKind[ColonToken](146,23): :
+SyntaxKind[LineTerminatorToken](147,1): «line terminator»
+SyntaxKind[IndentToken](147,1): «indent»
+SyntaxKind[Identifier](147,2): OptionalParameter
+SyntaxKind[LineTerminatorToken](148,1): «line terminator»
+SyntaxKind[Identifier](148,2): OptionalParameterList
+SyntaxKind[Terminal](148,24): `,`
+SyntaxKind[Identifier](148,28): OptionalParameter
+SyntaxKind[LineTerminatorToken](149,1): «line terminator»
+SyntaxKind[DedentToken](149,1): «dedent»
+SyntaxKind[LineTerminatorToken](150,1): «line terminator»
+SyntaxKind[Identifier](150,1): OptionalParameter
+SyntaxKind[ColonToken](150,19): :
+SyntaxKind[LineTerminatorToken](151,1): «line terminator»
+SyntaxKind[IndentToken](151,1): «indent»
+SyntaxKind[Identifier](151,2): AccessibilityModifier
+SyntaxKind[QuestionToken](151,23): ?
+SyntaxKind[Identifier](151,25): Identifier
+SyntaxKind[Terminal](151,36): `?`
+SyntaxKind[Identifier](151,40): TypeAnnotation
+SyntaxKind[QuestionToken](151,54): ?
+SyntaxKind[LineTerminatorToken](152,1): «line terminator»
+SyntaxKind[Identifier](152,2): AccessibilityModifier
+SyntaxKind[QuestionToken](152,23): ?
+SyntaxKind[Identifier](152,25): Identifier
+SyntaxKind[Identifier](152,36): TypeAnnotation
+SyntaxKind[QuestionToken](152,50): ?
+SyntaxKind[Identifier](152,52): Initializer
+SyntaxKind[LineTerminatorToken](153,1): «line terminator»
+SyntaxKind[Identifier](153,2): Identifier
+SyntaxKind[Terminal](153,13): `?`
+SyntaxKind[Terminal](153,17): `:`
+SyntaxKind[Identifier](153,21): StringLiteral
+SyntaxKind[LineTerminatorToken](154,1): «line terminator»
+SyntaxKind[DedentToken](154,1): «dedent»
+SyntaxKind[LineTerminatorToken](155,1): «line terminator»
+SyntaxKind[Identifier](155,1): RestParameter
+SyntaxKind[ColonToken](155,15): :
+SyntaxKind[LineTerminatorToken](156,1): «line terminator»
+SyntaxKind[IndentToken](156,1): «indent»
+SyntaxKind[Terminal](156,2): `...`
+SyntaxKind[Identifier](156,8): Identifier
+SyntaxKind[Identifier](156,19): TypeAnnotation
+SyntaxKind[QuestionToken](156,33): ?
+SyntaxKind[LineTerminatorToken](157,1): «line terminator»
+SyntaxKind[DedentToken](157,1): «dedent»
+SyntaxKind[LineTerminatorToken](158,1): «line terminator»
+SyntaxKind[Identifier](158,1): ConstructSignature
+SyntaxKind[ColonToken](158,20): :
+SyntaxKind[LineTerminatorToken](159,1): «line terminator»
+SyntaxKind[IndentToken](159,1): «indent»
+SyntaxKind[Terminal](159,2): `new`
+SyntaxKind[Identifier](159,8): TypeParameters
+SyntaxKind[QuestionToken](159,22): ?
+SyntaxKind[Terminal](159,24): `(`
+SyntaxKind[Identifier](159,28): ParameterList
+SyntaxKind[QuestionToken](159,41): ?
+SyntaxKind[Terminal](159,43): `)`
+SyntaxKind[Identifier](159,47): TypeAnnotation
+SyntaxKind[QuestionToken](159,61): ?
+SyntaxKind[LineTerminatorToken](160,1): «line terminator»
+SyntaxKind[DedentToken](160,1): «dedent»
+SyntaxKind[LineTerminatorToken](161,1): «line terminator»
+SyntaxKind[Identifier](161,1): IndexSignature
+SyntaxKind[ColonToken](161,16): :
+SyntaxKind[LineTerminatorToken](162,1): «line terminator»
+SyntaxKind[IndentToken](162,1): «indent»
+SyntaxKind[Terminal](162,2): `[`
+SyntaxKind[Identifier](162,6): Identifier
+SyntaxKind[Terminal](162,17): `:`
+SyntaxKind[Terminal](162,21): `string`
+SyntaxKind[Terminal](162,30): `]`
+SyntaxKind[Identifier](162,34): TypeAnnotation
+SyntaxKind[LineTerminatorToken](163,1): «line terminator»
+SyntaxKind[Terminal](163,2): `[`
+SyntaxKind[Identifier](163,6): Identifier
+SyntaxKind[Terminal](163,17): `:`
+SyntaxKind[Terminal](163,21): `number`
+SyntaxKind[Terminal](163,30): `]`
+SyntaxKind[Identifier](163,34): TypeAnnotation
+SyntaxKind[LineTerminatorToken](164,1): «line terminator»
+SyntaxKind[DedentToken](164,1): «dedent»
+SyntaxKind[LineTerminatorToken](165,1): «line terminator»
+SyntaxKind[Identifier](165,1): MethodSignature
+SyntaxKind[ColonToken](165,17): :
+SyntaxKind[LineTerminatorToken](166,1): «line terminator»
+SyntaxKind[IndentToken](166,1): «indent»
+SyntaxKind[Identifier](166,2): PropertyName
+SyntaxKind[Terminal](166,17): `?`
+SyntaxKind[QuestionToken](166,20): ?
+SyntaxKind[Identifier](166,24): CallSignature
+SyntaxKind[LineTerminatorToken](167,1): «line terminator»
+SyntaxKind[DedentToken](167,1): «dedent»
+SyntaxKind[LineTerminatorToken](168,1): «line terminator»
+SyntaxKind[Identifier](168,1): TypeAliasDeclaration
+SyntaxKind[ColonToken](168,22): :
+SyntaxKind[LineTerminatorToken](169,1): «line terminator»
+SyntaxKind[IndentToken](169,1): «indent»
+SyntaxKind[Terminal](169,2): `type`
+SyntaxKind[Identifier](169,9): Identifier
+SyntaxKind[Terminal](169,20): `=`
+SyntaxKind[Identifier](169,24): Type
+SyntaxKind[Terminal](169,29): `;`
+SyntaxKind[LineTerminatorToken](170,1): «line terminator»
+SyntaxKind[DedentToken](170,1): «dedent»
+SyntaxKind[LineTerminatorToken](171,1): «line terminator»
+SyntaxKind[LineTerminatorToken](172,1): «line terminator»
+SyntaxKind[LineTerminatorToken](173,1): «line terminator»
+SyntaxKind[Identifier](173,1): PropertyAssignment
+SyntaxKind[ColonToken](173,20): :
+SyntaxKind[LineTerminatorToken](174,1): «line terminator»
+SyntaxKind[IndentToken](174,1): «indent»
+SyntaxKind[Identifier](174,2): PropertyName
+SyntaxKind[Terminal](174,15): `:`
+SyntaxKind[Identifier](174,19): AssignmentExpression
+SyntaxKind[LineTerminatorToken](175,1): «line terminator»
+SyntaxKind[Identifier](175,2): PropertyName
+SyntaxKind[Identifier](175,15): CallSignature
+SyntaxKind[Terminal](175,29): `{`
+SyntaxKind[Identifier](175,33): FunctionBody
+SyntaxKind[Terminal](175,46): `}`
+SyntaxKind[LineTerminatorToken](176,1): «line terminator»
+SyntaxKind[Identifier](176,2): GetAccessor
+SyntaxKind[LineTerminatorToken](177,1): «line terminator»
+SyntaxKind[Identifier](177,2): SetAccessor
+SyntaxKind[LineTerminatorToken](178,1): «line terminator»
+SyntaxKind[DedentToken](178,1): «dedent»
+SyntaxKind[LineTerminatorToken](179,1): «line terminator»
+SyntaxKind[Identifier](179,1): GetAccessor
+SyntaxKind[ColonToken](179,13): :
+SyntaxKind[LineTerminatorToken](180,1): «line terminator»
+SyntaxKind[IndentToken](180,1): «indent»
+SyntaxKind[Terminal](180,2): `get`
+SyntaxKind[Identifier](180,8): PropertyName
+SyntaxKind[Terminal](180,21): `(`
+SyntaxKind[Terminal](180,25): `)`
+SyntaxKind[Identifier](180,29): TypeAnnotation
+SyntaxKind[QuestionToken](180,43): ?
+SyntaxKind[Terminal](180,45): `{`
+SyntaxKind[Identifier](180,49): FunctionBody
+SyntaxKind[Terminal](180,62): `}`
+SyntaxKind[LineTerminatorToken](181,1): «line terminator»
+SyntaxKind[DedentToken](181,1): «dedent»
+SyntaxKind[LineTerminatorToken](182,1): «line terminator»
+SyntaxKind[Identifier](182,1): SetAccessor
+SyntaxKind[ColonToken](182,12): :
+SyntaxKind[LineTerminatorToken](183,1): «line terminator»
+SyntaxKind[IndentToken](183,1): «indent»
+SyntaxKind[Terminal](183,2): `set`
+SyntaxKind[Identifier](183,8): PropertyName
+SyntaxKind[Terminal](183,21): `(`
+SyntaxKind[Identifier](183,25): Identifier
+SyntaxKind[Identifier](183,36): TypeAnnotation
+SyntaxKind[QuestionToken](183,50): ?
+SyntaxKind[Terminal](183,52): `)`
+SyntaxKind[Terminal](183,56): `{`
+SyntaxKind[Identifier](183,60): FunctionBody
+SyntaxKind[Terminal](183,73): `}`
+SyntaxKind[LineTerminatorToken](184,1): «line terminator»
+SyntaxKind[DedentToken](184,1): «dedent»
+SyntaxKind[LineTerminatorToken](185,1): «line terminator»
+SyntaxKind[Identifier](185,1): ElementList
+SyntaxKind[ColonToken](185,13): :
+SyntaxKind[LineTerminatorToken](186,1): «line terminator»
+SyntaxKind[IndentToken](186,1): «indent»
+SyntaxKind[Identifier](186,2): Elision
+SyntaxKind[QuestionToken](186,9): ?
+SyntaxKind[Identifier](186,12): AssignmentExpression
+SyntaxKind[LineTerminatorToken](187,1): «line terminator»
+SyntaxKind[Identifier](187,2): Elision
+SyntaxKind[QuestionToken](187,9): ?
+SyntaxKind[Identifier](187,12): SpreadElement
+SyntaxKind[LineTerminatorToken](188,1): «line terminator»
+SyntaxKind[Identifier](188,2): ElementList
+SyntaxKind[Terminal](188,14): `,`
+SyntaxKind[Identifier](188,18): Elision
+SyntaxKind[QuestionToken](188,25): ?
+SyntaxKind[Identifier](188,27): AssignmentExpression
+SyntaxKind[LineTerminatorToken](189,1): «line terminator»
+SyntaxKind[Identifier](189,2): ElementList
+SyntaxKind[Terminal](189,14): `,`
+SyntaxKind[Identifier](189,18): Elision
+SyntaxKind[QuestionToken](189,25): ?
+SyntaxKind[Identifier](189,27): SpreadElement
+SyntaxKind[LineTerminatorToken](190,1): «line terminator»
+SyntaxKind[DedentToken](190,1): «dedent»
+SyntaxKind[LineTerminatorToken](191,1): «line terminator»
+SyntaxKind[Identifier](191,1): SpreadElement
+SyntaxKind[ColonToken](191,15): :
+SyntaxKind[LineTerminatorToken](192,1): «line terminator»
+SyntaxKind[IndentToken](192,1): «indent»
+SyntaxKind[Terminal](192,2): `...`
+SyntaxKind[Identifier](192,8): AssignmentExpression
+SyntaxKind[LineTerminatorToken](193,1): «line terminator»
+SyntaxKind[DedentToken](193,1): «dedent»
+SyntaxKind[LineTerminatorToken](194,1): «line terminator»
+SyntaxKind[Identifier](194,1): CallExpression
+SyntaxKind[ColonToken](194,16): :
+SyntaxKind[LineTerminatorToken](195,1): «line terminator»
+SyntaxKind[IndentToken](195,1): «indent»
+SyntaxKind[Terminal](195,2): `super`
+SyntaxKind[Terminal](195,10): `(`
+SyntaxKind[Identifier](195,14): ArgumentList
+SyntaxKind[QuestionToken](195,26): ?
+SyntaxKind[Terminal](195,28): `)`
+SyntaxKind[LineTerminatorToken](196,1): «line terminator»
+SyntaxKind[Terminal](196,2): `super`
+SyntaxKind[Terminal](196,10): `.`
+SyntaxKind[Identifier](196,14): IdentifierName
+SyntaxKind[LineTerminatorToken](197,1): «line terminator»
+SyntaxKind[DedentToken](197,1): «dedent»
+SyntaxKind[LineTerminatorToken](198,1): «line terminator»
+SyntaxKind[Identifier](198,1): FunctionExpression
+SyntaxKind[ColonToken](198,20): :
+SyntaxKind[LineTerminatorToken](199,1): «line terminator»
+SyntaxKind[IndentToken](199,1): «indent»
+SyntaxKind[Terminal](199,2): `function`
+SyntaxKind[Identifier](199,13): Identifier
+SyntaxKind[QuestionToken](199,23): ?
+SyntaxKind[Identifier](199,25): CallSignature
+SyntaxKind[Terminal](199,39): `{`
+SyntaxKind[Identifier](199,43): FunctionBody
+SyntaxKind[Terminal](199,56): `}`
+SyntaxKind[LineTerminatorToken](200,1): «line terminator»
+SyntaxKind[DedentToken](200,1): «dedent»
+SyntaxKind[LineTerminatorToken](201,1): «line terminator»
+SyntaxKind[Identifier](201,1): AssignmentExpression
+SyntaxKind[ColonToken](201,22): :
+SyntaxKind[LineTerminatorToken](202,1): «line terminator»
+SyntaxKind[IndentToken](202,1): «indent»
+SyntaxKind[Identifier](202,2): ArrowFunctionExpression
+SyntaxKind[LineTerminatorToken](203,1): «line terminator»
+SyntaxKind[DedentToken](203,1): «dedent»
+SyntaxKind[LineTerminatorToken](204,1): «line terminator»
+SyntaxKind[Identifier](204,1): ArrowFunctionExpression
+SyntaxKind[ColonToken](204,25): :
+SyntaxKind[LineTerminatorToken](205,1): «line terminator»
+SyntaxKind[IndentToken](205,1): «indent»
+SyntaxKind[Identifier](205,2): ArrowFormalParameters
+SyntaxKind[Terminal](205,24): `=>`
+SyntaxKind[Identifier](205,29): Block
+SyntaxKind[LineTerminatorToken](206,1): «line terminator»
+SyntaxKind[Identifier](206,2): ArrowFormalParameters
+SyntaxKind[Terminal](206,24): `=>`
+SyntaxKind[Identifier](206,29): AssignmentExpression
+SyntaxKind[LineTerminatorToken](207,1): «line terminator»
+SyntaxKind[DedentToken](207,1): «dedent»
+SyntaxKind[LineTerminatorToken](208,1): «line terminator»
+SyntaxKind[Identifier](208,1): ArrowFormalParameters
+SyntaxKind[ColonToken](208,23): :
+SyntaxKind[LineTerminatorToken](209,1): «line terminator»
+SyntaxKind[IndentToken](209,1): «indent»
+SyntaxKind[Identifier](209,2): CallSignature
+SyntaxKind[LineTerminatorToken](210,1): «line terminator»
+SyntaxKind[Identifier](210,2): Identifier
+SyntaxKind[LineTerminatorToken](211,1): «line terminator»
+SyntaxKind[DedentToken](211,1): «dedent»
+SyntaxKind[LineTerminatorToken](212,1): «line terminator»
+SyntaxKind[Identifier](212,1): Arguments
+SyntaxKind[ColonToken](212,11): :
+SyntaxKind[LineTerminatorToken](213,1): «line terminator»
+SyntaxKind[IndentToken](213,1): «indent»
+SyntaxKind[Identifier](213,2): TypeArguments
+SyntaxKind[QuestionToken](213,15): ?
+SyntaxKind[Terminal](213,17): `(`
+SyntaxKind[Identifier](213,21): ArgumentList
+SyntaxKind[QuestionToken](213,33): ?
+SyntaxKind[Terminal](213,35): `)`
+SyntaxKind[LineTerminatorToken](214,1): «line terminator»
+SyntaxKind[DedentToken](214,1): «dedent»
+SyntaxKind[LineTerminatorToken](215,1): «line terminator»
+SyntaxKind[Identifier](215,1): UnaryExpression
+SyntaxKind[ColonToken](215,17): :
+SyntaxKind[LineTerminatorToken](216,1): «line terminator»
+SyntaxKind[IndentToken](216,1): «indent»
+SyntaxKind[Terminal](216,2): `<`
+SyntaxKind[Identifier](216,6): Type
+SyntaxKind[Terminal](216,11): `>`
+SyntaxKind[Identifier](216,15): UnaryExpression
+SyntaxKind[LineTerminatorToken](217,1): «line terminator»
+SyntaxKind[DedentToken](217,1): «dedent»
+SyntaxKind[LineTerminatorToken](218,1): «line terminator»
+SyntaxKind[LineTerminatorToken](219,1): «line terminator»
+SyntaxKind[LineTerminatorToken](220,1): «line terminator»
+SyntaxKind[Identifier](220,1): VariableDeclaration
+SyntaxKind[ColonToken](220,21): :
+SyntaxKind[LineTerminatorToken](221,1): «line terminator»
+SyntaxKind[IndentToken](221,1): «indent»
+SyntaxKind[Identifier](221,2): SimpleVariableDeclaration
+SyntaxKind[LineTerminatorToken](222,1): «line terminator»
+SyntaxKind[Identifier](222,2): DestructuringVariableDeclaration
+SyntaxKind[LineTerminatorToken](223,1): «line terminator»
+SyntaxKind[DedentToken](223,1): «dedent»
+SyntaxKind[LineTerminatorToken](224,1): «line terminator»
+SyntaxKind[Identifier](224,1): SimpleVariableDeclaration
+SyntaxKind[ColonToken](224,27): :
+SyntaxKind[LineTerminatorToken](225,1): «line terminator»
+SyntaxKind[IndentToken](225,1): «indent»
+SyntaxKind[Identifier](225,2): Identifier
+SyntaxKind[Identifier](225,13): TypeAnnotation
+SyntaxKind[QuestionToken](225,27): ?
+SyntaxKind[Identifier](225,29): Initializer
+SyntaxKind[QuestionToken](225,40): ?
+SyntaxKind[LineTerminatorToken](226,1): «line terminator»
+SyntaxKind[DedentToken](226,1): «dedent»
+SyntaxKind[LineTerminatorToken](227,1): «line terminator»
+SyntaxKind[Identifier](227,1): TypeAnnotation
+SyntaxKind[ColonToken](227,16): :
+SyntaxKind[LineTerminatorToken](228,1): «line terminator»
+SyntaxKind[IndentToken](228,1): «indent»
+SyntaxKind[Terminal](228,2): `:`
+SyntaxKind[Identifier](228,6): Type
+SyntaxKind[LineTerminatorToken](229,1): «line terminator»
+SyntaxKind[DedentToken](229,1): «dedent»
+SyntaxKind[LineTerminatorToken](230,1): «line terminator»
+SyntaxKind[Identifier](230,1): DestructuringVariableDeclaration
+SyntaxKind[ColonToken](230,34): :
+SyntaxKind[LineTerminatorToken](231,1): «line terminator»
+SyntaxKind[IndentToken](231,1): «indent»
+SyntaxKind[Identifier](231,2): BindingPattern
+SyntaxKind[Identifier](231,17): TypeAnnotation
+SyntaxKind[QuestionToken](231,31): ?
+SyntaxKind[Identifier](231,33): Initializer
+SyntaxKind[LineTerminatorToken](232,1): «line terminator»
+SyntaxKind[DedentToken](232,1): «dedent»
+SyntaxKind[LineTerminatorToken](233,1): «line terminator»
+SyntaxKind[Identifier](233,1): BindingPattern
+SyntaxKind[ColonToken](233,16): :
+SyntaxKind[LineTerminatorToken](234,1): «line terminator»
+SyntaxKind[IndentToken](234,1): «indent»
+SyntaxKind[Identifier](234,2): ObjectBindingPattern
+SyntaxKind[LineTerminatorToken](235,1): «line terminator»
+SyntaxKind[Identifier](235,2): ArrayBindingPattern
+SyntaxKind[LineTerminatorToken](236,1): «line terminator»
+SyntaxKind[DedentToken](236,1): «dedent»
+SyntaxKind[LineTerminatorToken](237,1): «line terminator»
+SyntaxKind[Identifier](237,1): ObjectBindingPattern
+SyntaxKind[ColonToken](237,22): :
+SyntaxKind[LineTerminatorToken](238,1): «line terminator»
+SyntaxKind[IndentToken](238,1): «indent»
+SyntaxKind[Terminal](238,2): `{`
+SyntaxKind[Terminal](238,6): `}`
+SyntaxKind[LineTerminatorToken](239,1): «line terminator»
+SyntaxKind[Terminal](239,2): `{`
+SyntaxKind[Identifier](239,6): BindingPropertyList
+SyntaxKind[Terminal](239,26): `,`
+SyntaxKind[QuestionToken](239,29): ?
+SyntaxKind[Terminal](239,31): `}`
+SyntaxKind[LineTerminatorToken](240,1): «line terminator»
+SyntaxKind[DedentToken](240,1): «dedent»
+SyntaxKind[LineTerminatorToken](241,1): «line terminator»
+SyntaxKind[Identifier](241,1): BindingPropertyList
+SyntaxKind[ColonToken](241,21): :
+SyntaxKind[LineTerminatorToken](242,1): «line terminator»
+SyntaxKind[IndentToken](242,1): «indent»
+SyntaxKind[Identifier](242,2): BindingProperty
+SyntaxKind[LineTerminatorToken](243,1): «line terminator»
+SyntaxKind[Identifier](243,2): BindingPropertyList
+SyntaxKind[Terminal](243,22): `,`
+SyntaxKind[Identifier](243,26): BindingProperty
+SyntaxKind[LineTerminatorToken](244,1): «line terminator»
+SyntaxKind[DedentToken](244,1): «dedent»
+SyntaxKind[LineTerminatorToken](245,1): «line terminator»
+SyntaxKind[Identifier](245,1): BindingProperty
+SyntaxKind[ColonToken](245,17): :
+SyntaxKind[LineTerminatorToken](246,1): «line terminator»
+SyntaxKind[IndentToken](246,1): «indent»
+SyntaxKind[Identifier](246,2): Identifier
+SyntaxKind[Identifier](246,13): Initializer
+SyntaxKind[QuestionToken](246,24): ?
+SyntaxKind[LineTerminatorToken](247,1): «line terminator»
+SyntaxKind[Identifier](247,2): PropertyName
+SyntaxKind[Terminal](247,15): `:`
+SyntaxKind[Identifier](247,19): Identifier
+SyntaxKind[Identifier](247,30): Initializer
+SyntaxKind[QuestionToken](247,41): ?
+SyntaxKind[LineTerminatorToken](248,1): «line terminator»
+SyntaxKind[Identifier](248,2): PropertyName
+SyntaxKind[Terminal](248,15): `:`
+SyntaxKind[Identifier](248,19): BindingPattern
+SyntaxKind[Identifier](248,34): Initializer
+SyntaxKind[QuestionToken](248,45): ?
+SyntaxKind[LineTerminatorToken](249,1): «line terminator»
+SyntaxKind[DedentToken](249,1): «dedent»
+SyntaxKind[LineTerminatorToken](250,1): «line terminator»
+SyntaxKind[Identifier](250,1): ArrayBindingPattern
+SyntaxKind[ColonToken](250,21): :
+SyntaxKind[LineTerminatorToken](251,1): «line terminator»
+SyntaxKind[IndentToken](251,1): «indent»
+SyntaxKind[Terminal](251,2): `[`
+SyntaxKind[Identifier](251,6): Elision
+SyntaxKind[QuestionToken](251,13): ?
+SyntaxKind[Identifier](251,15): BindingRestElement
+SyntaxKind[QuestionToken](251,33): ?
+SyntaxKind[Terminal](251,35): `]`
+SyntaxKind[LineTerminatorToken](252,1): «line terminator»
+SyntaxKind[Terminal](252,2): `[`
+SyntaxKind[Identifier](252,6): BindingElementList
+SyntaxKind[Terminal](252,25): `]`
+SyntaxKind[LineTerminatorToken](253,1): «line terminator»
+SyntaxKind[Terminal](253,2): `[`
+SyntaxKind[Identifier](253,6): BindingElementList
+SyntaxKind[Terminal](253,25): `,`
+SyntaxKind[Identifier](253,29): Elision
+SyntaxKind[QuestionToken](253,36): ?
+SyntaxKind[Identifier](253,38): BindingRestElement
+SyntaxKind[QuestionToken](253,56): ?
+SyntaxKind[Terminal](253,58): `]`
+SyntaxKind[LineTerminatorToken](254,1): «line terminator»
+SyntaxKind[DedentToken](254,1): «dedent»
+SyntaxKind[LineTerminatorToken](255,1): «line terminator»
+SyntaxKind[Identifier](255,1): BindingElementList
+SyntaxKind[ColonToken](255,20): :
+SyntaxKind[LineTerminatorToken](256,1): «line terminator»
+SyntaxKind[IndentToken](256,1): «indent»
+SyntaxKind[Identifier](256,2): Elision
+SyntaxKind[QuestionToken](256,9): ?
+SyntaxKind[Identifier](256,11): BindingElement
+SyntaxKind[LineTerminatorToken](257,1): «line terminator»
+SyntaxKind[Identifier](257,2): BindingElementList
+SyntaxKind[Terminal](257,21): `,`
+SyntaxKind[Identifier](257,25): Elision
+SyntaxKind[QuestionToken](257,32): ?
+SyntaxKind[Identifier](257,34): BindingElement
+SyntaxKind[LineTerminatorToken](258,1): «line terminator»
+SyntaxKind[DedentToken](258,1): «dedent»
+SyntaxKind[LineTerminatorToken](259,1): «line terminator»
+SyntaxKind[Identifier](259,1): BindingElement
+SyntaxKind[ColonToken](259,16): :
+SyntaxKind[LineTerminatorToken](260,1): «line terminator»
+SyntaxKind[IndentToken](260,1): «indent»
+SyntaxKind[Identifier](260,2): Identifier
+SyntaxKind[Identifier](260,13): Initializer
+SyntaxKind[QuestionToken](260,24): ?
+SyntaxKind[LineTerminatorToken](261,1): «line terminator»
+SyntaxKind[Identifier](261,2): BindingPattern
+SyntaxKind[Identifier](261,17): Initializer
+SyntaxKind[QuestionToken](261,28): ?
+SyntaxKind[LineTerminatorToken](262,1): «line terminator»
+SyntaxKind[DedentToken](262,1): «dedent»
+SyntaxKind[LineTerminatorToken](263,1): «line terminator»
+SyntaxKind[Identifier](263,1): BindingRestElement
+SyntaxKind[ColonToken](263,20): :
+SyntaxKind[LineTerminatorToken](264,1): «line terminator»
+SyntaxKind[IndentToken](264,1): «indent»
+SyntaxKind[Terminal](264,2): `...`
+SyntaxKind[Identifier](264,8): Identifier
+SyntaxKind[LineTerminatorToken](265,1): «line terminator»
+SyntaxKind[DedentToken](265,1): «dedent»
+SyntaxKind[LineTerminatorToken](266,1): «line terminator»
+SyntaxKind[LineTerminatorToken](267,1): «line terminator»
+SyntaxKind[Identifier](267,1): FunctionDeclaration
+SyntaxKind[ColonToken](267,21): :
+SyntaxKind[LineTerminatorToken](268,1): «line terminator»
+SyntaxKind[IndentToken](268,1): «indent»
+SyntaxKind[Identifier](268,2): FunctionOverloads
+SyntaxKind[QuestionToken](268,19): ?
+SyntaxKind[Identifier](268,21): FunctionImplementation
+SyntaxKind[LineTerminatorToken](269,1): «line terminator»
+SyntaxKind[DedentToken](269,1): «dedent»
+SyntaxKind[LineTerminatorToken](270,1): «line terminator»
+SyntaxKind[Identifier](270,1): FunctionOverloads
+SyntaxKind[ColonToken](270,19): :
+SyntaxKind[LineTerminatorToken](271,1): «line terminator»
+SyntaxKind[IndentToken](271,1): «indent»
+SyntaxKind[Identifier](271,2): FunctionOverload
+SyntaxKind[LineTerminatorToken](272,1): «line terminator»
+SyntaxKind[Identifier](272,2): FunctionOverloads
+SyntaxKind[Identifier](272,20): FunctionOverload
+SyntaxKind[LineTerminatorToken](273,1): «line terminator»
+SyntaxKind[DedentToken](273,1): «dedent»
+SyntaxKind[LineTerminatorToken](274,1): «line terminator»
+SyntaxKind[Identifier](274,1): FunctionOverload
+SyntaxKind[ColonToken](274,18): :
+SyntaxKind[LineTerminatorToken](275,1): «line terminator»
+SyntaxKind[IndentToken](275,1): «indent»
+SyntaxKind[Terminal](275,2): `function`
+SyntaxKind[Identifier](275,13): Identifier
+SyntaxKind[Identifier](275,24): CallSignature
+SyntaxKind[Terminal](275,38): `;`
+SyntaxKind[LineTerminatorToken](276,1): «line terminator»
+SyntaxKind[DedentToken](276,1): «dedent»
+SyntaxKind[LineTerminatorToken](277,1): «line terminator»
+SyntaxKind[Identifier](277,1): FunctionImplementation
+SyntaxKind[ColonToken](277,24): :
+SyntaxKind[LineTerminatorToken](278,1): «line terminator»
+SyntaxKind[IndentToken](278,1): «indent»
+SyntaxKind[Terminal](278,2): `function`
+SyntaxKind[Identifier](278,13): Identifier
+SyntaxKind[Identifier](278,24): CallSignature
+SyntaxKind[Terminal](278,38): `{`
+SyntaxKind[Identifier](278,42): FunctionBody
+SyntaxKind[Terminal](278,55): `}`
+SyntaxKind[LineTerminatorToken](279,1): «line terminator»
+SyntaxKind[DedentToken](279,1): «dedent»
+SyntaxKind[LineTerminatorToken](280,1): «line terminator»
+SyntaxKind[LineTerminatorToken](281,1): «line terminator»
+SyntaxKind[Identifier](281,1): InterfaceDeclaration
+SyntaxKind[ColonToken](281,22): :
+SyntaxKind[LineTerminatorToken](282,1): «line terminator»
+SyntaxKind[IndentToken](282,1): «indent»
+SyntaxKind[Terminal](282,2): `interface`
+SyntaxKind[Identifier](282,14): Identifier
+SyntaxKind[Identifier](282,25): TypeParameters
+SyntaxKind[QuestionToken](282,39): ?
+SyntaxKind[Identifier](282,41): InterfaceExtendsClause
+SyntaxKind[QuestionToken](282,63): ?
+SyntaxKind[Identifier](282,65): ObjectType
+SyntaxKind[LineTerminatorToken](283,1): «line terminator»
+SyntaxKind[DedentToken](283,1): «dedent»
+SyntaxKind[LineTerminatorToken](284,1): «line terminator»
+SyntaxKind[Identifier](284,1): InterfaceExtendsClause
+SyntaxKind[ColonToken](284,24): :
+SyntaxKind[LineTerminatorToken](285,1): «line terminator»
+SyntaxKind[IndentToken](285,1): «indent»
+SyntaxKind[Terminal](285,2): `extends`
+SyntaxKind[Identifier](285,12): ClassOrInterfaceTypeList
+SyntaxKind[LineTerminatorToken](286,1): «line terminator»
+SyntaxKind[DedentToken](286,1): «dedent»
+SyntaxKind[LineTerminatorToken](287,1): «line terminator»
+SyntaxKind[Identifier](287,1): ClassOrInterfaceTypeList
+SyntaxKind[ColonToken](287,26): :
+SyntaxKind[LineTerminatorToken](288,1): «line terminator»
+SyntaxKind[IndentToken](288,1): «indent»
+SyntaxKind[Identifier](288,2): ClassOrInterfaceType
+SyntaxKind[LineTerminatorToken](289,1): «line terminator»
+SyntaxKind[Identifier](289,2): ClassOrInterfaceTypeList
+SyntaxKind[Terminal](289,27): `,`
+SyntaxKind[Identifier](289,31): ClassOrInterfaceType
+SyntaxKind[LineTerminatorToken](290,1): «line terminator»
+SyntaxKind[DedentToken](290,1): «dedent»
+SyntaxKind[LineTerminatorToken](291,1): «line terminator»
+SyntaxKind[Identifier](291,1): ClassOrInterfaceType
+SyntaxKind[ColonToken](291,22): :
+SyntaxKind[LineTerminatorToken](292,1): «line terminator»
+SyntaxKind[IndentToken](292,1): «indent»
+SyntaxKind[Identifier](292,2): TypeReference
+SyntaxKind[LineTerminatorToken](293,1): «line terminator»
+SyntaxKind[DedentToken](293,1): «dedent»
+SyntaxKind[LineTerminatorToken](294,1): «line terminator»
+SyntaxKind[LineTerminatorToken](295,1): «line terminator»
+SyntaxKind[Identifier](295,1): ClassDeclaration
+SyntaxKind[ColonToken](295,18): :
+SyntaxKind[LineTerminatorToken](296,1): «line terminator»
+SyntaxKind[IndentToken](296,1): «indent»
+SyntaxKind[Terminal](296,2): `class`
+SyntaxKind[Identifier](296,10): Identifier
+SyntaxKind[Identifier](296,21): TypeParameters
+SyntaxKind[QuestionToken](296,35): ?
+SyntaxKind[Identifier](296,37): ClassHeritage
+SyntaxKind[Terminal](296,51): `{`
+SyntaxKind[Identifier](296,55): ClassBody
+SyntaxKind[Terminal](296,65): `}`
+SyntaxKind[LineTerminatorToken](297,1): «line terminator»
+SyntaxKind[DedentToken](297,1): «dedent»
+SyntaxKind[LineTerminatorToken](298,1): «line terminator»
+SyntaxKind[Identifier](298,1): ClassHeritage
+SyntaxKind[ColonToken](298,15): :
+SyntaxKind[LineTerminatorToken](299,1): «line terminator»
+SyntaxKind[IndentToken](299,1): «indent»
+SyntaxKind[Identifier](299,2): ClassExtendsClause
+SyntaxKind[QuestionToken](299,20): ?
+SyntaxKind[Identifier](299,22): ImplementsClause
+SyntaxKind[QuestionToken](299,38): ?
+SyntaxKind[LineTerminatorToken](300,1): «line terminator»
+SyntaxKind[DedentToken](300,1): «dedent»
+SyntaxKind[LineTerminatorToken](301,1): «line terminator»
+SyntaxKind[Identifier](301,1): ClassExtendsClause
+SyntaxKind[ColonToken](301,20): :
+SyntaxKind[LineTerminatorToken](302,1): «line terminator»
+SyntaxKind[IndentToken](302,1): «indent»
+SyntaxKind[Terminal](302,2): `extends`
+SyntaxKind[Identifier](302,13): ClassType
+SyntaxKind[LineTerminatorToken](303,1): «line terminator»
+SyntaxKind[DedentToken](303,1): «dedent»
+SyntaxKind[LineTerminatorToken](304,1): «line terminator»
+SyntaxKind[Identifier](304,1): ClassType
+SyntaxKind[ColonToken](304,11): :
+SyntaxKind[LineTerminatorToken](305,1): «line terminator»
+SyntaxKind[IndentToken](305,1): «indent»
+SyntaxKind[Identifier](305,2): TypeReference
+SyntaxKind[LineTerminatorToken](306,1): «line terminator»
+SyntaxKind[DedentToken](306,1): «dedent»
+SyntaxKind[LineTerminatorToken](307,1): «line terminator»
+SyntaxKind[Identifier](307,1): ImplementsClause
+SyntaxKind[ColonToken](307,18): :
+SyntaxKind[LineTerminatorToken](308,1): «line terminator»
+SyntaxKind[IndentToken](308,1): «indent»
+SyntaxKind[Terminal](308,2): `implements`
+SyntaxKind[Identifier](308,15): ClassOrInterfaceTypeList
+SyntaxKind[LineTerminatorToken](309,1): «line terminator»
+SyntaxKind[DedentToken](309,1): «dedent»
+SyntaxKind[LineTerminatorToken](310,1): «line terminator»
+SyntaxKind[Identifier](310,1): ClassBody
+SyntaxKind[ColonToken](310,11): :
+SyntaxKind[LineTerminatorToken](311,1): «line terminator»
+SyntaxKind[IndentToken](311,1): «indent»
+SyntaxKind[Identifier](311,2): ClassElements
+SyntaxKind[QuestionToken](311,15): ?
+SyntaxKind[LineTerminatorToken](312,1): «line terminator»
+SyntaxKind[DedentToken](312,1): «dedent»
+SyntaxKind[LineTerminatorToken](313,1): «line terminator»
+SyntaxKind[Identifier](313,1): ClassElements
+SyntaxKind[ColonToken](313,14): :
+SyntaxKind[LineTerminatorToken](314,1): «line terminator»
+SyntaxKind[IndentToken](314,1): «indent»
+SyntaxKind[Identifier](314,2): ClassElement
+SyntaxKind[LineTerminatorToken](315,1): «line terminator»
+SyntaxKind[Identifier](315,2): ClassElements
+SyntaxKind[Identifier](315,16): ClassElement
+SyntaxKind[LineTerminatorToken](316,1): «line terminator»
+SyntaxKind[DedentToken](316,1): «dedent»
+SyntaxKind[LineTerminatorToken](317,1): «line terminator»
+SyntaxKind[Identifier](317,1): ClassElement
+SyntaxKind[ColonToken](317,13): :
+SyntaxKind[LineTerminatorToken](318,1): «line terminator»
+SyntaxKind[IndentToken](318,1): «indent»
+SyntaxKind[Identifier](318,2): ConstructorDeclaration
+SyntaxKind[LineTerminatorToken](319,1): «line terminator»
+SyntaxKind[Identifier](319,2): PropertyMemberDeclaration
+SyntaxKind[LineTerminatorToken](320,1): «line terminator»
+SyntaxKind[Identifier](320,2): IndexMemberDeclaration
+SyntaxKind[LineTerminatorToken](321,1): «line terminator»
+SyntaxKind[DedentToken](321,1): «dedent»
+SyntaxKind[LineTerminatorToken](322,1): «line terminator»
+SyntaxKind[Identifier](322,1): ConstructorDeclaration
+SyntaxKind[ColonToken](322,23): :
+SyntaxKind[LineTerminatorToken](323,1): «line terminator»
+SyntaxKind[IndentToken](323,1): «indent»
+SyntaxKind[Identifier](323,2): ConstructorOverloads
+SyntaxKind[QuestionToken](323,22): ?
+SyntaxKind[Identifier](323,24): ConstructorImplementation
+SyntaxKind[LineTerminatorToken](324,1): «line terminator»
+SyntaxKind[DedentToken](324,1): «dedent»
+SyntaxKind[LineTerminatorToken](325,1): «line terminator»
+SyntaxKind[Identifier](325,1): ConstructorOverloads
+SyntaxKind[ColonToken](325,21): :
+SyntaxKind[LineTerminatorToken](326,1): «line terminator»
+SyntaxKind[IndentToken](326,1): «indent»
+SyntaxKind[Identifier](326,2): ConstructorOverload
+SyntaxKind[LineTerminatorToken](327,1): «line terminator»
+SyntaxKind[Identifier](327,2): ConstructorOverloads
+SyntaxKind[Identifier](327,23): ConstructorOverload
+SyntaxKind[LineTerminatorToken](328,1): «line terminator»
+SyntaxKind[DedentToken](328,1): «dedent»
+SyntaxKind[LineTerminatorToken](329,1): «line terminator»
+SyntaxKind[Identifier](329,1): ConstructorOverload
+SyntaxKind[ColonToken](329,20): :
+SyntaxKind[LineTerminatorToken](330,1): «line terminator»
+SyntaxKind[IndentToken](330,1): «indent»
+SyntaxKind[Identifier](330,2): AccessibilityModifier
+SyntaxKind[QuestionToken](330,23): ?
+SyntaxKind[Terminal](330,25): `constructor`
+SyntaxKind[Terminal](330,39): `(`
+SyntaxKind[Identifier](330,43): ParameterList
+SyntaxKind[QuestionToken](330,56): ?
+SyntaxKind[Terminal](330,58): `)`
+SyntaxKind[Terminal](330,62): `;`
+SyntaxKind[LineTerminatorToken](331,1): «line terminator»
+SyntaxKind[DedentToken](331,1): «dedent»
+SyntaxKind[LineTerminatorToken](332,1): «line terminator»
+SyntaxKind[Identifier](332,1): ConstructorImplementation
+SyntaxKind[ColonToken](332,26): :
+SyntaxKind[LineTerminatorToken](333,1): «line terminator»
+SyntaxKind[IndentToken](333,1): «indent»
+SyntaxKind[Identifier](333,2): AccessibilityModifier
+SyntaxKind[QuestionToken](333,23): ?
+SyntaxKind[Terminal](333,25): `constructor`
+SyntaxKind[Terminal](333,39): `(`
+SyntaxKind[Identifier](333,43): ParameterList
+SyntaxKind[QuestionToken](333,56): ?
+SyntaxKind[Terminal](333,58): `)`
+SyntaxKind[Terminal](333,62): `{`
+SyntaxKind[Identifier](333,66): FunctionBody
+SyntaxKind[Terminal](333,79): `}`
+SyntaxKind[LineTerminatorToken](334,1): «line terminator»
+SyntaxKind[DedentToken](334,1): «dedent»
+SyntaxKind[LineTerminatorToken](335,1): «line terminator»
+SyntaxKind[Identifier](335,1): PropertyMemberDeclaration
+SyntaxKind[ColonToken](335,26): :
+SyntaxKind[LineTerminatorToken](336,1): «line terminator»
+SyntaxKind[IndentToken](336,1): «indent»
+SyntaxKind[Identifier](336,2): MemberVariableDeclaration
+SyntaxKind[LineTerminatorToken](337,1): «line terminator»
+SyntaxKind[Identifier](337,2): MemberFunctionDeclaration
+SyntaxKind[LineTerminatorToken](338,1): «line terminator»
+SyntaxKind[Identifier](338,2): MemberAccessorDeclaration
+SyntaxKind[LineTerminatorToken](339,1): «line terminator»
+SyntaxKind[DedentToken](339,1): «dedent»
+SyntaxKind[LineTerminatorToken](340,1): «line terminator»
+SyntaxKind[Identifier](340,1): MemberVariableDeclaration
+SyntaxKind[ColonToken](340,26): :
+SyntaxKind[LineTerminatorToken](341,1): «line terminator»
+SyntaxKind[IndentToken](341,1): «indent»
+SyntaxKind[Identifier](341,2): AccessibilityModifier
+SyntaxKind[QuestionToken](341,23): ?
+SyntaxKind[Terminal](341,25): `static`
+SyntaxKind[QuestionToken](341,33): ?
+SyntaxKind[Identifier](341,35): PropertyName
+SyntaxKind[Identifier](341,48): TypeAnnotation
+SyntaxKind[QuestionToken](341,62): ?
+SyntaxKind[Identifier](341,64): Initializer
+SyntaxKind[QuestionToken](341,75): ?
+SyntaxKind[Terminal](341,77): `;`
+SyntaxKind[LineTerminatorToken](342,1): «line terminator»
+SyntaxKind[DedentToken](342,1): «dedent»
+SyntaxKind[LineTerminatorToken](343,1): «line terminator»
+SyntaxKind[Identifier](343,1): MemberFunctionDeclaration
+SyntaxKind[ColonToken](343,26): :
+SyntaxKind[LineTerminatorToken](344,1): «line terminator»
+SyntaxKind[IndentToken](344,1): «indent»
+SyntaxKind[Identifier](344,2): MemberFunctionOverloads
+SyntaxKind[QuestionToken](344,25): ?
+SyntaxKind[Identifier](344,27): MemberFunctionImplementation
+SyntaxKind[LineTerminatorToken](345,1): «line terminator»
+SyntaxKind[DedentToken](345,1): «dedent»
+SyntaxKind[LineTerminatorToken](346,1): «line terminator»
+SyntaxKind[Identifier](346,1): MemberFunctionOverloads
+SyntaxKind[ColonToken](346,24): :
+SyntaxKind[LineTerminatorToken](347,1): «line terminator»
+SyntaxKind[IndentToken](347,1): «indent»
+SyntaxKind[Identifier](347,2): MemberFunctionOverload
+SyntaxKind[LineTerminatorToken](348,1): «line terminator»
+SyntaxKind[Identifier](348,2): MemberFunctionOverloads
+SyntaxKind[Identifier](348,26): MemberFunctionOverload
+SyntaxKind[LineTerminatorToken](349,1): «line terminator»
+SyntaxKind[DedentToken](349,1): «dedent»
+SyntaxKind[LineTerminatorToken](350,1): «line terminator»
+SyntaxKind[Identifier](350,1): MemberFunctionOverload
+SyntaxKind[ColonToken](350,23): :
+SyntaxKind[LineTerminatorToken](351,1): «line terminator»
+SyntaxKind[IndentToken](351,1): «indent»
+SyntaxKind[Identifier](351,2): AccessibilityModifier
+SyntaxKind[QuestionToken](351,23): ?
+SyntaxKind[Terminal](351,25): `static`
+SyntaxKind[QuestionToken](351,33): ?
+SyntaxKind[Identifier](351,35): PropertyName
+SyntaxKind[Identifier](351,48): CallSignature
+SyntaxKind[Terminal](351,62): `;`
+SyntaxKind[LineTerminatorToken](352,1): «line terminator»
+SyntaxKind[DedentToken](352,1): «dedent»
+SyntaxKind[LineTerminatorToken](353,1): «line terminator»
+SyntaxKind[Identifier](353,1): MemberFunctionImplementation
+SyntaxKind[ColonToken](353,29): :
+SyntaxKind[LineTerminatorToken](354,1): «line terminator»
+SyntaxKind[IndentToken](354,1): «indent»
+SyntaxKind[Identifier](354,2): AccessibilityModifier
+SyntaxKind[QuestionToken](354,23): ?
+SyntaxKind[Terminal](354,25): `static`
+SyntaxKind[QuestionToken](354,33): ?
+SyntaxKind[Identifier](354,35): PropertyName
+SyntaxKind[Identifier](354,48): CallSignature
+SyntaxKind[Terminal](354,62): `{`
+SyntaxKind[Identifier](354,66): FunctionBody
+SyntaxKind[Terminal](354,79): `}`
+SyntaxKind[LineTerminatorToken](355,1): «line terminator»
+SyntaxKind[DedentToken](355,1): «dedent»
+SyntaxKind[LineTerminatorToken](356,1): «line terminator»
+SyntaxKind[Identifier](356,1): MemberAccessorDeclaration
+SyntaxKind[ColonToken](356,26): :
+SyntaxKind[LineTerminatorToken](357,1): «line terminator»
+SyntaxKind[IndentToken](357,1): «indent»
+SyntaxKind[Identifier](357,2): AccessibilityModifier
+SyntaxKind[QuestionToken](357,23): ?
+SyntaxKind[Terminal](357,25): `static`
+SyntaxKind[QuestionToken](357,33): ?
+SyntaxKind[Identifier](357,35): GetAccessor
+SyntaxKind[LineTerminatorToken](358,1): «line terminator»
+SyntaxKind[Identifier](358,2): AccessibilityModifier
+SyntaxKind[QuestionToken](358,23): ?
+SyntaxKind[Terminal](358,25): `static`
+SyntaxKind[QuestionToken](358,33): ?
+SyntaxKind[Identifier](358,35): SetAccessor
+SyntaxKind[LineTerminatorToken](359,1): «line terminator»
+SyntaxKind[DedentToken](359,1): «dedent»
+SyntaxKind[LineTerminatorToken](360,1): «line terminator»
+SyntaxKind[Identifier](360,1): IndexMemberDeclaration
+SyntaxKind[ColonToken](360,23): :
+SyntaxKind[LineTerminatorToken](361,1): «line terminator»
+SyntaxKind[IndentToken](361,1): «indent»
+SyntaxKind[Identifier](361,2): IndexSignature
+SyntaxKind[Terminal](361,17): `;`
+SyntaxKind[LineTerminatorToken](362,1): «line terminator»
+SyntaxKind[DedentToken](362,1): «dedent»
+SyntaxKind[LineTerminatorToken](363,1): «line terminator»
+SyntaxKind[LineTerminatorToken](364,1): «line terminator»
+SyntaxKind[Identifier](364,1): EnumDeclaration
+SyntaxKind[ColonToken](364,16): :
+SyntaxKind[LineTerminatorToken](365,1): «line terminator»
+SyntaxKind[IndentToken](365,1): «indent»
+SyntaxKind[Terminal](365,2): `const`
+SyntaxKind[QuestionToken](365,9): ?
+SyntaxKind[Terminal](365,11): `enum`
+SyntaxKind[Identifier](365,18): Identifier
+SyntaxKind[Terminal](365,29): `{`
+SyntaxKind[Identifier](365,33): EnumBody
+SyntaxKind[QuestionToken](365,41): ?
+SyntaxKind[Terminal](365,43): `}`
+SyntaxKind[LineTerminatorToken](366,1): «line terminator»
+SyntaxKind[DedentToken](366,1): «dedent»
+SyntaxKind[LineTerminatorToken](367,1): «line terminator»
+SyntaxKind[Identifier](367,1): EnumBody
+SyntaxKind[ColonToken](367,9): :
+SyntaxKind[LineTerminatorToken](368,1): «line terminator»
+SyntaxKind[IndentToken](368,1): «indent»
+SyntaxKind[Identifier](368,2): EnumMemberList
+SyntaxKind[Terminal](368,17): `,`
+SyntaxKind[QuestionToken](368,20): ?
+SyntaxKind[LineTerminatorToken](369,1): «line terminator»
+SyntaxKind[DedentToken](369,1): «dedent»
+SyntaxKind[LineTerminatorToken](370,1): «line terminator»
+SyntaxKind[Identifier](370,1): EnumMemberList
+SyntaxKind[ColonToken](370,15): :
+SyntaxKind[LineTerminatorToken](371,1): «line terminator»
+SyntaxKind[IndentToken](371,1): «indent»
+SyntaxKind[Identifier](371,2): EnumMember
+SyntaxKind[LineTerminatorToken](372,1): «line terminator»
+SyntaxKind[Identifier](372,2): EnumMemberList
+SyntaxKind[Terminal](372,17): `,`
+SyntaxKind[Identifier](372,21): EnumMember
+SyntaxKind[LineTerminatorToken](373,1): «line terminator»
+SyntaxKind[DedentToken](373,1): «dedent»
+SyntaxKind[LineTerminatorToken](374,1): «line terminator»
+SyntaxKind[Identifier](374,1): EnumMember
+SyntaxKind[ColonToken](374,11): :
+SyntaxKind[LineTerminatorToken](375,1): «line terminator»
+SyntaxKind[IndentToken](375,1): «indent»
+SyntaxKind[Identifier](375,2): PropertyName
+SyntaxKind[LineTerminatorToken](376,1): «line terminator»
+SyntaxKind[Identifier](376,2): PropertyName
+SyntaxKind[Terminal](376,15): `=`
+SyntaxKind[Identifier](376,19): EnumValue
+SyntaxKind[LineTerminatorToken](377,1): «line terminator»
+SyntaxKind[DedentToken](377,1): «dedent»
+SyntaxKind[LineTerminatorToken](378,1): «line terminator»
+SyntaxKind[Identifier](378,1): EnumValue
+SyntaxKind[ColonToken](378,10): :
+SyntaxKind[LineTerminatorToken](379,1): «line terminator»
+SyntaxKind[IndentToken](379,1): «indent»
+SyntaxKind[Identifier](379,2): AssignmentExpression
+SyntaxKind[LineTerminatorToken](380,1): «line terminator»
+SyntaxKind[DedentToken](380,1): «dedent»
+SyntaxKind[LineTerminatorToken](381,1): «line terminator»
+SyntaxKind[LineTerminatorToken](382,1): «line terminator»
+SyntaxKind[Identifier](382,1): ModuleDeclaration
+SyntaxKind[ColonToken](382,18): :
+SyntaxKind[LineTerminatorToken](383,1): «line terminator»
+SyntaxKind[IndentToken](383,1): «indent»
+SyntaxKind[Terminal](383,2): `module`
+SyntaxKind[Identifier](383,11): IdentifierPath
+SyntaxKind[Terminal](383,26): `{`
+SyntaxKind[Identifier](383,30): ModuleBody
+SyntaxKind[Terminal](383,41): `}`
+SyntaxKind[LineTerminatorToken](384,1): «line terminator»
+SyntaxKind[DedentToken](384,1): «dedent»
+SyntaxKind[LineTerminatorToken](385,1): «line terminator»
+SyntaxKind[Identifier](385,1): IdentifierPath
+SyntaxKind[ColonToken](385,15): :
+SyntaxKind[LineTerminatorToken](386,1): «line terminator»
+SyntaxKind[IndentToken](386,1): «indent»
+SyntaxKind[Identifier](386,2): Identifier
+SyntaxKind[LineTerminatorToken](387,1): «line terminator»
+SyntaxKind[Identifier](387,2): IdentifierPath
+SyntaxKind[Terminal](387,17): `.`
+SyntaxKind[Identifier](387,21): Identifier
+SyntaxKind[LineTerminatorToken](388,1): «line terminator»
+SyntaxKind[DedentToken](388,1): «dedent»
+SyntaxKind[LineTerminatorToken](389,1): «line terminator»
+SyntaxKind[Identifier](389,1): ModuleBody
+SyntaxKind[ColonToken](389,11): :
+SyntaxKind[LineTerminatorToken](390,1): «line terminator»
+SyntaxKind[IndentToken](390,1): «indent»
+SyntaxKind[Identifier](390,2): ModuleElements
+SyntaxKind[QuestionToken](390,16): ?
+SyntaxKind[LineTerminatorToken](391,1): «line terminator»
+SyntaxKind[DedentToken](391,1): «dedent»
+SyntaxKind[LineTerminatorToken](392,1): «line terminator»
+SyntaxKind[Identifier](392,1): ModuleElements
+SyntaxKind[ColonToken](392,15): :
+SyntaxKind[LineTerminatorToken](393,1): «line terminator»
+SyntaxKind[IndentToken](393,1): «indent»
+SyntaxKind[Identifier](393,2): ModuleElement
+SyntaxKind[LineTerminatorToken](394,1): «line terminator»
+SyntaxKind[Identifier](394,2): ModuleElements
+SyntaxKind[Identifier](394,17): ModuleElement
+SyntaxKind[LineTerminatorToken](395,1): «line terminator»
+SyntaxKind[DedentToken](395,1): «dedent»
+SyntaxKind[LineTerminatorToken](396,1): «line terminator»
+SyntaxKind[Identifier](396,1): ModuleElement
+SyntaxKind[ColonToken](396,14): :
+SyntaxKind[LineTerminatorToken](397,1): «line terminator»
+SyntaxKind[IndentToken](397,1): «indent»
+SyntaxKind[Identifier](397,2): Statement
+SyntaxKind[LineTerminatorToken](398,1): «line terminator»
+SyntaxKind[Terminal](398,2): `export`
+SyntaxKind[QuestionToken](398,10): ?
+SyntaxKind[Identifier](398,12): VariableDeclaration
+SyntaxKind[LineTerminatorToken](399,1): «line terminator»
+SyntaxKind[Terminal](399,2): `export`
+SyntaxKind[QuestionToken](399,10): ?
+SyntaxKind[Identifier](399,12): FunctionDeclaration
+SyntaxKind[LineTerminatorToken](400,1): «line terminator»
+SyntaxKind[Terminal](400,2): `export`
+SyntaxKind[QuestionToken](400,10): ?
+SyntaxKind[Identifier](400,12): ClassDeclaration
+SyntaxKind[LineTerminatorToken](401,1): «line terminator»
+SyntaxKind[Terminal](401,2): `export`
+SyntaxKind[QuestionToken](401,10): ?
+SyntaxKind[Identifier](401,12): InterfaceDeclaration
+SyntaxKind[LineTerminatorToken](402,1): «line terminator»
+SyntaxKind[Terminal](402,2): `export`
+SyntaxKind[QuestionToken](402,10): ?
+SyntaxKind[Identifier](402,12): TypeAliasDeclaration
+SyntaxKind[LineTerminatorToken](403,1): «line terminator»
+SyntaxKind[Terminal](403,2): `export`
+SyntaxKind[QuestionToken](403,10): ?
+SyntaxKind[Identifier](403,12): EnumDeclaration
+SyntaxKind[LineTerminatorToken](404,1): «line terminator»
+SyntaxKind[Terminal](404,2): `export`
+SyntaxKind[QuestionToken](404,10): ?
+SyntaxKind[Identifier](404,12): ModuleDeclaration
+SyntaxKind[LineTerminatorToken](405,1): «line terminator»
+SyntaxKind[Terminal](405,2): `export`
+SyntaxKind[QuestionToken](405,10): ?
+SyntaxKind[Identifier](405,12): ImportDeclaration
+SyntaxKind[LineTerminatorToken](406,1): «line terminator»
+SyntaxKind[Terminal](406,2): `export`
+SyntaxKind[QuestionToken](406,10): ?
+SyntaxKind[Identifier](406,12): AmbientDeclaration
+SyntaxKind[LineTerminatorToken](407,1): «line terminator»
+SyntaxKind[DedentToken](407,1): «dedent»
+SyntaxKind[LineTerminatorToken](408,1): «line terminator»
+SyntaxKind[Identifier](408,1): ImportDeclaration
+SyntaxKind[ColonToken](408,18): :
+SyntaxKind[LineTerminatorToken](409,1): «line terminator»
+SyntaxKind[IndentToken](409,1): «indent»
+SyntaxKind[Terminal](409,2): `import`
+SyntaxKind[Identifier](409,11): Identifier
+SyntaxKind[Terminal](409,22): `=`
+SyntaxKind[Identifier](409,26): EntityName
+SyntaxKind[Terminal](409,37): `;`
+SyntaxKind[LineTerminatorToken](410,1): «line terminator»
+SyntaxKind[DedentToken](410,1): «dedent»
+SyntaxKind[LineTerminatorToken](411,1): «line terminator»
+SyntaxKind[Identifier](411,1): EntityName
+SyntaxKind[ColonToken](411,11): :
+SyntaxKind[LineTerminatorToken](412,1): «line terminator»
+SyntaxKind[IndentToken](412,1): «indent»
+SyntaxKind[Identifier](412,2): ModuleName
+SyntaxKind[LineTerminatorToken](413,1): «line terminator»
+SyntaxKind[Identifier](413,2): ModuleName
+SyntaxKind[Terminal](413,13): `.`
+SyntaxKind[Identifier](413,17): Identifier
+SyntaxKind[LineTerminatorToken](414,1): «line terminator»
+SyntaxKind[DedentToken](414,1): «dedent»
+SyntaxKind[LineTerminatorToken](415,1): «line terminator»
+SyntaxKind[LineTerminatorToken](416,1): «line terminator»
+SyntaxKind[Identifier](416,1): SourceFile
+SyntaxKind[ColonToken](416,11): :
+SyntaxKind[LineTerminatorToken](417,1): «line terminator»
+SyntaxKind[IndentToken](417,1): «indent»
+SyntaxKind[Identifier](417,2): ImplementationSourceFile
+SyntaxKind[LineTerminatorToken](418,1): «line terminator»
+SyntaxKind[Identifier](418,2): DeclarationSourceFile
+SyntaxKind[LineTerminatorToken](419,1): «line terminator»
+SyntaxKind[DedentToken](419,1): «dedent»
+SyntaxKind[LineTerminatorToken](420,1): «line terminator»
+SyntaxKind[Identifier](420,1): ImplementationSourceFile
+SyntaxKind[ColonToken](420,25): :
+SyntaxKind[LineTerminatorToken](421,1): «line terminator»
+SyntaxKind[IndentToken](421,1): «indent»
+SyntaxKind[Identifier](421,2): ImplementationElements
+SyntaxKind[QuestionToken](421,24): ?
+SyntaxKind[LineTerminatorToken](422,1): «line terminator»
+SyntaxKind[DedentToken](422,1): «dedent»
+SyntaxKind[LineTerminatorToken](423,1): «line terminator»
+SyntaxKind[Identifier](423,1): ImplementationElements
+SyntaxKind[ColonToken](423,23): :
+SyntaxKind[LineTerminatorToken](424,1): «line terminator»
+SyntaxKind[IndentToken](424,1): «indent»
+SyntaxKind[Identifier](424,2): ImplementationElement
+SyntaxKind[LineTerminatorToken](425,1): «line terminator»
+SyntaxKind[Identifier](425,2): ImplementationElements
+SyntaxKind[Identifier](425,25): ImplementationElement
+SyntaxKind[LineTerminatorToken](426,1): «line terminator»
+SyntaxKind[DedentToken](426,1): «dedent»
+SyntaxKind[LineTerminatorToken](427,1): «line terminator»
+SyntaxKind[Identifier](427,1): ImplementationElement
+SyntaxKind[ColonToken](427,22): :
+SyntaxKind[LineTerminatorToken](428,1): «line terminator»
+SyntaxKind[IndentToken](428,1): «indent»
+SyntaxKind[Identifier](428,2): ModuleElement
+SyntaxKind[LineTerminatorToken](429,1): «line terminator»
+SyntaxKind[Identifier](429,2): ExportAssignment
+SyntaxKind[LineTerminatorToken](430,1): «line terminator»
+SyntaxKind[Identifier](430,2): AmbientExternalModuleDeclaration
+SyntaxKind[LineTerminatorToken](431,1): «line terminator»
+SyntaxKind[Terminal](431,2): `export`
+SyntaxKind[QuestionToken](431,10): ?
+SyntaxKind[Identifier](431,12): ExternalImportDeclaration
+SyntaxKind[LineTerminatorToken](432,1): «line terminator»
+SyntaxKind[DedentToken](432,1): «dedent»
+SyntaxKind[LineTerminatorToken](433,1): «line terminator»
+SyntaxKind[Identifier](433,1): DeclarationSourceFile
+SyntaxKind[ColonToken](433,22): :
+SyntaxKind[LineTerminatorToken](434,1): «line terminator»
+SyntaxKind[IndentToken](434,1): «indent»
+SyntaxKind[Identifier](434,2): DeclarationElements
+SyntaxKind[QuestionToken](434,21): ?
+SyntaxKind[LineTerminatorToken](435,1): «line terminator»
+SyntaxKind[DedentToken](435,1): «dedent»
+SyntaxKind[LineTerminatorToken](436,1): «line terminator»
+SyntaxKind[Identifier](436,1): DeclarationElements
+SyntaxKind[ColonToken](436,20): :
+SyntaxKind[LineTerminatorToken](437,1): «line terminator»
+SyntaxKind[IndentToken](437,1): «indent»
+SyntaxKind[Identifier](437,2): DeclarationElement
+SyntaxKind[LineTerminatorToken](438,1): «line terminator»
+SyntaxKind[Identifier](438,2): DeclarationElements
+SyntaxKind[Identifier](438,22): DeclarationElement
+SyntaxKind[LineTerminatorToken](439,1): «line terminator»
+SyntaxKind[DedentToken](439,1): «dedent»
+SyntaxKind[LineTerminatorToken](440,1): «line terminator»
+SyntaxKind[Identifier](440,1): DeclarationElement
+SyntaxKind[ColonToken](440,19): :
+SyntaxKind[LineTerminatorToken](441,1): «line terminator»
+SyntaxKind[IndentToken](441,1): «indent»
+SyntaxKind[Identifier](441,2): ExportAssignment
+SyntaxKind[LineTerminatorToken](442,1): «line terminator»
+SyntaxKind[Identifier](442,2): AmbientExternalModuleDeclaration
+SyntaxKind[LineTerminatorToken](443,1): «line terminator»
+SyntaxKind[Terminal](443,2): `export`
+SyntaxKind[QuestionToken](443,10): ?
+SyntaxKind[Identifier](443,12): InterfaceDeclaration
+SyntaxKind[LineTerminatorToken](444,1): «line terminator»
+SyntaxKind[Terminal](444,2): `export`
+SyntaxKind[QuestionToken](444,10): ?
+SyntaxKind[Identifier](444,12): TypeAliasDeclaration
+SyntaxKind[LineTerminatorToken](445,1): «line terminator»
+SyntaxKind[Terminal](445,2): `export`
+SyntaxKind[QuestionToken](445,10): ?
+SyntaxKind[Identifier](445,12): ImportDeclaration
+SyntaxKind[LineTerminatorToken](446,1): «line terminator»
+SyntaxKind[Terminal](446,2): `export`
+SyntaxKind[QuestionToken](446,10): ?
+SyntaxKind[Identifier](446,12): AmbientDeclaration
+SyntaxKind[LineTerminatorToken](447,1): «line terminator»
+SyntaxKind[Terminal](447,2): `export`
+SyntaxKind[QuestionToken](447,10): ?
+SyntaxKind[Identifier](447,12): ExternalImportDeclaration
+SyntaxKind[LineTerminatorToken](448,1): «line terminator»
+SyntaxKind[DedentToken](448,1): «dedent»
+SyntaxKind[LineTerminatorToken](449,1): «line terminator»
+SyntaxKind[Identifier](449,1): ExternalImportDeclaration
+SyntaxKind[ColonToken](449,26): :
+SyntaxKind[LineTerminatorToken](450,1): «line terminator»
+SyntaxKind[IndentToken](450,1): «indent»
+SyntaxKind[Terminal](450,2): `import`
+SyntaxKind[Identifier](450,11): Identifier
+SyntaxKind[Terminal](450,22): `=`
+SyntaxKind[Identifier](450,26): ExternalModuleReference
+SyntaxKind[Terminal](450,50): `;`
+SyntaxKind[LineTerminatorToken](451,1): «line terminator»
+SyntaxKind[DedentToken](451,1): «dedent»
+SyntaxKind[LineTerminatorToken](452,1): «line terminator»
+SyntaxKind[Identifier](452,1): ExternalModuleReference
+SyntaxKind[ColonToken](452,24): :
+SyntaxKind[LineTerminatorToken](453,1): «line terminator»
+SyntaxKind[IndentToken](453,1): «indent»
+SyntaxKind[Terminal](453,2): `require`
+SyntaxKind[Terminal](453,12): `(`
+SyntaxKind[Identifier](453,16): StringLiteral
+SyntaxKind[Terminal](453,30): `)`
+SyntaxKind[LineTerminatorToken](454,1): «line terminator»
+SyntaxKind[DedentToken](454,1): «dedent»
+SyntaxKind[LineTerminatorToken](455,1): «line terminator»
+SyntaxKind[Identifier](455,1): ExportAssignment
+SyntaxKind[ColonToken](455,17): :
+SyntaxKind[LineTerminatorToken](456,1): «line terminator»
+SyntaxKind[IndentToken](456,1): «indent»
+SyntaxKind[Terminal](456,2): `export`
+SyntaxKind[Terminal](456,11): `=`
+SyntaxKind[Identifier](456,15): Identifier
+SyntaxKind[Terminal](456,26): `;`
+SyntaxKind[LineTerminatorToken](457,1): «line terminator»
+SyntaxKind[DedentToken](457,1): «dedent»
+SyntaxKind[LineTerminatorToken](458,1): «line terminator»
+SyntaxKind[LineTerminatorToken](459,1): «line terminator»
+SyntaxKind[Identifier](459,1): AmbientDeclaration
+SyntaxKind[ColonToken](459,19): :
+SyntaxKind[LineTerminatorToken](460,1): «line terminator»
+SyntaxKind[IndentToken](460,1): «indent»
+SyntaxKind[Terminal](460,2): `declare`
+SyntaxKind[Identifier](460,12): AmbientVariableDeclaration
+SyntaxKind[LineTerminatorToken](461,1): «line terminator»
+SyntaxKind[Terminal](461,2): `declare`
+SyntaxKind[Identifier](461,12): AmbientFunctionDeclaration
+SyntaxKind[LineTerminatorToken](462,1): «line terminator»
+SyntaxKind[Terminal](462,2): `declare`
+SyntaxKind[Identifier](462,12): AmbientClassDeclaration
+SyntaxKind[LineTerminatorToken](463,1): «line terminator»
+SyntaxKind[Terminal](463,2): `declare`
+SyntaxKind[Identifier](463,12): AmbientEnumDeclaration
+SyntaxKind[LineTerminatorToken](464,1): «line terminator»
+SyntaxKind[Terminal](464,2): `declare`
+SyntaxKind[Identifier](464,12): AmbientModuleDeclaration
+SyntaxKind[LineTerminatorToken](465,1): «line terminator»
+SyntaxKind[DedentToken](465,1): «dedent»
+SyntaxKind[LineTerminatorToken](466,1): «line terminator»
+SyntaxKind[Identifier](466,1): AmbientVariableDeclaration
+SyntaxKind[ColonToken](466,27): :
+SyntaxKind[LineTerminatorToken](467,1): «line terminator»
+SyntaxKind[IndentToken](467,1): «indent»
+SyntaxKind[Terminal](467,2): `var`
+SyntaxKind[Identifier](467,8): Identifier
+SyntaxKind[Identifier](467,19): TypeAnnotation
+SyntaxKind[QuestionToken](467,33): ?
+SyntaxKind[Terminal](467,35): `;`
+SyntaxKind[LineTerminatorToken](468,1): «line terminator»
+SyntaxKind[DedentToken](468,1): «dedent»
+SyntaxKind[LineTerminatorToken](469,1): «line terminator»
+SyntaxKind[Identifier](469,1): AmbientFunctionDeclaration
+SyntaxKind[ColonToken](469,27): :
+SyntaxKind[LineTerminatorToken](470,1): «line terminator»
+SyntaxKind[IndentToken](470,1): «indent»
+SyntaxKind[Terminal](470,2): `function`
+SyntaxKind[Identifier](470,13): Identifier
+SyntaxKind[Identifier](470,24): CallSignature
+SyntaxKind[Terminal](470,38): `;`
+SyntaxKind[LineTerminatorToken](471,1): «line terminator»
+SyntaxKind[DedentToken](471,1): «dedent»
+SyntaxKind[LineTerminatorToken](472,1): «line terminator»
+SyntaxKind[Identifier](472,1): AmbientClassDeclaration
+SyntaxKind[ColonToken](472,24): :
+SyntaxKind[LineTerminatorToken](473,1): «line terminator»
+SyntaxKind[IndentToken](473,1): «indent»
+SyntaxKind[Terminal](473,2): `class`
+SyntaxKind[Identifier](473,10): Identifier
+SyntaxKind[Identifier](473,21): TypeParameters
+SyntaxKind[QuestionToken](473,35): ?
+SyntaxKind[Identifier](473,37): ClassHeritage
+SyntaxKind[Terminal](473,51): `{`
+SyntaxKind[Identifier](473,55): AmbientClassBody
+SyntaxKind[Terminal](473,72): `}`
+SyntaxKind[LineTerminatorToken](474,1): «line terminator»
+SyntaxKind[DedentToken](474,1): «dedent»
+SyntaxKind[LineTerminatorToken](475,1): «line terminator»
+SyntaxKind[Identifier](475,1): AmbientClassBody
+SyntaxKind[ColonToken](475,17): :
+SyntaxKind[LineTerminatorToken](476,1): «line terminator»
+SyntaxKind[IndentToken](476,1): «indent»
+SyntaxKind[Identifier](476,2): AmbientClassBodyElements
+SyntaxKind[QuestionToken](476,26): ?
+SyntaxKind[LineTerminatorToken](477,1): «line terminator»
+SyntaxKind[DedentToken](477,1): «dedent»
+SyntaxKind[LineTerminatorToken](478,1): «line terminator»
+SyntaxKind[Identifier](478,1): AmbientClassBodyElements
+SyntaxKind[ColonToken](478,25): :
+SyntaxKind[LineTerminatorToken](479,1): «line terminator»
+SyntaxKind[IndentToken](479,1): «indent»
+SyntaxKind[Identifier](479,2): AmbientClassBodyElement
+SyntaxKind[LineTerminatorToken](480,1): «line terminator»
+SyntaxKind[Identifier](480,2): AmbientClassBodyElements
+SyntaxKind[Identifier](480,27): AmbientClassBodyElement
+SyntaxKind[LineTerminatorToken](481,1): «line terminator»
+SyntaxKind[DedentToken](481,1): «dedent»
+SyntaxKind[LineTerminatorToken](482,1): «line terminator»
+SyntaxKind[Identifier](482,1): AmbientClassBodyElement
+SyntaxKind[ColonToken](482,24): :
+SyntaxKind[LineTerminatorToken](483,1): «line terminator»
+SyntaxKind[IndentToken](483,1): «indent»
+SyntaxKind[Identifier](483,2): AmbientConstructorDeclaration
+SyntaxKind[LineTerminatorToken](484,1): «line terminator»
+SyntaxKind[Identifier](484,2): AmbientPropertyMemberDeclaration
+SyntaxKind[LineTerminatorToken](485,1): «line terminator»
+SyntaxKind[Identifier](485,2): IndexSignature
+SyntaxKind[LineTerminatorToken](486,1): «line terminator»
+SyntaxKind[DedentToken](486,1): «dedent»
+SyntaxKind[LineTerminatorToken](487,1): «line terminator»
+SyntaxKind[Identifier](487,1): AmbientConstructorDeclaration
+SyntaxKind[ColonToken](487,30): :
+SyntaxKind[LineTerminatorToken](488,1): «line terminator»
+SyntaxKind[IndentToken](488,1): «indent»
+SyntaxKind[Terminal](488,2): `constructor`
+SyntaxKind[Terminal](488,16): `(`
+SyntaxKind[Identifier](488,20): ParameterList
+SyntaxKind[QuestionToken](488,33): ?
+SyntaxKind[Terminal](488,35): `)`
+SyntaxKind[Terminal](488,39): `;`
+SyntaxKind[LineTerminatorToken](489,1): «line terminator»
+SyntaxKind[DedentToken](489,1): «dedent»
+SyntaxKind[LineTerminatorToken](490,1): «line terminator»
+SyntaxKind[Identifier](490,1): AmbientPropertyMemberDeclaration
+SyntaxKind[ColonToken](490,33): :
+SyntaxKind[LineTerminatorToken](491,1): «line terminator»
+SyntaxKind[IndentToken](491,1): «indent»
+SyntaxKind[Identifier](491,2): AccessibilityModifier
+SyntaxKind[QuestionToken](491,23): ?
+SyntaxKind[Terminal](491,25): `static`
+SyntaxKind[QuestionToken](491,33): ?
+SyntaxKind[Identifier](491,35): PropertyName
+SyntaxKind[Identifier](491,48): TypeAnnotation
+SyntaxKind[QuestionToken](491,62): ?
+SyntaxKind[Terminal](491,64): `;`
+SyntaxKind[LineTerminatorToken](492,1): «line terminator»
+SyntaxKind[Identifier](492,2): AccessibilityModifier
+SyntaxKind[QuestionToken](492,23): ?
+SyntaxKind[Terminal](492,25): `static`
+SyntaxKind[QuestionToken](492,33): ?
+SyntaxKind[Identifier](492,35): PropertyName
+SyntaxKind[Identifier](492,48): CallSignature
+SyntaxKind[Terminal](492,62): `;`
+SyntaxKind[LineTerminatorToken](493,1): «line terminator»
+SyntaxKind[DedentToken](493,1): «dedent»
+SyntaxKind[LineTerminatorToken](494,1): «line terminator»
+SyntaxKind[Identifier](494,1): AmbientEnumDeclaration
+SyntaxKind[ColonToken](494,23): :
+SyntaxKind[LineTerminatorToken](495,1): «line terminator»
+SyntaxKind[IndentToken](495,1): «indent»
+SyntaxKind[Identifier](495,2): EnumDeclaration
+SyntaxKind[LineTerminatorToken](496,1): «line terminator»
+SyntaxKind[DedentToken](496,1): «dedent»
+SyntaxKind[LineTerminatorToken](497,1): «line terminator»
+SyntaxKind[Identifier](497,1): AmbientModuleDeclaration
+SyntaxKind[ColonToken](497,25): :
+SyntaxKind[LineTerminatorToken](498,1): «line terminator»
+SyntaxKind[IndentToken](498,1): «indent»
+SyntaxKind[Terminal](498,2): `module`
+SyntaxKind[Identifier](498,11): IdentifierPath
+SyntaxKind[Terminal](498,26): `{`
+SyntaxKind[Identifier](498,30): AmbientModuleBody
+SyntaxKind[Terminal](498,48): `}`
+SyntaxKind[LineTerminatorToken](499,1): «line terminator»
+SyntaxKind[DedentToken](499,1): «dedent»
+SyntaxKind[LineTerminatorToken](500,1): «line terminator»
+SyntaxKind[Identifier](500,1): AmbientModuleBody
+SyntaxKind[ColonToken](500,18): :
+SyntaxKind[LineTerminatorToken](501,1): «line terminator»
+SyntaxKind[IndentToken](501,1): «indent»
+SyntaxKind[Identifier](501,2): AmbientModuleElements
+SyntaxKind[QuestionToken](501,23): ?
+SyntaxKind[LineTerminatorToken](502,1): «line terminator»
+SyntaxKind[DedentToken](502,1): «dedent»
+SyntaxKind[LineTerminatorToken](503,1): «line terminator»
+SyntaxKind[Identifier](503,1): AmbientModuleElements
+SyntaxKind[ColonToken](503,22): :
+SyntaxKind[LineTerminatorToken](504,1): «line terminator»
+SyntaxKind[IndentToken](504,1): «indent»
+SyntaxKind[Identifier](504,2): AmbientModuleElement
+SyntaxKind[LineTerminatorToken](505,1): «line terminator»
+SyntaxKind[Identifier](505,2): AmbientModuleElements
+SyntaxKind[Identifier](505,24): AmbientModuleElement
+SyntaxKind[LineTerminatorToken](506,1): «line terminator»
+SyntaxKind[DedentToken](506,1): «dedent»
+SyntaxKind[LineTerminatorToken](507,1): «line terminator»
+SyntaxKind[Identifier](507,1): AmbientModuleElement
+SyntaxKind[ColonToken](507,21): :
+SyntaxKind[LineTerminatorToken](508,1): «line terminator»
+SyntaxKind[IndentToken](508,1): «indent»
+SyntaxKind[Terminal](508,2): `export`
+SyntaxKind[QuestionToken](508,10): ?
+SyntaxKind[Identifier](508,12): AmbientVariableDeclaration
+SyntaxKind[LineTerminatorToken](509,1): «line terminator»
+SyntaxKind[Terminal](509,2): `export`
+SyntaxKind[QuestionToken](509,10): ?
+SyntaxKind[Identifier](509,12): AmbientFunctionDeclaration
+SyntaxKind[LineTerminatorToken](510,1): «line terminator»
+SyntaxKind[Terminal](510,2): `export`
+SyntaxKind[QuestionToken](510,10): ?
+SyntaxKind[Identifier](510,12): AmbientClassDeclaration
+SyntaxKind[LineTerminatorToken](511,1): «line terminator»
+SyntaxKind[Terminal](511,2): `export`
+SyntaxKind[QuestionToken](511,10): ?
+SyntaxKind[Identifier](511,12): InterfaceDeclaration
+SyntaxKind[LineTerminatorToken](512,1): «line terminator»
+SyntaxKind[Terminal](512,2): `export`
+SyntaxKind[QuestionToken](512,10): ?
+SyntaxKind[Identifier](512,12): AmbientEnumDeclaration
+SyntaxKind[LineTerminatorToken](513,1): «line terminator»
+SyntaxKind[Terminal](513,2): `export`
+SyntaxKind[QuestionToken](513,10): ?
+SyntaxKind[Identifier](513,12): AmbientModuleDeclaration
+SyntaxKind[LineTerminatorToken](514,1): «line terminator»
+SyntaxKind[Terminal](514,2): `export`
+SyntaxKind[QuestionToken](514,10): ?
+SyntaxKind[Identifier](514,12): ImportDeclaration
+SyntaxKind[LineTerminatorToken](515,1): «line terminator»
+SyntaxKind[DedentToken](515,1): «dedent»
+SyntaxKind[LineTerminatorToken](516,1): «line terminator»
+SyntaxKind[Identifier](516,1): AmbientExternalModuleDeclaration
+SyntaxKind[ColonToken](516,33): :
+SyntaxKind[LineTerminatorToken](517,1): «line terminator»
+SyntaxKind[IndentToken](517,1): «indent»
+SyntaxKind[Terminal](517,2): `declare`
+SyntaxKind[Terminal](517,12): `module`
+SyntaxKind[Identifier](517,21): StringLiteral
+SyntaxKind[Terminal](517,35): `{`
+SyntaxKind[Identifier](517,39): AmbientExternalModuleBody
+SyntaxKind[Terminal](517,65): `}`
+SyntaxKind[LineTerminatorToken](518,1): «line terminator»
+SyntaxKind[DedentToken](518,1): «dedent»
+SyntaxKind[LineTerminatorToken](519,1): «line terminator»
+SyntaxKind[Identifier](519,1): AmbientExternalModuleBody
+SyntaxKind[ColonToken](519,26): :
+SyntaxKind[LineTerminatorToken](520,1): «line terminator»
+SyntaxKind[IndentToken](520,1): «indent»
+SyntaxKind[Identifier](520,2): AmbientExternalModuleElements
+SyntaxKind[QuestionToken](520,31): ?
+SyntaxKind[LineTerminatorToken](521,1): «line terminator»
+SyntaxKind[DedentToken](521,1): «dedent»
+SyntaxKind[LineTerminatorToken](522,1): «line terminator»
+SyntaxKind[Identifier](522,1): AmbientExternalModuleElements
+SyntaxKind[ColonToken](522,30): :
+SyntaxKind[LineTerminatorToken](523,1): «line terminator»
+SyntaxKind[IndentToken](523,1): «indent»
+SyntaxKind[Identifier](523,2): AmbientExternalModuleElement
+SyntaxKind[LineTerminatorToken](524,1): «line terminator»
+SyntaxKind[Identifier](524,2): AmbientExternalModuleElements
+SyntaxKind[Identifier](524,32): AmbientExternalModuleElement
+SyntaxKind[LineTerminatorToken](525,1): «line terminator»
+SyntaxKind[DedentToken](525,1): «dedent»
+SyntaxKind[LineTerminatorToken](526,1): «line terminator»
+SyntaxKind[Identifier](526,1): AmbientExternalModuleElement
+SyntaxKind[ColonToken](526,29): :
+SyntaxKind[LineTerminatorToken](527,1): «line terminator»
+SyntaxKind[IndentToken](527,1): «indent»
+SyntaxKind[Identifier](527,2): AmbientModuleElement
+SyntaxKind[LineTerminatorToken](528,1): «line terminator»
+SyntaxKind[Identifier](528,2): ExportAssignment
+SyntaxKind[LineTerminatorToken](529,1): «line terminator»
+SyntaxKind[Terminal](529,2): `export`
+SyntaxKind[QuestionToken](529,10): ?
+SyntaxKind[Identifier](529,12): ExternalImportDeclaration
+SyntaxKind[LineTerminatorToken](530,1): «line terminator»
+SyntaxKind[DedentToken](530,1): «dedent»
+SyntaxKind[EndOfFileToken](530,1): «EndOfFileToken»