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

Hey, that's pretty neat. But what (grammar) source did you use to generate that markdown? Is it https://tc39.github.io/ecma262/#sec-ecmascript-language-lexical-grammar ?