docs: function isListElement(parsingContext, inErrorRecovery) {
              var node = currentNode(parsingContext);
              if (node) {
                  return true;
              }
              switch (parsingContext) {
                  case 0 /* SourceElements */:
                  case 1 /* BlockStatements */:
                  case 3 /* SwitchClauseStatements */:
                      // If we're in error recovery, then we don't want to treat ';' as an empty statement.
                      // The problem is that ';' can show up in far too many contexts, and if we see one
                      // and assume it's a statement, then we may bail out inappropriately from whatever
                      // we're parsing.  For example, if we have a semicolon in the middle of a class, then
                      // we really don't want to assume the class is over and we're on a statement in the
                      // outer module.  We just want to consume and move on.
                      return !(token() === 23 /* SemicolonToken */ && inErrorRecovery) && isStartOfStatement();
                  case 2 /* SwitchClauses */:
                      return token() === 71 /* CaseKeyword */ || token() === 77 /* DefaultKeyword */;
                  case 4 /* TypeMembers */:
                      return lookAhead(isTypeMemberStart);
                  case 5 /* ClassMembers */:
                      // We allow semicolons as class elements (as specified by ES6) as long as we're
                      // not in error recovery.  If we're in error recovery, we don't want an errant
                      // semicolon to be treated as a class member (since they're almost always used
                      // for statements.
                      return lookAhead(isClassMemberStart) || (token() === 23 /* SemicolonToken */ && !inErrorRecovery);
                  case 6 /* EnumMembers */:
                      // Include open bracket computed properties. This technically also lets in indexers,
                      // which would be a candidate for improved error reporting.
                      return token() === 19 /* OpenBracketToken */ || isLiteralPropertyName();
                  case 12 /* ObjectLiteralMembers */:
                      return token() === 19 /* OpenBracketToken */ || token() === 37 /* AsteriskToken */ || isLiteralPropertyName();
                  case 9 /* ObjectBindingElements */:
                      return token() === 19 /* OpenBracketToken */ || isLiteralPropertyName();
                  case 7 /* HeritageClauseElement */:
                      // If we see { } then only consume it as an expression if it is followed by , or {
                      // That way we won't consume the body of a class in its heritage clause.
                      if (token() === 15 /* OpenBraceToken */) {
                          return lookAhead(isValidHeritageClauseObjectLiteral);
                      }
                      if (!inErrorRecovery) {
                          return isStartOfLeftHandSideExpression() && !isHeritageClauseExtendsOrImplementsKeyword();
                      }
                      else {
                          // If we're in error recovery we tighten up what we're willing to match.
                          // That way we don't treat something like "this" as a valid heritage clause
                          // element during recovery.
                          return isIdentifier() && !isHeritageClauseExtendsOrImplementsKeyword();
                      }
                  case 8 /* VariableDeclarations */:
                      return isIdentifierOrPattern();
                  case 10 /* ArrayBindingElements */:
                      return token() === 24 /* CommaToken */ || token() === 22 /* DotDotDotToken */ || isIdentifierOrPattern();
                  case 17 /* TypeParameters */:
                      return isIdentifier();
                  case 11 /* ArgumentExpressions */:
                  case 15 /* ArrayLiteralMembers */:
                      return token() === 24 /* CommaToken */ || token() === 22 /* DotDotDotToken */ || isStartOfExpression();
                  case 16 /* Parameters */:
                      return isStartOfParameter();
                  case 18 /* TypeArguments */:
                  case 19 /* TupleElementTypes */:
                      return token() === 24 /* CommaToken */ || isStartOfType();
                  case 20 /* HeritageClauses */:
                      return isHeritageClause();
                  case 21 /* ImportOrExportSpecifiers */:
                      return ts.tokenIsIdentifierOrKeyword(token());
                  case 13 /* JsxAttributes */:
                      return ts.tokenIsIdentifierOrKeyword(token()) || token() === 15 /* OpenBraceToken */;
                  case 14 /* JsxChildren */:
                      return true;
                  case 22 /* JSDocFunctionParameters */:
                  case 23 /* JSDocTypeArguments */:
                  case 25 /* JSDocTupleTypes */:
                      return JSDocParser.isJSDocType();
                  case 24 /* JSDocRecordMembers */:
                      return isSimplePropertyName();
              }
              ts.Debug.fail("Non-exhaustive case in 'isListElement'.");
          }