Dilbilgisi Özeti

#A.1 Sözcüksel Dilbilgisi

SourceCharacter SourceCharacter :: herhangi bir Unicode kod noktası

InputElementDiv InputElementDiv :: WhiteSpace LineTerminator Comment CommonToken DivPunctuator RightBracePunctuator

InputElementRegExp InputElementRegExp :: WhiteSpace LineTerminator Comment CommonToken RightBracePunctuator RegularExpressionLiteral

InputElementRegExpOrTemplateTail InputElementRegExpOrTemplateTail :: WhiteSpace LineTerminator Comment CommonToken RegularExpressionLiteral TemplateSubstitutionTail

InputElementTemplateTail InputElementTemplateTail :: WhiteSpace LineTerminator Comment CommonToken DivPunctuator TemplateSubstitutionTail

InputElementHashbangOrRegExp InputElementHashbangOrRegExp :: WhiteSpace LineTerminator Comment CommonToken HashbangComment RegularExpressionLiteral

WhiteSpace WhiteSpace ::

LineTerminator LineTerminator ::

LineTerminatorSequence LineTerminatorSequence :: [lookahead ≠ ]

Comment Comment :: MultiLineComment SingleLineComment

MultiLineComment MultiLineComment :: /* MultiLineCommentCharsopt ***/**

MultiLineCommentChars MultiLineCommentChars :: MultiLineNotAsteriskChar MultiLineCommentCharsopt ***** PostAsteriskCommentCharsopt

PostAsteriskCommentChars PostAsteriskCommentChars :: MultiLineNotForwardSlashOrAsteriskChar MultiLineCommentCharsopt ***** PostAsteriskCommentCharsopt

MultiLineNotAsteriskChar MultiLineNotAsteriskChar :: SourceCharacter but not *****

MultiLineNotForwardSlashOrAsteriskChar MultiLineNotForwardSlashOrAsteriskChar :: SourceCharacter but not one of / or *****

SingleLineComment SingleLineComment :: // SingleLineCommentCharsopt

SingleLineCommentChars SingleLineCommentChars :: SingleLineCommentChar SingleLineCommentCharsopt

SingleLineCommentChar SingleLineCommentChar :: SourceCharacter but not LineTerminator

HashbangComment HashbangComment :: #! SingleLineCommentCharsopt

CommonToken CommonToken :: IdentifierName PrivateIdentifier Punctuator NumericLiteral StringLiteral Template

PrivateIdentifier PrivateIdentifier :: # IdentifierName

IdentifierName IdentifierName :: IdentifierStart IdentifierName IdentifierPart

IdentifierStart IdentifierStart :: IdentifierStartChar **** UnicodeEscapeSequence

IdentifierPart IdentifierPart :: IdentifierPartChar **** UnicodeEscapeSequence

IdentifierStartChar IdentifierStartChar :: UnicodeIDStart $ _

IdentifierPartChar IdentifierPartChar :: UnicodeIDContinue $

AsciiLetter AsciiLetter :: one of a b c d e f g h i j k l m n o p q r s t u v w x y z A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

UnicodeIDStart UnicodeIDStart :: "ID_Start" Unicode özelliğine sahip herhangi bir Unicode kod noktası

UnicodeIDContinue UnicodeIDContinue :: "ID_Continue" Unicode özelliğine sahip herhangi bir Unicode kod noktası

ReservedWord ReservedWord :: one of await break case catch class const continue debugger default delete do else enum export extends false finally for function if import in instanceof new null return super switch this throw true try typeof var void while with yield

Punctuator Punctuator :: OptionalChainingPunctuator OtherPunctuator

OptionalChainingPunctuator OptionalChainingPunctuator :: ?. [lookahead ∉ DecimalDigit]

OtherPunctuator OtherPunctuator :: one of { ( ) [ ] . ... ; , <** **> <=** **>= == != === !== + - ***** % ****** ++ -- <<** **>> >>> & | ^ ! ~ && || ?? ? : = += -= ***=** %= ****=** <<=** **>>= >>>= &= |= ^= &&= ||= ??= =>

DivPunctuator DivPunctuator :: / /=

RightBracePunctuator RightBracePunctuator :: }

NullLiteral NullLiteral :: null

BooleanLiteral BooleanLiteral :: true false

NumericLiteralSeparator NumericLiteralSeparator :: _

NumericLiteral NumericLiteral :: DecimalLiteral DecimalBigIntegerLiteral NonDecimalIntegerLiteral[+Sep] NonDecimalIntegerLiteral[+Sep] BigIntLiteralSuffix LegacyOctalIntegerLiteral

DecimalBigIntegerLiteral DecimalBigIntegerLiteral :: 0 BigIntLiteralSuffix NonZeroDigit DecimalDigits[+Sep]opt BigIntLiteralSuffix NonZeroDigit NumericLiteralSeparator DecimalDigits[+Sep] BigIntLiteralSuffix

NonDecimalIntegerLiteral NonDecimalIntegerLiteral[Sep] :: BinaryIntegerLiteral[?Sep] OctalIntegerLiteral[?Sep] HexIntegerLiteral[?Sep]

BigIntLiteralSuffix BigIntLiteralSuffix :: n

DecimalLiteral DecimalLiteral :: DecimalIntegerLiteral . DecimalDigits[+Sep]opt ExponentPart[+Sep]opt . DecimalDigits[+Sep] ExponentPart[+Sep]opt DecimalIntegerLiteral ExponentPart[+Sep]opt

DecimalIntegerLiteral DecimalIntegerLiteral :: 0 NonZeroDigit NonZeroDigit NumericLiteralSeparatoropt DecimalDigits[+Sep] NonOctalDecimalIntegerLiteral

DecimalDigits DecimalDigits[Sep] :: DecimalDigit DecimalDigits[?Sep] DecimalDigit [+Sep] DecimalDigits[+Sep] NumericLiteralSeparator DecimalDigit

DecimalDigit DecimalDigit :: one of 0 1 2 3 4 5 6 7 8 9

NonZeroDigit NonZeroDigit :: one of 1 2 3 4 5 6 7 8 9

ExponentPart ExponentPart[Sep] :: ExponentIndicator SignedInteger[?Sep]

ExponentIndicator ExponentIndicator :: one of e E

SignedInteger SignedInteger[Sep] :: DecimalDigits[?Sep] + DecimalDigits[?Sep] - DecimalDigits[?Sep]

BinaryIntegerLiteral BinaryIntegerLiteral[Sep] :: 0b BinaryDigits[?Sep] 0B BinaryDigits[?Sep]

BinaryDigits BinaryDigits[Sep] :: BinaryDigit BinaryDigits[?Sep] BinaryDigit [+Sep] BinaryDigits[+Sep] NumericLiteralSeparator BinaryDigit

BinaryDigit BinaryDigit :: one of 0 1

OctalIntegerLiteral OctalIntegerLiteral[Sep] :: 0o OctalDigits[?Sep] 0O OctalDigits[?Sep]

OctalDigits OctalDigits[Sep] :: OctalDigit OctalDigits[?Sep] OctalDigit [+Sep] OctalDigits[+Sep] NumericLiteralSeparator OctalDigit

LegacyOctalIntegerLiteral LegacyOctalIntegerLiteral :: 0 OctalDigit LegacyOctalIntegerLiteral OctalDigit

NonOctalDecimalIntegerLiteral NonOctalDecimalIntegerLiteral :: 0 NonOctalDigit LegacyOctalLikeDecimalIntegerLiteral NonOctalDigit NonOctalDecimalIntegerLiteral DecimalDigit

LegacyOctalLikeDecimalIntegerLiteral LegacyOctalLikeDecimalIntegerLiteral :: 0 OctalDigit LegacyOctalLikeDecimalIntegerLiteral OctalDigit

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

NonOctalDigit NonOctalDigit :: one of 8 9

HexIntegerLiteral HexIntegerLiteral[Sep] :: 0x HexDigits[?Sep] 0X HexDigits[?Sep]

HexDigits HexDigits[Sep] :: HexDigit HexDigits[?Sep] HexDigit [+Sep] HexDigits[+Sep] NumericLiteralSeparator HexDigit

HexDigit HexDigit :: one of 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F

StringLiteral StringLiteral :: " DoubleStringCharactersopt " ' SingleStringCharactersopt '

DoubleStringCharacters DoubleStringCharacters :: DoubleStringCharacter DoubleStringCharactersopt

SingleStringCharacters SingleStringCharacters :: SingleStringCharacter SingleStringCharactersopt

DoubleStringCharacter DoubleStringCharacter :: SourceCharacter but not one of " or **** or LineTerminator **** EscapeSequence LineContinuation

SingleStringCharacter SingleStringCharacter :: SourceCharacter but not one of ' or **** or LineTerminator **** EscapeSequence LineContinuation

LineContinuation LineContinuation :: **** LineTerminatorSequence

