   200→}
   201→
   202→/**
   203→ *  Parse statement list
   204→ *
   205→ * @param parser  Parser object
   206→ * @param context Context masks
   207→ * @param scope Scope object
   208→ */
   209→
   210→function parseStatementListItem(
   211→  parser: Parser,
   212→  context: Context,
   213→  scope: Scope | undefined,
   214→  privateScope: PrivateScope | undefined,
   215→  origin: Origin,
   216→  labels: ESTree.Labels,
   217→): ESTree.Statement {
   218→  // ECMA 262 10th Edition
   219→  // StatementListItem[Yield, Return] :
   220→  //   Statement[?Yield, ?Return]
   221→  //   Declaration[?Yield]
   222→  //
   223→  // Declaration[Yield] :
   224→  //   HoistableDeclaration[?Yield]
   225→  //   ClassDeclaration[?Yield]
   226→  //   LexicalDeclaration[In, ?Yield]
   227→  //
   228→  // HoistableDeclaration[Yield, Default] :
   229→  //   FunctionDeclaration[?Yield, ?Default]
   230→  //   GeneratorDeclaration[?Yield, ?Default]
   231→  //
   232→  // LexicalDeclaration[In, Yield] :
   233→  //   LetOrConst BindingList[?In, ?Yield] ;
   234→  const start = parser.tokenStart;
   235→
   236→  switch (parser.getToken()) {
   237→    //   HoistableDeclaration[?Yield, ~Default]
   238→    case Token.FunctionKeyword:
   239→      return parseFunctionDeclaration(
   240→        parser,
   241→        context,
   242→        scope,
   243→        privateScope,
   244→        origin,
   245→        1,
   246→        HoistedFunctionFlags.None,
   247→        0,
   248→        start,
   249→      );
   250→
   251→    case Token.Decorator: // @decorator
   252→    case Token.ClassKeyword: // ClassDeclaration[?Yield, ~Default]
   253→      return parseClassDeclaration(parser, context, scope, privateScope, HoistedClassFlags.None);
   254→    // LexicalDeclaration[In, ?Yield]
   255→    // LetOrConst BindingList[?In, ?Yield]
   256→    case Token.ConstKeyword:
   257→      return parseLexicalDeclaration(parser, context, scope, privateScope, BindingKind.Const, Origin.None);
   258→    case Token.LetKeyword:
   259→      return parseLetIdentOrVarDeclarationStatement(parser, context, scope, privateScope, origin);
   260→    // ExportDeclaration
   261→    case Token.ExportKeyword:
   262→      parser.report(Errors.InvalidImportExportSloppy, 'export');
   263→    // ImportDeclaration
   264→    case Token.ImportKeyword:
   265→      nextToken(parser, context);
   266→      switch (parser.getToken()) {
   267→        case Token.LeftParen:
   268→          return parseImportCallDeclaration(parser, context, privateScope, start);
   269→        case Token.Period:
   270→          return parseImportMetaDeclaration(parser, context, start);
   271→        default:
   272→          parser.report(Errors.InvalidImportExportSloppy, 'import');
   273→      }
   274→    //   async [no LineTerminator here] AsyncArrowBindingIdentifier ...
   275→    //   async [no LineTerminator here] ArrowFormalParameters ...
   276→    case Token.AsyncKeyword:
   277→      return parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, privateScope, origin, labels, 1);
   278→    default:
   279→      return parseStatement(parser, context, scope, privateScope, origin, labels, 1);
   280→  }
   281→}
   282→
   283→/**
   284→ * Parse statement
   285→ *
   286→ * @param parser  Parser object
   287→ * @param context Context masks
   288→ * @param allowFuncDecl Allow / disallow func statement
   289→ */
   290→
   291→function parseStatement(
   292→  parser: Parser,
   293→  context: Context,
   294→  scope: Scope | undefined,
   295→  privateScope: PrivateScope | undefined,
   296→  origin: Origin,
   297→  labels: ESTree.Labels,
   298→  allowFuncDecl: 0 | 1,
   299→): ESTree.Statement {
   300→  // Statement ::
   301→  //   Block
   302→  //   VariableStatement
   303→  //   EmptyStatement
   304→  //   ExpressionStatement
   305→  //   IfStatement
   306→  //   IterationStatement
   307→  //   ContinueStatement
   308→  //   BreakStatement
   309→  //   ReturnStatement
   310→  //   WithStatement
   311→  //   LabelledStatement
   312→  //   SwitchStatement
   313→  //   ThrowStatement
   314→  //   TryStatement
   315→  //   DebuggerStatement
   316→
   317→  switch (parser.getToken()) {
   318→    // VariableStatement[?Yield]
   319→    case Token.VarKeyword:
   320→      return parseVariableStatement(parser, context, scope, privateScope, Origin.None);
   321→    // [+Return] ReturnStatement[?Yield]
   322→    case Token.ReturnKeyword:
   323→      return parseReturnStatement(parser, context, privateScope);
   324→    case Token.IfKeyword:
   325→      return parseIfStatement(parser, context, scope, privateScope, labels);
   326→    case Token.ForKeyword:
   327→      return parseForStatement(parser, context, scope, privateScope, labels);
   328→    // BreakableStatement[Yield, Return]:
   329→    //   IterationStatement[?Yield, ?Return]
   330→    //   SwitchStatement[?Yield, ?Return]
   331→    case Token.DoKeyword:
   332→      return parseDoWhileStatement(parser, context, scope, privateScope, labels);
   333→    case Token.WhileKeyword:
   334→      return parseWhileStatement(parser, context, scope, privateScope, labels);
   335→    case Token.SwitchKeyword:
   336→      return parseSwitchStatement(parser, context, scope, privateScope, labels);
   337→    case Token.Semicolon:
   338→      // EmptyStatement
   339→      return parseEmptyStatement(parser, context);
   340→    // BlockStatement[?Yield, ?Return]
   341→    case Token.LeftBrace:
   342→      return parseBlock(
   343→        parser,
   344→        context,
   345→        scope?.createChildScope(),
   346→        privateScope,
   347→        labels,
   348→        parser.tokenStart,
   349→      ) as ESTree.Statement;
   350→
   351→    // ThrowStatement[?Yield]
   352→    case Token.ThrowKeyword:
   353→      return parseThrowStatement(parser, context, privateScope);
   354→    case Token.BreakKeyword:
   355→      // BreakStatement[?Yield]
   356→      return parseBreakStatement(parser, context, labels);
   357→    // ContinueStatement[?Yield]
   358→    case Token.ContinueKeyword:
   359→      return parseContinueStatement(parser, context, labels);
   360→    // TryStatement[?Yield, ?Return]
   361→    case Token.TryKeyword:
   362→      return parseTryStatement(parser, context, scope, privateScope, labels);
   363→    // WithStatement[?Yield, ?Return]
   364→    case Token.WithKeyword:
   365→      return parseWithStatement(parser, context, scope, privateScope, labels);
   366→    case Token.DebuggerKeyword:
   367→      // DebuggerStatement
   368→      return parseDebuggerStatement(parser, context);
   369→    case Token.AsyncKeyword:
   370→      return parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, privateScope, origin, labels, 0);
   371→    // Miscellaneous error cases arguably better caught here than elsewhere
   372→    case Token.CatchKeyword:
   373→      parser.report(Errors.CatchWithoutTry);
   374→    case Token.FinallyKeyword:
   375→      parser.report(Errors.FinallyWithoutTry);
   376→    case Token.FunctionKeyword:
   377→      // FunctionDeclaration & ClassDeclaration is forbidden by lookahead
   378→      // restriction in an arbitrary statement position.
   379→      parser.report(
   380→        context & Context.Strict
   381→          ? Errors.StrictFunction
   382→          : !parser.options.webcompat
   383→            ? Errors.WebCompatFunction
   384→            : Errors.SloppyFunction,
   385→      );
   386→    case Token.ClassKeyword:
   387→      parser.report(Errors.ClassForbiddenAsStatement);
   388→
   389→    default:
   390→      return parseExpressionOrLabelledStatement(parser, context, scope, privateScope, origin, labels, allowFuncDecl);
   391→  }
   392→}
   393→
   394→/**
   395→ * Parses either expression or labeled statement
   396→ *
   397→ * @param parser  Parser object
   398→ * @param context Context masks
   399→ * @param allowFuncDecl Allow / disallow func statement
   400→ */
   401→
   402→function parseExpressionOrLabelledStatement(
   403→  parser: Parser,
   404→  context: Context,
   405→  scope: Scope | undefined,
   406→  privateScope: PrivateScope | undefined,
   407→  origin: Origin,
   408→  labels: ESTree.Labels,
   409→  allowFuncDecl: 0 | 1,
   410→): ESTree.ExpressionStatement | ESTree.LabeledStatement {
   411→  // ExpressionStatement | LabelledStatement ::
   412→  //   Expression ';'
   413→  //   Identifier ':' Statement
   414→  //
   415→  // ExpressionStatement[Yield] :
   416→  //   [lookahead not in {{, function, class, let [}] Expression[In, ?Yield] ;
   417→
   418→  const { tokenValue, tokenStart } = parser;
   419→  const token = parser.getToken();
   420→
   421→  let expr: ESTree.Expression;
   422→
   423→  switch (token) {
   424→    case Token.LetKeyword:
   425→      expr = parseIdentifier(parser, context);
   426→      if (context & Context.Strict) parser.report(Errors.UnexpectedLetStrictReserved);
   427→
   428→      // "let" followed by either "[", "{" or an identifier means a lexical
   429→      // declaration, which should not appear here.
   430→      // However, ASI may insert a line break before an identifier or a brace.
   431→      if (parser.getToken() === Token.LeftBracket) parser.report(Errors.RestrictedLetProduction);
   432→
   433→      break;
   434→
   435→    default:
   436→      expr = parsePrimaryExpression(parser, context, privateScope, BindingKind.Empty, 0, 1, 0, 1, parser.tokenStart);
   437→  }
   438→
   439→  /** LabelledStatement[Yield, Await, Return]:
   440→   *
   441→   * ExpressionStatement | LabelledStatement ::
   442→   * Expression ';'
   443→   *   Identifier ':' Statement
   444→   *
   445→   * ExpressionStatement[Yield] :
   446→   *   [lookahead not in {{, function, class, let [}] Expression[In, ?Yield] ;
   447→   */
   448→  if (token & Token.IsIdentifier && parser.getToken() === Token.Colon) {
   449→    return parseLabelledStatement(
   450→      parser,
   451→      context,
   452→      scope,
   453→      privateScope,
   454→      origin,
   455→      labels,
   456→      tokenValue,
   457→      expr,
   458→      token,
   459→      allowFuncDecl,
   460→      tokenStart,
   461→    );
   462→  }
   463→  /** MemberExpression :
   464→   *   1. PrimaryExpression
   465→   *   2. MemberExpression [ AssignmentExpression ]
   466→   *   3. MemberExpression . IdentifierName
   467→   *   4. MemberExpression TemplateLiteral
   468→   *
   469→   * CallExpression :
   470→   *   1. MemberExpression Arguments
   471→   *   2. CallExpression ImportCall
   472→   *   3. CallExpression Arguments
   473→   *   4. CallExpression [ AssignmentExpression ]
   474→   *   5. CallExpression . IdentifierName
   475→   *   6. CallExpression TemplateLiteral
   476→   *
   477→   *  UpdateExpression ::
   478→   *   ('++' | '--')? LeftHandSideExpression
   479→   *
   480→   */
   481→
   482→  expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 0, 0, tokenStart);
   483→
   484→  /** AssignmentExpression :
   485→   *   1. ConditionalExpression
   486→   *   2. LeftHandSideExpression = AssignmentExpression
   487→   *
   488→   */
   489→
   490→  expr = parseAssignmentExpression(parser, context, privateScope, 0, 0, tokenStart, expr as ESTree.ArgumentExpression);
   491→
   492→  /** Sequence expression
   493→   *
   494→   * Note: The comma operator leads to a sequence expression which is not equivalent
   495→   * to the ES Expression, but it's part of the ESTree specs:
   496→   *
   497→   * https://github.com/estree/estree/blob/master/es5.md#sequenceexpression
   498→   *
   499→   */

[8414 more lines in file. Use offset=500 to continue.]