parser_tables.py

from jsparagus import runtime
from jsparagus.runtime import Nt, ErrorToken

actions = [
    # 0. <empty>
    #       InitNt(goal=Nt('Script')) ::= · Script
    {'var': 2, ';': 3, 'if': 4, 'continue': 5, 'break': 6, 'return': 7, 'with': 8, 'throw': 9, 'try': 10, 'debugger': 11, 'class': 12, '{': 13, 'do': 14, 'while': 15, 'for': 16, 'switch': 17, 'Name': 18, 'NameWithEscape': 18, 'let': 19, 'static': 18, 'implements': 18, 'interface': 18, 'package': 18, 'private': 18, 'protected': 18, 'public': 18, 'as': 18, 'async': 20, 'from': 18, 'get': 18, 'of': 18, 'set': 18, 'target': 18, 'function': 21, 'const': 22, 'yield': 23, 'new': 24, 'await': 25, '(': 26, 'super': 27, 'import': 28, 'this': 29, 'RegularExpressionLiteral': 30, 'NullLiteral': 31, 'BooleanLiteral': 32, 'NumericLiteral': 33, 'BigIntLiteral': 34, 'StringLiteral': 35, '[': 36, 'NoSubstitutionTemplate': 37, 'TemplateHead': 38, 'delete': 39, 'void': 40, 'typeof': 41, '+': 42, '-': 43, '~': 44, '!': 45, '++': 46, '--': 47, None: -1},

    # 1. <empty>
    #       InitNt(goal=Nt('Module')) ::= · Module
    {'import': 123, 'export': 124, 'var': 2, ';': 3, 'if': 4, 'continue': 5, 'break': 6, 'return': 7, 'with': 8, 'throw': 9, 'try': 10, 'debugger': 11, 'class': 12, '{': 13, 'do': 14, 'while': 15, 'for': 16, 'switch': 17, 'Name': 18, 'NameWithEscape': 18, 'let': 19, 'static': 18, 'implements': 18, 'interface': 18, 'package': 18, 'private': 18, 'protected': 18, 'public': 18, 'as': 18, 'async': 20, 'from': 18, 'get': 18, 'of': 18, 'set': 18, 'target': 18, 'function': 21, 'const': 22, 'yield': 23, 'new': 24, 'await': 25, '(': 26, 'super': 27, 'this': 29, 'RegularExpressionLiteral': 30, 'NullLiteral': 31, 'BooleanLiteral': 32, 'NumericLiteral': 33, 'BigIntLiteral': 34, 'StringLiteral': 35, '[': 36, 'NoSubstitutionTemplate': 37, 'TemplateHead': 38, 'delete': 39, 'void': 40, 'typeof': 41, '+': 42, '-': 43, '~': 44, '!': 45, '++': 46, '--': 47, None: -3},

    # 2. "var"
    #       VariableStatement ::= "var" · VariableDeclarationList[+In] ";"
    #       VariableStatement ::= "var" · VariableDeclarationList[+In] ErrorSymbol(asi)
    {'Name': 132, 'NameWithEscape': 132, 'let': 132, 'static': 132, 'implements': 132, 'interface': 132, 'package': 132, 'private': 132, 'protected': 132, 'public': 132, 'as': 132, 'async': 132, 'from': 132, 'get': 132, 'of': 132, 'set': 132, 'target': 132, 'yield': 133, 'await': 134, '{': 135, '[': 136},

    # 3. ";"
    #       EmptyStatement ::= ";" ·
    {None: -52, '{': -52, 'var': -52, ';': -52, 'delete': -52, 'void': -52, 'typeof': -52, '+': -52, '-': -52, '~': -52, '!': -52, '++': -52, '--': -52, 'yield': -52, 'Name': -52, 'NameWithEscape': -52, 'let': -52, 'static': -52, 'implements': -52, 'interface': -52, 'package': -52, 'private': -52, 'protected': -52, 'public': -52, 'as': -52, 'async': -52, 'from': -52, 'get': -52, 'of': -52, 'set': -52, 'target': -52, 'await': -52, '(': -52, 'this': -52, 'NullLiteral': -52, 'BooleanLiteral': -52, 'NumericLiteral': -52, 'BigIntLiteral': -52, 'StringLiteral': -52, '[': -52, 'RegularExpressionLiteral': -52, 'NoSubstitutionTemplate': -52, 'TemplateHead': -52, 'new': -52, 'super': -52, 'import': -52, 'if': -52, 'do': -52, 'while': -52, 'for': -52, 'switch': -52, 'continue': -52, 'break': -52, 'return': -52, 'with': -52, 'throw': -52, 'try': -52, 'debugger': -52, 'function': -52, 'class': -52, 'const': -52, 'export': -52, '}': -52, 'else': -52, 'case': -52, 'default': -52},

    # 4. "if"
    #       IfStatement ::= "if" · "(" Expression[+In] ")" Statement "else" Statement
    #       IfStatement ::= "if" · "(" Expression[+In] ")" Statement
    #       IfStatement ::= "if" · "(" Expression[+In] ")" FunctionDeclaration[~Default] "else" Statement
    #       IfStatement ::= "if" · "(" Expression[+In] ")" Statement "else" FunctionDeclaration[~Default]
    #       IfStatement ::= "if" · "(" Expression[+In] ")" FunctionDeclaration[~Default] "else" FunctionDeclaration[~Default]
    #       IfStatement ::= "if" · "(" Expression[+In] ")" FunctionDeclaration[~Default]
    {'(': 143},

    # 5. "continue"
    #       ContinueStatement ::= "continue" · ";"
    #       ContinueStatement ::= "continue" · ErrorSymbol(asi)
    #       ContinueStatement ::= "continue" · NoLineTerminatorHere LabelIdentifier ";"
    #       ContinueStatement ::= "continue" · NoLineTerminatorHere LabelIdentifier ErrorSymbol(asi)
    {';': 144, ErrorToken: 145, 'Name': -9223372036854775808, 'NameWithEscape': -9223372036854775808, 'let': -9223372036854775808, 'static': -9223372036854775808, 'implements': -9223372036854775808, 'interface': -9223372036854775808, 'package': -9223372036854775808, 'private': -9223372036854775808, 'protected': -9223372036854775808, 'public': -9223372036854775808, 'as': -9223372036854775808, 'async': -9223372036854775808, 'from': -9223372036854775808, 'get': -9223372036854775808, 'of': -9223372036854775808, 'set': -9223372036854775808, 'target': -9223372036854775808},

    # 6. "break"
    #       BreakStatement ::= "break" · ";"
    #       BreakStatement ::= "break" · ErrorSymbol(asi)
    #       BreakStatement ::= "break" · NoLineTerminatorHere LabelIdentifier ";"
    #       BreakStatement ::= "break" · NoLineTerminatorHere LabelIdentifier ErrorSymbol(asi)
    {';': 148, ErrorToken: 149, 'Name': -9223372036854775808, 'NameWithEscape': -9223372036854775808, 'let': -9223372036854775808, 'static': -9223372036854775808, 'implements': -9223372036854775808, 'interface': -9223372036854775808, 'package': -9223372036854775808, 'private': -9223372036854775808, 'protected': -9223372036854775808, 'public': -9223372036854775808, 'as': -9223372036854775808, 'async': -9223372036854775808, 'from': -9223372036854775808, 'get': -9223372036854775808, 'of': -9223372036854775808, 'set': -9223372036854775808, 'target': -9223372036854775808},

    # 7. "return"
    #       ReturnStatement ::= "return" · ";"
    #       ReturnStatement ::= "return" · ErrorSymbol(asi)
    #       ReturnStatement ::= "return" · NoLineTerminatorHere Expression[+In] ";"
    #       ReturnStatement ::= "return" · NoLineTerminatorHere Expression[+In] ErrorSymbol(asi)
    {';': 151, ErrorToken: 152, 'yield': -9223372036854775807, 'async': -9223372036854775806, 'new': -9223372036854775805, 'Name': -9223372036854775804, 'NameWithEscape': -9223372036854775804, 'let': -9223372036854775804, 'static': -9223372036854775804, 'implements': -9223372036854775804, 'interface': -9223372036854775804, 'package': -9223372036854775804, 'private': -9223372036854775804, 'protected': -9223372036854775804, 'public': -9223372036854775804, 'as': -9223372036854775804, 'from': -9223372036854775804, 'get': -9223372036854775804, 'of': -9223372036854775804, 'set': -9223372036854775804, 'target': -9223372036854775804, 'await': -9223372036854775803, '(': -9223372036854775802, 'super': -9223372036854775801, 'import': -9223372036854775800, 'this': -9223372036854775799, 'RegularExpressionLiteral': -9223372036854775798, 'NullLiteral': -9223372036854775797, 'BooleanLiteral': -9223372036854775796, 'NumericLiteral': -9223372036854775795, 'BigIntLiteral': -9223372036854775794, 'StringLiteral': -9223372036854775793, '[': -9223372036854775792, '{': -9223372036854775791, 'function': -9223372036854775790, 'class': -9223372036854775789, 'NoSubstitutionTemplate': -9223372036854775788, 'TemplateHead': -9223372036854775787, 'delete': -9223372036854775786, 'void': -9223372036854775785, 'typeof': -9223372036854775784, '+': -9223372036854775783, '-': -9223372036854775782, '~': -9223372036854775781, '!': -9223372036854775780, '++': -9223372036854775779, '--': -9223372036854775778},

    # 8. "with"
    #       WithStatement ::= "with" · "(" Expression[+In] ")" Statement
    {'(': 165},

    # 9. "throw"
    #       ThrowStatement ::= "throw" · NoLineTerminatorHere Expression[+In] ";"
    #       ThrowStatement ::= "throw" · NoLineTerminatorHere Expression[+In] ErrorSymbol(asi)
    {'yield': -9223372036854775807, 'async': -9223372036854775806, 'new': -9223372036854775805, 'Name': -9223372036854775804, 'NameWithEscape': -9223372036854775804, 'let': -9223372036854775804, 'static': -9223372036854775804, 'implements': -9223372036854775804, 'interface': -9223372036854775804, 'package': -9223372036854775804, 'private': -9223372036854775804, 'protected': -9223372036854775804, 'public': -9223372036854775804, 'as': -9223372036854775804, 'from': -9223372036854775804, 'get': -9223372036854775804, 'of': -9223372036854775804, 'set': -9223372036854775804, 'target': -9223372036854775804, 'await': -9223372036854775803, '(': -9223372036854775802, 'super': -9223372036854775801, 'import': -9223372036854775800, 'this': -9223372036854775799, 'RegularExpressionLiteral': -9223372036854775798, 'NullLiteral': -9223372036854775797, 'BooleanLiteral': -9223372036854775796, 'NumericLiteral': -9223372036854775795, 'BigIntLiteral': -9223372036854775794, 'StringLiteral': -9223372036854775793, '[': -9223372036854775792, '{': -9223372036854775791, 'function': -9223372036854775790, 'class': -9223372036854775789, 'NoSubstitutionTemplate': -9223372036854775788, 'TemplateHead': -9223372036854775787, 'delete': -9223372036854775786, 'void': -9223372036854775785, 'typeof': -9223372036854775784, '+': -9223372036854775783, '-': -9223372036854775782, '~': -9223372036854775781, '!': -9223372036854775780, '++': -9223372036854775779, '--': -9223372036854775778},

    # 10. "try"
    #       TryStatement ::= "try" · Block Catch
    #       TryStatement ::= "try" · Block Finally
    #       TryStatement ::= "try" · Block Catch Finally
    {'{': 13},

    # 11. "debugger"
    #       DebuggerStatement ::= "debugger" · ";"
    #       DebuggerStatement ::= "debugger" · ErrorSymbol(asi)
    {';': 168, ErrorToken: 169},

    # 12. "class"
    #       ClassDeclaration[~Default] ::= "class" · BindingIdentifier ClassTail
    {'Name': 132, 'NameWithEscape': 132, 'let': 132, 'static': 132, 'implements': 132, 'interface': 132, 'package': 132, 'private': 132, 'protected': 132, 'public': 132, 'as': 132, 'async': 132, 'from': 132, 'get': 132, 'of': 132, 'set': 132, 'target': 132, 'yield': 133, 'await': 134},

    # 13. "{"
    #       Block ::= "{" · "}"
    #       Block ::= "{" · StatementList "}"
    {'}': 171, 'var': 2, ';': 3, 'if': 4, 'continue': 5, 'break': 6, 'return': 7, 'with': 8, 'throw': 9, 'try': 10, 'debugger': 11, 'class': 12, '{': 13, 'do': 14, 'while': 15, 'for': 16, 'switch': 17, 'Name': 18, 'NameWithEscape': 18, 'let': 19, 'static': 18, 'implements': 18, 'interface': 18, 'package': 18, 'private': 18, 'protected': 18, 'public': 18, 'as': 18, 'async': 20, 'from': 18, 'get': 18, 'of': 18, 'set': 18, 'target': 18, 'function': 21, 'const': 22, 'yield': 23, 'new': 24, 'await': 25, '(': 26, 'super': 27, 'import': 28, 'this': 29, 'RegularExpressionLiteral': 30, 'NullLiteral': 31, 'BooleanLiteral': 32, 'NumericLiteral': 33, 'BigIntLiteral': 34, 'StringLiteral': 35, '[': 36, 'NoSubstitutionTemplate': 37, 'TemplateHead': 38, 'delete': 39, 'void': 40, 'typeof': 41, '+': 42, '-': 43, '~': 44, '!': 45, '++': 46, '--': 47},

    # 14. "do"
    #       IterationStatement ::= "do" · Statement "while" "(" Expression[+In] ")" ";"
    #       IterationStatement ::= "do" · Statement "while" "(" Expression[+In] ")" ErrorSymbol(do_while_asi)
    {'var': 2, ';': 3, 'if': 4, 'continue': 5, 'break': 6, 'return': 7, 'with': 8, 'throw': 9, 'try': 10, 'debugger': 11, '{': 13, 'do': 14, 'while': 15, 'for': 16, 'switch': 17, 'Name': 18, 'NameWithEscape': 18, 'let': 146, 'static': 18, 'implements': 18, 'interface': 18, 'package': 18, 'private': 18, 'protected': 18, 'public': 18, 'as': 18, 'async': 146, 'from': 18, 'get': 18, 'of': 18, 'set': 18, 'target': 18, 'yield': 23, 'new': 24, 'await': 25, '(': 26, 'super': 27, 'import': 28, 'this': 29, 'RegularExpressionLiteral': 30, 'NullLiteral': 31, 'BooleanLiteral': 32, 'NumericLiteral': 33, 'BigIntLiteral': 34, 'StringLiteral': 35, '[': 36, 'NoSubstitutionTemplate': 37, 'TemplateHead': 38, 'delete': 39, 'void': 40, 'typeof': 41, '+': 42, '-': 43, '~': 44, '!': 45, '++': 46, '--': 47},

    # 15. "while"
    #       IterationStatement ::= "while" · "(" Expression[+In] ")" Statement
    {'(': 174},

    # 16. "for"
    #       IterationStatement ::= "for" · "(" [lookahead != 'let'] ";" ";" ")" Statement
    #       IterationStatement ::= "for" · "(" [lookahead != 'let'] Expression[~In] ";" ";" ")" Statement
    #       IterationStatement ::= "for" · "(" [lookahead != 'let'] ";" Expression[+In] ";" ")" Statement
    #       IterationStatement ::= "for" · "(" [lookahead != 'let'] Expression[~In] ";" Expression[+In] ";" ")" Statement
    #       IterationStatement ::= "for" · "(" [lookahead != 'let'] ";" ";" Expression[+In] ")" Statement
    #       IterationStatement ::= "for" · "(" [lookahead != 'let'] Expression[~In] ";" ";" Expression[+In] ")" Statement
    #       IterationStatement ::= "for" · "(" [lookahead != 'let'] ";" Expression[+In] ";" Expression[+In] ")" Statement
    #       IterationStatement ::= "for" · "(" [lookahead != 'let'] Expression[~In] ";" Expression[+In] ";" Expression[+In] ")" Statement
    #       IterationStatement ::= "for" · "(" "var" VariableDeclarationList[~In] ";" ";" ")" Statement
    #       IterationStatement ::= "for" · "(" "var" VariableDeclarationList[~In] ";" Expression[+In] ";" ")" Statement
    #       IterationStatement ::= "for" · "(" "var" VariableDeclarationList[~In] ";" ";" Expression[+In] ")" Statement
    #       IterationStatement ::= "for" · "(" "var" VariableDeclarationList[~In] ";" Expression[+In] ";" Expression[+In] ")" Statement
    #       IterationStatement ::= "for" · "(" ForLexicalDeclaration[~In] ";" ")" Statement
    #       IterationStatement ::= "for" · "(" ForLexicalDeclaration[~In] Expression[+In] ";" ")" Statement
    #       IterationStatement ::= "for" · "(" ForLexicalDeclaration[~In] ";" Expression[+In] ")" Statement
    #       IterationStatement ::= "for" · "(" ForLexicalDeclaration[~In] Expression[+In] ";" Expression[+In] ")" Statement
    #       IterationStatement ::= "for" · "(" [lookahead != 'let'] LeftHandSideExpression "in" Expression[+In] ")" Statement
    #       IterationStatement ::= "for" · "(" "var" ForBinding "in" Expression[+In] ")" Statement
    #       IterationStatement ::= "for" · "(" "var" BindingIdentifier Initializer[~In] "in" Expression[+In] ")" Statement
    #       IterationStatement ::= "for" · "(" ForDeclaration "in" Expression[+In] ")" Statement
    #       IterationStatement ::= "for" · "(" [lookahead not in {'async', 'let'}] LeftHandSideExpression "of" AssignmentExpression[+In] ")" Statement
    #       IterationStatement ::= "for" · "(" "var" ForBinding "of" AssignmentExpression[+In] ")" Statement
    #       IterationStatement ::= "for" · "(" ForDeclaration "of" AssignmentExpression[+In] ")" Statement
    #       IterationStatement ::= "for" · "await" "(" [lookahead not in {'async', 'let'}] LeftHandSideExpression "of" AssignmentExpression[+In] ")" Statement
    #       IterationStatement ::= "for" · "await" "(" "var" ForBinding "of" AssignmentExpression[+In] ")" Statement
    #       IterationStatement ::= "for" · "await" "(" ForDeclaration "of" AssignmentExpression[+In] ")" Statement
    {'(': 175, 'await': 176},

    # 17. "switch"
    #       SwitchStatement ::= "switch" · "(" Expression[+In] ")" CaseBlock
    {'(': 177},

    # 18. Identifier
    #       LabelIdentifier ::= Identifier ·
    #       BindingIdentifier ::= Identifier ·
    #       IdentifierReference ::= Identifier ·
    {':': -153, '=>': -171, '(': -469, '=': -469, '?.': -469, '*=': -469, '/=': -469, '%=': -469, '+=': -469, '-=': -469, '<<=': -469, '>>=': -469, '>>>=': -469, '&=': -469, '^=': -469, '|=': -469, '**=': -469, '[': -469, '.': -469, 'NoSubstitutionTemplate': -469, 'TemplateHead': -469, '**': -469, '++': -469, '--': -469, ';': -469, '??': -469, '?': -469, ErrorToken: -469, '*': -469, '/': -469, '%': -469, '+': -469, '-': -469, '<<': -469, '>>': -469, '>>>': -469, '<': -469, '>': -469, '<=': -469, '>=': -469, 'instanceof': -469, 'in': -469, '==': -469, '!=': -469, '===': -469, '!==': -469, '&': -469, '^': -469, '|': -469, '&&': -469, '||': -469, ',': -469},

    # 19. Identifier
    #       LabelIdentifier ::= Identifier ·
    #       LetOrConst ::= "let" ·
    {':': -153, 'Name': -178, 'NameWithEscape': -178, 'let': -178, 'static': -178, 'implements': -178, 'interface': -178, 'package': -178, 'private': -178, 'protected': -178, 'public': -178, 'as': -178, 'async': -178, 'from': -178, 'get': -178, 'of': -178, 'set': -178, 'target': -178, 'yield': -178, 'await': -178, '{': -178, '[': -178},

    # 20. Identifier
    #       LabelIdentifier ::= Identifier ·
    #       AsyncFunctionDeclaration[~Default] ::= "async" · NoLineTerminatorHere "function" BindingIdentifier "(" ")" "{" "}"
    #       AsyncFunctionDeclaration[~Default] ::= "async" · NoLineTerminatorHere "function" BindingIdentifier "(" FormalParameters ")" "{" "}"
    #       AsyncFunctionDeclaration[~Default] ::= "async" · NoLineTerminatorHere "function" BindingIdentifier "(" ")" "{" AsyncFunctionBody "}"
    #       AsyncFunctionDeclaration[~Default] ::= "async" · NoLineTerminatorHere "function" BindingIdentifier "(" FormalParameters ")" "{" AsyncFunctionBody "}"
    #       AsyncGeneratorDeclaration[~Default] ::= "async" · NoLineTerminatorHere "function" "*" BindingIdentifier "(" ")" "{" "}"
    #       AsyncGeneratorDeclaration[~Default] ::= "async" · NoLineTerminatorHere "function" "*" BindingIdentifier "(" FormalParameters ")" "{" "}"
    #       AsyncGeneratorDeclaration[~Default] ::= "async" · NoLineTerminatorHere "function" "*" BindingIdentifier "(" ")" "{" AsyncGeneratorBody "}"
    #       AsyncGeneratorDeclaration[~Default] ::= "async" · NoLineTerminatorHere "function" "*" BindingIdentifier "(" FormalParameters ")" "{" AsyncGeneratorBody "}"
    {'function': -9223372036854775777, ':': -153},

    # 21. "function"
    #       FunctionDeclaration[~Default] ::= "function" · BindingIdentifier "(" ")" "{" "}"
    #       FunctionDeclaration[~Default] ::= "function" · BindingIdentifier "(" FormalParameters ")" "{" "}"
    #       FunctionDeclaration[~Default] ::= "function" · BindingIdentifier "(" ")" "{" FunctionBody "}"
    #       FunctionDeclaration[~Default] ::= "function" · BindingIdentifier "(" FormalParameters ")" "{" FunctionBody "}"
    #       GeneratorDeclaration[~Default] ::= "function" · "*" BindingIdentifier "(" ")" "{" "}"
    #       GeneratorDeclaration[~Default] ::= "function" · "*" BindingIdentifier "(" FormalParameters ")" "{" "}"
    #       GeneratorDeclaration[~Default] ::= "function" · "*" BindingIdentifier "(" ")" "{" GeneratorBody "}"
    #       GeneratorDeclaration[~Default] ::= "function" · "*" BindingIdentifier "(" FormalParameters ")" "{" GeneratorBody "}"
    {'*': 179, 'Name': 132, 'NameWithEscape': 132, 'let': 132, 'static': 132, 'implements': 132, 'interface': 132, 'package': 132, 'private': 132, 'protected': 132, 'public': 132, 'as': 132, 'async': 132, 'from': 132, 'get': 132, 'of': 132, 'set': 132, 'target': 132, 'yield': 133, 'await': 134},

    # 22. "const"
    #       LetOrConst ::= "const" ·
    {'Name': -179, 'NameWithEscape': -179, 'let': -179, 'static': -179, 'implements': -179, 'interface': -179, 'package': -179, 'private': -179, 'protected': -179, 'public': -179, 'as': -179, 'async': -179, 'from': -179, 'get': -179, 'of': -179, 'set': -179, 'target': -179, 'yield': -179, 'await': -179, '{': -179, '[': -179},

    # 23. "yield"
    #       YieldExpression[+In] ::= "yield" ·
    #       YieldExpression[+In] ::= "yield" · NoLineTerminatorHere AssignmentExpression[+In]
    #       YieldExpression[+In] ::= "yield" · NoLineTerminatorHere "*" AssignmentExpression[+In]
    #       BindingIdentifier ::= "yield" ·
    {'*': -9223372036854775776, 'yield': -9223372036854775807, 'async': -9223372036854775806, 'new': -9223372036854775805, 'Name': -9223372036854775804, 'NameWithEscape': -9223372036854775804, 'let': -9223372036854775804, 'static': -9223372036854775804, 'implements': -9223372036854775804, 'interface': -9223372036854775804, 'package': -9223372036854775804, 'private': -9223372036854775804, 'protected': -9223372036854775804, 'public': -9223372036854775804, 'as': -9223372036854775804, 'from': -9223372036854775804, 'get': -9223372036854775804, 'of': -9223372036854775804, 'set': -9223372036854775804, 'target': -9223372036854775804, 'await': -9223372036854775803, '(': -9223372036854775802, 'super': -9223372036854775801, 'import': -9223372036854775800, 'this': -9223372036854775799, 'RegularExpressionLiteral': -9223372036854775798, 'NullLiteral': -9223372036854775797, 'BooleanLiteral': -9223372036854775796, 'NumericLiteral': -9223372036854775795, 'BigIntLiteral': -9223372036854775794, 'StringLiteral': -9223372036854775793, '[': -9223372036854775792, '{': -9223372036854775791, 'function': -9223372036854775790, 'class': -9223372036854775789, 'NoSubstitutionTemplate': -9223372036854775788, 'TemplateHead': -9223372036854775787, 'delete': -9223372036854775786, 'void': -9223372036854775785, 'typeof': -9223372036854775784, '+': -9223372036854775783, '-': -9223372036854775782, '~': -9223372036854775781, '!': -9223372036854775780, '++': -9223372036854775779, '--': -9223372036854775778, ';': -223, ErrorToken: -223, ',': -223, ')': -223, ']': -223, 'TemplateTail': -223, 'TemplateMiddle': -223, ':': -223, '}': -223, '=>': -172},

    # 24. "new"
    #       NewExpression ::= "new" · NewExpression
    #       MemberExpression ::= "new" · MemberExpression Arguments
    #       NewTarget ::= "new" · "." "target"
    {'.': 183, 'new': 24, 'this': 29, 'RegularExpressionLiteral': 30, 'super': 184, 'Name': 185, 'NameWithEscape': 185, 'let': 185, 'static': 185, 'implements': 185, 'interface': 185, 'package': 185, 'private': 185, 'protected': 185, 'public': 185, 'as': 185, 'async': 186, 'from': 185, 'get': 185, 'of': 185, 'set': 185, 'target': 185, 'NullLiteral': 31, 'BooleanLiteral': 32, 'NumericLiteral': 33, 'BigIntLiteral': 34, 'StringLiteral': 35, '[': 36, '{': 155, 'function': 156, 'class': 157, 'NoSubstitutionTemplate': 37, '(': 26, 'TemplateHead': 38},

    # 25. "await"
    #       BindingIdentifier ::= "await" ·
    #       AwaitExpression ::= "await" · UnaryExpression
    {'delete': 39, 'void': 40, 'typeof': 41, '+': 42, '-': 43, '~': 44, '!': 45, '++': 46, '--': 47, 'await': 190, 'new': 24, 'super': 27, 'import': 28, 'this': 29, 'RegularExpressionLiteral': 30, 'Name': 185, 'NameWithEscape': 185, 'let': 185, 'static': 185, 'implements': 185, 'interface': 185, 'package': 185, 'private': 185, 'protected': 185, 'public': 185, 'as': 185, 'async': 186, 'from': 185, 'get': 185, 'of': 185, 'set': 185, 'target': 185, 'NullLiteral': 31, 'BooleanLiteral': 32, 'NumericLiteral': 33, 'BigIntLiteral': 34, 'StringLiteral': 35, '[': 36, '{': 155, 'function': 156, 'class': 157, 'NoSubstitutionTemplate': 37, '(': 26, 'TemplateHead': 38, '=>': -173},

    # 26. "("
    #       CoverParenthesizedExpressionAndArrowParameterList ::= "(" · Expression[+In] ")"
    #       CoverParenthesizedExpressionAndArrowParameterList ::= "(" · Expression[+In] "," ")"
    #       CoverParenthesizedExpressionAndArrowParameterList ::= "(" · ")"
    #       CoverParenthesizedExpressionAndArrowParameterList ::= "(" · "..." BindingIdentifier ")"
    #       CoverParenthesizedExpressionAndArrowParameterList ::= "(" · "..." BindingPattern ")"
    #       CoverParenthesizedExpressionAndArrowParameterList ::= "(" · Expression[+In] "," "..." BindingIdentifier ")"
    #       CoverParenthesizedExpressionAndArrowParameterList ::= "(" · Expression[+In] "," "..." BindingPattern ")"
    {')': 195, '...': 196, 'yield': 23, 'async': 153, 'new': 24, 'Name': 154, 'NameWithEscape': 154, 'let': 154, 'static': 154, 'implements': 154, 'interface': 154, 'package': 154, 'private': 154, 'protected': 154, 'public': 154, 'as': 154, 'from': 154, 'get': 154, 'of': 154, 'set': 154, 'target': 154, 'await': 25, '(': 26, 'super': 27, 'import': 28, 'this': 29, 'RegularExpressionLiteral': 30, 'NullLiteral': 31, 'BooleanLiteral': 32, 'NumericLiteral': 33, 'BigIntLiteral': 34, 'StringLiteral': 35, '[': 36, '{': 155, 'function': 156, 'class': 157, 'NoSubstitutionTemplate': 37, 'TemplateHead': 38, 'delete': 39, 'void': 40, 'typeof': 41, '+': 42, '-': 43, '~': 44, '!': 45, '++': 46, '--': 47},

    # 27. "super"
    #       SuperCall ::= "super" · Arguments
    #       SuperProperty ::= "super" · "[" Expression[+In] "]"
    #       SuperProperty ::= "super" · "." IdentifierName
    {'[': 198, '.': 199, '(': 200},

    # 28. "import"
    #       ImportCall ::= "import" · "(" AssignmentExpression[+In] ")"
    {'(': 202},

    # 29. "this"
    #       PrimaryExpression ::= "this" ·
    {'(': -415, '=': -415, '?.': -415, '*=': -415, '/=': -415, '%=': -415, '+=': -415, '-=': -415, '<<=': -415, '>>=': -415, '>>>=': -415, '&=': -415, '^=': -415, '|=': -415, '**=': -415, '[': -415, '.': -415, 'NoSubstitutionTemplate': -415, 'TemplateHead': -415, '**': -415, '++': -415, '--': -415, ';': -415, '??': -415, '?': -415, ErrorToken: -415, '*': -415, '/': -415, '%': -415, '+': -415, '-': -415, '<<': -415, '>>': -415, '>>>': -415, '<': -415, '>': -415, '<=': -415, '>=': -415, 'instanceof': -415, 'in': -415, '==': -415, '!=': -415, '===': -415, '!==': -415, '&': -415, '^': -415, '|': -415, '&&': -415, '||': -415, ',': -415, ')': -415, ']': -415, 'TemplateTail': -415, 'TemplateMiddle': -415, 'of': -415, ':': -415, '}': -415, '{': -415},

    # 30. RegularExpressionLiteral
    #       PrimaryExpression ::= RegularExpressionLiteral ·
    {'(': -425, '=': -425, '?.': -425, '*=': -425, '/=': -425, '%=': -425, '+=': -425, '-=': -425, '<<=': -425, '>>=': -425, '>>>=': -425, '&=': -425, '^=': -425, '|=': -425, '**=': -425, '[': -425, '.': -425, 'NoSubstitutionTemplate': -425, 'TemplateHead': -425, '**': -425, '++': -425, '--': -425, ';': -425, '??': -425, '?': -425, ErrorToken: -425, '*': -425, '/': -425, '%': -425, '+': -425, '-': -425, '<<': -425, '>>': -425, '>>>': -425, '<': -425, '>': -425, '<=': -425, '>=': -425, 'instanceof': -425, 'in': -425, '==': -425, '!=': -425, '===': -425, '!==': -425, '&': -425, '^': -425, '|': -425, '&&': -425, '||': -425, ',': -425, ')': -425, ']': -425, 'TemplateTail': -425, 'TemplateMiddle': -425, 'of': -425, ':': -425, '}': -425, '{': -425},

    # 31. NullLiteral
    #       Literal ::= NullLiteral ·
    {'(': -470, '=': -470, '?.': -470, '*=': -470, '/=': -470, '%=': -470, '+=': -470, '-=': -470, '<<=': -470, '>>=': -470, '>>>=': -470, '&=': -470, '^=': -470, '|=': -470, '**=': -470, '[': -470, '.': -470, 'NoSubstitutionTemplate': -470, 'TemplateHead': -470, '**': -470, '++': -470, '--': -470, ';': -470, '??': -470, '?': -470, ErrorToken: -470, '*': -470, '/': -470, '%': -470, '+': -470, '-': -470, '<<': -470, '>>': -470, '>>>': -470, '<': -470, '>': -470, '<=': -470, '>=': -470, 'instanceof': -470, 'in': -470, '==': -470, '!=': -470, '===': -470, '!==': -470, '&': -470, '^': -470, '|': -470, '&&': -470, '||': -470, ',': -470, ')': -470, ']': -470, 'TemplateTail': -470, 'TemplateMiddle': -470, 'of': -470, ':': -470, '}': -470, '{': -470},

    # 32. BooleanLiteral
    #       Literal ::= BooleanLiteral ·
    {'(': -471, '=': -471, '?.': -471, '*=': -471, '/=': -471, '%=': -471, '+=': -471, '-=': -471, '<<=': -471, '>>=': -471, '>>>=': -471, '&=': -471, '^=': -471, '|=': -471, '**=': -471, '[': -471, '.': -471, 'NoSubstitutionTemplate': -471, 'TemplateHead': -471, '**': -471, '++': -471, '--': -471, ';': -471, '??': -471, '?': -471, ErrorToken: -471, '*': -471, '/': -471, '%': -471, '+': -471, '-': -471, '<<': -471, '>>': -471, '>>>': -471, '<': -471, '>': -471, '<=': -471, '>=': -471, 'instanceof': -471, 'in': -471, '==': -471, '!=': -471, '===': -471, '!==': -471, '&': -471, '^': -471, '|': -471, '&&': -471, '||': -471, ',': -471, ')': -471, ']': -471, 'TemplateTail': -471, 'TemplateMiddle': -471, 'of': -471, ':': -471, '}': -471, '{': -471},

    # 33. NumericLiteral
    #       Literal ::= NumericLiteral ·
    {'(': -472, '=': -472, '?.': -472, '*=': -472, '/=': -472, '%=': -472, '+=': -472, '-=': -472, '<<=': -472, '>>=': -472, '>>>=': -472, '&=': -472, '^=': -472, '|=': -472, '**=': -472, '[': -472, '.': -472, 'NoSubstitutionTemplate': -472, 'TemplateHead': -472, '**': -472, '++': -472, '--': -472, ';': -472, '??': -472, '?': -472, ErrorToken: -472, '*': -472, '/': -472, '%': -472, '+': -472, '-': -472, '<<': -472, '>>': -472, '>>>': -472, '<': -472, '>': -472, '<=': -472, '>=': -472, 'instanceof': -472, 'in': -472, '==': -472, '!=': -472, '===': -472, '!==': -472, '&': -472, '^': -472, '|': -472, '&&': -472, '||': -472, ',': -472, ')': -472, ']': -472, 'TemplateTail': -472, 'TemplateMiddle': -472, 'of': -472, ':': -472, '}': -472, '{': -472},

    # 34. BigIntLiteral
    #       Literal ::= BigIntLiteral ·
    {'(': -473, '=': -473, '?.': -473, '*=': -473, '/=': -473, '%=': -473, '+=': -473, '-=': -473, '<<=': -473, '>>=': -473, '>>>=': -473, '&=': -473, '^=': -473, '|=': -473, '**=': -473, '[': -473, '.': -473, 'NoSubstitutionTemplate': -473, 'TemplateHead': -473, '**': -473, '++': -473, '--': -473, ';': -473, '??': -473, '?': -473, ErrorToken: -473, '*': -473, '/': -473, '%': -473, '+': -473, '-': -473, '<<': -473, '>>': -473, '>>>': -473, '<': -473, '>': -473, '<=': -473, '>=': -473, 'instanceof': -473, 'in': -473, '==': -473, '!=': -473, '===': -473, '!==': -473, '&': -473, '^': -473, '|': -473, '&&': -473, '||': -473, ',': -473, ')': -473, ']': -473, 'TemplateTail': -473, 'TemplateMiddle': -473, 'of': -473, ':': -473, '}': -473, '{': -473},

    # 35. StringLiteral
    #       Literal ::= StringLiteral ·
    {'(': -474, '=': -474, '?.': -474, '*=': -474, '/=': -474, '%=': -474, '+=': -474, '-=': -474, '<<=': -474, '>>=': -474, '>>>=': -474, '&=': -474, '^=': -474, '|=': -474, '**=': -474, '[': -474, '.': -474, 'NoSubstitutionTemplate': -474, 'TemplateHead': -474, '**': -474, '++': -474, '--': -474, ';': -474, '??': -474, '?': -474, ErrorToken: -474, '*': -474, '/': -474, '%': -474, '+': -474, '-': -474, '<<': -474, '>>': -474, '>>>': -474, '<': -474, '>': -474, '<=': -474, '>=': -474, 'instanceof': -474, 'in': -474, '==': -474, '!=': -474, '===': -474, '!==': -474, '&': -474, '^': -474, '|': -474, '&&': -474, '||': -474, ',': -474, ')': -474, ']': -474, 'TemplateTail': -474, 'TemplateMiddle': -474, 'of': -474, ':': -474, '}': -474, '{': -474},

    # 36. "["
    #       ArrayLiteral ::= "[" · "]"
    #       ArrayLiteral ::= "[" · Elision "]"
    #       ArrayLiteral ::= "[" · ElementList "]"
    #       ArrayLiteral ::= "[" · ElementList "," "]"
    #       ArrayLiteral ::= "[" · ElementList "," Elision "]"
    {']': 203, ',': 204, '...': 205, 'yield': 23, 'async': 153, 'new': 24, 'Name': 154, 'NameWithEscape': 154, 'let': 154, 'static': 154, 'implements': 154, 'interface': 154, 'package': 154, 'private': 154, 'protected': 154, 'public': 154, 'as': 154, 'from': 154, 'get': 154, 'of': 154, 'set': 154, 'target': 154, 'await': 25, '(': 26, 'super': 27, 'import': 28, 'this': 29, 'RegularExpressionLiteral': 30, 'NullLiteral': 31, 'BooleanLiteral': 32, 'NumericLiteral': 33, 'BigIntLiteral': 34, 'StringLiteral': 35, '[': 36, '{': 155, 'function': 156, 'class': 157, 'NoSubstitutionTemplate': 37, 'TemplateHead': 38, 'delete': 39, 'void': 40, 'typeof': 41, '+': 42, '-': 43, '~': 44, '!': 45, '++': 46, '--': 47},

    # 37. NoSubstitutionTemplate
    #       TemplateLiteral ::= NoSubstitutionTemplate ·
    {'(': -364, '=': -364, '?.': -364, '*=': -364, '/=': -364, '%=': -364, '+=': -364, '-=': -364, '<<=': -364, '>>=': -364, '>>>=': -364, '&=': -364, '^=': -364, '|=': -364, '**=': -364, '[': -364, '.': -364, 'NoSubstitutionTemplate': -364, 'TemplateHead': -364, '**': -364, '++': -364, '--': -364, ';': -364, '??': -364, '?': -364, ErrorToken: -364, '*': -364, '/': -364, '%': -364, '+': -364, '-': -364, '<<': -364, '>>': -364, '>>>': -364, '<': -364, '>': -364, '<=': -364, '>=': -364, 'instanceof': -364, 'in': -364, '==': -364, '!=': -364, '===': -364, '!==': -364, '&': -364, '^': -364, '|': -364, '&&': -364, '||': -364, ',': -364, ')': -364, ']': -364, 'TemplateTail': -364, 'TemplateMiddle': -364, 'of': -364, ':': -364, '}': -364, '{': -364},

    # 38. TemplateHead
    #       SubstitutionTemplate ::= TemplateHead · Expression[+In] TemplateSpans
    {'yield': 23, 'async': 153, 'new': 24, 'Name': 154, 'NameWithEscape': 154, 'let': 154, 'static': 154, 'implements': 154, 'interface': 154, 'package': 154, 'private': 154, 'protected': 154, 'public': 154, 'as': 154, 'from': 154, 'get': 154, 'of': 154, 'set': 154, 'target': 154, 'await': 25, '(': 26, 'super': 27, 'import': 28, 'this': 29, 'RegularExpressionLiteral': 30, 'NullLiteral': 31, 'BooleanLiteral': 32, 'NumericLiteral': 33, 'BigIntLiteral': 34, 'StringLiteral': 35, '[': 36, '{': 155, 'function': 156, 'class': 157, 'NoSubstitutionTemplate': 37, 'TemplateHead': 38, 'delete': 39, 'void': 40, 'typeof': 41, '+': 42, '-': 43, '~': 44, '!': 45, '++': 46, '--': 47},

    # 39. "delete"
    #       UnaryExpression ::= "delete" · UnaryExpression
    {'delete': 39, 'void': 40, 'typeof': 41, '+': 42, '-': 43, '~': 44, '!': 45, '++': 46, '--': 47, 'await': 190, 'new': 24, 'super': 27, 'import': 28, 'this': 29, 'RegularExpressionLiteral': 30, 'Name': 185, 'NameWithEscape': 185, 'let': 185, 'static': 185, 'implements': 185, 'interface': 185, 'package': 185, 'private': 185, 'protected': 185, 'public': 185, 'as': 185, 'async': 186, 'from': 185, 'get': 185, 'of': 185, 'set': 185, 'target': 185, 'NullLiteral': 31, 'BooleanLiteral': 32, 'NumericLiteral': 33, 'BigIntLiteral': 34, 'StringLiteral': 35, '[': 36, '{': 155, 'function': 156, 'class': 157, 'NoSubstitutionTemplate': 37, '(': 26, 'TemplateHead': 38},

    # 40. "void"
    #       UnaryExpression ::= "void" · UnaryExpression
    {'delete': 39, 'void': 40, 'typeof': 41, '+': 42, '-': 43, '~': 44, '!': 45, '++': 46, '--': 47, 'await': 190, 'new': 24, 'super': 27, 'import': 28, 'this': 29, 'RegularExpressionLiteral': 30, 'Name': 185, 'NameWithEscape': 185, 'let': 185, 'static': 185, 'implements': 185, 'interface': 185, 'package': 185, 'private': 185, 'protected': 185, 'public': 185, 'as': 185, 'async': 186, 'from': 185, 'get': 185, 'of': 185, 'set': 185, 'target': 185, 'NullLiteral': 31, 'BooleanLiteral': 32, 'NumericLiteral': 33, 'BigIntLiteral': 34, 'StringLiteral': 35, '[': 36, '{': 155, 'function': 156, 'class': 157, 'NoSubstitutionTemplate': 37, '(': 26, 'TemplateHead': 38},

    # 41. "typeof"
    #       UnaryExpression ::= "typeof" · UnaryExpression
    {'delete': 39, 'void': 40, 'typeof': 41, '+': 42, '-': 43, '~': 44, '!': 45, '++': 46, '--': 47, 'await': 190, 'new': 24, 'super': 27, 'import': 28, 'this': 29, 'RegularExpressionLiteral': 30, 'Name': 185, 'NameWithEscape': 185, 'let': 185, 'static': 185, 'implements': 185, 'interface': 185, 'package': 185, 'private': 185, 'protected': 185, 'public': 185, 'as': 185, 'async': 186, 'from': 185, 'get': 185, 'of': 185, 'set': 185, 'target': 185, 'NullLiteral': 31, 'BooleanLiteral': 32, 'NumericLiteral': 33, 'BigIntLiteral': 34, 'StringLiteral': 35, '[': 36, '{': 155, 'function': 156, 'class': 157, 'NoSubstitutionTemplate': 37, '(': 26, 'TemplateHead': 38},

    # 42. "+"
    #       UnaryExpression ::= "+" · UnaryExpression
    {'delete': 39, 'void': 40, 'typeof': 41, '+': 42, '-': 43, '~': 44, '!': 45, '++': 46, '--': 47, 'await': 190, 'new': 24, 'super': 27, 'import': 28, 'this': 29, 'RegularExpressionLiteral': 30, 'Name': 185, 'NameWithEscape': 185, 'let': 185, 'static': 185, 'implements': 185, 'interface': 185, 'package': 185, 'private': 185, 'protected': 185, 'public': 185, 'as': 185, 'async': 186, 'from': 185, 'get': 185, 'of': 185, 'set': 185, 'target': 185, 'NullLiteral': 31, 'BooleanLiteral': 32, 'NumericLiteral': 33, 'BigIntLiteral': 34, 'StringLiteral': 35, '[': 36, '{': 155, 'function': 156, 'class': 157, 'NoSubstitutionTemplate': 37, '(': 26, 'TemplateHead': 38},

    # 43. "-"
    #       UnaryExpression ::= "-" · UnaryExpression
    {'delete': 39, 'void': 40, 'typeof': 41, '+': 42, '-': 43, '~': 44, '!': 45, '++': 46, '--': 47, 'await': 190, 'new': 24, 'super': 27, 'import': 28, 'this': 29, 'RegularExpressionLiteral': 30, 'Name': 185, 'NameWithEscape': 185, 'let': 185, 'static': 185, 'implements': 185, 'interface': 185, 'package': 185, 'private': 185, 'protected': 185, 'public': 185, 'as': 185, 'async': 186, 'from': 185, 'get': 185, 'of': 185, 'set': 185, 'target': 185, 'NullLiteral': 31, 'BooleanLiteral': 32, 'NumericLiteral': 33, 'BigIntLiteral': 34, 'StringLiteral': 35, '[': 36, '{': 155, 'function': 156, 'class': 157, 'NoSubstitutionTemplate': 37, '(': 26, 'TemplateHead': 38},

    # 44. "~"
    #       UnaryExpression ::= "~" · UnaryExpression
    {'delete': 39, 'void': 40, 'typeof': 41, '+': 42, '-': 43, '~': 44, '!': 45, '++': 46, '--': 47, 'await': 190, 'new': 24, 'super': 27, 'import': 28, 'this': 29, 'RegularExpressionLiteral': 30, 'Name': 185, 'NameWithEscape': 185, 'let': 185, 'static': 185, 'implements': 185, 'interface': 185, 'package': 185, 'private': 185, 'protected': 185, 'public': 185, 'as': 185, 'async': 186, 'from': 185, 'get': 185, 'of': 185, 'set': 185, 'target': 185, 'NullLiteral': 31, 'BooleanLiteral': 32, 'NumericLiteral': 33, 'BigIntLiteral': 34, 'StringLiteral': 35, '[': 36, '{': 155, 'function': 156, 'class': 157, 'NoSubstitutionTemplate': 37, '(': 26, 'TemplateHead': 38},

    # 45. "!"
    #       UnaryExpression ::= "!" · UnaryExpression
    {'delete': 39, 'void': 40, 'typeof': 41, '+': 42, '-': 43, '~': 44, '!': 45, '++': 46, '--': 47, 'await': 190, 'new': 24, 'super': 27, 'import': 28, 'this': 29, 'RegularExpressionLiteral': 30, 'Name': 185, 'NameWithEscape': 185, 'let': 185, 'static': 185, 'implements': 185, 'interface': 185, 'package': 185, 'private': 185, 'protected': 185, 'public': 185, 'as': 185, 'async': 186, 'from': 185, 'get': 185, 'of': 185, 'set': 185, 'target': 185, 'NullLiteral': 31, 'BooleanLiteral': 32, 'NumericLiteral': 33, 'BigIntLiteral': 34, 'StringLiteral': 35, '[': 36, '{': 155, 'function': 156, 'class': 157, 'NoSubstitutionTemplate': 37, '(': 26, 'TemplateHead': 38},

    # 46. "++"
    #       UpdateExpression ::= "++" · UnaryExpression
    {'delete': 39, 'void': 40, 'typeof': 41, '+': 42, '-': 43, '~': 44, '!': 45, '++': 46, '--': 47, 'await': 190, 'new': 24, 'super': 27, 'import': 28, 'this': 29, 'RegularExpressionLiteral': 30, 'Name': 185, 'NameWithEscape': 185, 'let': 185, 'static': 185, 'implements': 185, 'interface': 185, 'package': 185, 'private': 185, 'protected': 185, 'public': 185, 'as': 185, 'async': 186, 'from': 185, 'get': 185, 'of': 185, 'set': 185, 'target': 185, 'NullLiteral': 31, 'BooleanLiteral': 32, 'NumericLiteral': 33, 'BigIntLiteral': 34, 'StringLiteral': 35, '[': 36, '{': 155, 'function': 156, 'class': 157, 'NoSubstitutionTemplate': 37, '(': 26, 'TemplateHead': 38},

    # 47. "--"
    #       UpdateExpression ::= "--" · UnaryExpression
    {'delete': 39, 'void': 40, 'typeof': 41, '+': 42, '-': 43, '~': 44, '!': 45, '++': 46, '--': 47, 'await': 190, 'new': 24, 'super': 27, 'import': 28, 'this': 29, 'RegularExpressionLiteral': 30, 'Name': 185, 'NameWithEscape': 185, 'let': 185, 'static': 185, 'implements': 185, 'interface': 185, 'package': 185, 'private': 185, 'protected': 185, 'public': 185, 'as': 185, 'async': 186, 'from': 185, 'get': 185, 'of': 185, 'set': 185, 'target': 185, 'NullLiteral': 31, 'BooleanLiteral': 32, 'NumericLiteral': 33, 'BigIntLiteral': 34, 'StringLiteral': 35, '[': 36, '{': 155, 'function': 156, 'class': 157, 'NoSubstitutionTemplate': 37, '(': 26, 'TemplateHead': 38},

    # 48. Script
    #       InitNt(goal=Nt('Script')) ::= Script ·
    {None: -4611686018427387905},

    # 49. ScriptBody
    #       Script ::= ScriptBody ·
    {None: -2},

    # 50. StatementList
    #       ScriptBody ::= StatementList ·
    #       StatementList ::= StatementList · StatementListItem
    {'var': 2, ';': 3, 'if': 4, 'continue': 5, 'break': 6, 'return': 7, 'with': 8, 'throw': 9, 'try': 10, 'debugger': 11, 'class': 12, '{': 13, 'do': 14, 'while': 15, 'for': 16, 'switch': 17, 'Name': 18, 'NameWithEscape': 18, 'let': 19, 'static': 18, 'implements': 18, 'interface': 18, 'package': 18, 'private': 18, 'protected': 18, 'public': 18, 'as': 18, 'async': 20, 'from': 18, 'get': 18, 'of': 18, 'set': 18, 'target': 18, 'function': 21, 'const': 22, 'yield': 23, 'new': 24, 'await': 25, '(': 26, 'super': 27, 'import': 28, 'this': 29, 'RegularExpressionLiteral': 30, 'NullLiteral': 31, 'BooleanLiteral': 32, 'NumericLiteral': 33, 'BigIntLiteral': 34, 'StringLiteral': 35, '[': 36, 'NoSubstitutionTemplate': 37, 'TemplateHead': 38, 'delete': 39, 'void': 40, 'typeof': 41, '+': 42, '-': 43, '~': 44, '!': 45, '++': 46, '--': 47, None: -5},

    # 51. StatementListItem
    #       StatementList ::= StatementListItem ·
    {None: -7, '{': -7, 'var': -7, ';': -7, 'delete': -7, 'void': -7, 'typeof': -7, '+': -7, '-': -7, '~': -7, '!': -7, '++': -7, '--': -7, 'yield': -7, 'Name': -7, 'NameWithEscape': -7, 'let': -7, 'static': -7, 'implements': -7, 'interface': -7, 'package': -7, 'private': -7, 'protected': -7, 'public': -7, 'as': -7, 'async': -7, 'from': -7, 'get': -7, 'of': -7, 'set': -7, 'target': -7, 'await': -7, '(': -7, 'this': -7, 'NullLiteral': -7, 'BooleanLiteral': -7, 'NumericLiteral': -7, 'BigIntLiteral': -7, 'StringLiteral': -7, '[': -7, 'RegularExpressionLiteral': -7, 'NoSubstitutionTemplate': -7, 'TemplateHead': -7, 'new': -7, 'super': -7, 'import': -7, 'if': -7, 'do': -7, 'while': -7, 'for': -7, 'switch': -7, 'continue': -7, 'break': -7, 'return': -7, 'with': -7, 'throw': -7, 'try': -7, 'debugger': -7, 'function': -7, 'class': -7, 'const': -7, '}': -7, 'case': -7, 'default': -7},

    # 52. Statement
    #       StatementListItem ::= Statement ·
    {None: -11, '{': -11, 'var': -11, ';': -11, 'delete': -11, 'void': -11, 'typeof': -11, '+': -11, '-': -11, '~': -11, '!': -11, '++': -11, '--': -11, 'yield': -11, 'Name': -11, 'NameWithEscape': -11, 'let': -11, 'static': -11, 'implements': -11, 'interface': -11, 'package': -11, 'private': -11, 'protected': -11, 'public': -11, 'as': -11, 'async': -11, 'from': -11, 'get': -11, 'of': -11, 'set': -11, 'target': -11, 'await': -11, '(': -11, 'this': -11, 'NullLiteral': -11, 'BooleanLiteral': -11, 'NumericLiteral': -11, 'BigIntLiteral': -11, 'StringLiteral': -11, '[': -11, 'RegularExpressionLiteral': -11, 'NoSubstitutionTemplate': -11, 'TemplateHead': -11, 'new': -11, 'super': -11, 'import': -11, 'if': -11, 'do': -11, 'while': -11, 'for': -11, 'switch': -11, 'continue': -11, 'break': -11, 'return': -11, 'with': -11, 'throw': -11, 'try': -11, 'debugger': -11, 'function': -11, 'class': -11, 'const': -11, 'export': -11, '}': -11, 'case': -11, 'default': -11},

    # 53. Declaration
    #       StatementListItem ::= Declaration ·
    {None: -12, '{': -12, 'var': -12, ';': -12, 'delete': -12, 'void': -12, 'typeof': -12, '+': -12, '-': -12, '~': -12, '!': -12, '++': -12, '--': -12, 'yield': -12, 'Name': -12, 'NameWithEscape': -12, 'let': -12, 'static': -12, 'implements': -12, 'interface': -12, 'package': -12, 'private': -12, 'protected': -12, 'public': -12, 'as': -12, 'async': -12, 'from': -12, 'get': -12, 'of': -12, 'set': -12, 'target': -12, 'await': -12, '(': -12, 'this': -12, 'NullLiteral': -12, 'BooleanLiteral': -12, 'NumericLiteral': -12, 'BigIntLiteral': -12, 'StringLiteral': -12, '[': -12, 'RegularExpressionLiteral': -12, 'NoSubstitutionTemplate': -12, 'TemplateHead': -12, 'new': -12, 'super': -12, 'import': -12, 'if': -12, 'do': -12, 'while': -12, 'for': -12, 'switch': -12, 'continue': -12, 'break': -12, 'return': -12, 'with': -12, 'throw': -12, 'try': -12, 'debugger': -12, 'function': -12, 'class': -12, 'const': -12, 'export': -12, '}': -12, 'case': -12, 'default': -12},

    # 54. BlockStatement
    #       Statement ::= BlockStatement ·
    {None: -16, '{': -16, 'var': -16, ';': -16, 'delete': -16, 'void': -16, 'typeof': -16, '+': -16, '-': -16, '~': -16, '!': -16, '++': -16, '--': -16, 'yield': -16, 'Name': -16, 'NameWithEscape': -16, 'let': -16, 'static': -16, 'implements': -16, 'interface': -16, 'package': -16, 'private': -16, 'protected': -16, 'public': -16, 'as': -16, 'async': -16, 'from': -16, 'get': -16, 'of': -16, 'set': -16, 'target': -16, 'await': -16, '(': -16, 'this': -16, 'NullLiteral': -16, 'BooleanLiteral': -16, 'NumericLiteral': -16, 'BigIntLiteral': -16, 'StringLiteral': -16, '[': -16, 'RegularExpressionLiteral': -16, 'NoSubstitutionTemplate': -16, 'TemplateHead': -16, 'new': -16, 'super': -16, 'import': -16, 'if': -16, 'do': -16, 'while': -16, 'for': -16, 'switch': -16, 'continue': -16, 'break': -16, 'return': -16, 'with': -16, 'throw': -16, 'try': -16, 'debugger': -16, 'function': -16, 'class': -16, 'const': -16, 'export': -16, '}': -16, 'else': -16, 'case': -16, 'default': -16},

    # 55. VariableStatement
    #       Statement ::= VariableStatement ·
    {None: -17, '{': -17, 'var': -17, ';': -17, 'delete': -17, 'void': -17, 'typeof': -17, '+': -17, '-': -17, '~': -17, '!': -17, '++': -17, '--': -17, 'yield': -17, 'Name': -17, 'NameWithEscape': -17, 'let': -17, 'static': -17, 'implements': -17, 'interface': -17, 'package': -17, 'private': -17, 'protected': -17, 'public': -17, 'as': -17, 'async': -17, 'from': -17, 'get': -17, 'of': -17, 'set': -17, 'target': -17, 'await': -17, '(': -17, 'this': -17, 'NullLiteral': -17, 'BooleanLiteral': -17, 'NumericLiteral': -17, 'BigIntLiteral': -17, 'StringLiteral': -17, '[': -17, 'RegularExpressionLiteral': -17, 'NoSubstitutionTemplate': -17, 'TemplateHead': -17, 'new': -17, 'super': -17, 'import': -17, 'if': -17, 'do': -17, 'while': -17, 'for': -17, 'switch': -17, 'continue': -17, 'break': -17, 'return': -17, 'with': -17, 'throw': -17, 'try': -17, 'debugger': -17, 'function': -17, 'class': -17, 'const': -17, 'export': -17, '}': -17, 'else': -17, 'case': -17, 'default': -17},

    # 56. EmptyStatement
    #       Statement ::= EmptyStatement ·
    {None: -18, '{': -18, 'var': -18, ';': -18, 'delete': -18, 'void': -18, 'typeof': -18, '+': -18, '-': -18, '~': -18, '!': -18, '++': -18, '--': -18, 'yield': -18, 'Name': -18, 'NameWithEscape': -18, 'let': -18, 'static': -18, 'implements': -18, 'interface': -18, 'package': -18, 'private': -18, 'protected': -18, 'public': -18, 'as': -18, 'async': -18, 'from': -18, 'get': -18, 'of': -18, 'set': -18, 'target': -18, 'await': -18, '(': -18, 'this': -18, 'NullLiteral': -18, 'BooleanLiteral': -18, 'NumericLiteral': -18, 'BigIntLiteral': -18, 'StringLiteral': -18, '[': -18, 'RegularExpressionLiteral': -18, 'NoSubstitutionTemplate': -18, 'TemplateHead': -18, 'new': -18, 'super': -18, 'import': -18, 'if': -18, 'do': -18, 'while': -18, 'for': -18, 'switch': -18, 'continue': -18, 'break': -18, 'return': -18, 'with': -18, 'throw': -18, 'try': -18, 'debugger': -18, 'function': -18, 'class': -18, 'const': -18, 'export': -18, '}': -18, 'else': -18, 'case': -18, 'default': -18},

    # 57. ExpressionStatement
    #       Statement ::= ExpressionStatement ·
    {None: -19, '{': -19, 'var': -19, ';': -19, 'delete': -19, 'void': -19, 'typeof': -19, '+': -19, '-': -19, '~': -19, '!': -19, '++': -19, '--': -19, 'yield': -19, 'Name': -19, 'NameWithEscape': -19, 'let': -19, 'static': -19, 'implements': -19, 'interface': -19, 'package': -19, 'private': -19, 'protected': -19, 'public': -19, 'as': -19, 'async': -19, 'from': -19, 'get': -19, 'of': -19, 'set': -19, 'target': -19, 'await': -19, '(': -19, 'this': -19, 'NullLiteral': -19, 'BooleanLiteral': -19, 'NumericLiteral': -19, 'BigIntLiteral': -19, 'StringLiteral': -19, '[': -19, 'RegularExpressionLiteral': -19, 'NoSubstitutionTemplate': -19, 'TemplateHead': -19, 'new': -19, 'super': -19, 'import': -19, 'if': -19, 'do': -19, 'while': -19, 'for': -19, 'switch': -19, 'continue': -19, 'break': -19, 'return': -19, 'with': -19, 'throw': -19, 'try': -19, 'debugger': -19, 'function': -19, 'class': -19, 'const': -19, 'export': -19, '}': -19, 'else': -19, 'case': -19, 'default': -19},

    # 58. IfStatement
    #       Statement ::= IfStatement ·
    {None: -20, '{': -20, 'var': -20, ';': -20, 'delete': -20, 'void': -20, 'typeof': -20, '+': -20, '-': -20, '~': -20, '!': -20, '++': -20, '--': -20, 'yield': -20, 'Name': -20, 'NameWithEscape': -20, 'let': -20, 'static': -20, 'implements': -20, 'interface': -20, 'package': -20, 'private': -20, 'protected': -20, 'public': -20, 'as': -20, 'async': -20, 'from': -20, 'get': -20, 'of': -20, 'set': -20, 'target': -20, 'await': -20, '(': -20, 'this': -20, 'NullLiteral': -20, 'BooleanLiteral': -20, 'NumericLiteral': -20, 'BigIntLiteral': -20, 'StringLiteral': -20, '[': -20, 'RegularExpressionLiteral': -20, 'NoSubstitutionTemplate': -20, 'TemplateHead': -20, 'new': -20, 'super': -20, 'import': -20, 'if': -20, 'do': -20, 'while': -20, 'for': -20, 'switch': -20, 'continue': -20, 'break': -20, 'return': -20, 'with': -20, 'throw': -20, 'try': -20, 'debugger': -20, 'function': -20, 'class': -20, 'const': -20, 'export': -20, '}': -20, 'else': -20, 'case': -20, 'default': -20},

    # 59. BreakableStatement
    #       Statement ::= BreakableStatement ·
    {None: -21, '{': -21, 'var': -21, ';': -21, 'delete': -21, 'void': -21, 'typeof': -21, '+': -21, '-': -21, '~': -21, '!': -21, '++': -21, '--': -21, 'yield': -21, 'Name': -21, 'NameWithEscape': -21, 'let': -21, 'static': -21, 'implements': -21, 'interface': -21, 'package': -21, 'private': -21, 'protected': -21, 'public': -21, 'as': -21, 'async': -21, 'from': -21, 'get': -21, 'of': -21, 'set': -21, 'target': -21, 'await': -21, '(': -21, 'this': -21, 'NullLiteral': -21, 'BooleanLiteral': -21, 'NumericLiteral': -21, 'BigIntLiteral': -21, 'StringLiteral': -21, '[': -21, 'RegularExpressionLiteral': -21, 'NoSubstitutionTemplate': -21, 'TemplateHead': -21, 'new': -21, 'super': -21, 'import': -21, 'if': -21, 'do': -21, 'while': -21, 'for': -21, 'switch': -21, 'continue': -21, 'break': -21, 'return': -21, 'with': -21, 'throw': -21, 'try': -21, 'debugger': -21, 'function': -21, 'class': -21, 'const': -21, 'export': -21, '}': -21, 'else': -21, 'case': -21, 'default': -21},

    # 60. ContinueStatement
    #       Statement ::= ContinueStatement ·
    {None: -22, '{': -22, 'var': -22, ';': -22, 'delete': -22, 'void': -22, 'typeof': -22, '+': -22, '-': -22, '~': -22, '!': -22, '++': -22, '--': -22, 'yield': -22, 'Name': -22, 'NameWithEscape': -22, 'let': -22, 'static': -22, 'implements': -22, 'interface': -22, 'package': -22, 'private': -22, 'protected': -22, 'public': -22, 'as': -22, 'async': -22, 'from': -22, 'get': -22, 'of': -22, 'set': -22, 'target': -22, 'await': -22, '(': -22, 'this': -22, 'NullLiteral': -22, 'BooleanLiteral': -22, 'NumericLiteral': -22, 'BigIntLiteral': -22, 'StringLiteral': -22, '[': -22, 'RegularExpressionLiteral': -22, 'NoSubstitutionTemplate': -22, 'TemplateHead': -22, 'new': -22, 'super': -22, 'import': -22, 'if': -22, 'do': -22, 'while': -22, 'for': -22, 'switch': -22, 'continue': -22, 'break': -22, 'return': -22, 'with': -22, 'throw': -22, 'try': -22, 'debugger': -22, 'function': -22, 'class': -22, 'const': -22, 'export': -22, '}': -22, 'else': -22, 'case': -22, 'default': -22},

    # 61. BreakStatement
    #       Statement ::= BreakStatement ·
    {None: -23, '{': -23, 'var': -23, ';': -23, 'delete': -23, 'void': -23, 'typeof': -23, '+': -23, '-': -23, '~': -23, '!': -23, '++': -23, '--': -23, 'yield': -23, 'Name': -23, 'NameWithEscape': -23, 'let': -23, 'static': -23, 'implements': -23, 'interface': -23, 'package': -23, 'private': -23, 'protected': -23, 'public': -23, 'as': -23, 'async': -23, 'from': -23, 'get': -23, 'of': -23, 'set': -23, 'target': -23, 'await': -23, '(': -23, 'this': -23, 'NullLiteral': -23, 'BooleanLiteral': -23, 'NumericLiteral': -23, 'BigIntLiteral': -23, 'StringLiteral': -23, '[': -23, 'RegularExpressionLiteral': -23, 'NoSubstitutionTemplate': -23, 'TemplateHead': -23, 'new': -23, 'super': -23, 'import': -23, 'if': -23, 'do': -23, 'while': -23, 'for': -23, 'switch': -23, 'continue': -23, 'break': -23, 'return': -23, 'with': -23, 'throw': -23, 'try': -23, 'debugger': -23, 'function': -23, 'class': -23, 'const': -23, 'export': -23, '}': -23, 'else': -23, 'case': -23, 'default': -23},

    # 62. ReturnStatement
    #       Statement ::= ReturnStatement ·
    {None: -24, '{': -24, 'var': -24, ';': -24, 'delete': -24, 'void': -24, 'typeof': -24, '+': -24, '-': -24, '~': -24, '!': -24, '++': -24, '--': -24, 'yield': -24, 'Name': -24, 'NameWithEscape': -24, 'let': -24, 'static': -24, 'implements': -24, 'interface': -24, 'package': -24, 'private': -24, 'protected': -24, 'public': -24, 'as': -24, 'async': -24, 'from': -24, 'get': -24, 'of': -24, 'set': -24, 'target': -24, 'await': -24, '(': -24, 'this': -24, 'NullLiteral': -24, 'BooleanLiteral': -24, 'NumericLiteral': -24, 'BigIntLiteral': -24, 'StringLiteral': -24, '[': -24, 'RegularExpressionLiteral': -24, 'NoSubstitutionTemplate': -24, 'TemplateHead': -24, 'new': -24, 'super': -24, 'import': -24, 'if': -24, 'do': -24, 'while': -24, 'for': -24, 'switch': -24, 'continue': -24, 'break': -24, 'return': -24, 'with': -24, 'throw': -24, 'try': -24, 'debugger': -24, 'function': -24, 'class': -24, 'const': -24, 'export': -24, '}': -24, 'else': -24, 'case': -24, 'default': -24},

    # 63. WithStatement
    #       Statement ::= WithStatement ·
    {None: -25, '{': -25, 'var': -25, ';': -25, 'delete': -25, 'void': -25, 'typeof': -25, '+': -25, '-': -25, '~': -25, '!': -25, '++': -25, '--': -25, 'yield': -25, 'Name': -25, 'NameWithEscape': -25, 'let': -25, 'static': -25, 'implements': -25, 'interface': -25, 'package': -25, 'private': -25, 'protected': -25, 'public': -25, 'as': -25, 'async': -25, 'from': -25, 'get': -25, 'of': -25, 'set': -25, 'target': -25, 'await': -25, '(': -25, 'this': -25, 'NullLiteral': -25, 'BooleanLiteral': -25, 'NumericLiteral': -25, 'BigIntLiteral': -25, 'StringLiteral': -25, '[': -25, 'RegularExpressionLiteral': -25, 'NoSubstitutionTemplate': -25, 'TemplateHead': -25, 'new': -25, 'super': -25, 'import': -25, 'if': -25, 'do': -25, 'while': -25, 'for': -25, 'switch': -25, 'continue': -25, 'break': -25, 'return': -25, 'with': -25, 'throw': -25, 'try': -25, 'debugger': -25, 'function': -25, 'class': -25, 'const': -25, 'export': -25, '}': -25, 'else': -25, 'case': -25, 'default': -25},

    # 64. LabelledStatement
    #       Statement ::= LabelledStatement ·
    {None: -26, '{': -26, 'var': -26, ';': -26, 'delete': -26, 'void': -26, 'typeof': -26, '+': -26, '-': -26, '~': -26, '!': -26, '++': -26, '--': -26, 'yield': -26, 'Name': -26, 'NameWithEscape': -26, 'let': -26, 'static': -26, 'implements': -26, 'interface': -26, 'package': -26, 'private': -26, 'protected': -26, 'public': -26, 'as': -26, 'async': -26, 'from': -26, 'get': -26, 'of': -26, 'set': -26, 'target': -26, 'await': -26, '(': -26, 'this': -26, 'NullLiteral': -26, 'BooleanLiteral': -26, 'NumericLiteral': -26, 'BigIntLiteral': -26, 'StringLiteral': -26, '[': -26, 'RegularExpressionLiteral': -26, 'NoSubstitutionTemplate': -26, 'TemplateHead': -26, 'new': -26, 'super': -26, 'import': -26, 'if': -26, 'do': -26, 'while': -26, 'for': -26, 'switch': -26, 'continue': -26, 'break': -26, 'return': -26, 'with': -26, 'throw': -26, 'try': -26, 'debugger': -26, 'function': -26, 'class': -26, 'const': -26, 'export': -26, '}': -26, 'else': -26, 'case': -26, 'default': -26},

    # 65. ThrowStatement
    #       Statement ::= ThrowStatement ·
    {None: -27, '{': -27, 'var': -27, ';': -27, 'delete': -27, 'void': -27, 'typeof': -27, '+': -27, '-': -27, '~': -27, '!': -27, '++': -27, '--': -27, 'yield': -27, 'Name': -27, 'NameWithEscape': -27, 'let': -27, 'static': -27, 'implements': -27, 'interface': -27, 'package': -27, 'private': -27, 'protected': -27, 'public': -27, 'as': -27, 'async': -27, 'from': -27, 'get': -27, 'of': -27, 'set': -27, 'target': -27, 'await': -27, '(': -27, 'this': -27, 'NullLiteral': -27, 'BooleanLiteral': -27, 'NumericLiteral': -27, 'BigIntLiteral': -27, 'StringLiteral': -27, '[': -27, 'RegularExpressionLiteral': -27, 'NoSubstitutionTemplate': -27, 'TemplateHead': -27, 'new': -27, 'super': -27, 'import': -27, 'if': -27, 'do': -27, 'while': -27, 'for': -27, 'switch': -27, 'continue': -27, 'break': -27, 'return': -27, 'with': -27, 'throw': -27, 'try': -27, 'debugger': -27, 'function': -27, 'class': -27, 'const': -27, 'export': -27, '}': -27, 'else': -27, 'case': -27, 'default': -27},

    # 66. TryStatement
    #       Statement ::= TryStatement ·
    {None: -28, '{': -28, 'var': -28, ';': -28, 'delete': -28, 'void': -28, 'typeof': -28, '+': -28, '-': -28, '~': -28, '!': -28, '++': -28, '--': -28, 'yield': -28, 'Name': -28, 'NameWithEscape': -28, 'let': -28, 'static': -28, 'implements': -28, 'interface': -28, 'package': -28, 'private': -28, 'protected': -28, 'public': -28, 'as': -28, 'async': -28, 'from': -28, 'get': -28, 'of': -28, 'set': -28, 'target': -28, 'await': -28, '(': -28, 'this': -28, 'NullLiteral': -28, 'BooleanLiteral': -28, 'NumericLiteral': -28, 'BigIntLiteral': -28, 'StringLiteral': -28, '[': -28, 'RegularExpressionLiteral': -28, 'NoSubstitutionTemplate': -28, 'TemplateHead': -28, 'new': -28, 'super': -28, 'import': -28, 'if': -28, 'do': -28, 'while': -28, 'for': -28, 'switch': -28, 'continue': -28, 'break': -28, 'return': -28, 'with': -28, 'throw': -28, 'try': -28, 'debugger': -28, 'function': -28, 'class': -28, 'const': -28, 'export': -28, '}': -28, 'else': -28, 'case': -28, 'default': -28},

    # 67. DebuggerStatement
    #       Statement ::= DebuggerStatement ·
    {None: -29, '{': -29, 'var': -29, ';': -29, 'delete': -29, 'void': -29, 'typeof': -29, '+': -29, '-': -29, '~': -29, '!': -29, '++': -29, '--': -29, 'yield': -29, 'Name': -29, 'NameWithEscape': -29, 'let': -29, 'static': -29, 'implements': -29, 'interface': -29, 'package': -29, 'private': -29, 'protected': -29, 'public': -29, 'as': -29, 'async': -29, 'from': -29, 'get': -29, 'of': -29, 'set': -29, 'target': -29, 'await': -29, '(': -29, 'this': -29, 'NullLiteral': -29, 'BooleanLiteral': -29, 'NumericLiteral': -29, 'BigIntLiteral': -29, 'StringLiteral': -29, '[': -29, 'RegularExpressionLiteral': -29, 'NoSubstitutionTemplate': -29, 'TemplateHead': -29, 'new': -29, 'super': -29, 'import': -29, 'if': -29, 'do': -29, 'while': -29, 'for': -29, 'switch': -29, 'continue': -29, 'break': -29, 'return': -29, 'with': -29, 'throw': -29, 'try': -29, 'debugger': -29, 'function': -29, 'class': -29, 'const': -29, 'export': -29, '}': -29, 'else': -29, 'case': -29, 'default': -29},

    # 68. HoistableDeclaration[~Default]
    #       Declaration ::= HoistableDeclaration[~Default] ·
    {None: -30, '{': -30, 'var': -30, ';': -30, 'delete': -30, 'void': -30, 'typeof': -30, '+': -30, '-': -30, '~': -30, '!': -30, '++': -30, '--': -30, 'yield': -30, 'Name': -30, 'NameWithEscape': -30, 'let': -30, 'static': -30, 'implements': -30, 'interface': -30, 'package': -30, 'private': -30, 'protected': -30, 'public': -30, 'as': -30, 'async': -30, 'from': -30, 'get': -30, 'of': -30, 'set': -30, 'target': -30, 'await': -30, '(': -30, 'this': -30, 'NullLiteral': -30, 'BooleanLiteral': -30, 'NumericLiteral': -30, 'BigIntLiteral': -30, 'StringLiteral': -30, '[': -30, 'RegularExpressionLiteral': -30, 'NoSubstitutionTemplate': -30, 'TemplateHead': -30, 'new': -30, 'super': -30, 'import': -30, 'if': -30, 'do': -30, 'while': -30, 'for': -30, 'switch': -30, 'continue': -30, 'break': -30, 'return': -30, 'with': -30, 'throw': -30, 'try': -30, 'debugger': -30, 'function': -30, 'class': -30, 'const': -30, 'export': -30, '}': -30, 'case': -30, 'default': -30},

    # 69. ClassDeclaration[~Default]
    #       Declaration ::= ClassDeclaration[~Default] ·
    {None: -31, '{': -31, 'var': -31, ';': -31, 'delete': -31, 'void': -31, 'typeof': -31, '+': -31, '-': -31, '~': -31, '!': -31, '++': -31, '--': -31, 'yield': -31, 'Name': -31, 'NameWithEscape': -31, 'let': -31, 'static': -31, 'implements': -31, 'interface': -31, 'package': -31, 'private': -31, 'protected': -31, 'public': -31, 'as': -31, 'async': -31, 'from': -31, 'get': -31, 'of': -31, 'set': -31, 'target': -31, 'await': -31, '(': -31, 'this': -31, 'NullLiteral': -31, 'BooleanLiteral': -31, 'NumericLiteral': -31, 'BigIntLiteral': -31, 'StringLiteral': -31, '[': -31, 'RegularExpressionLiteral': -31, 'NoSubstitutionTemplate': -31, 'TemplateHead': -31, 'new': -31, 'super': -31, 'import': -31, 'if': -31, 'do': -31, 'while': -31, 'for': -31, 'switch': -31, 'continue': -31, 'break': -31, 'return': -31, 'with': -31, 'throw': -31, 'try': -31, 'debugger': -31, 'function': -31, 'class': -31, 'const': -31, 'export': -31, '}': -31, 'case': -31, 'default': -31},

    # 70. LexicalDeclaration[+In]
    #       Declaration ::= LexicalDeclaration[+In] ·
    {None: -32, '{': -32, 'var': -32, ';': -32, 'delete': -32, 'void': -32, 'typeof': -32, '+': -32, '-': -32, '~': -32, '!': -32, '++': -32, '--': -32, 'yield': -32, 'Name': -32, 'NameWithEscape': -32, 'let': -32, 'static': -32, 'implements': -32, 'interface': -32, 'package': -32, 'private': -32, 'protected': -32, 'public': -32, 'as': -32, 'async': -32, 'from': -32, 'get': -32, 'of': -32, 'set': -32, 'target': -32, 'await': -32, '(': -32, 'this': -32, 'NullLiteral': -32, 'BooleanLiteral': -32, 'NumericLiteral': -32, 'BigIntLiteral': -32, 'StringLiteral': -32, '[': -32, 'RegularExpressionLiteral': -32, 'NoSubstitutionTemplate': -32, 'TemplateHead': -32, 'new': -32, 'super': -32, 'import': -32, 'if': -32, 'do': -32, 'while': -32, 'for': -32, 'switch': -32, 'continue': -32, 'break': -32, 'return': -32, 'with': -32, 'throw': -32, 'try': -32, 'debugger': -32, 'function': -32, 'class': -32, 'const': -32, 'export': -32, '}': -32, 'case': -32, 'default': -32},

    # 71. Block
    #       BlockStatement ::= Block ·
    {None: -49, '{': -49, 'var': -49, ';': -49, 'delete': -49, 'void': -49, 'typeof': -49, '+': -49, '-': -49, '~': -49, '!': -49, '++': -49, '--': -49, 'yield': -49, 'Name': -49, 'NameWithEscape': -49, 'let': -49, 'static': -49, 'implements': -49, 'interface': -49, 'package': -49, 'private': -49, 'protected': -49, 'public': -49, 'as': -49, 'async': -49, 'from': -49, 'get': -49, 'of': -49, 'set': -49, 'target': -49, 'await': -49, '(': -49, 'this': -49, 'NullLiteral': -49, 'BooleanLiteral': -49, 'NumericLiteral': -49, 'BigIntLiteral': -49, 'StringLiteral': -49, '[': -49, 'RegularExpressionLiteral': -49, 'NoSubstitutionTemplate': -49, 'TemplateHead': -49, 'new': -49, 'super': -49, 'import': -49, 'if': -49, 'do': -49, 'while': -49, 'for': -49, 'switch': -49, 'continue': -49, 'break': -49, 'return': -49, 'with': -49, 'throw': -49, 'try': -49, 'debugger': -49, 'function': -49, 'class': -49, 'const': -49, 'export': -49, '}': -49, 'else': -49, 'case': -49, 'default': -49},

    # 72. Expression[+In]
    #       ExpressionStatement ::= [lookahead not in {'{', 'function', 'async', 'class', 'let'}] Expression[+In] · ";"
    #       ExpressionStatement ::= [lookahead not in {'{', 'function', 'async', 'class', 'let'}] Expression[+In] · ErrorSymbol(asi)
    #       Expression[+In] ::= Expression[+In] · "," AssignmentExpression[+In]
    {';': 221, ErrorToken: 222, ',': 223},

    # 73. IterationStatement
    #       BreakableStatement ::= IterationStatement ·
    {None: -61, '{': -61, 'var': -61, ';': -61, 'delete': -61, 'void': -61, 'typeof': -61, '+': -61, '-': -61, '~': -61, '!': -61, '++': -61, '--': -61, 'yield': -61, 'Name': -61, 'NameWithEscape': -61, 'let': -61, 'static': -61, 'implements': -61, 'interface': -61, 'package': -61, 'private': -61, 'protected': -61, 'public': -61, 'as': -61, 'async': -61, 'from': -61, 'get': -61, 'of': -61, 'set': -61, 'target': -61, 'await': -61, '(': -61, 'this': -61, 'NullLiteral': -61, 'BooleanLiteral': -61, 'NumericLiteral': -61, 'BigIntLiteral': -61, 'StringLiteral': -61, '[': -61, 'RegularExpressionLiteral': -61, 'NoSubstitutionTemplate': -61, 'TemplateHead': -61, 'new': -61, 'super': -61, 'import': -61, 'if': -61, 'do': -61, 'while': -61, 'for': -61, 'switch': -61, 'continue': -61, 'break': -61, 'return': -61, 'with': -61, 'throw': -61, 'try': -61, 'debugger': -61, 'function': -61, 'class': -61, 'const': -61, 'export': -61, '}': -61, 'else': -61, 'case': -61, 'default': -61},

    # 74. SwitchStatement
    #       BreakableStatement ::= SwitchStatement ·
    {None: -62, '{': -62, 'var': -62, ';': -62, 'delete': -62, 'void': -62, 'typeof': -62, '+': -62, '-': -62, '~': -62, '!': -62, '++': -62, '--': -62, 'yield': -62, 'Name': -62, 'NameWithEscape': -62, 'let': -62, 'static': -62, 'implements': -62, 'interface': -62, 'package': -62, 'private': -62, 'protected': -62, 'public': -62, 'as': -62, 'async': -62, 'from': -62, 'get': -62, 'of': -62, 'set': -62, 'target': -62, 'await': -62, '(': -62, 'this': -62, 'NullLiteral': -62, 'BooleanLiteral': -62, 'NumericLiteral': -62, 'BigIntLiteral': -62, 'StringLiteral': -62, '[': -62, 'RegularExpressionLiteral': -62, 'NoSubstitutionTemplate': -62, 'TemplateHead': -62, 'new': -62, 'super': -62, 'import': -62, 'if': -62, 'do': -62, 'while': -62, 'for': -62, 'switch': -62, 'continue': -62, 'break': -62, 'return': -62, 'with': -62, 'throw': -62, 'try': -62, 'debugger': -62, 'function': -62, 'class': -62, 'const': -62, 'export': -62, '}': -62, 'else': -62, 'case': -62, 'default': -62},

    # 75. LabelIdentifier
    #       LabelledStatement ::= LabelIdentifier · ":" LabelledItem
    {':': 224},

    # 76. FunctionDeclaration[~Default]
    #       HoistableDeclaration[~Default] ::= FunctionDeclaration[~Default] ·
    {None: -84, '{': -84, 'var': -84, ';': -84, 'delete': -84, 'void': -84, 'typeof': -84, '+': -84, '-': -84, '~': -84, '!': -84, '++': -84, '--': -84, 'yield': -84, 'Name': -84, 'NameWithEscape': -84, 'let': -84, 'static': -84, 'implements': -84, 'interface': -84, 'package': -84, 'private': -84, 'protected': -84, 'public': -84, 'as': -84, 'async': -84, 'from': -84, 'get': -84, 'of': -84, 'set': -84, 'target': -84, 'await': -84, '(': -84, 'this': -84, 'NullLiteral': -84, 'BooleanLiteral': -84, 'NumericLiteral': -84, 'BigIntLiteral': -84, 'StringLiteral': -84, '[': -84, 'RegularExpressionLiteral': -84, 'NoSubstitutionTemplate': -84, 'TemplateHead': -84, 'new': -84, 'super': -84, 'import': -84, 'if': -84, 'do': -84, 'while': -84, 'for': -84, 'switch': -84, 'continue': -84, 'break': -84, 'return': -84, 'with': -84, 'throw': -84, 'try': -84, 'debugger': -84, 'function': -84, 'class': -84, 'const': -84, 'export': -84, '}': -84, 'case': -84, 'default': -84},

    # 77. GeneratorDeclaration[~Default]
    #       HoistableDeclaration[~Default] ::= GeneratorDeclaration[~Default] ·
    {None: -85, '{': -85, 'var': -85, ';': -85, 'delete': -85, 'void': -85, 'typeof': -85, '+': -85, '-': -85, '~': -85, '!': -85, '++': -85, '--': -85, 'yield': -85, 'Name': -85, 'NameWithEscape': -85, 'let': -85, 'static': -85, 'implements': -85, 'interface': -85, 'package': -85, 'private': -85, 'protected': -85, 'public': -85, 'as': -85, 'async': -85, 'from': -85, 'get': -85, 'of': -85, 'set': -85, 'target': -85, 'await': -85, '(': -85, 'this': -85, 'NullLiteral': -85, 'BooleanLiteral': -85, 'NumericLiteral': -85, 'BigIntLiteral': -85, 'StringLiteral': -85, '[': -85, 'RegularExpressionLiteral': -85, 'NoSubstitutionTemplate': -85, 'TemplateHead': -85, 'new': -85, 'super': -85, 'import': -85, 'if': -85, 'do': -85, 'while': -85, 'for': -85, 'switch': -85, 'continue': -85, 'break': -85, 'return': -85, 'with': -85, 'throw': -85, 'try': -85, 'debugger': -85, 'function': -85, 'class': -85, 'const': -85, 'export': -85, '}': -85, 'case': -85, 'default': -85},

    # 78. AsyncFunctionDeclaration[~Default]
    #       HoistableDeclaration[~Default] ::= AsyncFunctionDeclaration[~Default] ·
    {None: -86, '{': -86, 'var': -86, ';': -86, 'delete': -86, 'void': -86, 'typeof': -86, '+': -86, '-': -86, '~': -86, '!': -86, '++': -86, '--': -86, 'yield': -86, 'Name': -86, 'NameWithEscape': -86, 'let': -86, 'static': -86, 'implements': -86, 'interface': -86, 'package': -86, 'private': -86, 'protected': -86, 'public': -86, 'as': -86, 'async': -86, 'from': -86, 'get': -86, 'of': -86, 'set': -86, 'target': -86, 'await': -86, '(': -86, 'this': -86, 'NullLiteral': -86, 'BooleanLiteral': -86, 'NumericLiteral': -86, 'BigIntLiteral': -86, 'StringLiteral': -86, '[': -86, 'RegularExpressionLiteral': -86, 'NoSubstitutionTemplate': -86, 'TemplateHead': -86, 'new': -86, 'super': -86, 'import': -86, 'if': -86, 'do': -86, 'while': -86, 'for': -86, 'switch': -86, 'continue': -86, 'break': -86, 'return': -86, 'with': -86, 'throw': -86, 'try': -86, 'debugger': -86, 'function': -86, 'class': -86, 'const': -86, 'export': -86, '}': -86, 'case': -86, 'default': -86},

    # 79. AsyncGeneratorDeclaration[~Default]
    #       HoistableDeclaration[~Default] ::= AsyncGeneratorDeclaration[~Default] ·
    {None: -87, '{': -87, 'var': -87, ';': -87, 'delete': -87, 'void': -87, 'typeof': -87, '+': -87, '-': -87, '~': -87, '!': -87, '++': -87, '--': -87, 'yield': -87, 'Name': -87, 'NameWithEscape': -87, 'let': -87, 'static': -87, 'implements': -87, 'interface': -87, 'package': -87, 'private': -87, 'protected': -87, 'public': -87, 'as': -87, 'async': -87, 'from': -87, 'get': -87, 'of': -87, 'set': -87, 'target': -87, 'await': -87, '(': -87, 'this': -87, 'NullLiteral': -87, 'BooleanLiteral': -87, 'NumericLiteral': -87, 'BigIntLiteral': -87, 'StringLiteral': -87, '[': -87, 'RegularExpressionLiteral': -87, 'NoSubstitutionTemplate': -87, 'TemplateHead': -87, 'new': -87, 'super': -87, 'import': -87, 'if': -87, 'do': -87, 'while': -87, 'for': -87, 'switch': -87, 'continue': -87, 'break': -87, 'return': -87, 'with': -87, 'throw': -87, 'try': -87, 'debugger': -87, 'function': -87, 'class': -87, 'const': -87, 'export': -87, '}': -87, 'case': -87, 'default': -87},

    # 80. LetOrConst
    #       LexicalDeclaration[+In] ::= LetOrConst · BindingList[+In] ";"
    #       LexicalDeclaration[+In] ::= LetOrConst · BindingList[+In] ErrorSymbol(asi)
    {'Name': 132, 'NameWithEscape': 132, 'let': 132, 'static': 132, 'implements': 132, 'interface': 132, 'package': 132, 'private': 132, 'protected': 132, 'public': 132, 'as': 132, 'async': 132, 'from': 132, 'get': 132, 'of': 132, 'set': 132, 'target': 132, 'yield': 133, 'await': 134, '{': 135, '[': 136},

    # 81. AssignmentExpression[+In]
    #       Expression[+In] ::= AssignmentExpression[+In] ·
    {';': -117, ErrorToken: -117, ',': -117, ')': -117, 'TemplateTail': -117, 'TemplateMiddle': -117, ']': -117, ':': -117},

    # 82. ConditionalExpression[+In]
    #       AssignmentExpression[+In] ::= ConditionalExpression[+In] ·
    {';': -107, ErrorToken: -107, ',': -107, ')': -107, ']': -107, 'TemplateTail': -107, 'TemplateMiddle': -107, ':': -107, '}': -107},

    # 83. YieldExpression[+In]
    #       AssignmentExpression[+In] ::= YieldExpression[+In] ·
    {';': -108, ErrorToken: -108, ',': -108, ')': -108, ']': -108, 'TemplateTail': -108, 'TemplateMiddle': -108, ':': -108, '}': -108},

    # 84. ArrowFunction[+In]
    #       AssignmentExpression[+In] ::= ArrowFunction[+In] ·
    {';': -109, ErrorToken: -109, ',': -109, ')': -109, ']': -109, 'TemplateTail': -109, 'TemplateMiddle': -109, ':': -109, '}': -109},

    # 85. AsyncArrowFunction[+In]
    #       AssignmentExpression[+In] ::= AsyncArrowFunction[+In] ·
    {';': -110, ErrorToken: -110, ',': -110, ')': -110, ']': -110, 'TemplateTail': -110, 'TemplateMiddle': -110, ':': -110, '}': -110},

    # 86. LeftHandSideExpression
    #       AssignmentExpression[+In] ::= LeftHandSideExpression · "=" AssignmentExpression[+In]
    #       AssignmentExpression[+In] ::= LeftHandSideExpression · AssignmentOperator AssignmentExpression[+In]
    #       UpdateExpression ::= LeftHandSideExpression ·
    #       UpdateExpression ::= LeftHandSideExpression · NoLineTerminatorHere "++"
    #       UpdateExpression ::= LeftHandSideExpression · NoLineTerminatorHere "--"
    {'=': 229, '++': -9223372036854775775, '--': -9223372036854775774, '*=': 232, '/=': 233, '%=': 234, '+=': 235, '-=': 236, '<<=': 237, '>>=': 238, '>>>=': 239, '&=': 240, '^=': 241, '|=': 242, '**=': 243, '**': -630, ';': -630, '??': -630, '?': -630, ErrorToken: -630, '*': -630, '/': -630, '%': -630, '+': -630, '-': -630, '<<': -630, '>>': -630, '>>>': -630, '<': -630, '>': -630, '<=': -630, '>=': -630, 'instanceof': -630, 'in': -630, '==': -630, '!=': -630, '===': -630, '!==': -630, '&': -630, '^': -630, '|': -630, '&&': -630, '||': -630, ',': -630, ')': -630, ']': -630, 'TemplateTail': -630, 'TemplateMiddle': -630, ':': -630, '}': -630},

    # 87. ShortCircuitExpression[+In]
    #       ConditionalExpression[+In] ::= ShortCircuitExpression[+In] ·
    #       ConditionalExpression[+In] ::= ShortCircuitExpression[+In] · "?" AssignmentExpression[+In] ":" AssignmentExpression[+In]
    {'?': 245, ';': -221, ErrorToken: -221, ',': -221, ')': -221, ']': -221, 'TemplateTail': -221, 'TemplateMiddle': -221, ':': -221, '}': -221},

    # 88. ArrowParameters
    #       ArrowFunction[+In] ::= ArrowParameters · NoLineTerminatorHere "=>" ConciseBody[+In]
    {'=>': -9223372036854775773},

    # 89. CoverCallExpressionAndAsyncArrowHead
    #       AsyncArrowFunction[+In] ::= CoverCallExpressionAndAsyncArrowHead · NoLineTerminatorHere "=>" AsyncConciseBody[+In]
    #       CallExpression ::= CoverCallExpressionAndAsyncArrowHead ·
    {'=>': -9223372036854775772, '=': -303, '*=': -303, '/=': -303, '%=': -303, '+=': -303, '-=': -303, '<<=': -303, '>>=': -303, '>>>=': -303, '&=': -303, '^=': -303, '|=': -303, '**=': -303, '(': -303, '[': -303, '.': -303, 'NoSubstitutionTemplate': -303, 'TemplateHead': -303, '?.': -303, '**': -303, '++': -303, '--': -303, ';': -303, '??': -303, '?': -303, ErrorToken: -303, '*': -303, '/': -303, '%': -303, '+': -303, '-': -303, '<<': -303, '>>': -303, '>>>': -303, '<': -303, '>': -303, '<=': -303, '>=': -303, 'instanceof': -303, 'in': -303, '==': -303, '!=': -303, '===': -303, '!==': -303, '&': -303, '^': -303, '|': -303, '&&': -303, '||': -303, ',': -303, ')': -303, ']': -303, 'TemplateTail': -303, 'TemplateMiddle': -303, ':': -303, '}': -303},

    # 90. NewExpression
    #       LeftHandSideExpression ::= NewExpression ·
    {'=': -229, '*=': -229, '/=': -229, '%=': -229, '+=': -229, '-=': -229, '<<=': -229, '>>=': -229, '>>>=': -229, '&=': -229, '^=': -229, '|=': -229, '**=': -229, '**': -229, '++': -229, '--': -229, ';': -229, '??': -229, '?': -229, ErrorToken: -229, '*': -229, '/': -229, '%': -229, '+': -229, '-': -229, '<<': -229, '>>': -229, '>>>': -229, '<': -229, '>': -229, '<=': -229, '>=': -229, 'instanceof': -229, 'in': -229, '==': -229, '!=': -229, '===': -229, '!==': -229, '&': -229, '^': -229, '|': -229, '&&': -229, '||': -229, ',': -229, ')': -229, ']': -229, 'TemplateTail': -229, 'TemplateMiddle': -229, 'of': -229, ':': -229, '}': -229, '{': -229},

    # 91. CallExpression
    #       LeftHandSideExpression ::= CallExpression ·
    #       CallExpression ::= CallExpression · Arguments
    #       CallExpression ::= CallExpression · "[" Expression[+In] "]"
    #       CallExpression ::= CallExpression · "." IdentifierName
    #       CallExpression ::= CallExpression · TemplateLiteral
    #       CallExpression ::= CallExpression · "." PrivateIdentifier
    #       OptionalExpression ::= CallExpression · OptionalChain
    {'[': 248, '.': 249, '(': 200, 'NoSubstitutionTemplate': 37, '?.': 250, 'TemplateHead': 38, '=': -230, '*=': -230, '/=': -230, '%=': -230, '+=': -230, '-=': -230, '<<=': -230, '>>=': -230, '>>>=': -230, '&=': -230, '^=': -230, '|=': -230, '**=': -230, '**': -230, '++': -230, '--': -230, ';': -230, '??': -230, '?': -230, ErrorToken: -230, '*': -230, '/': -230, '%': -230, '+': -230, '-': -230, '<<': -230, '>>': -230, '>>>': -230, '<': -230, '>': -230, '<=': -230, '>=': -230, 'instanceof': -230, 'in': -230, '==': -230, '!=': -230, '===': -230, '!==': -230, '&': -230, '^': -230, '|': -230, '&&': -230, '||': -230, ',': -230, ')': -230, ']': -230, 'TemplateTail': -230, 'TemplateMiddle': -230, 'of': -230, ':': -230, '}': -230, '{': -230},

    # 92. OptionalExpression
    #       LeftHandSideExpression ::= OptionalExpression ·
    #       OptionalExpression ::= OptionalExpression · OptionalChain
    {'?.': 250, '=': -231, '*=': -231, '/=': -231, '%=': -231, '+=': -231, '-=': -231, '<<=': -231, '>>=': -231, '>>>=': -231, '&=': -231, '^=': -231, '|=': -231, '**=': -231, '**': -231, '++': -231, '--': -231, ';': -231, '??': -231, '?': -231, ErrorToken: -231, '*': -231, '/': -231, '%': -231, '+': -231, '-': -231, '<<': -231, '>>': -231, '>>>': -231, '<': -231, '>': -231, '<=': -231, '>=': -231, 'instanceof': -231, 'in': -231, '==': -231, '!=': -231, '===': -231, '!==': -231, '&': -231, '^': -231, '|': -231, '&&': -231, '||': -231, ',': -231, ')': -231, ']': -231, 'TemplateTail': -231, 'TemplateMiddle': -231, 'of': -231, ':': -231, '}': -231, '{': -231},

    # 93. LogicalORExpression[+In]
    #       ShortCircuitExpression[+In] ::= LogicalORExpression[+In] ·
    #       LogicalORExpression[+In] ::= LogicalORExpression[+In] · "||" LogicalANDExpression[+In]
    {'||': 255, ';': -289, '?': -289, ErrorToken: -289, ',': -289, ')': -289, ']': -289, 'TemplateTail': -289, 'TemplateMiddle': -289, ':': -289, '}': -289},

    # 94. CoalesceExpression[+In]
    #       ShortCircuitExpression[+In] ::= CoalesceExpression[+In] ·
    #       CoalesceExpressionHead[+In] ::= CoalesceExpression[+In] ·
    {';': -290, '?': -290, ErrorToken: -290, ',': -290, ')': -290, ']': -290, 'TemplateTail': -290, 'TemplateMiddle': -290, ':': -290, '}': -290, '??': -411},

    # 95. BindingIdentifier
    #       ArrowParameters ::= BindingIdentifier ·
    {'=>': -291},

    # 96. CoverParenthesizedExpressionAndArrowParameterList
    #       ArrowParameters ::= CoverParenthesizedExpressionAndArrowParameterList ·
    #       PrimaryExpression ::= CoverParenthesizedExpressionAndArrowParameterList ·
    {'=>': -292, '(': -427, '=': -427, '?.': -427, '*=': -427, '/=': -427, '%=': -427, '+=': -427, '-=': -427, '<<=': -427, '>>=': -427, '>>>=': -427, '&=': -427, '^=': -427, '|=': -427, '**=': -427, '[': -427, '.': -427, 'NoSubstitutionTemplate': -427, 'TemplateHead': -427, '**': -427, '++': -427, '--': -427, ';': -427, '??': -427, '?': -427, ErrorToken: -427, '*': -427, '/': -427, '%': -427, '+': -427, '-': -427, '<<': -427, '>>': -427, '>>>': -427, '<': -427, '>': -427, '<=': -427, '>=': -427, 'instanceof': -427, 'in': -427, '==': -427, '!=': -427, '===': -427, '!==': -427, '&': -427, '^': -427, '|': -427, '&&': -427, '||': -427, ',': -427, ')': -427, ']': -427, 'TemplateTail': -427, 'TemplateMiddle': -427, 'of': -427, ':': -427, '}': -427},

    # 97. MemberExpression
    #       CoverCallExpressionAndAsyncArrowHead ::= MemberExpression · Arguments
    #       NewExpression ::= MemberExpression ·
    #       OptionalExpression ::= MemberExpression · OptionalChain
    #       MemberExpression ::= MemberExpression · "[" Expression[+In] "]"
    #       MemberExpression ::= MemberExpression · "." IdentifierName
    #       MemberExpression ::= MemberExpression · TemplateLiteral
    #       MemberExpression ::= MemberExpression · "." PrivateIdentifier
    {'[': 256, '.': 257, '(': 200, '?.': 250, 'NoSubstitutionTemplate': 37, 'TemplateHead': 38, '=': -301, '*=': -301, '/=': -301, '%=': -301, '+=': -301, '-=': -301, '<<=': -301, '>>=': -301, '>>>=': -301, '&=': -301, '^=': -301, '|=': -301, '**=': -301, '**': -301, '++': -301, '--': -301, ';': -301, '??': -301, '?': -301, ErrorToken: -301, '*': -301, '/': -301, '%': -301, '+': -301, '-': -301, '<<': -301, '>>': -301, '>>>': -301, '<': -301, '>': -301, '<=': -301, '>=': -301, 'instanceof': -301, 'in': -301, '==': -301, '!=': -301, '===': -301, '!==': -301, '&': -301, '^': -301, '|': -301, '&&': -301, '||': -301, ',': -301, ')': -301, ']': -301, 'TemplateTail': -301, 'TemplateMiddle': -301, 'of': -301, ':': -301, '}': -301, '{': -301},

    # 98. SuperCall
    #       CallExpression ::= SuperCall ·
    {'=': -304, '*=': -304, '/=': -304, '%=': -304, '+=': -304, '-=': -304, '<<=': -304, '>>=': -304, '>>>=': -304, '&=': -304, '^=': -304, '|=': -304, '**=': -304, '(': -304, '[': -304, '.': -304, 'NoSubstitutionTemplate': -304, 'TemplateHead': -304, '?.': -304, '**': -304, '++': -304, '--': -304, ';': -304, '??': -304, '?': -304, ErrorToken: -304, '*': -304, '/': -304, '%': -304, '+': -304, '-': -304, '<<': -304, '>>': -304, '>>>': -304, '<': -304, '>': -304, '<=': -304, '>=': -304, 'instanceof': -304, 'in': -304, '==': -304, '!=': -304, '===': -304, '!==': -304, '&': -304, '^': -304, '|': -304, '&&': -304, '||': -304, ',': -304, ')': -304, ']': -304, 'TemplateTail': -304, 'TemplateMiddle': -304, 'of': -304, ':': -304, '}': -304, '{': -304},

    # 99. ImportCall
    #       CallExpression ::= ImportCall ·
    {'=': -305, '*=': -305, '/=': -305, '%=': -305, '+=': -305, '-=': -305, '<<=': -305, '>>=': -305, '>>>=': -305, '&=': -305, '^=': -305, '|=': -305, '**=': -305, '(': -305, '[': -305, '.': -305, 'NoSubstitutionTemplate': -305, 'TemplateHead': -305, '?.': -305, '**': -305, '++': -305, '--': -305, ';': -305, '??': -305, '?': -305, ErrorToken: -305, '*': -305, '/': -305, '%': -305, '+': -305, '-': -305, '<<': -305, '>>': -305, '>>>': -305, '<': -305, '>': -305, '<=': -305, '>=': -305, 'instanceof': -305, 'in': -305, '==': -305, '!=': -305, '===': -305, '!==': -305, '&': -305, '^': -305, '|': -305, '&&': -305, '||': -305, ',': -305, ')': -305, ']': -305, 'TemplateTail': -305, 'TemplateMiddle': -305, 'of': -305, ':': -305, '}': -305, '{': -305},