EscapeSequence EscapeSequence :: CharacterEscapeSequence 0 [lookahead ∉ DecimalDigit] LegacyOctalEscapeSequence NonOctalDecimalEscapeSequence HexEscapeSequence UnicodeEscapeSequence

CharacterEscapeSequence CharacterEscapeSequence :: SingleEscapeCharacter NonEscapeCharacter

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

NonEscapeCharacter NonEscapeCharacter :: SourceCharacter but not one of EscapeCharacter or LineTerminator

EscapeCharacter EscapeCharacter :: SingleEscapeCharacter DecimalDigit x u

LegacyOctalEscapeSequence LegacyOctalEscapeSequence :: 0 [lookahead ∈ { 8, 9 }] NonZeroOctalDigit [lookahead ∉ OctalDigit] ZeroToThree OctalDigit [lookahead ∉ OctalDigit] FourToSeven OctalDigit ZeroToThree OctalDigit OctalDigit

NonZeroOctalDigit NonZeroOctalDigit :: OctalDigit but not 0

ZeroToThree ZeroToThree :: one of 0 1 2 3

FourToSeven FourToSeven :: one of 4 5 6 7

NonOctalDecimalEscapeSequence NonOctalDecimalEscapeSequence :: one of 8 9

HexEscapeSequence HexEscapeSequence :: x HexDigit HexDigit

UnicodeEscapeSequence UnicodeEscapeSequence :: u Hex4Digits u{ CodePoint }

Hex4Digits Hex4Digits :: HexDigit HexDigit HexDigit HexDigit

RegularExpressionLiteral RegularExpressionLiteral :: / RegularExpressionBody / RegularExpressionFlags

RegularExpressionBody RegularExpressionBody :: RegularExpressionFirstChar RegularExpressionChars

RegularExpressionChars RegularExpressionChars :: [empty] RegularExpressionChars RegularExpressionChar

