Standard ECMA-262

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

See 11.2

WhiteSpace ::

<TAB>

<VT>

<FF>

<SP>

<NBSP>

<USP>

See 11.3

LineTerminator ::

<LF>

<CR>

<LS>

<PS>

See 11.3

LineTerminatorSequence ::

<LF>

<CR> [lookahead ≠ <LF> ]

<LS>

<PS>

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

See 11.5

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”, “Other_ID_Continue”, or “Other_ID_Start”

See 11.6.2

ReservedWord ::

Keyword

FutureReservedWord

NullLiteral

BooleanLiteral

See 11.6.2.1

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`

See 11.6.2.2

FutureReservedWord ::

enum

await

await is only treated as a FutureReservedWord when Module is the goal symbol of the syntactic grammar.

The following tokens are also considered to be FutureReservedWords when parsing strict mode code (see 10.2.1).

`implements`	`package`	`protected`
`interface`	`private`	`public`

See 11.7

Punctuator :: one of

`{`	`}`	`(`	`)`	`[`	`]`
`.`	`;`	`,`	`<`	`>`	`<=`
`>=`	`==`	`!=`	`===`	`!==`
`+`	`-`	`*`	`%`	`++`	`--`
`<<`	`>>`	`>>>`	`&`	`\|`	`^`
`!`	`~`	`&&`	`\|\|`	`?`	`:`
`=`	`+=`	`-=`	`*=`	`%=`	`<<=`
`>>=`	`>>>=`	`&=`	`\|=`	`^=`	`=>`

See 11.7

DivPunctuator :: one of

/

/=

See 11.7

RightBracePunctuator :: one of

}

See 11.8.1

NullLiteral ::

null

See 11.8.2

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

A.2 Expressions

See 12.1

IdentifierReference_[Yield] :

Identifier

[~Yield] yield

BindingIdentifier_[Yield] : See 12.1

Identifier
[~Yield] yield

See 12.1

LabelIdentifier_[Yield] :

Identifier

[~Yield] yield

See 12.1

Identifier :

IdentifierName but not ReservedWord

See 12.2

PrimaryExpression_[Yield] :

this

IdentifierReference_[?Yield]

Literal

ArrayLiteral_[?Yield]

ObjectLiteral_[?Yield]

FunctionExpression

ClassExpression_[?Yield]

GeneratorExpression

RegularExpressionLiteral

TemplateLiteral_[?Yield]

CoverParenthesizedExpressionAndArrowParameterList_[?Yield]

See 12.2

CoverParenthesizedExpressionAndArrowParameterList_[Yield] :

( Expression_{[In, ?Yield]} )

( )

( ... BindingIdentifier_[?Yield] )

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

When processing the production

PrimaryExpression_[Yield] : CoverParenthesizedExpressionAndArrowParameterList_[?Yield]
the interpretation of CoverParenthesizedExpressionAndArrowParameterList is refined using the following grammar:

See 12.2

ParenthesizedExpression_[Yield] :

( Expression_{[In, ?Yield]} )

See 12.2.4

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]}

See 12.2.9

TemplateLiteral_[Yield] :

NoSubstitutionTemplate

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

See 12.2.9

TemplateSpans_[Yield] :

TemplateTail

TemplateMiddleList_[?Yield] TemplateTail

See 12.2.9

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]

See 12.4

PostfixExpression_[Yield] :

LeftHandSideExpression_[?Yield]

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

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

See 12.5

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]

See 12.6

MultiplicativeExpression_[Yield] :

UnaryExpression_[?Yield]

MultiplicativeExpression_[?Yield] MultiplicativeOperator UnaryExpression_[?Yield]

See 12.6

MultiplicativeOperator : one of

* / %

See 12.7

AdditiveExpression_[Yield] :

MultiplicativeExpression_[?Yield]

AdditiveExpression_[?Yield] + MultiplicativeExpression_[?Yield]

AdditiveExpression_[?Yield] - MultiplicativeExpression_[?Yield]

See 12.8

ShiftExpression_[Yield] :

AdditiveExpression_[?Yield]

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

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

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

See 12.9

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]

See 12.10

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]}

See 12.11

BitwiseANDExpression_{[In, Yield]} :

EqualityExpression_{[?In, ?Yield]}

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

See 12.11

BitwiseXORExpression_{[In, Yield]} :

BitwiseANDExpression_{[?In, ?Yield]}

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

See 12.11

BitwiseORExpression_{[In, Yield]} :

BitwiseXORExpression_{[?In, ?Yield]}

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

See 12.12

LogicalANDExpression_{[In, Yield]} :

BitwiseORExpression_{[?In, ?Yield]}

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

See 12.12

LogicalORExpression_{[In, Yield]} :

LogicalANDExpression_{[?In, ?Yield]}

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

See 12.13

ConditionalExpression_{[In, Yield]} :

LogicalORExpression_{[?In, ?Yield]}

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

See 12.14

AssignmentExpression_{[In, Yield]} :

ConditionalExpression_{[?In, ?Yield]}

[+Yield] YieldExpression_[?In]

ArrowFunction_{[?In, ?Yield]}

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

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

See 12.14

AssignmentOperator : one of

*= /= %= += -= <<= >>= >>>= &= ^= |=

See 12.15

Expression_{[In, Yield]} :

AssignmentExpression_{[?In, ?Yield]}

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

A.3 Statements

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]}

See 13.3.2

VariableStatement_[Yield] :

var VariableDeclarationList_{[In, ?Yield]} ;

See 13.3.2

VariableDeclarationList_{[In, Yield]} :

VariableDeclaration_{[?In, ?Yield]}

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

See 13.3.2

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