  1847→function parseForStatement(
  1848→  parser: Parser,
  1849→  context: Context,
  1850→  scope: Scope | undefined,
  1851→  privateScope: PrivateScope | undefined,
  1852→  labels: ESTree.Labels,
  1853→): ESTree.ForStatement | ESTree.ForInStatement | ESTree.ForOfStatement {
  1854→  const start = parser.tokenStart;
  1855→
  1856→  nextToken(parser, context);
  1857→
  1858→  const forAwait =
  1859→    ((context & Context.InAwaitContext) > 0 || ((context & Context.Module) > 0 && (context & Context.InGlobal) > 0)) &&
  1860→    consumeOpt(parser, context, Token.AwaitKeyword);
  1861→
  1862→  consume(parser, context | Context.AllowRegExp, Token.LeftParen);
  1863→
  1864→  scope = scope?.createChildScope(ScopeKind.ForStatement);
  1865→
  1866→  let test: ESTree.Expression | null = null;
  1867→  let update: ESTree.Expression | null = null;
  1868→  let destructible: AssignmentKind | DestructuringKind = 0;
  1869→  let init = null;
  1870→  let isVarDecl =
  1871→    parser.getToken() === Token.VarKeyword ||
  1872→    parser.getToken() === Token.LetKeyword ||
  1873→    parser.getToken() === Token.ConstKeyword;
  1874→  let right;
  1875→
  1876→  const { tokenStart } = parser;
  1877→  const token = parser.getToken();
  1878→
  1879→  if (isVarDecl) {
  1880→    if (token === Token.LetKeyword) {
  1881→      init = parseIdentifier(parser, context);
  1882→      if (parser.getToken() & (Token.IsIdentifier | Token.IsPatternStart)) {
  1883→        if (parser.getToken() === Token.InKeyword) {
  1884→          if (context & Context.Strict) parser.report(Errors.DisallowedLetInStrict);
  1885→        } else {
  1886→          init = parser.finishNode<ESTree.VariableDeclaration>(
  1887→            {
  1888→              type: 'VariableDeclaration',
  1889→              kind: 'let',
  1890→              declarations: parseVariableDeclarationList(
  1891→                parser,
  1892→                context | Context.DisallowIn,
  1893→                scope,
  1894→                privateScope,
  1895→                BindingKind.Let,
  1896→                Origin.ForStatement,
  1897→              ),
  1898→            },
  1899→            tokenStart,
  1900→          );
  1901→        }
  1902→
  1903→        parser.assignable = AssignmentKind.Assignable;
  1904→      } else if (context & Context.Strict) {
  1905→        parser.report(Errors.DisallowedLetInStrict);
  1906→      } else {
  1907→        isVarDecl = false;
  1908→        parser.assignable = AssignmentKind.Assignable;
  1909→        init = parseMemberOrUpdateExpression(parser, context, privateScope, init, 0, 0, tokenStart);
  1910→
  1911→        // `for of` only allows LeftHandSideExpressions which do not start with `let`, and no other production matches
  1912→        if (parser.getToken() === Token.OfKeyword) parser.report(Errors.ForOfLet);
  1913→      }
  1914→    } else {
  1915→      nextToken(parser, context);
  1916→
  1917→      init = parser.finishNode(
  1918→        token === Token.VarKeyword
  1919→          ? {
  1920→              type: 'VariableDeclaration',
  1921→              kind: 'var',
  1922→              declarations: parseVariableDeclarationList(
  1923→                parser,
  1924→                context | Context.DisallowIn,
  1925→                scope,
  1926→                privateScope,
  1927→                BindingKind.Variable,
  1928→                Origin.ForStatement,
  1929→              ),
  1930→            }
  1931→          : {
  1932→              type: 'VariableDeclaration',
  1933→              kind: 'const',
  1934→              declarations: parseVariableDeclarationList(
  1935→                parser,
  1936→                context | Context.DisallowIn,
  1937→                scope,
  1938→                privateScope,
  1939→                BindingKind.Const,
  1940→                Origin.ForStatement,
  1941→              ),
  1942→            },
  1943→        tokenStart,
  1944→      );
  1945→
  1946→      parser.assignable = AssignmentKind.Assignable;
  1947→    }
  1948→  } else if (token === Token.Semicolon) {
  1949→    if (forAwait) parser.report(Errors.InvalidForAwait);
  1950→  } else if ((token & Token.IsPatternStart) === Token.IsPatternStart) {
  1951→    const patternStart = parser.tokenStart;
  1952→    init =
  1953→      token === Token.LeftBrace
  1954→        ? parseObjectLiteralOrPattern(
  1955→            parser,
  1956→            context,
  1957→            void 0,
  1958→            privateScope,
  1959→            1,
  1960→            0,
  1961→            0,
  1962→            BindingKind.Empty,
  1963→            Origin.ForStatement,
  1964→          )
  1965→        : parseArrayExpressionOrPattern(
  1966→            parser,
  1967→            context,
  1968→            void 0,
  1969→            privateScope,
  1970→            1,
  1971→            0,
  1972→            0,
  1973→            BindingKind.Empty,
  1974→            Origin.ForStatement,
  1975→          );
  1976→
  1977→    destructible = parser.destructible;
  1978→
  1979→    if (destructible & DestructuringKind.SeenProto) {
  1980→      parser.report(Errors.DuplicateProto);
  1981→    }
  1982→
  1983→    parser.assignable =
  1984→      destructible & DestructuringKind.CannotDestruct ? AssignmentKind.CannotAssign : AssignmentKind.Assignable;
  1985→
  1986→    init = parseMemberOrUpdateExpression(
  1987→      parser,
  1988→      context | Context.DisallowIn,
  1989→      privateScope,
  1990→      init as ESTree.Expression,
  1991→      0,
  1992→      0,
  1993→      patternStart,
  1994→    );
  1995→  } else {
  1996→    init = parseLeftHandSideExpression(parser, context | Context.DisallowIn, privateScope, 1, 0, 1);
  1997→  }
  1998→
  1999→  if ((parser.getToken() & Token.IsInOrOf) === Token.IsInOrOf) {
  2000→    if (parser.getToken() === Token.OfKeyword) {
  2001→      if (parser.assignable & AssignmentKind.CannotAssign)
  2002→        parser.report(Errors.CantAssignToInOfForLoop, forAwait ? 'await' : 'of');
  2003→
  2004→      reinterpretToPattern(parser, init);
  2005→      nextToken(parser, context | Context.AllowRegExp);
  2006→
  2007→      // IterationStatement:
  2008→      //  for(LeftHandSideExpression of AssignmentExpression) Statement
  2009→      //  for await(LeftHandSideExpression of AssignmentExpression) Statement
  2010→      right = parseExpression(parser, context, privateScope, 1, 0, parser.tokenStart);
  2011→
  2012→      consume(parser, context | Context.AllowRegExp, Token.RightParen);
  2013→
  2014→      const body = parseIterationStatementBody(parser, context, scope, privateScope, labels);
  2015→
  2016→      return parser.finishNode<ESTree.ForOfStatement>(
  2017→        {
  2018→          type: 'ForOfStatement',
  2019→          left: init,
  2020→          right,
  2021→          body,
  2022→          await: forAwait,
  2023→        },
  2024→        start,
  2025→      );
  2026→    }
  2027→
  2028→    if (parser.assignable & AssignmentKind.CannotAssign) parser.report(Errors.CantAssignToInOfForLoop, 'in');
  2029→
  2030→    reinterpretToPattern(parser, init);
  2031→    nextToken(parser, context | Context.AllowRegExp);
  2032→
  2033→    // `for await` only accepts the `for-of` type
  2034→    if (forAwait) parser.report(Errors.InvalidForAwait);
  2035→
  2036→    // IterationStatement:
  2037→    //  for(LeftHandSideExpression in Expression) Statement
  2038→    right = parseExpressions(parser, context, privateScope, 0, 1, parser.tokenStart);
  2039→
  2040→    consume(parser, context | Context.AllowRegExp, Token.RightParen);
  2041→    const body = parseIterationStatementBody(parser, context, scope, privateScope, labels);
  2042→
  2043→    return parser.finishNode<ESTree.ForInStatement>(
  2044→      {
  2045→        type: 'ForInStatement',
  2046→        body,
  2047→        left: init,
  2048→        right,
  2049→      },
  2050→      start,
  2051→    );
  2052→  }
  2053→
  2054→  if (forAwait) parser.report(Errors.InvalidForAwait);
  2055→
  2056→  if (!isVarDecl) {
  2057→    if (destructible & DestructuringKind.HasToDestruct && parser.getToken() !== Token.Assign) {
  2058→      parser.report(Errors.CantAssignToInOfForLoop, 'loop');
  2059→    }
  2060→
  2061→    init = parseAssignmentExpression(parser, context | Context.DisallowIn, privateScope, 0, 0, tokenStart, init);
  2062→  }
  2063→
  2064→  if (parser.getToken() === Token.Comma)
  2065→    init = parseSequenceExpression(parser, context, privateScope, 0, tokenStart, init);
  2066→
  2067→  consume(parser, context | Context.AllowRegExp, Token.Semicolon);
  2068→
  2069→  if (parser.getToken() !== Token.Semicolon)
  2070→    test = parseExpressions(parser, context, privateScope, 0, 1, parser.tokenStart);
  2071→
  2072→  consume(parser, context | Context.AllowRegExp, Token.Semicolon);
  2073→
  2074→  if (parser.getToken() !== Token.RightParen)
  2075→    update = parseExpressions(parser, context, privateScope, 0, 1, parser.tokenStart);
  2076→
  2077→  consume(parser, context | Context.AllowRegExp, Token.RightParen);
  2078→
  2079→  const body = parseIterationStatementBody(parser, context, scope, privateScope, labels);
  2080→
  2081→  return parser.finishNode<ESTree.ForStatement>(
  2082→    {
  2083→      type: 'ForStatement',
  2084→      init,
  2085→      test,
  2086→      update,
  2087→      body,
  2088→    },
  2089→    start,
  2090→  );
  2091→}
  2092→
  2093→/**
  2094→ * Parses restricted identifier in import & export declaration
  2095→ *
  2096→ * @param parser  Parser object
  2097→ * @param context Context masks
  2098→ * @param scope Scope object
  2099→ */
  2100→function parseRestrictedIdentifier(parser: Parser, context: Context, scope: Scope | undefined): ESTree.Identifier {
  2101→  if (!isValidIdentifier(context, parser.getToken())) parser.report(Errors.UnexpectedStrictReserved);
  2102→  if ((parser.getToken() & Token.IsEvalOrArguments) === Token.IsEvalOrArguments)
  2103→    parser.report(Errors.StrictEvalArguments);
  2104→  scope?.addBlockName(context, parser.tokenValue, BindingKind.Let, Origin.None);
  2105→  return parseIdentifier(parser, context);
  2106→}
  2107→
  2108→/**
  2109→ * Parse import declaration
  2110→ *
  2111→ * @see [Link](https://tc39.github.io/ecma262/#prod-ImportDeclaration)
  2112→ *
  2113→ * @param parser  Parser object
  2114→ * @param context Context masks
  2115→ * @param scope Scope object
  2116→ */
  2117→function parseImportDeclaration(
  2118→  parser: Parser,
  2119→  context: Context,
  2120→  scope: Scope | undefined,
  2121→): ESTree.ImportDeclaration | ESTree.ExpressionStatement {
  2122→  // ImportDeclaration :
  2123→  //   'import' ImportClause 'from' ModuleSpecifier ';'
  2124→  //   'import' ModuleSpecifier ';'
  2125→  //
  2126→  // ImportClause :

[6787 more lines in file. Use offset=2127 to continue.]