code: function parseStatement() {
          var token = lookahead(),
              expr,
              labeledBody;
  
          if (token.type === Token.EOF) {
              throwUnexpected(token);
          }
  
          if (token.type === Token.Punctuator) {
              switch (token.value) {
              case ';':
                  return parseEmptyStatement();
              case '{':
                  return parseBlock();
              case '(':
                  return parseExpressionStatement();
              default:
                  break;
              }
          }
  
          if (token.type === Token.Keyword) {
              switch (token.value) {
              case 'break':
                  return parseBreakStatement();
              case 'continue':
                  return parseContinueStatement();
              case 'debugger':
                  return parseDebuggerStatement();
              case 'do':
                  return parseDoWhileStatement();
              case 'for':
                  return parseForStatement();
              case 'function':
                  return parseFunctionDeclaration();
              case 'if':
                  return parseIfStatement();
              case 'return':
                  return parseReturnStatement();
              case 'switch':
                  return parseSwitchStatement();
              case 'throw':
                  return parseThrowStatement();
              case 'try':
                  return parseTryStatement();
              case 'var':
                  return parseVariableStatement();
              case 'while':
                  return parseWhileStatement();
              case 'with':
                  return parseWithStatement();
              default:
                  break;
              }
          }
  
          if(token.type === Token.Punctuator) {
              if(token.value === extra.parse.interpolator) return parseAtExpression(token);
              if(token.value === "<") return parseHtmlExpression(token);
          }
  
          expr = parseExpression();
  
          // 12.12 Labelled Statements
          if ((expr.type === Syntax.Identifier) && match(':')) {
              lex();
  
              if (Object.prototype.hasOwnProperty.call(labelSet, expr.name)) {
                  throwError({}, Messages.Redeclaration, 'Label', expr.name);
              }
  
              labelSet[expr.name] = true;
              labeledBody = parseStatement();
              delete labelSet[expr.name];
  
              return {
                  type: Syntax.LabeledStatement,
                  label: expr,
                  body: labeledBody
              };
          }
  
          consumeSemicolon();
  
          return {
              type: Syntax.ExpressionStatement,
              expression: expr
          };
      }
docs: 12 Statements