code: function parseStatement() {
          var type = lookahead.type,
              expr,
              labeledBody,
              key,
              node;
  
          if (type === Token.EOF) {
              throwUnexpectedToken(lookahead);
          }
  
          if (type === Token.Punctuator && lookahead.value === '{') {
              return parseBlock();
          }
  
          node = new Node();
  
          if (type === Token.Punctuator) {
              switch (lookahead.value) {
              case ';':
                  return parseEmptyStatement(node);
              case '(':
                  return parseExpressionStatement(node);
              default:
                  break;
              }
          } else if (type === Token.Keyword) {
              switch (lookahead.value) {
              case 'break':
                  return parseBreakStatement(node);
              case 'continue':
                  return parseContinueStatement(node);
              case 'debugger':
                  return parseDebuggerStatement(node);
              case 'do':
                  return parseDoWhileStatement(node);
              case 'for':
                  return parseForStatement(node);
              case 'function':
                  return parseFunctionDeclaration(node);
              case 'if':
                  return parseIfStatement(node);
              case 'return':
                  return parseReturnStatement(node);
              case 'switch':
                  return parseSwitchStatement(node);
              case 'throw':
                  return parseThrowStatement(node);
              case 'try':
                  return parseTryStatement(node);
              case 'var':
                  return parseVariableStatement(node);
              case 'while':
                  return parseWhileStatement(node);
              case 'with':
                  return parseWithStatement(node);
              default:
                  break;
              }
          }
  
          expr = parseExpression();
  
          // 12.12 Labelled Statements
          if ((expr.type === Syntax.Identifier) && match(':')) {
              lex();
  
              key = '$' + expr.name;
              if (Object.prototype.hasOwnProperty.call(state.labelSet, key)) {
                  throwError(Messages.Redeclaration, 'Label', expr.name);
              }
  
              state.labelSet[key] = true;
              labeledBody = parseStatement();
              delete state.labelSet[key];
              return node.finishLabeledStatement(expr, labeledBody);
          }
  
          consumeSemicolon();
  
          return node.finishExpressionStatement(expr);
      }
docs: 12 Statements