RegularExpressionFirstChar RegularExpressionFirstChar :: RegularExpressionNonTerminator but not one of ***** or **** or / or [ RegularExpressionBackslashSequence RegularExpressionClass

RegularExpressionChar RegularExpressionChar :: RegularExpressionNonTerminator but not one of **** or / or [ RegularExpressionBackslashSequence RegularExpressionClass

RegularExpressionBackslashSequence RegularExpressionBackslashSequence :: **** RegularExpressionNonTerminator

RegularExpressionNonTerminator RegularExpressionNonTerminator :: SourceCharacter but not LineTerminator

RegularExpressionClass RegularExpressionClass :: [ RegularExpressionClassChars ]

RegularExpressionClassChars RegularExpressionClassChars :: [empty] RegularExpressionClassChars RegularExpressionClassChar

RegularExpressionClassChar RegularExpressionClassChar :: RegularExpressionNonTerminator but not one of ] or **** RegularExpressionBackslashSequence

RegularExpressionFlags RegularExpressionFlags :: [empty] RegularExpressionFlags IdentifierPartChar

Template Template :: NoSubstitutionTemplate TemplateHead

NoSubstitutionTemplate NoSubstitutionTemplate :: ** *[TemplateCharacters](13_sec-ecmascript-language-lexical-grammar.md#prod-TemplateCharacters)opt* **

TemplateHead TemplateHead :: ` TemplateCharactersopt ${

TemplateSubstitutionTail TemplateSubstitutionTail :: TemplateMiddle TemplateTail

TemplateMiddle TemplateMiddle :: } TemplateCharactersopt ${

TemplateTail TemplateTail :: } TemplateCharactersopt `

TemplateCharacters TemplateCharacters :: TemplateCharacter TemplateCharactersopt

TemplateCharacter TemplateCharacter :: $ [lookahead ≠ {] **** TemplateEscapeSequence **** NotEscapeSequence LineContinuation LineTerminatorSequence SourceCharacter but not one of ` or **** or $ or LineTerminator

TemplateEscapeSequence TemplateEscapeSequence :: CharacterEscapeSequence 0 [lookahead ∉ DecimalDigit] HexEscapeSequence UnicodeEscapeSequence

NotEscapeSequence NotEscapeSequence :: 0 DecimalDigit DecimalDigit but not 0 x [lookahead ∉ HexDigit] x HexDigit [lookahead ∉ HexDigit] u [lookahead ∉ HexDigit] [lookahead ≠ {] u HexDigit [lookahead ∉ HexDigit] u HexDigit HexDigit [lookahead ∉ HexDigit] u HexDigit HexDigit HexDigit [lookahead ∉ HexDigit] u { [lookahead ∉ HexDigit] u { NotCodePoint [lookahead ∉ HexDigit] u { CodePoint [lookahead ∉ HexDigit] [lookahead ≠ }]

NotCodePoint NotCodePoint :: HexDigits[~Sep] but only if the MV of HexDigits > 0x10FFFF

CodePoint CodePoint :: HexDigits[~Sep] but only if the MV of HexDigits ≤ 0x10FFFF

#A.2 İfadeler

IdentifierReference IdentifierReference[Yield, Await] : Identifier [~Yield] yield [~Await] await

BindingIdentifier BindingIdentifier[Yield, Await] : Identifier yield await

LabelIdentifier LabelIdentifier[Yield, Await] : Identifier [~Yield] yield [~Await] await

Identifier Identifier : IdentifierName but not ReservedWord

PrimaryExpression PrimaryExpression[Yield, Await] : this IdentifierReference[?Yield, ?Await] Literal ArrayLiteral[?Yield, ?Await] ObjectLiteral[?Yield, ?Await] FunctionExpression ClassExpression[?Yield, ?Await] GeneratorExpression AsyncFunctionExpression AsyncGeneratorExpression RegularExpressionLiteral TemplateLiteral[?Yield, ?Await, ~Tagged] CoverParenthesizedExpressionAndArrowParameterList[?Yield, ?Await]

CoverParenthesizedExpressionAndArrowParameterList CoverParenthesizedExpressionAndArrowParameterList[Yield, Await] : ( Expression[+In, ?Yield, ?Await] ) ( Expression[+In, ?Yield, ?Await] , ) ( ) ( ... BindingIdentifier[?Yield, ?Await] ) ( ... BindingPattern[?Yield, ?Await] ) ( Expression[+In, ?Yield, ?Await] , ... BindingIdentifier[?Yield, ?Await] ) ( Expression[+In, ?Yield, ?Await] , ... BindingPattern[?Yield, ?Await] )

Şu üretimin bir örneği işlenirken

PrimaryExpression PrimaryExpression[Yield, Await] : CoverParenthesizedExpressionAndArrowParameterList[?Yield, ?Await] CoverParenthesizedExpressionAndArrowParameterList yorumu aşağıdaki dilbilgisi kullanılarak iyileştirilir:

ParenthesizedExpression ParenthesizedExpression[Yield, Await] : ( Expression[+In, ?Yield, ?Await] )

Literal Literal : NullLiteral BooleanLiteral NumericLiteral StringLiteral

ArrayLiteral ArrayLiteral[Yield, Await] : [ Elisionopt ] [ ElementList[?Yield, ?Await] ] [ ElementList[?Yield, ?Await] , Elisionopt ]

ElementList ElementList[Yield, Await] : Elisionopt AssignmentExpression[+In, ?Yield, ?Await] Elisionopt SpreadElement[?Yield, ?Await] ElementList[?Yield, ?Await] , Elisionopt AssignmentExpression[+In, ?Yield, ?Await] ElementList[?Yield, ?Await] , Elisionopt SpreadElement[?Yield, ?Await]

Elision Elision : , Elision ,

SpreadElement SpreadElement[Yield, Await] : ... AssignmentExpression[+In, ?Yield, ?Await]

ObjectLiteral ObjectLiteral[Yield, Await] : { } { PropertyDefinitionList[?Yield, ?Await] } { PropertyDefinitionList[?Yield, ?Await] , }

PropertyDefinitionList PropertyDefinitionList[Yield, Await] : PropertyDefinition[?Yield, ?Await] PropertyDefinitionList[?Yield, ?Await] , PropertyDefinition[?Yield, ?Await]

PropertyDefinition PropertyDefinition[Yield, Await] : IdentifierReference[?Yield, ?Await] CoverInitializedName[?Yield, ?Await] PropertyName[?Yield, ?Await] : AssignmentExpression[+In, ?Yield, ?Await] MethodDefinition[?Yield, ?Await] ... AssignmentExpression[+In, ?Yield, ?Await]

PropertyName PropertyName[Yield, Await] : LiteralPropertyName ComputedPropertyName[?Yield, ?Await]

LiteralPropertyName LiteralPropertyName : IdentifierName StringLiteral NumericLiteral

ComputedPropertyName ComputedPropertyName[Yield, Await] : [ AssignmentExpression[+In, ?Yield, ?Await] ]

CoverInitializedName CoverInitializedName[Yield, Await] : IdentifierReference[?Yield, ?Await] Initializer[+In, ?Yield, ?Await]

Initializer Initializer[In, Yield, Await] : = AssignmentExpression[?In, ?Yield, ?Await]

TemplateLiteral TemplateLiteral[Yield, Await, Tagged] : NoSubstitutionTemplate SubstitutionTemplate[?Yield, ?Await, ?Tagged]

SubstitutionTemplate SubstitutionTemplate[Yield, Await, Tagged] : TemplateHead Expression[+In, ?Yield, ?Await] TemplateSpans[?Yield, ?Await, ?Tagged]

TemplateSpans TemplateSpans[Yield, Await, Tagged] : TemplateTail TemplateMiddleList[?Yield, ?Await, ?Tagged] TemplateTail

TemplateMiddleList TemplateMiddleList[Yield, Await, Tagged] : TemplateMiddle Expression[+In, ?Yield, ?Await] TemplateMiddleList[?Yield, ?Await, ?Tagged] TemplateMiddle Expression[+In, ?Yield, ?Await]

MemberExpression MemberExpression[Yield, Await] : PrimaryExpression[?Yield, ?Await] MemberExpression[?Yield, ?Await] [ Expression[+In, ?Yield, ?Await] ] MemberExpression[?Yield, ?Await] . IdentifierName MemberExpression[?Yield, ?Await] TemplateLiteral[?Yield, ?Await, +Tagged] SuperProperty[?Yield, ?Await] MetaProperty new MemberExpression[?Yield, ?Await] Arguments[?Yield, ?Await] MemberExpression[?Yield, ?Await] . PrivateIdentifier

SuperProperty SuperProperty[Yield, Await] : super [ Expression[+In, ?Yield, ?Await] ] super . IdentifierName

MetaProperty MetaProperty : NewTarget ImportMeta

NewTarget NewTarget : new . target

ImportMeta ImportMeta : import . meta

NewExpression NewExpression[Yield, Await] : MemberExpression[?Yield, ?Await] new NewExpression[?Yield, ?Await]

CallExpression CallExpression[Yield, Await] : CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] SuperCall[?Yield, ?Await] ImportCall[?Yield, ?Await] CallExpression[?Yield, ?Await] Arguments[?Yield, ?Await] CallExpression[?Yield, ?Await] [ Expression[+In, ?Yield, ?Await] ] CallExpression[?Yield, ?Await] . IdentifierName CallExpression[?Yield, ?Await] TemplateLiteral[?Yield, ?Await, +Tagged] CallExpression[?Yield, ?Await] . PrivateIdentifier

Şu üretimin bir örneği işlenirken

CallExpression CallExpression[Yield, Await] : CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] CoverCallExpressionAndAsyncArrowHead yorumu aşağıdaki dilbilgisi kullanılarak iyileştirilir:

CallMemberExpression CallMemberExpression[Yield, Await] : MemberExpression[?Yield, ?Await] Arguments[?Yield, ?Await]

SuperCall SuperCall[Yield, Await] : super Arguments[?Yield, ?Await]

ImportCall ImportCall[Yield, Await] : import ( AssignmentExpression[+In, ?Yield, ?Await] ,opt ) import ( AssignmentExpression[+In, ?Yield, ?Await] , AssignmentExpression[+In, ?Yield, ?Await] ,opt )

Arguments Arguments[Yield, Await] : ( ) ( ArgumentList[?Yield, ?Await] ) ( ArgumentList[?Yield, ?Await] , )

ArgumentList ArgumentList[Yield, Await] : AssignmentExpression[+In, ?Yield, ?Await] ... AssignmentExpression[+In, ?Yield, ?Await] ArgumentList[?Yield, ?Await] , AssignmentExpression[+In, ?Yield, ?Await] ArgumentList[?Yield, ?Await] , ... AssignmentExpression[+In, ?Yield, ?Await]

OptionalExpression OptionalExpression[Yield, Await] : MemberExpression[?Yield, ?Await] OptionalChain[?Yield, ?Await] CallExpression[?Yield, ?Await] OptionalChain[?Yield, ?Await] OptionalExpression[?Yield, ?Await] OptionalChain[?Yield, ?Await]

OptionalChain OptionalChain[Yield, Await] : ?. Arguments[?Yield, ?Await] ?. [ Expression[+In, ?Yield, ?Await] ] ?. IdentifierName ?. TemplateLiteral[?Yield, ?Await, +Tagged] ?. PrivateIdentifier OptionalChain[?Yield, ?Await] Arguments[?Yield, ?Await] OptionalChain[?Yield, ?Await] [ Expression[+In, ?Yield, ?Await] ] OptionalChain[?Yield, ?Await] . IdentifierName OptionalChain[?Yield, ?Await] TemplateLiteral[?Yield, ?Await, +Tagged] OptionalChain[?Yield, ?Await] . PrivateIdentifier

LeftHandSideExpression LeftHandSideExpression[Yield, Await] : NewExpression[?Yield, ?Await] CallExpression[?Yield, ?Await] OptionalExpression[?Yield, ?Await]

UpdateExpression UpdateExpression[Yield, Await] : LeftHandSideExpression[?Yield, ?Await] LeftHandSideExpression[?Yield, ?Await] [no LineTerminator here] ++ LeftHandSideExpression[?Yield, ?Await] [no LineTerminator here] -- ++ UnaryExpression[?Yield, ?Await] -- UnaryExpression[?Yield, ?Await]

UnaryExpression UnaryExpression[Yield, Await] : UpdateExpression[?Yield, ?Await] delete UnaryExpression[?Yield, ?Await] void UnaryExpression[?Yield, ?Await] typeof UnaryExpression[?Yield, ?Await] + UnaryExpression[?Yield, ?Await] - UnaryExpression[?Yield, ?Await] ~ UnaryExpression[?Yield, ?Await] ! UnaryExpression[?Yield, ?Await] [+Await] AwaitExpression[?Yield]

ExponentiationExpression ExponentiationExpression[Yield, Await] : UnaryExpression[?Yield, ?Await] UpdateExpression[?Yield, ?Await] ****** ExponentiationExpression[?Yield, ?Await]

MultiplicativeExpression MultiplicativeExpression[Yield, Await] : ExponentiationExpression[?Yield, ?Await] MultiplicativeExpression[?Yield, ?Await] MultiplicativeOperator ExponentiationExpression[?Yield, ?Await]

MultiplicativeOperator MultiplicativeOperator : one of ***** / %

AdditiveExpression AdditiveExpression[Yield, Await] : MultiplicativeExpression[?Yield, ?Await] AdditiveExpression[?Yield, ?Await] + MultiplicativeExpression[?Yield, ?Await] AdditiveExpression[?Yield, ?Await] - MultiplicativeExpression[?Yield, ?Await]

ShiftExpression ShiftExpression[Yield, Await] : AdditiveExpression[?Yield, ?Await] ShiftExpression[?Yield, ?Await] <<** *AdditiveExpression[?Yield, ?Await]* *ShiftExpression[?Yield, ?Await]* **>> AdditiveExpression[?Yield, ?Await] ShiftExpression[?Yield, ?Await] >>> AdditiveExpression[?Yield, ?Await]

RelationalExpression RelationalExpression[In, Yield, Await] : ShiftExpression[?Yield, ?Await] RelationalExpression[?In, ?Yield, ?Await] <** *ShiftExpression[?Yield, ?Await]* *RelationalExpression[?In, ?Yield, ?Await]* **> ShiftExpression[?Yield, ?Await] RelationalExpression[?In, ?Yield, ?Await] <=** *ShiftExpression[?Yield, ?Await]* *RelationalExpression[?In, ?Yield, ?Await]* **>= ShiftExpression[?Yield, ?Await] RelationalExpression[?In, ?Yield, ?Await] instanceof ShiftExpression[?Yield, ?Await] [+In] RelationalExpression[+In, ?Yield, ?Await] in ShiftExpression[?Yield, ?Await] [+In] PrivateIdentifier in ShiftExpression[?Yield, ?Await]

EqualityExpression EqualityExpression[In, Yield, Await] : RelationalExpression[?In, ?Yield, ?Await] EqualityExpression[?In, ?Yield, ?Await] == RelationalExpression[?In, ?Yield, ?Await] EqualityExpression[?In, ?Yield, ?Await] != RelationalExpression[?In, ?Yield, ?Await] EqualityExpression[?In, ?Yield, ?Await] === RelationalExpression[?In, ?Yield, ?Await] EqualityExpression[?In, ?Yield, ?Await] !== RelationalExpression[?In, ?Yield, ?Await]

BitwiseANDExpression BitwiseANDExpression[In, Yield, Await] : EqualityExpression[?In, ?Yield, ?Await] BitwiseANDExpression[?In, ?Yield, ?Await] & EqualityExpression[?In, ?Yield, ?Await]

BitwiseXORExpression BitwiseXORExpression[In, Yield, Await] : BitwiseANDExpression[?In, ?Yield, ?Await] BitwiseXORExpression[?In, ?Yield, ?Await] ^ BitwiseANDExpression[?In, ?Yield, ?Await]

BitwiseORExpression BitwiseORExpression[In, Yield, Await] : BitwiseXORExpression[?In, ?Yield, ?Await] BitwiseORExpression[?In, ?Yield, ?Await] | BitwiseXORExpression[?In, ?Yield, ?Await]

LogicalANDExpression LogicalANDExpression[In, Yield, Await] : BitwiseORExpression[?In, ?Yield, ?Await] LogicalANDExpression[?In, ?Yield, ?Await] && BitwiseORExpression[?In, ?Yield, ?Await]

LogicalORExpression LogicalORExpression[In, Yield, Await] : LogicalANDExpression[?In, ?Yield, ?Await] LogicalORExpression[?In, ?Yield, ?Await] || LogicalANDExpression[?In, ?Yield, ?Await]

CoalesceExpression CoalesceExpression[In, Yield, Await] : CoalesceExpressionHead[?In, ?Yield, ?Await] ?? BitwiseORExpression[?In, ?Yield, ?Await]

CoalesceExpressionHead CoalesceExpressionHead[In, Yield, Await] : CoalesceExpression[?In, ?Yield, ?Await] BitwiseORExpression[?In, ?Yield, ?Await]

ShortCircuitExpression ShortCircuitExpression[In, Yield, Await] : LogicalORExpression[?In, ?Yield, ?Await] CoalesceExpression[?In, ?Yield, ?Await]

ConditionalExpression ConditionalExpression[In, Yield, Await] : ShortCircuitExpression[?In, ?Yield, ?Await] ShortCircuitExpression[?In, ?Yield, ?Await] ? AssignmentExpression[+In, ?Yield, ?Await] : AssignmentExpression[?In, ?Yield, ?Await]

AssignmentExpression AssignmentExpression[In, Yield, Await] : ConditionalExpression[?In, ?Yield, ?Await] [+Yield] YieldExpression[?In, ?Await] ArrowFunction[?In, ?Yield, ?Await] AsyncArrowFunction[?In, ?Yield, ?Await] LeftHandSideExpression[?Yield, ?Await] = AssignmentExpression[?In, ?Yield, ?Await] LeftHandSideExpression[?Yield, ?Await] AssignmentOperator AssignmentExpression[?In, ?Yield, ?Await] LeftHandSideExpression[?Yield, ?Await] &&= AssignmentExpression[?In, ?Yield, ?Await] LeftHandSideExpression[?Yield, ?Await] ||= AssignmentExpression[?In, ?Yield, ?Await] LeftHandSideExpression[?Yield, ?Await] ??= AssignmentExpression[?In, ?Yield, ?Await]

AssignmentOperator AssignmentOperator : one of ***=** /= %= += -= <<=** **>>= >>>= &= ^= |= ****=**

Belirli durumlarda, şu üretimin bir örneği işlenirken

AssignmentExpression AssignmentExpression[In, Yield, Await] : LeftHandSideExpression[?Yield, ?Await] = AssignmentExpression[?In, ?Yield, ?Await] LeftHandSideExpression yorumu aşağıdaki dilbilgisi kullanılarak iyileştirilir:

AssignmentPattern AssignmentPattern[Yield, Await] : ObjectAssignmentPattern[?Yield, ?Await] ArrayAssignmentPattern[?Yield, ?Await]

ObjectAssignmentPattern ObjectAssignmentPattern[Yield, Await] : { } { AssignmentRestProperty[?Yield, ?Await] } { AssignmentPropertyList[?Yield, ?Await] } { AssignmentPropertyList[?Yield, ?Await] , AssignmentRestProperty[?Yield, ?Await]opt }

ArrayAssignmentPattern ArrayAssignmentPattern[Yield, Await] : [ Elisionopt AssignmentRestElement[?Yield, ?Await]opt ] [ AssignmentElementList[?Yield, ?Await] ] [ AssignmentElementList[?Yield, ?Await] , Elisionopt AssignmentRestElement[?Yield, ?Await]opt ]

AssignmentRestProperty AssignmentRestProperty[Yield, Await] : ... DestructuringAssignmentTarget[?Yield, ?Await]

AssignmentPropertyList AssignmentPropertyList[Yield, Await] : AssignmentProperty[?Yield, ?Await] AssignmentPropertyList[?Yield, ?Await] , AssignmentProperty[?Yield, ?Await]

AssignmentElementList AssignmentElementList[Yield, Await] : AssignmentElisionElement[?Yield, ?Await] AssignmentElementList[?Yield, ?Await] , AssignmentElisionElement[?Yield, ?Await]

AssignmentElisionElement AssignmentElisionElement[Yield, Await] : Elisionopt AssignmentElement[?Yield, ?Await]

AssignmentProperty AssignmentProperty[Yield, Await] : IdentifierReference[?Yield, ?Await] Initializer[+In, ?Yield, ?Await]opt PropertyName[?Yield, ?Await] : AssignmentElement[?Yield, ?Await]

AssignmentElement AssignmentElement[Yield, Await] : DestructuringAssignmentTarget[?Yield, ?Await] Initializer[+In, ?Yield, ?Await]opt

AssignmentRestElement AssignmentRestElement[Yield, Await] : ... DestructuringAssignmentTarget[?Yield, ?Await]

DestructuringAssignmentTarget DestructuringAssignmentTarget[Yield, Await] : LeftHandSideExpression[?Yield, ?Await]

Expression Expression[In, Yield, Await] : AssignmentExpression[?In, ?Yield, ?Await] Expression[?In, ?Yield, ?Await] , AssignmentExpression[?In, ?Yield, ?Await]

#A.3 Deyimler

Statement Statement[Yield, Await, Return] : BlockStatement[?Yield, ?Await, ?Return] VariableStatement[?Yield, ?Await] EmptyStatement ExpressionStatement[?Yield, ?Await] IfStatement[?Yield, ?Await, ?Return] BreakableStatement[?Yield, ?Await, ?Return] ContinueStatement[?Yield, ?Await] BreakStatement[?Yield, ?Await] [+Return] ReturnStatement[?Yield, ?Await] WithStatement[?Yield, ?Await, ?Return] LabelledStatement[?Yield, ?Await, ?Return] ThrowStatement[?Yield, ?Await] TryStatement[?Yield, ?Await, ?Return] DebuggerStatement

Declaration Declaration[Yield, Await] : HoistableDeclaration[?Yield, ?Await, ~Default] ClassDeclaration[?Yield, ?Await, ~Default] LexicalDeclaration[+In, ?Yield, ?Await]

HoistableDeclaration HoistableDeclaration[Yield, Await, Default] : FunctionDeclaration[?Yield, ?Await, ?Default] GeneratorDeclaration[?Yield, ?Await, ?Default] AsyncFunctionDeclaration[?Yield, ?Await, ?Default] AsyncGeneratorDeclaration[?Yield, ?Await, ?Default]

BreakableStatement BreakableStatement[Yield, Await, Return] : IterationStatement[?Yield, ?Await, ?Return] SwitchStatement[?Yield, ?Await, ?Return]

BlockStatement BlockStatement[Yield, Await, Return] : Block[?Yield, ?Await, ?Return]

Block Block[Yield, Await, Return] : { StatementList[?Yield, ?Await, ?Return]opt }

StatementList StatementList[Yield, Await, Return] : StatementListItem[?Yield, ?Await, ?Return] StatementList[?Yield, ?Await, ?Return] StatementListItem[?Yield, ?Await, ?Return]

StatementListItem StatementListItem[Yield, Await, Return] : Statement[?Yield, ?Await, ?Return] Declaration[?Yield, ?Await]

LexicalDeclaration LexicalDeclaration[In, Yield, Await] : LetOrConst BindingList[?In, ?Yield, ?Await] ;

LetOrConst LetOrConst : let const

BindingList BindingList[In, Yield, Await] : LexicalBinding[?In, ?Yield, ?Await] BindingList[?In, ?Yield, ?Await] , LexicalBinding[?In, ?Yield, ?Await]

LexicalBinding LexicalBinding[In, Yield, Await] : BindingIdentifier[?Yield, ?Await] Initializer[?In, ?Yield, ?Await]opt BindingPattern[?Yield, ?Await] Initializer[?In, ?Yield, ?Await]

VariableStatement VariableStatement[Yield, Await] : var VariableDeclarationList[+In, ?Yield, ?Await] ;

VariableDeclarationList VariableDeclarationList[In, Yield, Await] : VariableDeclaration[?In, ?Yield, ?Await] VariableDeclarationList[?In, ?Yield, ?Await] , VariableDeclaration[?In, ?Yield, ?Await]

VariableDeclaration VariableDeclaration[In, Yield, Await] : BindingIdentifier[?Yield, ?Await] Initializer[?In, ?Yield, ?Await]opt BindingPattern[?Yield, ?Await] Initializer[?In, ?Yield, ?Await]

BindingPattern BindingPattern[Yield, Await] : ObjectBindingPattern[?Yield, ?Await] ArrayBindingPattern[?Yield, ?Await]

ObjectBindingPattern ObjectBindingPattern[Yield, Await] : { } { BindingRestProperty[?Yield, ?Await] } { BindingPropertyList[?Yield, ?Await] } { BindingPropertyList[?Yield, ?Await] , BindingRestProperty[?Yield, ?Await]opt }

ArrayBindingPattern ArrayBindingPattern[Yield, Await] : [ Elisionopt BindingRestElement[?Yield, ?Await]opt ] [ BindingElementList[?Yield, ?Await] ] [ BindingElementList[?Yield, ?Await] , Elisionopt BindingRestElement[?Yield, ?Await]opt ]

BindingRestProperty BindingRestProperty[Yield, Await] : ... BindingIdentifier[?Yield, ?Await]

BindingPropertyList BindingPropertyList[Yield, Await] : BindingProperty[?Yield, ?Await] BindingPropertyList[?Yield, ?Await] , BindingProperty[?Yield, ?Await]

BindingElementList BindingElementList[Yield, Await] : BindingElisionElement[?Yield, ?Await] BindingElementList[?Yield, ?Await] , BindingElisionElement[?Yield, ?Await]

BindingElisionElement BindingElisionElement[Yield, Await] : Elisionopt BindingElement[?Yield, ?Await]

BindingProperty BindingProperty[Yield, Await] : SingleNameBinding[?Yield, ?Await] PropertyName[?Yield, ?Await] : BindingElement[?Yield, ?Await]

BindingElement BindingElement[Yield, Await] : SingleNameBinding[?Yield, ?Await] BindingPattern[?Yield, ?Await] Initializer[+In, ?Yield, ?Await]opt

SingleNameBinding SingleNameBinding[Yield, Await] : BindingIdentifier[?Yield, ?Await] Initializer[+In, ?Yield, ?Await]opt

BindingRestElement BindingRestElement[Yield, Await] : ... BindingIdentifier[?Yield, ?Await] ... BindingPattern[?Yield, ?Await]

EmptyStatement EmptyStatement : ;

ExpressionStatement ExpressionStatement[Yield, Await] : [lookahead ∉ { {, function, async [no LineTerminator here] function, class, let [ }] Expression[+In, ?Yield, ?Await] ;

IfStatement IfStatement[Yield, Await, Return] : if ( Expression[+In, ?Yield, ?Await] ) Statement[?Yield, ?Await, ?Return] else Statement[?Yield, ?Await, ?Return] if ( Expression[+In, ?Yield, ?Await] ) Statement[?Yield, ?Await, ?Return] [lookahead ≠ else]

IterationStatement IterationStatement[Yield, Await, Return] : DoWhileStatement[?Yield, ?Await, ?Return] WhileStatement[?Yield, ?Await, ?Return] ForStatement[?Yield, ?Await, ?Return] ForInOfStatement[?Yield, ?Await, ?Return]

DoWhileStatement DoWhileStatement[Yield, Await, Return] : do Statement[?Yield, ?Await, ?Return] while ( Expression[+In, ?Yield, ?Await] ) ;

WhileStatement WhileStatement[Yield, Await, Return] : while ( Expression[+In, ?Yield, ?Await] ) Statement[?Yield, ?Await, ?Return]

ForStatement ForStatement[Yield, Await, Return] : for ( [lookahead ≠ let [] Expression[~In, ?Yield, ?Await]opt ; Expression[+In, ?Yield, ?Await]opt ; Expression[+In, ?Yield, ?Await]opt ) Statement[?Yield, ?Await, ?Return] for ( var VariableDeclarationList[~In, ?Yield, ?Await] ; Expression[+In, ?Yield, ?Await]opt ; Expression[+In, ?Yield, ?Await]opt ) Statement[?Yield, ?Await, ?Return] for ( LexicalDeclaration[~In, ?Yield, ?Await] Expression[+In, ?Yield, ?Await]opt ; Expression[+In, ?Yield, ?Await]opt ) Statement[?Yield, ?Await, ?Return]

ForInOfStatement ForInOfStatement[Yield, Await, Return] : for ( [lookahead ≠ let [] LeftHandSideExpression[?Yield, ?Await] in Expression[+In, ?Yield, ?Await] ) Statement[?Yield, ?Await, ?Return] for ( var ForBinding[?Yield, ?Await] in Expression[+In, ?Yield, ?Await] ) Statement[?Yield, ?Await, ?Return] for ( ForDeclaration[?Yield, ?Await] in Expression[+In, ?Yield, ?Await] ) Statement[?Yield, ?Await, ?Return] for ( [lookahead ∉ { let, async of }] LeftHandSideExpression[?Yield, ?Await] of AssignmentExpression[+In, ?Yield, ?Await] ) Statement[?Yield, ?Await, ?Return] for ( var ForBinding[?Yield, ?Await] of AssignmentExpression[+In, ?Yield, ?Await] ) Statement[?Yield, ?Await, ?Return] for ( ForDeclaration[?Yield, ?Await] of AssignmentExpression[+In, ?Yield, ?Await] ) Statement[?Yield, ?Await, ?Return] [+Await] for await ( [lookahead ≠ let] LeftHandSideExpression[?Yield, ?Await] of AssignmentExpression[+In, ?Yield, ?Await] ) Statement[?Yield, ?Await, ?Return] [+Await] for await ( var ForBinding[?Yield, ?Await] of AssignmentExpression[+In, ?Yield, ?Await] ) Statement[?Yield, ?Await, ?Return] [+Await] for await ( ForDeclaration[?Yield, ?Await] of AssignmentExpression[+In, ?Yield, ?Await] ) Statement[?Yield, ?Await, ?Return]

ForDeclaration ForDeclaration[Yield, Await] : LetOrConst ForBinding[?Yield, ?Await]

ForBinding ForBinding[Yield, Await] : BindingIdentifier[?Yield, ?Await] BindingPattern[?Yield, ?Await]

ContinueStatement ContinueStatement[Yield, Await] : continue ; continue [no LineTerminator here] LabelIdentifier[?Yield, ?Await] ;

BreakStatement BreakStatement[Yield, Await] : break ; break [no LineTerminator here] LabelIdentifier[?Yield, ?Await] ;

ReturnStatement ReturnStatement[Yield, Await] : return ; return [no LineTerminator here] Expression[+In, ?Yield, ?Await] ;

WithStatement WithStatement[Yield, Await, Return] : with ( Expression[+In, ?Yield, ?Await] ) Statement[?Yield, ?Await, ?Return]

SwitchStatement SwitchStatement[Yield, Await, Return] : switch ( Expression[+In, ?Yield, ?Await] ) CaseBlock[?Yield, ?Await, ?Return]

CaseBlock CaseBlock[Yield, Await, Return] : { CaseClauses[?Yield, ?Await, ?Return]opt } { CaseClauses[?Yield, ?Await, ?Return]opt DefaultClause[?Yield, ?Await, ?Return] CaseClauses[?Yield, ?Await, ?Return]opt }

CaseClauses CaseClauses[Yield, Await, Return] : CaseClause[?Yield, ?Await, ?Return] CaseClauses[?Yield, ?Await, ?Return] CaseClause[?Yield, ?Await, ?Return]

CaseClause CaseClause[Yield, Await, Return] : case Expression[+In, ?Yield, ?Await] : StatementList[?Yield, ?Await, ?Return]opt

DefaultClause DefaultClause[Yield, Await, Return] : default : StatementList[?Yield, ?Await, ?Return]opt

LabelledStatement LabelledStatement[Yield, Await, Return] : LabelIdentifier[?Yield, ?Await] : LabelledItem[?Yield, ?Await, ?Return]

LabelledItem LabelledItem[Yield, Await, Return] : Statement[?Yield, ?Await, ?Return] FunctionDeclaration[?Yield, ?Await, ~Default]

ThrowStatement ThrowStatement[Yield, Await] : throw [no LineTerminator here] Expression[+In, ?Yield, ?Await] ;

TryStatement TryStatement[Yield, Await, Return] : try Block[?Yield, ?Await, ?Return] Catch[?Yield, ?Await, ?Return] try Block[?Yield, ?Await, ?Return] Finally[?Yield, ?Await, ?Return] try Block[?Yield, ?Await, ?Return] Catch[?Yield, ?Await, ?Return] Finally[?Yield, ?Await, ?Return]

Catch Catch[Yield, Await, Return] : catch ( CatchParameter[?Yield, ?Await] ) Block[?Yield, ?Await, ?Return] catch Block[?Yield, ?Await, ?Return]

Finally Finally[Yield, Await, Return] : finally Block[?Yield, ?Await, ?Return]

CatchParameter CatchParameter[Yield, Await] : BindingIdentifier[?Yield, ?Await] BindingPattern[?Yield, ?Await]

DebuggerStatement DebuggerStatement : debugger ;

#A.4 Fonksiyonlar ve Sınıflar

UniqueFormalParameters UniqueFormalParameters[Yield, Await] : FormalParameters[?Yield, ?Await]

FormalParameters FormalParameters[Yield, Await] : [empty] FunctionRestParameter[?Yield, ?Await] FormalParameterList[?Yield, ?Await] FormalParameterList[?Yield, ?Await] , FormalParameterList[?Yield, ?Await] , FunctionRestParameter[?Yield, ?Await]

FormalParameterList FormalParameterList[Yield, Await] : FormalParameter[?Yield, ?Await] FormalParameterList[?Yield, ?Await] , FormalParameter[?Yield, ?Await]

FunctionRestParameter FunctionRestParameter[Yield, Await] : BindingRestElement[?Yield, ?Await]

FormalParameter FormalParameter[Yield, Await] : BindingElement[?Yield, ?Await]

FunctionDeclaration FunctionDeclaration[Yield, Await, Default] : function BindingIdentifier[?Yield, ?Await] ( FormalParameters[~Yield, ~Await] ) { FunctionBody[~Yield, ~Await] } [+Default] function ( FormalParameters[~Yield, ~Await] ) { FunctionBody[~Yield, ~Await] }

FunctionExpression FunctionExpression : function BindingIdentifier[~Yield, ~Await]opt ( FormalParameters[~Yield, ~Await] ) { FunctionBody[~Yield, ~Await] }

FunctionBody FunctionBody[Yield, Await] : FunctionStatementList[?Yield, ?Await]

FunctionStatementList FunctionStatementList[Yield, Await] : StatementList[?Yield, ?Await, +Return]opt

ArrowFunction ArrowFunction[In, Yield, Await] : ArrowParameters[?Yield, ?Await] [no LineTerminator here] => ConciseBody[?In]

ArrowParameters ArrowParameters[Yield, Await] : BindingIdentifier[?Yield, ?Await] CoverParenthesizedExpressionAndArrowParameterList[?Yield, ?Await]

ConciseBody ConciseBody[In] : [lookahead ≠ {] ExpressionBody[?In, ~Await] { FunctionBody[~Yield, ~Await] }

ExpressionBody ExpressionBody[In, Await] : AssignmentExpression[?In, ~Yield, ?Await]

Şu üretimin bir örneği işlenirken

ArrowParameters ArrowParameters[Yield, Await] : CoverParenthesizedExpressionAndArrowParameterList[?Yield, ?Await] CoverParenthesizedExpressionAndArrowParameterList yorumu aşağıdaki dilbilgisi kullanılarak iyileştirilir:

ArrowFormalParameters ArrowFormalParameters[Yield, Await] : ( UniqueFormalParameters[?Yield, ?Await] )

AsyncArrowFunction AsyncArrowFunction[In, Yield, Await] : async [no LineTerminator here] AsyncArrowBindingIdentifier[?Yield] [no LineTerminator here] => AsyncConciseBody[?In] CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] [no LineTerminator here] => AsyncConciseBody[?In]

AsyncConciseBody AsyncConciseBody[In] : [lookahead ≠ {] ExpressionBody[?In, +Await] { AsyncFunctionBody }

AsyncArrowBindingIdentifier AsyncArrowBindingIdentifier[Yield] : BindingIdentifier[?Yield, +Await]

CoverCallExpressionAndAsyncArrowHead CoverCallExpressionAndAsyncArrowHead[Yield, Await] : MemberExpression[?Yield, ?Await] Arguments[?Yield, ?Await]

Şu üretimin bir örneği işlenirken

AsyncArrowFunction AsyncArrowFunction[In, Yield, Await] : CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] [no LineTerminator here] => AsyncConciseBody[?In] CoverCallExpressionAndAsyncArrowHead yorumu aşağıdaki dilbilgisi kullanılarak iyileştirilir:

AsyncArrowHead AsyncArrowHead : async [no LineTerminator here] ArrowFormalParameters[~Yield, +Await]

MethodDefinition MethodDefinition[Yield, Await] : ClassElementName[?Yield, ?Await] ( UniqueFormalParameters[~Yield, ~Await] ) { FunctionBody[~Yield, ~Await] } GeneratorMethod[?Yield, ?Await] AsyncMethod[?Yield, ?Await] AsyncGeneratorMethod[?Yield, ?Await] get ClassElementName[?Yield, ?Await] ( ) { FunctionBody[~Yield, ~Await] } set ClassElementName[?Yield, ?Await] ( PropertySetParameterList ) { FunctionBody[~Yield, ~Await] }

PropertySetParameterList PropertySetParameterList : FormalParameter[~Yield, ~Await]

GeneratorDeclaration GeneratorDeclaration[Yield, Await, Default] : function ***** BindingIdentifier[?Yield, ?Await] ( FormalParameters[+Yield, ~Await] ) { GeneratorBody } [+Default] function ***** ( FormalParameters[+Yield, ~Await] ) { GeneratorBody }

GeneratorExpression GeneratorExpression : function ***** BindingIdentifier[+Yield, ~Await]opt ( FormalParameters[+Yield, ~Await] ) { GeneratorBody }

GeneratorMethod GeneratorMethod[Yield, Await] : ***** ClassElementName[?Yield, ?Await] ( UniqueFormalParameters[+Yield, ~Await] ) { GeneratorBody }

GeneratorBody GeneratorBody : FunctionBody[+Yield, ~Await]

YieldExpression YieldExpression[In, Await] : yield yield [no LineTerminator here] AssignmentExpression[?In, +Yield, ?Await] yield [no LineTerminator here] ***** AssignmentExpression[?In, +Yield, ?Await]

AsyncGeneratorDeclaration AsyncGeneratorDeclaration[Yield, Await, Default] : async [no LineTerminator here] function ***** BindingIdentifier[?Yield, ?Await] ( FormalParameters[+Yield, +Await] ) { AsyncGeneratorBody } [+Default] async [no LineTerminator here] function ***** ( FormalParameters[+Yield, +Await] ) { AsyncGeneratorBody }

AsyncGeneratorExpression AsyncGeneratorExpression : async [no LineTerminator here] function ***** BindingIdentifier[+Yield, +Await]opt ( FormalParameters[+Yield, +Await] ) { AsyncGeneratorBody }

AsyncGeneratorMethod AsyncGeneratorMethod[Yield, Await] : async [no LineTerminator here] ***** ClassElementName[?Yield, ?Await] ( UniqueFormalParameters[+Yield, +Await] ) { AsyncGeneratorBody }

AsyncGeneratorBody AsyncGeneratorBody : FunctionBody[+Yield, +Await]

AsyncFunctionDeclaration AsyncFunctionDeclaration[Yield, Await, Default] : async [no LineTerminator here] function BindingIdentifier[?Yield, ?Await] ( FormalParameters[~Yield, +Await] ) { AsyncFunctionBody } [+Default] async [no LineTerminator here] function ( FormalParameters[~Yield, +Await] ) { AsyncFunctionBody }

AsyncFunctionExpression AsyncFunctionExpression : async [no LineTerminator here] function BindingIdentifier[~Yield, +Await]opt ( FormalParameters[~Yield, +Await] ) { AsyncFunctionBody }

AsyncMethod AsyncMethod[Yield, Await] : async [no LineTerminator here] ClassElementName[?Yield, ?Await] ( UniqueFormalParameters[~Yield, +Await] ) { AsyncFunctionBody }

AsyncFunctionBody AsyncFunctionBody : FunctionBody[~Yield, +Await]

AwaitExpression AwaitExpression[Yield] : await UnaryExpression[?Yield, +Await]

ClassDeclaration ClassDeclaration[Yield, Await, Default] : class BindingIdentifier[?Yield, ?Await] ClassTail[?Yield, ?Await] [+Default] class ClassTail[?Yield, ?Await]

ClassExpression ClassExpression[Yield, Await] : class BindingIdentifier[?Yield, ?Await]opt ClassTail[?Yield, ?Await]

ClassTail ClassTail[Yield, Await] : ClassHeritage[?Yield, ?Await]opt { ClassBody[?Yield, ?Await]opt }

ClassHeritage ClassHeritage[Yield, Await] : extends LeftHandSideExpression[?Yield, ?Await]

ClassBody ClassBody[Yield, Await] : ClassElementList[?Yield, ?Await]

ClassElementList ClassElementList[Yield, Await] : ClassElement[?Yield, ?Await] ClassElementList[?Yield, ?Await] ClassElement[?Yield, ?Await]

ClassElement ClassElement[Yield, Await] : MethodDefinition[?Yield, ?Await] static MethodDefinition[?Yield, ?Await] FieldDefinition[?Yield, ?Await] ; static FieldDefinition[?Yield, ?Await] ; ClassStaticBlock ;

FieldDefinition FieldDefinition[Yield, Await] : ClassElementName[?Yield, ?Await] Initializer[+In, ?Yield, ?Await]opt

ClassElementName ClassElementName[Yield, Await] : PropertyName[?Yield, ?Await] PrivateIdentifier

ClassStaticBlock ClassStaticBlock : static { ClassStaticBlockBody }

ClassStaticBlockBody ClassStaticBlockBody : ClassStaticBlockStatementList

ClassStaticBlockStatementList ClassStaticBlockStatementList : StatementList[~Yield, +Await, ~Return]opt

#A.5 Betikler ve Modüller

Script Script : ScriptBodyopt

ScriptBody ScriptBody : StatementList[~Yield, ~Await, ~Return]

Module Module : ModuleBodyopt

ModuleBody ModuleBody : ModuleItemList

ModuleItemList ModuleItemList : ModuleItem ModuleItemList ModuleItem

ModuleItem ModuleItem : ImportDeclaration ExportDeclaration StatementListItem[~Yield, +Await, ~Return]

ModuleExportName ModuleExportName : IdentifierName StringLiteral

ImportDeclaration ImportDeclaration : import ImportClause FromClause WithClauseopt ; import ModuleSpecifier WithClauseopt ;

ImportClause ImportClause : ImportedDefaultBinding NameSpaceImport NamedImports ImportedDefaultBinding , NameSpaceImport ImportedDefaultBinding , NamedImports

ImportedDefaultBinding ImportedDefaultBinding : ImportedBinding

NameSpaceImport NameSpaceImport : ***** as ImportedBinding

NamedImports NamedImports : { } { ImportsList } { ImportsList , }

FromClause FromClause : from ModuleSpecifier

ImportsList ImportsList : ImportSpecifier ImportsList , ImportSpecifier

ImportSpecifier ImportSpecifier : ImportedBinding ModuleExportName as ImportedBinding

ModuleSpecifier ModuleSpecifier : StringLiteral

ImportedBinding ImportedBinding : BindingIdentifier[~Yield, +Await]

WithClause WithClause : with { } with { WithEntries ,opt }

WithEntries WithEntries : AttributeKey : StringLiteral AttributeKey : StringLiteral , WithEntries

AttributeKey AttributeKey : IdentifierName StringLiteral

ExportDeclaration ExportDeclaration : export ExportFromClause FromClause WithClauseopt ; export NamedExports ; export VariableStatement[~Yield, +Await] export Declaration[~Yield, +Await] export default HoistableDeclaration[~Yield, +Await, +Default] export default ClassDeclaration[~Yield, +Await, +Default] export default [lookahead ∉ { function, async [no LineTerminator here] function, class }] AssignmentExpression[+In, ~Yield, +Await] ;

ExportFromClause ExportFromClause : ***** ***** as ModuleExportName NamedExports

NamedExports NamedExports : { } { ExportsList } { ExportsList , }

ExportsList ExportsList : ExportSpecifier ExportsList , ExportSpecifier

ExportSpecifier ExportSpecifier : ModuleExportName ModuleExportName as ModuleExportName

#A.6 Sayı Dönüşümleri

StringNumericLiteral StringNumericLiteral ::: StrWhiteSpaceopt StrWhiteSpaceopt StrNumericLiteral StrWhiteSpaceopt

StrWhiteSpace StrWhiteSpace ::: StrWhiteSpaceChar StrWhiteSpaceopt

StrWhiteSpaceChar StrWhiteSpaceChar ::: WhiteSpace LineTerminator

StrNumericLiteral StrNumericLiteral ::: StrDecimalLiteral NonDecimalIntegerLiteral[~Sep]

StrDecimalLiteral StrDecimalLiteral ::: StrUnsignedDecimalLiteral + StrUnsignedDecimalLiteral - StrUnsignedDecimalLiteral

StrUnsignedDecimalLiteral StrUnsignedDecimalLiteral ::: Infinity DecimalDigits[~Sep] . DecimalDigits[~Sep]opt ExponentPart[~Sep]opt . DecimalDigits[~Sep] ExponentPart[~Sep]opt DecimalDigits[~Sep] ExponentPart[~Sep]opt

StringNumericLiteral dilbilgisi tarafından açıkça tanımlanmayan tüm dilbilgisi sembolleri, Sayısal değişmezler için Sözcüksel Dilbilgisinde kullanılan tanımlara sahiptir.

StringIntegerLiteral StringIntegerLiteral ::: StrWhiteSpaceopt StrWhiteSpaceopt StrIntegerLiteral StrWhiteSpaceopt

StrIntegerLiteral StrIntegerLiteral ::: SignedInteger[~Sep] NonDecimalIntegerLiteral[~Sep]

#A.7 Saat Dilimi Sapması Dize Biçimi

UTCOffset UTCOffset ::: ASCIISign Hour ASCIISign Hour HourSubcomponents[+Extended] ASCIISign Hour HourSubcomponents[~Extended]

ASCIISign ASCIISign ::: one of + -

Hour Hour ::: 0 DecimalDigit 1 DecimalDigit 20 21 22 23

HourSubcomponents HourSubcomponents[Extended] ::: TimeSeparator[?Extended] MinuteSecond TimeSeparator[?Extended] MinuteSecond TimeSeparator[?Extended] MinuteSecond TemporalDecimalFractionopt

TimeSeparator TimeSeparator[Extended] ::: [+Extended] : [~Extended] [empty]

MinuteSecond MinuteSecond ::: 0 DecimalDigit 1 DecimalDigit 2 DecimalDigit 3 DecimalDigit 4 DecimalDigit 5 DecimalDigit

TemporalDecimalFraction TemporalDecimalFraction ::: TemporalDecimalSeparator DecimalDigit TemporalDecimalSeparator DecimalDigit DecimalDigit TemporalDecimalSeparator DecimalDigit DecimalDigit DecimalDigit TemporalDecimalSeparator DecimalDigit DecimalDigit DecimalDigit DecimalDigit TemporalDecimalSeparator DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit TemporalDecimalSeparator DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit TemporalDecimalSeparator DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit TemporalDecimalSeparator DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit TemporalDecimalSeparator DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit

TemporalDecimalSeparator TemporalDecimalSeparator ::: one of . ,

#A.8 Düzenli İfadeler

Pattern Pattern[UnicodeMode, UnicodeSetsMode, NamedCaptureGroups] :: Disjunction[?UnicodeMode, ?UnicodeSetsMode, ?NamedCaptureGroups]

Disjunction Disjunction[UnicodeMode, UnicodeSetsMode, NamedCaptureGroups] :: Alternative[?UnicodeMode, ?UnicodeSetsMode, ?NamedCaptureGroups] Alternative[?UnicodeMode, ?UnicodeSetsMode, ?NamedCaptureGroups] | Disjunction[?UnicodeMode, ?UnicodeSetsMode, ?NamedCaptureGroups]

Alternative Alternative[UnicodeMode, UnicodeSetsMode, NamedCaptureGroups] :: [empty] Alternative[?UnicodeMode, ?UnicodeSetsMode, ?NamedCaptureGroups] Term[?UnicodeMode, ?UnicodeSetsMode, ?NamedCaptureGroups]

Term Term[UnicodeMode, UnicodeSetsMode, NamedCaptureGroups] :: Assertion[?UnicodeMode, ?UnicodeSetsMode, ?NamedCaptureGroups] Atom[?UnicodeMode, ?UnicodeSetsMode, ?NamedCaptureGroups] Atom[?UnicodeMode, ?UnicodeSetsMode, ?NamedCaptureGroups] Quantifier

Assertion Assertion[UnicodeMode, UnicodeSetsMode, NamedCaptureGroups] :: ^ $ \b \B (?= Disjunction[?UnicodeMode, ?UnicodeSetsMode, ?NamedCaptureGroups] ) (?! Disjunction[?UnicodeMode, ?UnicodeSetsMode, ?NamedCaptureGroups] ) (?<= Disjunction[?UnicodeMode, ?UnicodeSetsMode, ?NamedCaptureGroups] ) (?<! Disjunction[?UnicodeMode, ?UnicodeSetsMode, ?NamedCaptureGroups] )

Quantifier Quantifier :: QuantifierPrefix QuantifierPrefix ?

QuantifierPrefix QuantifierPrefix :: ***** + ? { DecimalDigits[~Sep] } { DecimalDigits[~Sep] ,} { DecimalDigits[~Sep] , DecimalDigits[~Sep] }

Atom Atom[UnicodeMode, UnicodeSetsMode, NamedCaptureGroups] :: PatternCharacter . **** AtomEscape[?UnicodeMode, ?NamedCaptureGroups] CharacterClass[?UnicodeMode, ?UnicodeSetsMode] ( GroupSpecifier[?UnicodeMode]opt Disjunction[?UnicodeMode, ?UnicodeSetsMode, ?NamedCaptureGroups] ) (? RegularExpressionModifiers : Disjunction[?UnicodeMode, ?UnicodeSetsMode, ?NamedCaptureGroups] ) (? RegularExpressionModifiers - RegularExpressionModifiers : Disjunction[?UnicodeMode, ?UnicodeSetsMode, ?NamedCaptureGroups] )

RegularExpressionModifiers RegularExpressionModifiers :: [empty] RegularExpressionModifiers RegularExpressionModifier

RegularExpressionModifier RegularExpressionModifier :: one of i m s

SyntaxCharacter SyntaxCharacter :: one of ^ $ **** . ***** + ? ( ) [ ] { } |

PatternCharacter PatternCharacter :: SourceCharacter but not SyntaxCharacter

AtomEscape AtomEscape[UnicodeMode, NamedCaptureGroups] :: DecimalEscape CharacterClassEscape[?UnicodeMode] CharacterEscape[?UnicodeMode] [+NamedCaptureGroups] k GroupName[?UnicodeMode]

CharacterEscape CharacterEscape[UnicodeMode] :: ControlEscape c AsciiLetter 0 [lookahead ∉ DecimalDigit] HexEscapeSequence RegExpUnicodeEscapeSequence[?UnicodeMode] IdentityEscape[?UnicodeMode]

ControlEscape ControlEscape :: one of f n r t v

GroupSpecifier GroupSpecifier[UnicodeMode] :: ? GroupName[?UnicodeMode]

GroupName GroupName[UnicodeMode] :: <** *RegExpIdentifierName[?UnicodeMode]* **>

RegExpIdentifierName RegExpIdentifierName[UnicodeMode] :: RegExpIdentifierStart[?UnicodeMode] RegExpIdentifierName[?UnicodeMode] RegExpIdentifierPart[?UnicodeMode]

RegExpIdentifierStart RegExpIdentifierStart[UnicodeMode] :: IdentifierStartChar **** RegExpUnicodeEscapeSequence[+UnicodeMode] [~UnicodeMode] UnicodeLeadSurrogate UnicodeTrailSurrogate

RegExpIdentifierPart RegExpIdentifierPart[UnicodeMode] :: IdentifierPartChar **** RegExpUnicodeEscapeSequence[+UnicodeMode] [~UnicodeMode] UnicodeLeadSurrogate UnicodeTrailSurrogate

RegExpUnicodeEscapeSequence RegExpUnicodeEscapeSequence[UnicodeMode] :: [+UnicodeMode] u HexLeadSurrogate \u HexTrailSurrogate [+UnicodeMode] u HexLeadSurrogate [+UnicodeMode] u HexTrailSurrogate [+UnicodeMode] u HexNonSurrogate [~UnicodeMode] u Hex4Digits [+UnicodeMode] u{ CodePoint }

UnicodeLeadSurrogate UnicodeLeadSurrogate :: U+D800 ile U+DBFF arasındaki dahil aralıkta yer alan herhangi bir Unicode kod noktası

UnicodeTrailSurrogate UnicodeTrailSurrogate :: U+DC00 ile U+DFFF arasındaki dahil aralıkta yer alan herhangi bir Unicode kod noktası

İlişkili u HexLeadSurrogate seçimi belirsiz olan her \u HexTrailSurrogate, aksi takdirde karşılık gelen bir \u HexTrailSurrogate'ı olmayacak olan en yakın olası u HexLeadSurrogate ile ilişkilendirilecektir.

HexLeadSurrogate HexLeadSurrogate :: Hex4Digits but only if the MV of Hex4Digits is in the inclusive interval from 0xD800 to 0xDBFF

HexTrailSurrogate HexTrailSurrogate :: Hex4Digits but only if the MV of Hex4Digits is in the inclusive interval from 0xDC00 to 0xDFFF

HexNonSurrogate HexNonSurrogate :: Hex4Digits but only if the MV of Hex4Digits is not in the inclusive interval from 0xD800 to 0xDFFF

IdentityEscape IdentityEscape[UnicodeMode] :: [+UnicodeMode] SyntaxCharacter [+UnicodeMode] / [~UnicodeMode] SourceCharacter but not UnicodeIDContinue

DecimalEscape DecimalEscape :: NonZeroDigit DecimalDigits[~Sep]opt [lookahead ∉ DecimalDigit]

CharacterClassEscape CharacterClassEscape[UnicodeMode] :: d D s S w W [+UnicodeMode] p{ UnicodePropertyValueExpression } [+UnicodeMode] P{ UnicodePropertyValueExpression }

UnicodePropertyValueExpression UnicodePropertyValueExpression :: UnicodePropertyName = UnicodePropertyValue LoneUnicodePropertyNameOrValue

UnicodePropertyName UnicodePropertyName :: UnicodePropertyNameCharacters

UnicodePropertyNameCharacters UnicodePropertyNameCharacters :: UnicodePropertyNameCharacter UnicodePropertyNameCharactersopt

UnicodePropertyValue UnicodePropertyValue :: UnicodePropertyValueCharacters

LoneUnicodePropertyNameOrValue LoneUnicodePropertyNameOrValue :: UnicodePropertyValueCharacters

UnicodePropertyValueCharacters UnicodePropertyValueCharacters :: UnicodePropertyValueCharacter UnicodePropertyValueCharactersopt

UnicodePropertyValueCharacter UnicodePropertyValueCharacter :: UnicodePropertyNameCharacter DecimalDigit

UnicodePropertyNameCharacter UnicodePropertyNameCharacter :: AsciiLetter _

CharacterClass CharacterClass[UnicodeMode, UnicodeSetsMode] :: [ [lookahead ≠ ^] ClassContents[?UnicodeMode, ?UnicodeSetsMode] ] [^ ClassContents[?UnicodeMode, ?UnicodeSetsMode] ]

ClassContents ClassContents[UnicodeMode, UnicodeSetsMode] :: [empty] [~UnicodeSetsMode] NonemptyClassRanges[?UnicodeMode] [+UnicodeSetsMode] ClassSetExpression

NonemptyClassRanges NonemptyClassRanges[UnicodeMode] :: ClassAtom[?UnicodeMode] ClassAtom[?UnicodeMode] NonemptyClassRangesNoDash[?UnicodeMode] ClassAtom[?UnicodeMode] - ClassAtom[?UnicodeMode] ClassContents[?UnicodeMode, ~UnicodeSetsMode]

NonemptyClassRangesNoDash NonemptyClassRangesNoDash[UnicodeMode] :: ClassAtom[?UnicodeMode] ClassAtomNoDash[?UnicodeMode] NonemptyClassRangesNoDash[?UnicodeMode] ClassAtomNoDash[?UnicodeMode] - ClassAtom[?UnicodeMode] ClassContents[?UnicodeMode, ~UnicodeSetsMode]

ClassAtom ClassAtom[UnicodeMode] :: - ClassAtomNoDash[?UnicodeMode]

ClassAtomNoDash ClassAtomNoDash[UnicodeMode] :: SourceCharacter but not one of **** or ] or - **** ClassEscape[?UnicodeMode]

ClassEscape ClassEscape[UnicodeMode] :: b [+UnicodeMode] - CharacterClassEscape[?UnicodeMode] CharacterEscape[?UnicodeMode]

ClassSetExpression ClassSetExpression :: ClassUnion ClassIntersection ClassSubtraction

ClassUnion ClassUnion :: ClassSetRange ClassUnionopt ClassSetOperand ClassUnionopt

ClassIntersection ClassIntersection :: ClassSetOperand && [lookahead ≠ &] ClassSetOperand ClassIntersection && [lookahead ≠ &] ClassSetOperand

ClassSubtraction ClassSubtraction :: ClassSetOperand -- ClassSetOperand ClassSubtraction -- ClassSetOperand

ClassSetRange ClassSetRange :: ClassSetCharacter - ClassSetCharacter

ClassSetOperand ClassSetOperand :: NestedClass ClassStringDisjunction ClassSetCharacter

NestedClass NestedClass :: [ [lookahead ≠ ^] ClassContents[+UnicodeMode, +UnicodeSetsMode] ] [^ ClassContents[+UnicodeMode, +UnicodeSetsMode] ] **** CharacterClassEscape[+UnicodeMode]

ClassStringDisjunction ClassStringDisjunction :: \q{ ClassStringDisjunctionContents }

ClassStringDisjunctionContents ClassStringDisjunctionContents :: ClassString ClassString | ClassStringDisjunctionContents

ClassString ClassString :: [empty] NonEmptyClassString

NonEmptyClassString NonEmptyClassString :: ClassSetCharacter NonEmptyClassStringopt

ClassSetCharacter ClassSetCharacter :: [lookahead ∉ ClassSetReservedDoublePunctuator] SourceCharacter but not ClassSetSyntaxCharacter **** CharacterEscape[+UnicodeMode] **** ClassSetReservedPunctuator \b

ClassSetReservedDoublePunctuator ClassSetReservedDoublePunctuator :: one of && !! ## $$ %% ****** ++ ,, .. :: ;; <<** **==** **>> ?? @@ ^^ `` ~~

ClassSetSyntaxCharacter ClassSetSyntaxCharacter :: one of ( ) [ ] { } / - **** |

ClassSetReservedPunctuator ClassSetReservedPunctuator :: one of & - ! # % , : ; <** **=** **> @ ` ~