From fdd114355478099f84df7af39adb912e0aa58a11 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Wed, 8 Jun 2016 14:47:21 -0700 Subject: [PATCH] Fix issue with .gitignore, make operator token required for arguments in strict mode. --- .gitignore | 5 +- package.json | 2 +- src/lib/checker.ts | 4 + .../baselines/reference/es6.grammar.emu.html | 1994 +++++ tests/baselines/reference/es6.grammar.md | 974 ++ tests/baselines/reference/es6.grammar.nodes | 7939 +++++++++++++++++ tests/baselines/reference/es6.grammar.tokens | 5593 ++++++++++++ .../reference/grammarkdown.grammar.emu.html | 393 + .../reference/grammarkdown.grammar.md | 234 + .../reference/grammarkdown.grammar.nodes | 989 ++ .../reference/grammarkdown.grammar.tokens | 774 ++ .../reference/test.grammar.diagnostics | 11 + .../baselines/reference/test.grammar.emu.html | 40 + tests/baselines/reference/test.grammar.md | 23 + tests/baselines/reference/test.grammar.nodes | 163 + tests/baselines/reference/test.grammar.tokens | 111 + .../reference/typescript.grammar.emu.html | 1164 +++ .../baselines/reference/typescript.grammar.md | 515 ++ .../reference/typescript.grammar.nodes | 2614 ++++++ .../reference/typescript.grammar.tokens | 1792 ++++ 20 files changed, 25331 insertions(+), 3 deletions(-) create mode 100644 tests/baselines/reference/es6.grammar.emu.html create mode 100644 tests/baselines/reference/es6.grammar.md create mode 100644 tests/baselines/reference/es6.grammar.nodes create mode 100644 tests/baselines/reference/es6.grammar.tokens create mode 100644 tests/baselines/reference/grammarkdown.grammar.emu.html create mode 100644 tests/baselines/reference/grammarkdown.grammar.md create mode 100644 tests/baselines/reference/grammarkdown.grammar.nodes create mode 100644 tests/baselines/reference/grammarkdown.grammar.tokens create mode 100644 tests/baselines/reference/test.grammar.diagnostics create mode 100644 tests/baselines/reference/test.grammar.emu.html create mode 100644 tests/baselines/reference/test.grammar.md create mode 100644 tests/baselines/reference/test.grammar.nodes create mode 100644 tests/baselines/reference/test.grammar.tokens create mode 100644 tests/baselines/reference/typescript.grammar.emu.html create mode 100644 tests/baselines/reference/typescript.grammar.md create mode 100644 tests/baselines/reference/typescript.grammar.nodes create mode 100644 tests/baselines/reference/typescript.grammar.tokens 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»