thomasfoster96/es6-grammar.md

## es6-grammar.md

      
    Raw
  

              es6-grammar.md
            
          
    ES6 Grammar

Generated using http://github.com/rbuckton/grammarkdown
  SourceCharacter ::

   any Unicode code point
  InputElementDiv ::

   WhiteSpace

   LineTerminator

   Comment

   CommonToken

   DivPunctuator

   RightBracePunctuator
  InputElementRegExp ::

   WhiteSpace

   LineTerminator

   Comment

   CommonToken

   RightBracePunctuator

   RegularExpressionLiteral
  InputElementRegExpOrTemplateTail ::

   WhiteSpace

   LineTerminator

   Comment

   CommonToken

   RegularExpressionLiteral

   TemplateSubstitutionTail
  InputElementTemplateTail ::

   WhiteSpace

   LineTerminator

   Comment

   CommonToken

   DivPunctuator

   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

   SingleLineComment
  MultiLineComment ::

   /* MultiLineCommentChars_opt */
  MultiLineCommentChars ::

   MultiLineNotAsteriskChar MultiLineCommentChars_opt

   * PostAsteriskCommentChars_opt
  PostAsteriskCommentChars ::

   MultiLineNotForwardSlashOrAsteriskChar MultiLineCommentChars_opt

   * PostAsteriskCommentChars_opt
  MultiLineNotAsteriskChar ::

   SourceCharacter but not *
  MultiLineNotForwardSlashOrAsteriskChar ::

   SourceCharacter but not one of / or *
  SingleLineComment ::

   // SingleLineCommentChars_opt
  SingleLineCommentChars ::

   SingleLineCommentChar SingleLineCommentChars_opt
  SingleLineCommentChar ::

   SourceCharacter but not LineTerminator
  CommonToken ::

   IdentifierName

   Punctuator

   NumericLiteral

   StringLiteral

   Template
  IdentifierName ::

   IdentifierStart

   IdentifierName IdentifierPart
  IdentifierStart ::

   UnicodeIDStart

   $

   _

   \ UnicodeEscapeSequence
  IdentifierPart ::

   UnicodeIDContinue

   $

   _

   \ 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

   FutureReservedWord

   NullLiteral

   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

   BinaryIntegerLiteral

   OctalIntegerLiteral

   HexIntegerLiteral
  DecimalLiteral ::

   DecimalIntegerLiteral . DecimalDigits_opt ExponentPart_opt

   . DecimalDigits ExponentPart_opt

   DecimalIntegerLiteral ExponentPart_opt
  DecimalIntegerLiteral ::

   0

   NonZeroDigit DecimalDigits_opt
  DecimalDigits ::

   DecimalDigit

   DecimalDigits 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 SignedInteger
  ExponentIndicator :: one of
   e     E
  SignedInteger ::

   DecimalDigits

   + DecimalDigits

   - DecimalDigits
  BinaryIntegerLiteral ::

   0b BinaryDigits

   0B BinaryDigits
  BinaryDigits ::

   BinaryDigit

   BinaryDigits BinaryDigit
  BinaryDigit :: one of
   0     1
  OctalIntegerLiteral ::

   0o OctalDigits

   0O OctalDigits
  OctalDigits ::

   OctalDigit

   OctalDigits OctalDigit
  OctalDigit :: one of
   0     1     2     3     4     5     6     7
  HexIntegerLiteral ::

   0x HexDigits

   0X HexDigits
  HexDigits ::

   HexDigit

   HexDigits 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_opt "

   ' SingleStringCharacters_opt '
  DoubleStringCharacters ::

   DoubleStringCharacter DoubleStringCharacters_opt
  SingleStringCharacters ::

   SingleStringCharacter SingleStringCharacters_opt
  DoubleStringCharacter ::

   SourceCharacter but not one of " or \ or LineTerminator

   \ EscapeSequence

   LineContinuation
  SingleStringCharacter ::

   SourceCharacter but not one of ' or \ or LineTerminator

   \ EscapeSequence

   LineContinuation
  LineContinuation ::

   \ LineTerminatorSequence
  EscapeSequence ::

   CharacterEscapeSequence

   0 [lookahead ≠ DecimalDigit]

   HexEscapeSequence

   UnicodeEscapeSequence
  CharacterEscapeSequence ::

   SingleEscapeCharacter

   NonEscapeCharacter
  SingleEscapeCharacter :: one of
   '     "     \     b     f     n     r     t     v
  NonEscapeCharacter ::

   SourceCharacter but not one of EscapeCharacter or LineTerminator
  EscapeCharacter ::

   SingleEscapeCharacter

   DecimalDigit

   x

   u
  HexEscapeSequence ::

   x HexDigit HexDigit
  UnicodeEscapeSequence ::

   u Hex4Digits

   u{ HexDigits }
  Hex4Digits ::

   HexDigit HexDigit HexDigit HexDigit
  RegularExpressionLiteral ::

   / RegularExpressionBody / RegularExpressionFlags
  RegularExpressionBody ::

   RegularExpressionFirstChar RegularExpressionChars
  RegularExpressionChars ::

   [empty]

   RegularExpressionChars RegularExpressionChar
  RegularExpressionFirstChar ::

   RegularExpressionNonTerminator but not one of * or \ or / or [

   RegularExpressionBackslashSequence

   RegularExpressionClass
  RegularExpressionChar ::

   RegularExpressionNonTerminator but not one of \ or / or [

   RegularExpressionBackslashSequence

   RegularExpressionClass
  RegularExpressionBackslashSequence ::

   \ RegularExpressionNonTerminator
  RegularExpressionNonTerminator ::

   SourceCharacter but not LineTerminator
  RegularExpressionClass ::

   [ RegularExpressionClassChars ]
  RegularExpressionClassChars ::

   [empty]

   RegularExpressionClassChars RegularExpressionClassChar
  RegularExpressionClassChar ::

   RegularExpressionNonTerminator but not one of ] or \

   RegularExpressionBackslashSequence
  RegularExpressionFlags ::

   [empty]

   RegularExpressionFlags IdentifierPart
  Template ::

   NoSubstitutionTemplate

   TemplateHead
  NoSubstitutionTemplate ::

   ` TemplateCharacters_opt `
  TemplateHead ::

   ` TemplateCharacters_opt ${
  TemplateSubstitutionTail ::

   TemplateMiddle

   TemplateTail
  TemplateMiddle ::

   } TemplateCharacters_opt ${
  TemplateTail ::

   } TemplateCharacters_opt `
  TemplateCharacters ::

   TemplateCharacter TemplateCharacters_opt
  TemplateCharacter ::

   $ [lookahead ≠ {]

   \ EscapeSequence

   LineContinuation

   LineTerminatorSequence

   SourceCharacter but not one of ` or \ or $ or LineTerminator
  IdentifierReference_[Yield] :

   Identifier

   [~Yield] yield
  BindingIdentifier_[Yield] :

   Identifier

   [~Yield] yield
  LabelIdentifier_[Yield] :

   Identifier

   [~Yield] yield
  Identifier :

   IdentifierName but not ReservedWord
  PrimaryExpression_[Yield] :

   this

   IdentifierReference_[?Yield]

   Literal

   ArrayLiteral_[?Yield]

   ObjectLiteral_[?Yield]

   FunctionExpression

   ClassExpression_[?Yield]

   GeneratorExpression

   RegularExpressionLiteral

   TemplateLiteral_[?Yield]

   CoverParenthesizedExpressionAndArrowParameterList_[?Yield]
  CoverParenthesizedExpressionAndArrowParameterList_[Yield] :

   ( Expression_{[In, ?Yield]} )

   ( )

   ( ... BindingIdentifier_[?Yield] )

   ( Expression_{[In, ?Yield]} , ... BindingIdentifier_[?Yield] )
  Literal :

   NullLiteral

   BooleanLiteral

   NumericLiteral

   StringLiteral
  ArrayLiteral_[Yield] :

   [ Elision_opt ]

   [ ElementList_[?Yield] ]

   [ ElementList_[?Yield] , Elision_opt ]
  ElementList_[Yield] :

   Elision_opt AssignmentExpression_{[In, ?Yield]}

   Elision_opt SpreadElement_[?Yield]

   ElementList_[?Yield] , Elision_opt AssignmentExpression_{[In, ?Yield]}

   ElementList_[?Yield] , Elision_opt SpreadElement_[?Yield]
  Elision :

   ,

   Elision ,
  SpreadElement_[Yield] :

   ... AssignmentExpression_{[In, ?Yield]}
  ObjectLiteral_[Yield] :

   { }

   { PropertyDefinitionList_[?Yield] }

   { PropertyDefinitionList_[?Yield] , }
  PropertyDefinitionList_[Yield] :

   PropertyDefinition_[?Yield]

   PropertyDefinitionList_[?Yield] , PropertyDefinition_[?Yield]
  PropertyDefinition_[Yield] :

   IdentifierReference_[?Yield]

   CoverInitializedName_[?Yield]

   PropertyName_[?Yield] : AssignmentExpression_{[In, ?Yield]}

   MethodDefinition_[?Yield]
  PropertyName_[Yield] :

   LiteralPropertyName

   ComputedPropertyName_[?Yield]
  LiteralPropertyName :

   IdentifierName

   StringLiteral

   NumericLiteral
  ComputedPropertyName_[Yield] :

   [ AssignmentExpression_{[In, ?Yield]} ]
  CoverInitializedName_[Yield] :

   IdentifierReference_[?Yield] Initializer_{[In, ?Yield]}
  Initializer_{[In, Yield]} :

   = AssignmentExpression_{[?In, ?Yield]}
  TemplateLiteral_[Yield] :

   NoSubstitutionTemplate

   TemplateHead Expression_{[In, ?Yield]} TemplateSpans_[?Yield]
  TemplateSpans_[Yield] :

   TemplateTail

   TemplateMiddleList_[?Yield] TemplateTail
  TemplateMiddleList_[Yield] :

   TemplateMiddle Expression_{[In, ?Yield]}

   TemplateMiddleList_[?Yield] TemplateMiddle Expression_{[In, ?Yield]}
  MemberExpression_[Yield] :

   PrimaryExpression_[?Yield]

   MemberExpression_[?Yield] [ Expression_{[In, ?Yield]} ]

   MemberExpression_[?Yield] . IdentifierName

   MemberExpression_[?Yield] TemplateLiteral_[?Yield]

   SuperProperty_[?Yield]

   MetaProperty

   new MemberExpression_[?Yield] Arguments_[?Yield]
  SuperProperty_[Yield] :

   super [ Expression_{[In, ?Yield]} ]

   super . IdentifierName
  MetaProperty :

   NewTarget
  NewTarget :

   new . target
  NewExpression_[Yield] :

   MemberExpression_[?Yield]

   new NewExpression_[?Yield]
  CallExpression_[Yield] :

   MemberExpression_[?Yield] Arguments_[?Yield]

   SuperCall_[?Yield]

   CallExpression_[?Yield] Arguments_[?Yield]

   CallExpression_[?Yield] [ Expression_{[In, ?Yield]} ]

   CallExpression_[?Yield] . IdentifierName

   CallExpression_[?Yield] TemplateLiteral_[?Yield]
  SuperCall_[Yield] :

   super Arguments_[?Yield]
  Arguments_[Yield] :

   ( )

   ( ArgumentList_[?Yield] )
  ArgumentList_[Yield] :

   AssignmentExpression_{[In, ?Yield]}

   ... AssignmentExpression_{[In, ?Yield]}

   ArgumentList_[?Yield] , AssignmentExpression_{[In, ?Yield]}

   ArgumentList_[?Yield] , ... AssignmentExpression_{[In, ?Yield]}
  LeftHandSideExpression_[Yield] :

   NewExpression_[?Yield]

   CallExpression_[?Yield]
  PostfixExpression_[Yield] :

   LeftHandSideExpression_[?Yield]

   LeftHandSideExpression_[?Yield] [no LineTerminator here] ++

   LeftHandSideExpression_[?Yield] [no LineTerminator here] --
  UnaryExpression_[Yield] :

   PostfixExpression_[?Yield]

   delete UnaryExpression_[?Yield]

   void UnaryExpression_[?Yield]

   typeof UnaryExpression_[?Yield]

   ++ UnaryExpression_[?Yield]

   -- UnaryExpression_[?Yield]

   + UnaryExpression_[?Yield]

   - UnaryExpression_[?Yield]

   ~ UnaryExpression_[?Yield]

   ! UnaryExpression_[?Yield]
  MultiplicativeExpression_[Yield] :

   UnaryExpression_[?Yield]

   MultiplicativeExpression_[?Yield] MultiplicativeOperator UnaryExpression_[?Yield]
  MultiplicativeOperator : one of
   *     /     %
  AdditiveExpression_[Yield] :

   MultiplicativeExpression_[?Yield]

   AdditiveExpression_[?Yield] + MultiplicativeExpression_[?Yield]

   AdditiveExpression_[?Yield] - MultiplicativeExpression_[?Yield]
  ShiftExpression_[Yield] :

   AdditiveExpression_[?Yield]

   ShiftExpression_[?Yield] << AdditiveExpression_[?Yield]

   ShiftExpression_[?Yield] >> AdditiveExpression_[?Yield]

   ShiftExpression_[?Yield] >>> AdditiveExpression_[?Yield]
  RelationalExpression_{[In, Yield]} :

   ShiftExpression_[?Yield]

   RelationalExpression_{[?In, ?Yield]} < ShiftExpression_[?Yield]

   RelationalExpression_{[?In, ?Yield]} > ShiftExpression_[?Yield]

   RelationalExpression_{[?In, ?Yield]} <= ShiftExpression_[?Yield]

   RelationalExpression_{[?In, ?Yield]} >= ShiftExpression_[?Yield]

   RelationalExpression_{[?In, ?Yield]} instanceof ShiftExpression_[?Yield]

   [+In] RelationalExpression_{[In, ?Yield]} in ShiftExpression_[?Yield]
  EqualityExpression_{[In, Yield]} :

   RelationalExpression_{[?In, ?Yield]}

   EqualityExpression_{[?In, ?Yield]} == RelationalExpression_{[?In, ?Yield]}

   EqualityExpression_{[?In, ?Yield]} != RelationalExpression_{[?In, ?Yield]}

   EqualityExpression_{[?In, ?Yield]} === RelationalExpression_{[?In, ?Yield]}

   EqualityExpression_{[?In, ?Yield]} !== RelationalExpression_{[?In, ?Yield]}
  BitwiseANDExpression_{[In, Yield]} :

   EqualityExpression_{[?In, ?Yield]}

   BitwiseANDExpression_{[?In, ?Yield]} & EqualityExpression_{[?In, ?Yield]}
  BitwiseXORExpression_{[In, Yield]} :

   BitwiseANDExpression_{[?In, ?Yield]}

   BitwiseXORExpression_{[?In, ?Yield]} ^ BitwiseANDExpression_{[?In, ?Yield]}
  BitwiseORExpression_{[In, Yield]} :

   BitwiseXORExpression_{[?In, ?Yield]}

   BitwiseORExpression_{[?In, ?Yield]} | BitwiseXORExpression_{[?In, ?Yield]}
  LogicalANDExpression_{[In, Yield]} :

   BitwiseORExpression_{[?In, ?Yield]}

   LogicalANDExpression_{[?In, ?Yield]} && BitwiseORExpression_{[?In, ?Yield]}
  LogicalORExpression_{[In, Yield]} :

   LogicalANDExpression_{[?In, ?Yield]}

   LogicalORExpression_{[?In, ?Yield]} || LogicalANDExpression_{[?In, ?Yield]}
  ConditionalExpression_{[In, Yield]} :

   LogicalORExpression_{[?In, ?Yield]}

   LogicalORExpression_{[?In, ?Yield]} ? AssignmentExpression_{[In, ?Yield]} : AssignmentExpression_{[?In, ?Yield]}
  AssignmentExpression_{[In, Yield]} :

   ConditionalExpression_{[?In, ?Yield]}

   [+Yield] YieldExpression_[?In]

   ArrowFunction_{[?In, ?Yield]}

   LeftHandSideExpression_[?Yield] = AssignmentExpression_{[?In, ?Yield]}

   LeftHandSideExpression_[?Yield] AssignmentOperator AssignmentExpression_{[?In, ?Yield]}
  AssignmentOperator : one of
   *=    /=    %=    +=    -=    <<=   >>=   >>>=  &=    ^=  
   |=
  Expression_{[In, Yield]} :

   AssignmentExpression_{[?In, ?Yield]}

   Expression_{[?In, ?Yield]} , AssignmentExpression_{[?In, ?Yield]}
  Statement_{[Yield, Return]} :

   BlockStatement_{[?Yield, ?Return]}

   VariableStatement_[?Yield]

   EmptyStatement

   ExpressionStatement_[?Yield]

   IfStatement_{[?Yield, ?Return]}

   BreakableStatement_{[?Yield, ?Return]}

   ContinueStatement_[?Yield]

   BreakStatement_[?Yield]

   [+Return] ReturnStatement_[?Yield]

   WithStatement_{[?Yield, ?Return]}

   LabelledStatement_{[?Yield, ?Return]}

   ThrowStatement_[?Yield]

   TryStatement_{[?Yield, ?Return]}

   DebuggerStatement
  Declaration_[Yield] :

   HoistableDeclaration_[?Yield]

   ClassDeclaration_[?Yield]

   LexicalDeclaration_{[In, ?Yield]}
  HoistableDeclaration_{[Yield, Default]} :

   FunctionDeclaration_{[?Yield, ?Default]}

   GeneratorDeclaration_{[?Yield, ?Default]}
  BreakableStatement_{[Yield, Return]} :

   IterationStatement_{[?Yield, ?Return]}

   SwitchStatement_{[?Yield, ?Return]}
  BlockStatement_{[Yield, Return]} :

   Block_{[?Yield, ?Return]}
  Block_{[Yield, Return]} :

   { StatementList_{[?Yield, ?Return]}_opt }
  StatementList_{[Yield, Return]} :

   StatementListItem_{[?Yield, ?Return]}

   StatementList_{[?Yield, ?Return]} StatementListItem_{[?Yield, ?Return]}
  StatementListItem_{[Yield, Return]} :

   Statement_{[?Yield, ?Return]}

   Declaration_[?Yield]
  LexicalDeclaration_{[In, Yield]} :

   LetOrConst BindingList_{[?In, ?Yield]} ;
  LetOrConst :

   let

   const
  BindingList_{[In, Yield]} :

   LexicalBinding_{[?In, ?Yield]}

   BindingList_{[?In, ?Yield]} , LexicalBinding_{[?In, ?Yield]}
  LexicalBinding_{[In, Yield]} :

   BindingIdentifier_[?Yield] Initializer_{[?In, ?Yield]}_opt

   BindingPattern_[?Yield] Initializer_{[?In, ?Yield]}
  VariableStatement_[Yield] :

   var VariableDeclarationList_{[In, ?Yield]} ;
  VariableDeclarationList_{[In, Yield]} :

   VariableDeclaration_{[?In, ?Yield]}

   VariableDeclarationList_{[?In, ?Yield]} , VariableDeclaration_{[?In, ?Yield]}
  VariableDeclaration_{[In, Yield]} :

   BindingIdentifier_[?Yield] Initializer_{[?In, ?Yield]}_opt

   BindingPattern_[?Yield] Initializer_{[?In, ?Yield]}
  BindingPattern_[Yield] :

   ObjectBindingPattern_[?Yield]

   ArrayBindingPattern_[?Yield]
  ObjectBindingPattern_[Yield] :

   { }

   { BindingPropertyList_[?Yield] }

   { BindingPropertyList_[?Yield] , }
  ArrayBindingPattern_[Yield] :

   [ Elision_opt BindingRestElement_[?Yield]_opt ]

   [ BindingElementList_[?Yield] ]

   [ BindingElementList_[?Yield] , Elision_opt BindingRestElement_[?Yield]_opt ]
  BindingPropertyList_[Yield] :

   BindingProperty_[?Yield]

   BindingPropertyList_[?Yield] , BindingProperty_[?Yield]
  BindingElementList_[Yield] :

   BindingElisionElement_[?Yield]

   BindingElementList_[?Yield] , BindingElisionElement_[?Yield]
  BindingElisionElement_[Yield] :

   Elision_opt BindingElement_[?Yield]
  BindingProperty_[Yield] :

   SingleNameBinding_[?Yield]

   PropertyName_[?Yield] : BindingElement_[?Yield]
  BindingElement_[Yield] :

   SingleNameBinding_[?Yield]

   BindingPattern_[?Yield] Initializer_{[In, ?Yield]}_opt
  SingleNameBinding_[Yield] :

   BindingIdentifier_[?Yield] Initializer_{[In, ?Yield]}_opt
  BindingRestElement_[Yield] :

   ... BindingIdentifier_[?Yield]
  EmptyStatement :

   ;
  ExpressionStatement_[Yield] :

   [lookahead ∉ { {, function, class, let [ }] Expression_{[In, ?Yield]} ;
  IfStatement_{[Yield, Return]} :

   if ( Expression_{[In, ?Yield]} ) Statement_{[?Yield, ?Return]} else Statement_{[?Yield, ?Return]}

   if ( Expression_{[In, ?Yield]} ) Statement_{[?Yield, ?Return]}
  IterationStatement_{[Yield, Return]} :

   do Statement_{[?Yield, ?Return]} while ( Expression_{[In, ?Yield]} ) ;

   while ( Expression_{[In, ?Yield]} ) Statement_{[?Yield, ?Return]}

   for ( [lookahead ∉ { let [ }] Expression_[?Yield]_opt ; Expression_{[In, ?Yield]}_opt ; Expression_{[In, ?Yield]}_opt ) Statement_{[?Yield, ?Return]}

   for ( var VariableDeclarationList_[?Yield] ; Expression_{[In, ?Yield]}_opt ; Expression_{[In, ?Yield]}_opt ) Statement_{[?Yield, ?Return]}

   for ( LexicalDeclaration_[?Yield] Expression_{[In, ?Yield]}_opt ; Expression_{[In, ?Yield]}_opt ) Statement_{[?Yield, ?Return]}

   for ( [lookahead ∉ { let [ }] LeftHandSideExpression_[?Yield] in Expression_{[In, ?Yield]} ) Statement_{[?Yield, ?Return]}

   for ( var ForBinding_[?Yield] in Expression_{[In, ?Yield]} ) Statement_{[?Yield, ?Return]}

   for ( ForDeclaration_[?Yield] in Expression_{[In, ?Yield]} ) Statement_{[?Yield, ?Return]}

   for ( [lookahead ≠ let] LeftHandSideExpression_[?Yield] of AssignmentExpression_{[In, ?Yield]} ) Statement_{[?Yield, ?Return]}

   for ( var ForBinding_[?Yield] of AssignmentExpression_{[In, ?Yield]} ) Statement_{[?Yield, ?Return]}

   for ( ForDeclaration_[?Yield] of AssignmentExpression_{[In, ?Yield]} ) Statement_{[?Yield, ?Return]}
  ForDeclaration_[Yield] :

   LetOrConst ForBinding_[?Yield]
  ForBinding_[Yield] :

   BindingIdentifier_[?Yield]

   BindingPattern_[?Yield]
  ContinueStatement_[Yield] :

   continue ;

   continue [no LineTerminator here] LabelIdentifier_[?Yield] ;
  BreakStatement_[Yield] :

   break ;

   break [no LineTerminator here] LabelIdentifier_[?Yield] ;
  ReturnStatement_[Yield] :

   return ;

   return [no LineTerminator here] Expression_{[In, ?Yield]} ;
  WithStatement_{[Yield, Return]} :

   with ( Expression_{[In, ?Yield]} ) Statement_{[?Yield, ?Return]}
  SwitchStatement_{[Yield, Return]} :

   switch ( Expression_{[In, ?Yield]} ) CaseBlock_{[?Yield, ?Return]}
  CaseBlock_{[Yield, Return]} :

   { CaseClauses_{[?Yield, ?Return]}_opt }

   { CaseClauses_{[?Yield, ?Return]}_opt DefaultClause_{[?Yield, ?Return]} CaseClauses_{[?Yield, ?Return]}_opt }
  CaseClauses_{[Yield, Return]} :

   CaseClause_{[?Yield, ?Return]}

   CaseClauses_{[?Yield, ?Return]} CaseClause_{[?Yield, ?Return]}
  CaseClause_{[Yield, Return]} :

   case Expression_{[In, ?Yield]} : StatementList_{[?Yield, ?Return]}_opt
  DefaultClause_{[Yield, Return]} :

   default : StatementList_{[?Yield, ?Return]}_opt
  LabelledStatement_{[Yield, Return]} :

   LabelIdentifier_[?Yield] : LabelledItem_{[?Yield, ?Return]}
  LabelledItem_{[Yield, Return]} :

   Statement_{[?Yield, ?Return]}

   FunctionDeclaration_[?Yield]
  ThrowStatement_[Yield] :

   throw [no LineTerminator here] Expression_{[In, ?Yield]} ;
  TryStatement_{[Yield, Return]} :

   try Block_{[?Yield, ?Return]} Catch_{[?Yield, ?Return]}

   try Block_{[?Yield, ?Return]} Finally_{[?Yield, ?Return]}

   try Block_{[?Yield, ?Return]} Catch_{[?Yield, ?Return]} Finally_{[?Yield, ?Return]}
  Catch_{[Yield, Return]} :

   catch ( CatchParameter_[?Yield] ) Block_{[?Yield, ?Return]}
  Finally_{[Yield, Return]} :

   finally Block_{[?Yield, ?Return]}
  CatchParameter_[Yield] :

   BindingIdentifier_[?Yield]

   BindingPattern_[?Yield]
  DebuggerStatement :

   debugger ;
  FunctionDeclaration_{[Yield, Default]} :

   function BindingIdentifier_[?Yield] ( FormalParameters ) { FunctionBody }

   [+Default] function ( FormalParameters ) { FunctionBody }
  FunctionExpression :

   function BindingIdentifier_opt ( FormalParameters ) { FunctionBody }
  StrictFormalParameters_[Yield] :

   FormalParameters_[?Yield]
  FormalParameters_[Yield] :

   [empty]

   FormalParameterList_[?Yield]
  FormalParameterList_[Yield] :

   FunctionRestParameter_[?Yield]

   FormalsList_[?Yield]

   FormalsList_[?Yield] , FunctionRestParameter_[?Yield]
  FormalsList_[Yield] :

   FormalParameter_[?Yield]

   FormalsList_[?Yield] , FormalParameter_[?Yield]
  FunctionRestParameter_[Yield] :

   BindingRestElement_[?Yield]
  FormalParameter_[Yield] :

   BindingElement_[?Yield]
  FunctionBody_[Yield] :

   FunctionStatementList_[?Yield]
  FunctionStatementList_[Yield] :

   StatementList_{[?Yield, Return]}_opt
  ArrowFunction_{[In, Yield]} :

   ArrowParameters_[?Yield] [no LineTerminator here] => ConciseBody_[?In]
  ArrowParameters_[Yield] :

   BindingIdentifier_[?Yield]

   CoverParenthesizedExpressionAndArrowParameterList_[?Yield]
  ConciseBody_[In] :

   [lookahead ≠ {] AssignmentExpression_[?In]

   { FunctionBody }
  MethodDefinition_[Yield] :

   PropertyName_[?Yield] ( StrictFormalParameters ) { FunctionBody }

   GeneratorMethod_[?Yield]

   get PropertyName_[?Yield] ( ) { FunctionBody }

   set PropertyName_[?Yield] ( PropertySetParameterList ) { FunctionBody }
  PropertySetParameterList :

   FormalParameter
  GeneratorMethod_[Yield] :

   * PropertyName_[?Yield] ( StrictFormalParameters_[Yield] ) { GeneratorBody }
  GeneratorDeclaration_{[Yield, Default]} :

   function * BindingIdentifier_[?Yield] ( FormalParameters_[Yield] ) { GeneratorBody }

   [+Default] function * ( FormalParameters_[Yield] ) { GeneratorBody }
  GeneratorExpression :

   function * BindingIdentifier_[Yield]_opt ( FormalParameters_[Yield] ) { GeneratorBody }
  GeneratorBody :

   FunctionBody_[Yield]
  YieldExpression_[In] :

   yield

   yield [no LineTerminator here] AssignmentExpression_{[?In, Yield]}

   yield [no LineTerminator here] * AssignmentExpression_{[?In, Yield]}
  ClassDeclaration_{[Yield, Default]} :

   class BindingIdentifier_[?Yield] ClassTail_[?Yield]

   [+Default] class ClassTail_[?Yield]
  ClassExpression_[Yield] :

   class BindingIdentifier_[?Yield]_opt ClassTail_[?Yield]
  ClassTail_[Yield] :

   ClassHeritage_[?Yield]_opt { ClassBody_[?Yield]_opt }
  ClassHeritage_[Yield] :

   extends LeftHandSideExpression_[?Yield]
  ClassBody_[Yield] :

   ClassElementList_[?Yield]
  ClassElementList_[Yield] :

   ClassElement_[?Yield]

   ClassElementList_[?Yield] ClassElement_[?Yield]
  ClassElement_[Yield] :

   MethodDefinition_[?Yield]

   static MethodDefinition_[?Yield]

   ;
  Script :

   ScriptBody_opt
  ScriptBody :

   StatementList
  Module :

   ModuleBody_opt
  ModuleBody :

   ModuleItemList
  ModuleItemList :

   ModuleItem

   ModuleItemList ModuleItem
  ModuleItem :

   ImportDeclaration

   ExportDeclaration

   StatementListItem
  ImportDeclaration :

   import ImportClause FromClause ;

   import ModuleSpecifier ;
  ImportClause :

   ImportedDefaultBinding

   NameSpaceImport

   NamedImports

   ImportedDefaultBinding , NameSpaceImport

   ImportedDefaultBinding , NamedImports
  ImportedDefaultBinding :

   ImportedBinding
  NameSpaceImport :

   * as ImportedBinding
  NamedImports :

   { }

   { ImportsList }

   { ImportsList , }
  FromClause :

   from ModuleSpecifier
  ImportsList :

   ImportSpecifier

   ImportsList , ImportSpecifier
  ImportSpecifier :

   ImportedBinding

   IdentifierName as ImportedBinding
  ModuleSpecifier :

   StringLiteral
  ImportedBinding :

   BindingIdentifier
  ExportDeclaration :

   export * FromClause ;

   export ExportClause FromClause ;

   export ExportClause ;

   export VariableStatement

   export Declaration

   export default HoistableDeclaration_[Default]

   export default ClassDeclaration_[Default]

   export default [lookahead ∉ { function, class }] AssignmentExpression_[In] ;
  ExportClause :

   { }

   { ExportsList }

   { ExportsList , }
  ExportsList :

   ExportSpecifier

   ExportsList , ExportSpecifier
  ExportSpecifier :

   IdentifierName

   IdentifierName as IdentifierName