v4.4.6

bump `chalk`

.editorconfig

@@ -5,6 +5,7 @@ insert_final_newline = true
 charset = utf-8
 trim_trailing_whitespace = true
 insert_final_newline = true
+end_of_line = lf
 
 [*.{js,json}]
 indent_style = space

CHANGELOG.md

@@ -13,6 +13,60 @@ _Note: Gaps between patch versions are faulty/broken releases._
 
 See [CHANGELOG - 6to5](CHANGELOG-6to5.md) for the pre-4.0.0 version changelog.
 
+## 4.4.6
+
+ * **Bug Fix**
+  * Fix extending a class expression with no methods/only constructor. Thanks [@neVERberleRfellerER](https://github.com/neVERberleRfellerER)!
+  * Allow `MemberExpression` as a valid `left` of `ForOfStatement`.
+ * **Polish**
+  * Throw an error when people try and transpile code with the `@jsx React.DOM` pragma as it conflicts with the custom jsx constructo method detection.
+  * Crawl all comments for `@jsx` pragma.
+ * **Internal**
+  * Upgrade `chalk`.
+  * Upgrade `core-js`.
+
+## 4.4.5
+
+ * **Internal**
+  * Remove function self reference optimisation.
+
+## 4.4.4
+
+ * **Bug Fix**
+  * Handle inferred function ids to be reassigned and deopt to a slower but working equivalent.
+  * Don't unpack array patterns that have more elements than their right hand array expression.
+ * **Polish**
+  * Improve syntax highlighting in the code frame. Thanks [@lydell](https://github.com/lydell)!
+ * **Internal**
+  * Upgrade `acorn-babel`.
+
+## 4.4.3
+
+ * **Bug Fix**
+  * Fix `for...of` iterator break returns being duplicated.
+  * Only call `return` on the iterator if it exists.
+ * **Internal**
+  * Rename `selfContained` transformer to `runtime`.
+
+## 4.4.2
+
+ * **New Feature**
+  * Add `moduleId` option for specifying a custom module id.
+
+## 4.4.0
+
+ * **New Feature**
+  * `/*** @jsx NAMESPACE **/` comments are now honored by the `react` transformer.
+  * `getModuleName` option.
+  * Infer function expression names. Thanks [@RReverser](https://github.com/RReverser)!
+ * **Bug Fix**
+  * Add proper control flow for tail recursion optimisation.
+ * **Internal**
+  * Remove useless `format` options and move the `format.compact` option to `format`.
+ * **Polish**
+  * Newline handling of the code generator has been heavily improved.
+  * Code generator now deopts whitespace if the input size is >100KB.
+
 ## 4.3.0
 
  * **Breaking Change**

Makefile

@@ -119,5 +119,5 @@ publish-core:
 bootstrap:
 	npm install
 	git submodule update --init
-	cd vendor/regenerator; npm install
-	cd vendor/compat-table; npm install object-assign
+	cd vendor/regenerator && npm install
+	cd vendor/compat-table && npm install object-assign

README.md

@@ -1,5 +1,7 @@
 <p align="center">
-  <img alt="babel" src="https://raw.githubusercontent.com/babel/logo/master/logo.png" width="546">
+  <a href="https://babeljs.io/">
+    <img alt="babel" src="https://raw.githubusercontent.com/babel/logo/master/logo.png" width="546">
+  </a>
 </p>
 
 <p align="center">
@@ -7,6 +9,11 @@
 </p>
 
 <p align="center">
-  For more information view the <a href="https://babeljs.io/">documentation</a>. For
-  support visit the <a href="https://gitter.im/babel/babel">gitter room</a>.
+  For more information view the <a href="https://babeljs.io/">documentation</a>. For questions
+  and support please visit the <a href="https://gitter.im/babel/babel">gitter room</a> before
+  creating an issue.
+</p>
+
+<p align="center">
+  For documentation and website issues please visit the <a href="https://github.com/babel/babel.github.io">babel.github.io</a> repo.
 </p>

bin/_babel-node

@@ -50,7 +50,10 @@ var _eval = function (code, filename) {
     experimental: program.experimental,
     playground: program.playground
   }).code;
-  return vm.runInThisContext(code, filename);
+
+  return vm.runInThisContext(code, {
+    filename: filename
+  });
 };
 
 if (program.eval || program.print) {

bin/babel-minify

@@ -1,7 +0,0 @@
-#!/usr/bin/env node
-
-var opts = require("./babel").opts;
-opts.optional = (opts.optional || []).concat("minification");
-opts.format = {
-  compact: true
-};

bin/babel/index.js

@@ -15,6 +15,7 @@ commander.option("-r, --external-helpers", "Replace helpers with references to a
 commander.option("-e, --experimental", "Enable experimental support for proposed ES7 features");
 commander.option("-p, --playground", "Enable playground support");
 
+commander.option("-c, --compact [mode]", "When set to \"auto\" compact is `true` when the input size exceeds 100KB. (auto|true|false)", "auto");
 commander.option("-m, --modules [modules]", "Module formatter type to use [common]", "common");
 commander.option("-l, --whitelist [whitelist]", "Whitelist of transformers to ONLY use", util.list);
 commander.option("-b, --blacklist [blacklist]", "Blacklist of transformers to NOT use", util.list);
@@ -113,20 +114,16 @@ exports.opts = {
   optional:               commander.optional,
   comments:               !commander.removeComments,
   modules:                commander.modules,
+  compact:                commander.compact,
   loose:                  commander.loose
 };
 
-setTimeout(function () {
-  // this is just a hack to give `babel-minify` and other files including this
-  // time to modify `exports.opts`
+var fn;
 
-  var fn;
+if (commander.outDir) {
+  fn = require("./dir");
+} else {
+  fn = require("./file");
+}
 
-  if (commander.outDir) {
-    fn = require("./dir");
-  } else {
-    fn = require("./file");
-  }
-
-  fn(commander, filenames, exports.opts);
-}, 0);
+fn(commander, filenames, exports.opts);

bin/deprecated/6to5-minify

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-console.error("`6to5-minify` has been renamed to `babel-minify`");
-require("../babel-minify");

lib/babel/generation/buffer.js

@@ -59,13 +59,13 @@ Buffer.prototype.keyword = function (name) {
 
 Buffer.prototype.space = function () {
   if (this.format.compact) return;
-
-  if (this.buf && !this.isLast([" ", "\n"])) {
+  if (this.buf && !this.isLast(" ") && !this.isLast("\n")) {
     this.push(" ");
   }
 };
 
 Buffer.prototype.removeLast = function (cha) {
+  if (this.format.compact) return;
   if (!this.isLast(cha)) return;
 
   this.buf = this.buf.substr(0, this.buf.length - 1);
@@ -73,7 +73,9 @@ Buffer.prototype.removeLast = function (cha) {
 };
 
 Buffer.prototype.newline = function (i, removeLast) {
-  if (this.format.compact || this.format.concise) {
+  if (this.format.compact) return;
+
+  if (this.format.concise) {
     this.space();
     return;
   }
@@ -81,11 +83,14 @@ Buffer.prototype.newline = function (i, removeLast) {
   removeLast = removeLast || false;
 
   if (isNumber(i)) {
-    if (this.endsWith("{\n")) i--;
-    if (this.endsWith(repeating("\n", i > 0 ? i : 0))) return;
+    i = Math.min(2, i);
 
-    while (i--) {
+    if (this.endsWith("{\n") || this.endsWith(":\n")) i--;
+    if (i <= 0) return;
+
+    while (i > 0) {
       this._newline(removeLast);
+      i--;
     }
     return;
   }
@@ -98,11 +103,13 @@ Buffer.prototype.newline = function (i, removeLast) {
 };
 
 Buffer.prototype._newline = function (removeLast) {
+  // never allow more than two lines
+  if (this.endsWith("\n\n")) return;
+
+  // remove the last newline
   if (removeLast && this.isLast("\n")) this.removeLast("\n");
 
   this.removeLast(" ");
-
-  // remove whitespace if last character was a newline
   this._removeSpacesAfterLastNewline();
   this._push("\n");
 };
@@ -110,6 +117,7 @@ Buffer.prototype._newline = function (removeLast) {
 /**
  * If buffer ends with a newline and some spaces after it, trim those spaces.
  */
+
 Buffer.prototype._removeSpacesAfterLastNewline = function () {
   var lastNewlineIndex = this.buf.lastIndexOf("\n");
   if (lastNewlineIndex === -1)
@@ -130,7 +138,7 @@ Buffer.prototype._removeSpacesAfterLastNewline = function () {
 };
 
 Buffer.prototype.push = function (str, noIndent) {
-  if (this._indent && !noIndent && str !== "\n") {
+  if (!this.format.compact && this._indent && !noIndent && str !== "\n") {
     // we have an indent level and we aren't pushing a newline
     var indent = this.getIndent();
 
@@ -138,7 +146,7 @@ Buffer.prototype.push = function (str, noIndent) {
     str = str.replace(/\n/g, "\n" + indent);
 
     // we've got a newline before us so prepend on the indentation
-    if (this.isLast("\n")) str = indent + str;
+    if (this.isLast("\n")) this._push(indent);
   }
 
   this._push(str);
@@ -150,13 +158,13 @@ Buffer.prototype._push = function (str) {
 };
 
 Buffer.prototype.endsWith = function (str) {
-  var d = this.buf.length - str.length;
-  return d >= 0 && this.buf.lastIndexOf(str) === d;
+  return this.buf.slice(-str.length) === str;
 };
 
-Buffer.prototype.isLast = function (cha, shouldTrimRight) {
+Buffer.prototype.isLast = function (cha) {
+  if (this.format.compact) return false;
+
   var buf = this.buf;
-  if (shouldTrimRight) buf = trimRight(buf);
   var last = buf[buf.length - 1];
 
   if (Array.isArray(cha)) {

lib/babel/generation/generators/expressions.js

@@ -46,11 +46,9 @@ exports.ConditionalExpression = function (node, print) {
 exports.NewExpression = function (node, print) {
   this.push("new ");
   print(node.callee);
-  if (node.arguments.length || this.format.parentheses) {
-    this.push("(");
-    print.list(node.arguments);
-    this.push(")");
-  }
+  this.push("(");
+  print.list(node.arguments);
+  this.push(")");
 };
 
 exports.SequenceExpression = function (node, print) {

lib/babel/generation/generators/modules.js

@@ -62,6 +62,10 @@ exports.ImportDeclaration = function (node, print) {
 
   this.push("import ");
 
+  if (node.isType) {
+    this.push("type ");
+  }
+
   var specfiers = node.specifiers;
   if (specfiers && specfiers.length) {
     var foundImportSpecifier = false;

lib/babel/generation/generators/statements.js

@@ -22,12 +22,7 @@ exports.IfStatement = function (node, print) {
 
   if (node.alternate) {
     if (this.isLast("}")) this.space();
-    this.keyword("else");
-
-    if (this.format.format && !t.isBlockStatement(node.alternate)) {
-      this.push(" ");
-    }
-
+    this.push("else ");
     print.indentOnComments(node.alternate);
   }
 };
@@ -153,7 +148,14 @@ exports.SwitchStatement = function (node, print) {
   this.push(")");
   this.space();
   this.push("{");
-  print.sequence(node.cases, { indent: true });
+
+  print.sequence(node.cases, {
+    indent: true,
+    addNewlines: function (leading, cas) {
+      if (!leading && node.cases[node.cases.length - 1] === cas) return -1;
+    }
+  });
+
   this.push("}");
 };
 
@@ -166,8 +168,10 @@ exports.SwitchCase = function (node, print) {
     this.push("default:");
   }
 
-  this.newline();
-  print.sequence(node.consequent, { indent: true });
+  if (node.consequent.length) {
+    this.newline();
+    print.sequence(node.consequent, { indent: true });
+  }
 };
 
 exports.DebuggerStatement = function () {
@@ -189,7 +193,7 @@ exports.VariableDeclaration = function (node, print, parent) {
   }
 
   var sep = ",";
-  if (hasInits) {
+  if (!this.format.compact && hasInits) {
     sep += "\n" + repeating(" ", node.kind.length + 1);
   } else {
     sep += " ";

lib/babel/generation/generators/types.js

@@ -72,7 +72,7 @@ exports.ArrayPattern = function (node, print) {
       // both (all) of the holes.
       self.push(",");
     } else {
-      if (i > 0 && !self.format.compact) self.push(" ");
+      if (i > 0) self.push(" ");
       print(elem);
       if (i < len - 1) self.push(",");
     }

lib/babel/generation/index.js

@@ -12,9 +12,9 @@ var Whitespace   = require("./whitespace");
 var repeating    = require("repeating");
 var SourceMap    = require("./source-map");
 var Position     = require("./position");
+var messages     = require("../messages");
 var Buffer       = require("./buffer");
 var extend       = require("lodash/object/extend");
-var merge        = require("lodash/object/merge");
 var each         = require("lodash/collection/each");
 var n            = require("./node");
 var t            = require("../types");
@@ -28,7 +28,7 @@ function CodeGenerator(ast, opts, code) {
   this.opts     = opts;
   this.ast      = ast;
 
-  this.whitespace = new Whitespace(this.tokens, this.comments);
+  this.whitespace = new Whitespace(this.tokens, this.comments, this.format);
   this.position   = new Position;
   this.map        = new SourceMap(this.position, opts, code);
   this.buffer     = new Buffer(this.position, this.format);
@@ -47,17 +47,25 @@ CodeGenerator.normalizeOptions = function (code, opts) {
     if (indent && indent !== " ") style = indent;
   }
 
-  return merge({
-    parentheses: true,
+  var format = {
     comments: opts.comments == null || opts.comments,
-    compact: false,
-    concise: false,
+    compact: opts.compact,
     indent: {
       adjustMultilineComment: true,
       style: style,
       base: 0
     }
-  }, opts.format || {});
+  };
+
+  if (format.compact === "auto") {
+    format.compact = code.length > 100000; // 100KB
+
+    if (format.compact) {
+      console.error(messages.get("codeGeneratorDeopt", opts.filename, "100KB"));
+    }
+  }
+
+  return format;
 };
 
 CodeGenerator.generators = {
@@ -115,11 +123,7 @@ CodeGenerator.prototype.buildPrint = function (parent) {
 
   print.list = function (items, opts) {
     opts = opts || {};
-
-    var sep = opts.separator || ", ";
-    if (self.format.compact) sep = ",";
-    opts.separator = sep;
-
+    opts.separator = opts.separator || ", ";
     print.join(items, opts);
   };
 
@@ -167,13 +171,14 @@ CodeGenerator.prototype.print = function (node, parent, opts) {
     } else {
       // generated node
       if (!leading) lines++; // always include at least a single line after
+      if (opts.addNewlines) lines += opts.addNewlines(leading, node) || 0;
 
       var needs = n.needsWhitespaceAfter;
       if (leading) needs = n.needsWhitespaceBefore;
-      lines += needs(node, parent);
+      if (needs(node, parent)) lines++;
 
       // generated nodes can't add starting file whitespace
-      if (!self.buffer.get()) lines = 0;
+      if (!self.buffer.buf) lines = 0;
     }
 
     self.newline(lines);
@@ -227,6 +232,7 @@ CodeGenerator.prototype.printJoin = function (print, nodes, opts) {
   each(nodes, function (node, i) {
     print(node, {
       statement: opts.statement,
+      addNewlines: opts.addNewlines,
       after: function () {
         if (opts.iterator) {
           opts.iterator(node, i);
@@ -302,6 +308,7 @@ CodeGenerator.prototype._getComments = function (key, node) {
 
 CodeGenerator.prototype._printComments = function (comments) {
   if (this.format.compact) return;
+
   if (!this.format.comments) return;
   if (!comments || !comments.length) return;
 

lib/babel/generation/node/index.js

@@ -4,9 +4,9 @@ module.exports = Node;
 
 var whitespace = require("./whitespace");
 var parens     = require("./parentheses");
-var t          = require("../../types");
 var each       = require("lodash/collection/each");
 var some       = require("lodash/collection/some");
+var t          = require("../../types");
 
 var find = function (obj, node, parent) {
   if (!obj) return;
@@ -42,14 +42,19 @@ Node.needsWhitespace = function (node, parent, type) {
     node = node.expression;
   }
 
-  var lines = find(whitespace[type].nodes, node, parent);
-  if (lines) return lines;
+  var linesInfo = find(whitespace.nodes, node, parent);
 
-  each(find(whitespace[type].list, node, parent), function (expr) {
-    lines = Node.needsWhitespace(expr, node, type);
-    if (lines) return false;
-  });
-  return lines || 0;
+  if (!linesInfo) {
+    var items = find(whitespace.list, node, parent);
+    if (items) {
+      for (var i = 0; i < items.length; i++) {
+        linesInfo = Node.needsWhitespace(items[i], node, type);
+        if (linesInfo) break;
+      }
+    }
+  }
+
+  return (linesInfo && linesInfo[type]) || 0;
 };
 
 Node.needsWhitespaceBefore = function (node, parent) {

lib/babel/generation/node/whitespace.js

@@ -1,84 +1,159 @@
 "use strict";
 
-var t        = require("../../types");
-var each     = require("lodash/collection/each");
-var map      = require("lodash/collection/map");
-var isNumber = require("lodash/lang/isNumber");
+var isBoolean = require("lodash/lang/isBoolean");
+var each      = require("lodash/collection/each");
+var map       = require("lodash/collection/map");
+var t         = require("../../types");
 
-exports.before = {
-  nodes: {
-    Property: function (node, parent) {
-      if (parent.properties[0] === node) {
-        return 1;
-      }
-    },
+var crawl = function (node, state) {
+  state = state || {};
 
-    SpreadProperty: function (node, parent) {
-      return exports.before.nodes.Property(node, parent);
-    },
+  if (t.isMemberExpression(node)) {
+    crawl(node.object, state);
+    if (node.computed) crawl(node.property, state);
+  } else if (t.isBinary(node) || t.isAssignmentExpression(node)) {
+    crawl(node.left, state);
+    crawl(node.right, state);
+  } else if (t.isCallExpression(node)) {
+    state.hasCall = true;
+    crawl(node.callee, state);
+  } else if (t.isFunction(node)) {
+    state.hasFunction = true;
+  } else if (t.isIdentifier(node)) {
+    state.hasHelper = state.hasHelper || isHelper(node.callee);
+  }
 
-    SwitchCase: function (node, parent) {
-      if (parent.cases[0] === node) {
-        return 1;
-      }
-    },
+  return state;
+};
 
-    CallExpression: function (node) {
-      if (t.isFunction(node.callee)) {
-        return 1;
-      }
-    }
+var isHelper = function (node) {
+  if (t.isMemberExpression(node)) {
+    return isHelper(node.object) || isHelper(node.property);
+  } else if (t.isIdentifier(node)) {
+    return node.name === "require" || node.name[0] === "_";
+  } else if (t.isCallExpression(node)) {
+    return isHelper(node.callee);
+  } else if (t.isBinary(node) || t.isAssignmentExpression(node)) {
+    return (t.isIdentifier(node.left) && isHelper(node.left)) || isHelper(node.right);
+  } else {
+    return false;
   }
 };
 
-exports.after = {
-  nodes: {
-    LogicalExpression: function (node) {
-      return t.isFunction(node.left) || t.isFunction(node.right);
-    },
+var isType = function (node) {
+  return t.isLiteral(node) || t.isObjectExpression(node) || t.isArrayExpression(node) ||
+         t.isIdentifier(node) || t.isMemberExpression(node);
+};
 
-    AssignmentExpression: function (node) {
-      if (t.isFunction(node.right)) {
-        return 1;
+exports.nodes = {
+  AssignmentExpression: function (node) {
+    var state = crawl(node.right);
+    if ((state.hasCall && state.hasHelper) || state.hasFunction) {
+      return {
+        before: state.hasFunction,
+        after: true
+      };
+    }
+  },
+
+  SwitchCase: function (node, parent) {
+    return {
+      before: node.consequent.length || parent.cases[0] === node
+    };
+  },
+
+  LogicalExpression: function (node) {
+    if (t.isFunction(node.left) || t.isFunction(node.right)) {
+      return {
+        after: true
+      };
+    }
+  },
+
+  Literal: function (node) {
+    if (node.value === "use strict") {
+      return {
+        after: true
+      };
+    }
+  },
+
+  CallExpression: function (node) {
+    if (t.isFunction(node.callee) || isHelper(node)) {
+      return {
+        before: true,
+        after: true
+      };
+    }
+  },
+
+  VariableDeclaration: function (node) {
+    for (var i = 0; i < node.declarations.length; i++) {
+      var declar = node.declarations[i];
+
+      var enabled = isHelper(declar.id) && !isType(declar.init);
+      if (!enabled) {
+        var state = crawl(declar.init);
+        enabled = (isHelper(declar.init) && state.hasCall) || state.hasFunction;
+      }
+
+      if (enabled) {
+        return {
+          before: true,
+          after: true
+        };
       }
     }
   },
 
-  list: {
-    VariableDeclaration: function (node) {
-      return map(node.declarations, "init");
-    },
-
-    ArrayExpression: function (node) {
-      return node.elements;
-    },
-
-    ObjectExpression: function (node) {
-      return node.properties;
+  IfStatement: function (node) {
+    if (t.isBlockStatement(node.consequent)) {
+      return {
+        before: true,
+        after: true
+      };
     }
   }
 };
 
+exports.nodes.Property =
+exports.nodes.SpreadProperty = function (node, parent) {
+  if (parent.properties[0] === node) {
+    return {
+      before: true
+    };
+  }
+};
+
+exports.list = {
+  VariableDeclaration: function (node) {
+    return map(node.declarations, "init");
+  },
+
+  ArrayExpression: function (node) {
+    return node.elements;
+  },
+
+  ObjectExpression: function (node) {
+    return node.properties;
+  }
+};
+
 each({
-  Function: 1,
-  Class: 1,
-  For: 1,
-  ArrayExpression: { after: 1 },
-  ObjectExpression: { after: 1 },
-  SwitchStatement: 1,
-  IfStatement: { before: 1 },
-  CallExpression: { after: 1 },
-  Literal: { after: 1 }
+  Function: true,
+  Class: true,
+  Loop: true,
+  LabeledStatement: true,
+  SwitchStatement: true,
+  TryStatement: true
 }, function (amounts, type) {
-  if (isNumber(amounts)) {
+  if (isBoolean(amounts)) {
     amounts = { after: amounts, before: amounts };
   }
 
   each([type].concat(t.FLIPPED_ALIAS_KEYS[type] || []), function (type) {
-    each(amounts, function (amount, key) {
-      exports[key].nodes[type] = function () {
-        return amount;
-      };
-    });
+    exports.nodes[type] = function () {
+      return amounts;
+    };
   });
 });

lib/babel/generation/whitespace.js

@@ -13,11 +13,13 @@ var sortBy = require("lodash/collection/sortBy");
  * @param {Number} max Array length
  * @returns {Number} shiftedIndex
  */
+
 function getLookupIndex(i, base, max) {
   i += base;
 
-  if (i >= max)
+  if (i >= max) {
     i -= max;
+  }
 
   return i;
 }

lib/babel/helpers/code-frame.js

@@ -1,42 +1,59 @@
-// syntax highlighting based on https://github.com/dominictarr/ansi-highlight by the fantastic Dominic Tarr
-
-var repeating = require("repeating");
-var tokenize  = require("js-tokenizer");
-var chalk     = require("chalk");
+var lineNumbers = require("line-numbers");
+var repeating   = require("repeating");
+var jsTokens    = require("js-tokens");
+var esutils     = require("esutils");
+var chalk       = require("chalk");
+var ary         = require("lodash/function/ary");
 
 var defs = {
-  string1:  "red",
-  string2:  "red",
-  punct:    ["white", "bold"],
-  curly:    "green",
-  parens:   ["blue", "bold"],
-  square:   ["yellow"],
-  name:     "white",
-  keyword:  ["cyan"],
-  number:   "magenta",
-  regexp:   "magenta",
-  comment1: "grey",
-  comment2: "grey"
+  string:      chalk.red,
+  punctuation: chalk.white.bold,
+  operator:    chalk.white.bold,
+  curly:       chalk.green,
+  parens:      chalk.blue.bold,
+  square:      chalk.yellow,
+  name:        chalk.white,
+  keyword:     chalk.cyan,
+  number:      chalk.magenta,
+  regex:       chalk.magenta,
+  comment:     chalk.grey,
+  invalid:     chalk.inverse
 };
 
-var highlight = function (text) {
-  var colorize = function (str, col) {
-    if (!col) return str;
+var newline = /\r\n|[\n\r\u2028\u2029]/;
 
-    if (Array.isArray(col)) {
-      col.forEach(function (col) {
-        str = chalk[col](str);
-      });
-    } else {
-      str = chalk[col](str);
+var highlight = function (text) {
+  var tokenType = function (match) {
+    var token = jsTokens.matchToToken(match);
+    if (token.type === "name" && esutils.keyword.isKeywordES6(token.value)) {
+      return "keyword";
     }
-    return str;
+
+    if (token.type === "punctuation") {
+      switch (token.value) {
+        case "{":
+        case "}":
+          return "curly";
+        case "(":
+        case ")":
+          return "parens";
+        case "[":
+        case "]":
+          return "square";
+      }
+    }
+
+    return token.type;
   };
 
-  return tokenize(text, true).map(function (str) {
-    var type = tokenize.type(str);
-    return colorize(str, defs[type]);
-  }).join("");
+  return text.replace(jsTokens, function (match) {
+    var type = tokenType(arguments);
+    if (type in defs) {
+      var colorize = ary(defs[type], 1);
+      return match.split(newline).map(colorize).join("\n");
+    }
+    return match;
+  });
 };
 
 module.exports = function (lines, lineNumber, colNumber) {
@@ -46,33 +63,29 @@ module.exports = function (lines, lineNumber, colNumber) {
     lines = highlight(lines);
   }
 
-  lines = lines.split(/\r\n|[\n\r\u2028\u2029]/);
+  lines = lines.split(newline);
 
   var start = Math.max(lineNumber - 3, 0);
   var end   = Math.min(lines.length, lineNumber + 3);
-  var width = (end + "").length;
 
   if (!lineNumber && !colNumber) {
     start = 0;
     end = lines.length;
   }
 
-  return "\n" + lines.slice(start, end).map(function (line, i) {
-    var curr = i + start + 1;
-
-    var gutter = curr === lineNumber ? "> " : "  ";
-
-    var sep = curr + repeating(" ", width + 1);
-    gutter += sep + "| ";
-
-    var str = gutter + line;
-
-    if (colNumber && curr === lineNumber) {
-      str += "\n";
-      str += repeating(" ", gutter.length - 2);
-      str += "|" + repeating(" ", colNumber) + "^";
+  return "\n" + lineNumbers(lines.slice(start, end), {
+    start: start + 1,
+    before: "  ",
+    after: " | ",
+    transform: function (params) {
+      if (params.number !== lineNumber) {
+        return;
+      }
+      if (colNumber) {
+        params.line += "\n" + params.before + repeating(" ", params.width) +
+                       params.after + repeating(" ", colNumber - 1) + "^";
+      }
+      params.before = params.before.replace(/^./, ">");
     }
-
-    return str;
   }).join("\n");
 };

lib/babel/messages.js

@@ -17,7 +17,8 @@ exports.messages = {
   modulesIllegalExportName: "Illegal export $1",
   unknownForHead: "Unknown node type $1 in ForStatement",
   didYouMean: "Did you mean $1?",
-  evalInStrictMode: "eval is not allowed in strict mode"
+  evalInStrictMode: "eval is not allowed in strict mode",
+  codeGeneratorDeopt: "Note: The code generator has deoptimised the styling of $1 as it exceeds the max of $2."
 };
 
 exports.get = function (key) {

lib/babel/transformation/file.js

@@ -60,7 +60,6 @@ File.helpers = [
   "object-destructuring-empty",
   "temporal-undefined",
   "temporal-assert-defined",
-  "tail-call",
   "self-global"
 ];
 
@@ -83,12 +82,17 @@ File.validOptions = [
   "keepModuleIdExtensions",
   "code",
   "ast",
-  "format",
   "playground",
   "experimental",
-  "resolveModuleSource",
   "externalHelpers",
   "auxiliaryComment",
+  "compact",
+
+  "resolveModuleSource",
+  "moduleId",
+
+  // legacy
+  "format",
 
   // these are used by plugins
   "ignore",
@@ -114,7 +118,6 @@ File.prototype.normalizeOptions = function (opts) {
     experimental:           false,
     reactCompat:            false,
     playground:             false,
-    whitespace:             true,
     moduleIds:              false,
     blacklist:              [],
     whitelist:              [],
@@ -123,6 +126,7 @@ File.prototype.normalizeOptions = function (opts) {
     comments:               true,
     filename:               "unknown",
     modules:                "common",
+    compact:                "auto",
     loose:                  [],
     code:                   true,
     ast:                    true
@@ -134,11 +138,16 @@ File.prototype.normalizeOptions = function (opts) {
     opts.sourceRoot = slash(opts.sourceRoot);
   }
 
+  if (opts.moduleId) {
+    opts.moduleIds = true;
+  }
+
   opts.basename = path.basename(opts.filename, path.extname(opts.filename));
 
   opts.blacklist = util.arrayify(opts.blacklist);
   opts.whitelist = util.arrayify(opts.whitelist);
   opts.optional  = util.arrayify(opts.optional);
+  opts.compact   = util.booleanify(opts.compact);
   opts.loose     = util.arrayify(opts.loose);
 
   if (includes(opts.loose, "all") || includes(opts.loose, true)) {
@@ -167,7 +176,7 @@ File.prototype.normalizeOptions = function (opts) {
   }
 
   if (opts.externalHelpers) {
-    this.set("runtimeIdentifier", t.identifier("babelHelpers"));
+    this.set("helpersNamespace", t.identifier("babelHelpers"));
   }
 
   opts.blacklist = transform._ensureTransformerNames("blacklist", opts.blacklist);
@@ -177,8 +186,7 @@ File.prototype.normalizeOptions = function (opts) {
 
   if (opts.reactCompat) {
     opts.optional.push("reactCompat");
-    console.error("The reactCompat option has been moved into the optional transformer " +
-                  "`reactCompat` - backwards compatibility will be removed in v4.0.0");
+    console.error("The reactCompat option has been moved into the optional transformer `reactCompat`");
   }
 
   var ensureEnabled = function (key) {
@@ -325,7 +333,7 @@ File.prototype.addHelper = function (name) {
   var declar = program._declarations && program._declarations[name];
   if (declar) return declar.id;
 
-  var runtime = this.get("runtimeIdentifier");
+  var runtime = this.get("helpersNamespace");
   if (runtime) {
     name = t.identifier(t.toIdentifier(name));
     return t.memberExpression(runtime, name);

lib/babel/transformation/helpers/build-react-transformer.js

@@ -44,16 +44,19 @@ module.exports = function (exports, opts) {
   };
 
   exports.JSXAttribute = {
-    exit: function (node) {
-      var value = node.value || t.literal(true);
-
+    enter: function (node) {
+      var value = node.value;
       if (t.isLiteral(value) && isString(value.value)) {
         value.value = value.value.replace(/\n\s+/g, " ");
       }
+    },
 
+    exit: function (node) {
+      var value = node.value || t.literal(true);
       return t.inherits(t.property("init", node.name, value), node);
     }
   };
+
   exports.JSXOpeningElement = {
     exit: function (node, parent, scope, file) {
       var tagExpr = node.name;
@@ -73,7 +76,7 @@ module.exports = function (exports, opts) {
       };
 
       if (opts.pre) {
-        opts.pre(state);
+        opts.pre(state, file);
       }
 
       var attribs = node.attributes;
@@ -86,7 +89,7 @@ module.exports = function (exports, opts) {
       args.push(attribs);
 
       if (opts.post) {
-        opts.post(state);
+        opts.post(state, file);
       }
 
       return state.call || t.callExpression(state.callee, args);

lib/babel/transformation/helpers/name-method.js

@@ -5,15 +5,13 @@ var t    = require("../../types");
 
 var visitor = {
   enter: function (node, parent, scope, state) {
-    // check if this node is an identifier that matches the same as our function id
-    if (!t.isIdentifier(node, { name: state.id })) return;
-
-    // check if this node is the one referenced
-    if (!t.isReferenced(node, parent)) return;
+    // check if this node is a referenced identifier that matches the same as our
+    // function id
+    if (!t.isReferencedIdentifier(node, parent, { name: state.name })) return;
 
     // check that we don't have a local variable declared as that removes the need
     // for the wrapper
-    var localDeclar = scope.getBindingIdentifier(state.id);
+    var localDeclar = scope.getBindingIdentifier(state.name);
     if (localDeclar !== state.outerDeclar) return;
 
     state.selfReference = true;
@@ -21,33 +19,100 @@ var visitor = {
   }
 };
 
+var wrap = function (state, method, id, scope) {
+  if (state.selfReference) {
+    var templateName = "property-method-assignment-wrapper";
+    if (method.generator) templateName += "-generator";
+    return util.template(templateName, {
+      FUNCTION: method,
+      FUNCTION_ID: id,
+      FUNCTION_KEY: scope.generateUidIdentifier(id.name),
+      WRAPPER_KEY: scope.generateUidIdentifier(id.name + "Wrapper")
+    });
+  } else {
+    method.id = id;
+    return method;
+  }
+};
+
+var visit = function (node, name, scope) {
+  var state = {
+    selfAssignment: false,
+    selfReference:  false,
+    outerDeclar:    scope.getBindingIdentifier(name),
+    references:     [],
+    name:           name,
+  };
+
+  // check to see if we have a local binding of the id we're setting inside of
+  // the function, this is important as there are caveats associated
+
+  var bindingInfo = scope.getOwnBindingInfo(name);
+
+  if (bindingInfo) {
+    if (bindingInfo.kind === "param") {
+      // safari will blow up in strict mode with code like:
+      //
+      //   var t = function t(t) {};
+      //
+      // with the error:
+      //
+      //   Cannot declare a parameter named 't' as it shadows the name of a
+      //   strict mode function.
+      //
+      // this isn't to the spec and they've invented this behaviour which is
+      // **extremely** annoying so we avoid setting the name if it has a param
+      // with the same id
+      state.selfReference = true;
+    } else {
+      // otherwise it's defined somewhere in scope like:
+      //
+      //   var t = function () {
+      //     var t = 2;
+      //   };
+      //
+      // so we can safely just set the id and move along as it shadows the
+      // bound function id
+    }
+  } else {
+    scope.traverse(node, visitor, state);
+  }
+
+  return state;
+};
+
 exports.property = function (node, file, scope) {
   var key = t.toComputedKey(node, node.key);
   if (!t.isLiteral(key)) return node; // we can't set a function id with this
 
-  var id = t.toIdentifier(key.value);
-  key = t.identifier(id);
-
-  var state = {
-    id: id,
-    selfReference: false,
-    outerDeclar: scope.getBindingIdentifier(id),
-  };
-
-  scope.traverse(node, visitor, state);
+  var name = t.toIdentifier(key.value);
+  var id = t.identifier(name);
 
   var method = node.value;
-
-  if (state.selfReference) {
-    var templateName = "property-method-assignment-wrapper";
-    if (method.generator) templateName += "-generator";
-    node.value = util.template(templateName, {
-      FUNCTION: method,
-      FUNCTION_ID: key,
-      FUNCTION_KEY: scope.generateUidIdentifier(id),
-      WRAPPER_KEY: scope.generateUidIdentifier(id + "Wrapper")
-    });
-  } else {
-    method.id = key;
-  }
+  var state  = visit(method, name, scope);
+  node.value = wrap(state, method, id, scope);
+};
+
+exports.bare = function (node, parent, scope) {
+  // has an `id` so we don't need to infer one
+  if (node.id) return;
+
+  var id;
+  if (t.isProperty(parent) && parent.kind === "init" && !parent.computed) {
+    // { foo: function () {} };
+    id = parent.key;
+  } else if (t.isVariableDeclarator(parent)) {
+    // var foo = function () {};
+    id = parent.id;
+  } else {
+    return;
+  }
+
+  if (!t.isIdentifier(id)) return;
+
+  var name = t.toIdentifier(id.name);
+  id = t.identifier(name);
+
+  var state = visit(node, name, scope);
+  return wrap(state, node, id, scope);
 };

lib/babel/transformation/helpers/use-strict.js

@@ -1,21 +0,0 @@
-"use strict";
-
-var t = require("../../types");
-
-exports.has = function (node) {
-  var first = node.body[0];
-  return t.isExpressionStatement(first) && t.isLiteral(first.expression, { value: "use strict" });
-};
-
-exports.wrap = function (node, callback) {
-  var useStrictNode;
-  if (exports.has(node)) {
-    useStrictNode = node.body.shift();
-  }
-
-  callback();
-
-  if (useStrictNode) {
-    node.body.unshift(useStrictNode);
-  }
-};

lib/babel/transformation/modules/_default.js

@@ -146,6 +146,8 @@ DefaultFormatter.prototype.isLocalReference = function (node, scope) {
 
 DefaultFormatter.prototype.getModuleName = function () {
   var opts = this.file.opts;
+  if (opts.moduleId) return opts.moduleId;
+
   var filenameRelative = opts.filenameRelative;
   var moduleName = "";
 

lib/babel/transformation/modules/system.js

@@ -4,12 +4,11 @@ module.exports = SystemFormatter;
 
 var DefaultFormatter = require("./_default");
 var AMDFormatter     = require("./amd");
-var useStrict        = require("../helpers/use-strict");
 var util             = require("../../util");
-var t                = require("../../types");
 var last             = require("lodash/array/last");
 var each             = require("lodash/collection/each");
 var map              = require("lodash/collection/map");
+var t                = require("../../types");
 
 function SystemFormatter(file) {
   this.exportIdentifier = file.scope.generateUidIdentifier("export");
@@ -193,9 +192,5 @@ SystemFormatter.prototype.transform = function (program) {
 
   handlerBody.push(returnStatement);
 
-  if (useStrict.has(block)) {
-    handlerBody.unshift(block.body.shift());
-  }
-
   program.body = [runner];
 };

lib/babel/transformation/templates/named-func.js

@@ -1,7 +0,0 @@
-(function () {
-    function GET_OUTER_ID() {
-        return ID;
-    }
-
-    return FUNCTION;
-})()

lib/babel/transformation/templates/named-function.js

@@ -0,0 +1,7 @@
+(function () {
+  function GET_OUTER_ID() {
+    return FUNCTION_ID;
+  }
+
+  return FUNCTION;
+})()

lib/babel/transformation/templates/tail-call-body.js

@@ -1,3 +1,4 @@
 {
-  FUNCTION_ID:while (true) BLOCK
+  var AGAIN_ID = true;
+  FUNCTION_ID: while (AGAIN_ID) BLOCK
 }

lib/babel/transformation/templates/tail-call.js

@@ -1,23 +0,0 @@
-(function () {
-  function Tail(func, args, context) {
-    this.func = func;
-    this.args = args;
-    this.context = context;
-  }
-
-  Tail.prototype._isTailDescriptor = true;
-
-  var isRunning = false;
-
-  return function (func, args, context) {
-    var result = new Tail(func, args, context);
-    if (!isRunning) {
-      isRunning = true;
-      do {
-        result = result.func.apply(result.context, result.args);
-      } while (result instanceof Tail || (result && result._isTailDescriptor));
-      isRunning = false;
-    }
-    return result;
-  };
-})()

lib/babel/transformation/transformers/deprecated.json

@@ -1 +1,3 @@
-{}
+{
+  "selfContained": "runtime"
+}

lib/babel/transformation/transformers/es6/block-scoping.js

@@ -30,7 +30,7 @@ var isLet = function (node, parent) {
 };
 
 var isLetInitable = function (node, parent) {
-  return !t.isFor(parent) || t.isFor(parent) && parent.left !== node;
+  return !t.isFor(parent) || !t.isFor(parent, { left: node });
 };
 
 var isVar = function (node, parent) {

lib/babel/transformation/transformers/es6/classes.js

@@ -65,6 +65,7 @@ function ClassTransformer(node, file, scope, isStatement) {
 ClassTransformer.prototype.run = function () {
   var superName = this.superName;
   var className = this.className;
+  var classBody = this.node.body.body;
   var file      = this.file;
 
   //
@@ -77,13 +78,21 @@ ClassTransformer.prototype.run = function () {
       className
     ]))
   ]);
-  var constructor;
 
+  var constructor;
   if (this.node.id) {
     constructor = t.functionDeclaration(className, [], constructorBody);
     body.push(constructor);
   } else {
-    constructor = t.functionExpression(null, [], constructorBody);
+    var constructorName = null;
+    // when a class has no parent and there is only a constructor or no body
+    // then the constructor is not wrapped in a closure and needs to be named
+    var containsOnlyConstructor = classBody.length === 1 && classBody[0].key.name === "constructor";
+    if (!this.hasSuper && (classBody.length === 0 || containsOnlyConstructor)) {
+      constructorName = className;
+    }
+
+    constructor = t.functionExpression(constructorName, [], constructorBody);
     body.push(t.variableDeclaration("var", [
       t.variableDeclarator(className, constructor)
     ]));
@@ -159,7 +168,7 @@ ClassTransformer.prototype.buildBody = function () {
       }, true);
       replaceSupers.replace();
 
-      if (node.key.name === "constructor") {
+      if ((!node.computed && t.isIdentifier(node.key, { name: "constructor" })) || t.isLiteral(node.key, { value: "constructor" })) {
         this.pushConstructor(node);
       } else {
         this.pushMethod(node);

lib/babel/transformation/transformers/es6/destructuring.js

@@ -41,90 +41,114 @@ DestructuringTransformer.prototype.buildVariableDeclaration = function (id, init
   return declar;
 };
 
-DestructuringTransformer.prototype.push = function (elem, parentId) {
-  if (t.isObjectPattern(elem)) {
-    this.pushObjectPattern(elem, parentId);
-  } else if (t.isArrayPattern(elem)) {
-    this.pushArrayPattern(elem, parentId);
-  } else if (t.isAssignmentPattern(elem)) {
-    this.pushAssignmentPattern(elem, parentId);
+DestructuringTransformer.prototype.push = function (id, init) {
+  if (t.isObjectPattern(id)) {
+    this.pushObjectPattern(id, init);
+  } else if (t.isArrayPattern(id)) {
+    this.pushArrayPattern(id, init);
+  } else if (t.isAssignmentPattern(id)) {
+    this.pushAssignmentPattern(id, init);
   } else {
-    this.nodes.push(this.buildVariableAssignment(elem, parentId));
+    this.nodes.push(this.buildVariableAssignment(id, init));
   }
 };
 
-DestructuringTransformer.prototype.pushAssignmentPattern = function (pattern, parentId) {
-  var tempParentId = this.scope.generateUidBasedOnNode(parentId);
+DestructuringTransformer.prototype.get = function () {
+
+};
+
+DestructuringTransformer.prototype.pushAssignmentPattern = function (pattern, valueRef) {
+  // we need to assign the current value of the assignment to avoid evaluating
+  // it more than once
+
+  var tempValueRef = this.scope.generateUidBasedOnNode(valueRef);
 
   var declar = t.variableDeclaration("var", [
-    t.variableDeclarator(tempParentId, parentId)
+    t.variableDeclarator(tempValueRef, valueRef)
   ]);
   declar._blockHoist = this.blockHoist;
   this.nodes.push(declar);
 
+  //
+
   this.nodes.push(this.buildVariableAssignment(
     pattern.left,
     t.conditionalExpression(
-      t.binaryExpression("===", tempParentId, t.identifier("undefined")),
+      t.binaryExpression("===", tempValueRef, t.identifier("undefined")),
       pattern.right,
-      tempParentId
+      tempValueRef
     )
   ));
 };
 
-DestructuringTransformer.prototype.pushObjectSpread = function (pattern, parentId, prop, i) {
+DestructuringTransformer.prototype.pushObjectSpread = function (pattern, objRef, spreadProp, spreadPropIndex) {
   // get all the keys that appear in this object before the current spread
+
   var keys = [];
-  for (var i2 = 0; i2 < pattern.properties.length; i2++) {
-    var prop2 = pattern.properties[i2];
 
-    if (i2 >= i) break;
-    if (t.isSpreadProperty(prop2)) continue;
+  for (var i = 0; i < pattern.properties.length; i++) {
+    var prop = pattern.properties[i];
 
-    var key = prop2.key;
-    if (t.isIdentifier(key)) {
-      key = t.literal(prop2.key.name);
-    }
+    // we've exceeded the index of the spread property to all properties to the
+    // right need to be ignored
+    if (i >= spreadPropIndex) break;
+
+    // ignore other spread properties
+    if (t.isSpreadProperty(prop)) continue;
+
+    var key = prop.key;
+    if (t.isIdentifier(key)) key = t.literal(prop.key.name);
     keys.push(key);
   }
+
   keys = t.arrayExpression(keys);
 
-  var value = t.callExpression(this.file.addHelper("object-without-properties"), [parentId, keys]);
-  this.nodes.push(this.buildVariableAssignment(prop.argument, value));
+  //
+
+  var value = t.callExpression(this.file.addHelper("object-without-properties"), [objRef, keys]);
+  this.nodes.push(this.buildVariableAssignment(spreadProp.argument, value));
 };
 
-DestructuringTransformer.prototype.pushObjectProperty = function (prop, parentId) {
+DestructuringTransformer.prototype.pushObjectProperty = function (prop, propRef) {
   if (t.isLiteral(prop.key)) prop.computed = true;
 
-  var pattern2   = prop.value;
-  var patternId2 = t.memberExpression(parentId, prop.key, prop.computed);
+  var pattern = prop.value;
+  var objRef  = t.memberExpression(propRef, prop.key, prop.computed);
 
-  if (t.isPattern(pattern2)) {
-    this.push(pattern2, patternId2);
+  if (t.isPattern(pattern)) {
+    this.push(pattern, objRef);
   } else {
-    this.nodes.push(this.buildVariableAssignment(pattern2, patternId2));
+    this.nodes.push(this.buildVariableAssignment(pattern, objRef));
   }
 };
 
-DestructuringTransformer.prototype.pushObjectPattern = function (pattern, parentId) {
+DestructuringTransformer.prototype.pushObjectPattern = function (pattern, objRef) {
+  // https://github.com/babel/babel/issues/681
+
   if (!pattern.properties.length) {
     this.nodes.push(t.expressionStatement(
-      t.callExpression(this.file.addHelper("object-destructuring-empty"), [parentId])
+      t.callExpression(this.file.addHelper("object-destructuring-empty"), [objRef])
     ));
   }
 
-  if (pattern.properties.length > 1 && t.isMemberExpression(parentId)) {
-    var temp = this.scope.generateUidBasedOnNode(parentId, this.file);
-    this.nodes.push(this.buildVariableDeclaration(temp, parentId));
-    parentId = temp;
+  // if we have more than one properties in this pattern and the objectRef is a
+  // member expression then we need to assign it to a temporary variable so it's
+  // only evaluated once
+
+  if (pattern.properties.length > 1 && t.isMemberExpression(objRef)) {
+    var temp = this.scope.generateUidBasedOnNode(objRef, this.file);
+    this.nodes.push(this.buildVariableDeclaration(temp, objRef));
+    objRef = temp;
   }
 
+  //
+
   for (var i = 0; i < pattern.properties.length; i++) {
     var prop = pattern.properties[i];
     if (t.isSpreadProperty(prop)) {
-      this.pushObjectSpread(pattern, parentId, prop, i);
+      this.pushObjectSpread(pattern, objRef, prop, i);
     } else {
-      this.pushObjectProperty(prop, parentId);
+      this.pushObjectProperty(prop, objRef);
     }
   }
 };
@@ -138,19 +162,70 @@ var hasRest = function (pattern) {
   return false;
 };
 
-DestructuringTransformer.prototype.pushArrayPattern = function (pattern, parentId) {
+DestructuringTransformer.prototype.canUnpackArrayPattern = function (pattern, arr) {
+  // not an array so there's no way we can deal with this
+  if (!t.isArrayExpression(arr)) return false;
+
+  // pattern has less elements than the array and doesn't have a rest so some
+  // elements wont be evaluated
+  if (pattern.elements.length > arr.elements.length) return;
+  if (pattern.elements.length < arr.elements.length && !hasRest(pattern)) return false;
+
+  // deopt on holes
+  for (var i = 0; i < pattern.elements.length; i++) {
+    if (!pattern.elements[i]) return false;
+  }
+
+  return true;
+};
+
+DestructuringTransformer.prototype.pushUnpackedArrayPattern = function (pattern, arr) {
+  for (var i = 0; i < pattern.elements.length; i++) {
+    var elem = pattern.elements[i];
+    if (t.isRestElement(elem)) {
+      this.push(elem.argument, t.arrayExpression(arr.elements.slice(i)));
+    } else {
+      this.push(elem, arr.elements[i]);
+    }
+  }
+};
+
+DestructuringTransformer.prototype.pushArrayPattern = function (pattern, arrayRef) {
   if (!pattern.elements) return;
 
-  // if we have a rest then we need all the elements
+  // optimise basic array destructuring of an array expression
+  //
+  // we can't do this to a pattern of unequal size to it's right hand
+  // array expression as then there will be values that wont be evaluated
+  //
+  // eg: var [a, b] = [1, 2];
+
+  if (this.canUnpackArrayPattern(pattern, arrayRef)) {
+    return this.pushUnpackedArrayPattern(pattern, arrayRef);
+  }
+
+  // if we have a rest then we need all the elements so don't tell
+  // `scope.toArray` to only get a certain amount
+
   var count = !hasRest(pattern) && pattern.elements.length;
 
-  var toArray = this.scope.toArray(parentId, count);
+  // so we need to ensure that the `arrayRef` is an array, `scope.toArray` will
+  // return a locally bound identifier if it's been inferred to be an array,
+  // otherwise it'll be a call to a helper that will ensure it's one
 
-  var _parentId = this.scope.generateUidBasedOnNode(parentId);
-  this.nodes.push(this.buildVariableDeclaration(_parentId, toArray));
-  parentId = _parentId;
+  var toArray = this.scope.toArray(arrayRef, count);
 
-  this.scope.assignTypeGeneric(parentId.name, "Array");
+  if (t.isIdentifier(toArray)) {
+    // we've been given an identifier so it must have been inferred to be an
+    // array
+    arrayRef = toArray;
+  } else {
+    arrayRef = this.scope.generateUidBasedOnNode(arrayRef);
+    this.nodes.push(this.buildVariableDeclaration(arrayRef, toArray));
+    this.scope.assignTypeGeneric(arrayRef.name, "Array");
+  }
+
+  //
 
   for (var i = 0; i < pattern.elements.length; i++) {
     var elem = pattern.elements[i];
@@ -158,32 +233,39 @@ DestructuringTransformer.prototype.pushArrayPattern = function (pattern, parentI
     // hole
     if (!elem) continue;
 
-    var newPatternId;
+    var elemRef;
 
     if (t.isRestElement(elem)) {
-      newPatternId = this.scope.toArray(parentId);
+      elemRef = this.scope.toArray(arrayRef);
 
       if (i > 0) {
-        newPatternId = t.callExpression(t.memberExpression(newPatternId, t.identifier("slice")), [t.literal(i)]);
+        elemRef = t.callExpression(t.memberExpression(elemRef, t.identifier("slice")), [t.literal(i)]);
       }
 
+      // set the element to the rest element argument since we've dealt with it
+      // being a rest already
       elem = elem.argument;
     } else {
-      newPatternId = t.memberExpression(parentId, t.literal(i), true);
+      elemRef = t.memberExpression(arrayRef, t.literal(i), true);
     }
 
-    this.push(elem, newPatternId);
+    this.push(elem, elemRef);
   }
 };
 
-DestructuringTransformer.prototype.init = function (pattern, parentId) {
-  if (!t.isArrayExpression(parentId) && !t.isMemberExpression(parentId) && !t.isIdentifier(parentId)) {
-    var key = this.scope.generateUidBasedOnNode(parentId);
-    this.nodes.push(this.buildVariableDeclaration(key, parentId));
-    parentId = key;
+DestructuringTransformer.prototype.init = function (pattern, ref) {
+  // trying to destructure a value that we can't evaluate more than once so we
+  // need to save it to a variable
+
+  if (!t.isArrayExpression(ref) && !t.isMemberExpression(ref) && !t.isIdentifier(ref)) {
+    var key = this.scope.generateUidBasedOnNode(ref);
+    this.nodes.push(this.buildVariableDeclaration(key, ref));
+    ref = key;
   }
 
-  this.push(pattern, parentId);
+  //
+
+  this.push(pattern, ref);
 };
 
 exports.ForInStatement =
@@ -244,7 +326,7 @@ exports.Function = function (node, parent, scope, file) {
     if (!t.isPattern(pattern)) return pattern;
 
     hasDestructuringTransformer = true;
-    var parentId = scope.generateUidIdentifier("ref");
+    var ref = scope.generateUidIdentifier("ref");
 
     var destructuring = new DestructuringTransformer({
       blockHoist: node.params.length - i,
@@ -253,9 +335,9 @@ exports.Function = function (node, parent, scope, file) {
       file:       file,
       kind:       "var",
     });
-    destructuring.init(pattern, parentId);
+    destructuring.init(pattern, ref);
 
-    return parentId;
+    return ref;
   });
 
   if (!hasDestructuringTransformer) return;
@@ -337,7 +419,7 @@ exports.AssignmentExpression = function (node, parent, scope, file) {
   return t.toSequenceExpression(nodes, scope);
 };
 
-var variableDeclarationhasPattern = function (node) {
+var variableDeclarationHasPattern = function (node) {
   for (var i = 0; i < node.declarations.length; i++) {
     if (t.isPattern(node.declarations[i].id)) {
       return true;
@@ -348,7 +430,7 @@ var variableDeclarationhasPattern = function (node) {
 
 exports.VariableDeclaration = function (node, parent, scope, file) {
   if (t.isForInStatement(parent) || t.isForOfStatement(parent)) return;
-  if (!variableDeclarationhasPattern(node)) return;
+  if (!variableDeclarationHasPattern(node)) return;
 
   var nodes = [];
   var declar;

lib/babel/transformation/transformers/es6/for-of.js

@@ -37,11 +37,35 @@ exports.ForOfStatement = function (node, parent, scope, file) {
   return loop;
 };
 
+var breakVisitor = {
+  enter: function (node, parent, scope, state) {
+    if (t.isLoop(node)) {
+      state.ignoreLabeless = true;
+      scope.traverse(node, breakVisitor, state);
+      state.ignoreLabeless = false;
+      return this.skip();
+    }
+
+    if (t.isBreakStatement(node)) {
+      if (!node.label && state.ignoreLabeless) return;
+      if (node.label && node.label.name !== state.label) return;
+
+      var ret = t.expressionStatement(
+        t.callExpression(t.memberExpression(state.iteratorKey, t.identifier("return")), [])
+      );
+      ret = state.wrapReturn(ret);
+
+      this.skip();
+      return [ret, node];
+    }
+  }
+};
+
 var loose = function (node, parent, scope, file) {
   var left = node.left;
   var declar, id;
 
-  if (t.isIdentifier(left) || t.isPattern(left)) {
+  if (t.isIdentifier(left) || t.isPattern(left) || t.isMemberExpression(left)) {
     // for (i of test), for ({ i } of test)
     id = left;
   } else if (t.isVariableDeclaration(left)) {
@@ -54,9 +78,12 @@ var loose = function (node, parent, scope, file) {
     throw file.errorWithNode(left, messages.get("unknownForHead", left.type));
   }
 
+  var iteratorKey = scope.generateUidIdentifier("iterator");
+  var isArrayKey  = scope.generateUidIdentifier("isArray");
+
   var loop = util.template("for-of-loose", {
-    LOOP_OBJECT:  scope.generateUidIdentifier("iterator"),
-    IS_ARRAY:     scope.generateUidIdentifier("isArray"),
+    LOOP_OBJECT:  iteratorKey,
+    IS_ARRAY:     isArrayKey,
     OBJECT:       node.right,
     INDEX:        scope.generateUidIdentifier("i"),
     ID:           id
@@ -68,6 +95,24 @@ var loose = function (node, parent, scope, file) {
     loop.body.body.shift();
   }
 
+  //
+
+  scope.traverse(node, breakVisitor, {
+    iteratorKey: iteratorKey,
+    wrapReturn:  function (node) {
+      return t.ifStatement(
+        t.logicalExpression(
+          "&&",
+          t.unaryExpression("!", isArrayKey, true),
+          t.memberExpression(iteratorKey, t.identifier("return")
+        )
+      ), node);
+    },
+    label:       t.isLabeledStatement(parent) && parent.label.name
+  });
+
+  //
+
   return {
     declar: declar,
     loop:   loop
@@ -81,7 +126,7 @@ var spec = function (node, parent, scope, file) {
   var stepKey   = scope.generateUidIdentifier("step");
   var stepValue = t.memberExpression(stepKey, t.identifier("value"));
 
-  if (t.isIdentifier(left) || t.isPattern(left)) {
+  if (t.isIdentifier(left) || t.isPattern(left) || t.isMemberExpression(left)) {
     // for (i of test), for ({ i } of test)
     declar = t.expressionStatement(t.assignmentExpression("=", left, stepValue));
   } else if (t.isVariableDeclaration(left)) {
@@ -93,12 +138,28 @@ var spec = function (node, parent, scope, file) {
     throw file.errorWithNode(left, messages.get("unknownForHead", left.type));
   }
 
+  //
+
+  var iteratorKey = scope.generateUidIdentifier("iterator");
+
   var loop = util.template("for-of", {
-    ITERATOR_KEY: scope.generateUidIdentifier("iterator"),
+    ITERATOR_KEY: iteratorKey,
     STEP_KEY:     stepKey,
     OBJECT:       node.right
   });
 
+  //
+
+  scope.traverse(node, breakVisitor, {
+    iteratorKey: iteratorKey,
+    wrapReturn:  function (node) {
+      return t.ifStatement(t.memberExpression(iteratorKey, t.identifier("return")), node);
+    },
+    label:       t.isLabeledStatement(parent) && parent.label.name
+  });
+
+  //
+
   return {
     declar: declar,
     loop:   loop

lib/babel/transformation/transformers/es6/modules.js

@@ -5,6 +5,9 @@ var t = require("../../../types");
 exports.check = require("../internal/modules").check;
 
 exports.ImportDeclaration = function (node, parent, scope, file) {
+  // flow type
+  if (node.isType) return;
+
   var nodes = [];
 
   if (node.specifiers.length) {
@@ -24,6 +27,9 @@ exports.ImportDeclaration = function (node, parent, scope, file) {
 };
 
 exports.ExportDeclaration = function (node, parent, scope, file) {
+  // flow type
+  if (t.isTypeAlias(node.declaration)) return;
+
   var nodes = [];
   var i;
 

lib/babel/transformation/transformers/es6/properties.shorthand.js

@@ -1,17 +1,15 @@
 "use strict";
 
-var nameMethod = require("../../helpers/name-method");
-var t          = require("../../../types");
-var clone      = require("lodash/lang/clone");
+var clone = require("lodash/lang/clone");
+var t     = require("../../../types");
 
 exports.check = function (node) {
   return t.isProperty(node) && (node.method || node.shorthand);
 };
 
-exports.Property = function (node, parent, scope, file) {
+exports.Property = function (node) {
   if (node.method) {
     node.method = false;
-    nameMethod.property(node, file, scope);
   }
 
   if (node.shorthand) {

lib/babel/transformation/transformers/es6/tail-call.js

@@ -40,6 +40,10 @@ TailCallTransformer.prototype.getFunctionId = function () {
   return this.functionId = this.functionId || this.scope.generateUidIdentifier("function");
 };
 
+TailCallTransformer.prototype.getAgainId = function () {
+  return this.againId = this.againId || this.scope.generateUidIdentifier("again");
+};
+
 TailCallTransformer.prototype.getParams = function () {
   var params = this.params;
 
@@ -112,7 +116,12 @@ TailCallTransformer.prototype.run = function () {
     body.unshift(t.variableDeclaration("var", paramDecls));
   }
 
+  body.unshift(t.expressionStatement(
+    t.assignmentExpression("=", this.getAgainId(), t.literal(false)))
+  );
+
   node.body = util.template("tail-call-body", {
+    AGAIN_ID:      this.getAgainId(),
     THIS_ID:       this.thisId,
     ARGUMENTS_ID:  this.argumentsId,
     FUNCTION_ID:   this.getFunctionId(),
@@ -286,6 +295,9 @@ TailCallTransformer.prototype.subTransformCallExpression = function (node) {
     }
   }
 
+  body.push(t.expressionStatement(
+    t.assignmentExpression("=", this.getAgainId(), t.literal(true))
+  ));
   body.push(t.continueStatement(this.getFunctionId()));
 
   return body;

lib/babel/transformation/transformers/index.js

@@ -1,12 +1,18 @@
 module.exports = {
   useStrict:                               require("./other/use-strict"),
 
+  // this goes at the start so we only transform the original user code
+  "spec.functionName":                     require("./spec/function-name"),
+
   "validation.undeclaredVariableCheck":    require("./validation/undeclared-variable-check"),
   "validation.noForInOfAssignment":        require("./validation/no-for-in-of-assignment"),
   "validation.setters":                    require("./validation/setters"),
   "validation.react":                      require("./validation/react"),
   "spec.blockScopedFunctions":             require("./spec/block-scoped-functions"),
 
+  // needs to be before `_aliasFunction`
+  "es6.arrowFunctions":                    require("./es6/arrow-functions"),
+
   "playground.malletOperator":             require("./playground/mallet-operator"),
   "playground.methodBinding":              require("./playground/method-binding"),
   "playground.memoizationOperator":        require("./playground/memoization-operator"),
@@ -22,9 +28,6 @@ module.exports = {
   // needs to be before `_aliasFunction`
   "es7.comprehensions":                    require("./es7/comprehensions"),
 
-  // needs to be before `_aliasFunction`
-  "es6.arrowFunctions":                    require("./es6/arrow-functions"),
-
   "es6.classes":                           require("./es6/classes"),
 
   asyncToGenerator:                        require("./other/async-to-generator"),
@@ -76,7 +79,7 @@ module.exports = {
   // needs to be after `regenerator` due to needing `regeneratorRuntime` references
   // needs to be after `es6.forOf` due to needing `Symbol.iterator` references
   // needs to be before `es6.modules` due to dynamic imports
-  selfContained:                           require("./other/self-contained"),
+  runtime:                                require("./other/runtime"),
 
   // needs to be before `_blockHoist` due to function hoisting etc
   "es6.modules":                           require("./es6/modules"),
@@ -91,7 +94,6 @@ module.exports = {
 
   "spec.typeofSymbol":                     require("./spec/typeof-symbol"),
   "spec.undefinedToVoid":                  require("./spec/undefined-to-void"),
-  "spec.functionName":                     require("./spec/function-name"),
 
   _moduleFormatter:                        require("./internal/module-formatter"),
 

lib/babel/transformation/transformers/internal/block-hoist.js

@@ -1,9 +1,8 @@
 "use strict";
 
-var useStrict = require("../../helpers/use-strict");
-var groupBy   = require("lodash/collection/groupBy");
-var flatten   = require("lodash/array/flatten");
-var values    = require("lodash/object/values");
+var groupBy = require("lodash/collection/groupBy");
+var flatten = require("lodash/array/flatten");
+var values  = require("lodash/object/values");
 
 // Priority:
 //
@@ -22,15 +21,13 @@ exports.Program = {
     }
     if (!hasChange) return;
 
-    useStrict.wrap(node, function () {
-      var nodePriorities = groupBy(node.body, function (bodyNode) {
-        var priority = bodyNode._blockHoist;
-        if (priority == null) priority = 1;
-        if (priority === true) priority = 2;
-        return priority;
-      });
-
-      node.body = flatten(values(nodePriorities).reverse());
+    var nodePriorities = groupBy(node.body, function (bodyNode) {
+      var priority = bodyNode._blockHoist;
+      if (priority == null) priority = 1;
+      if (priority === true) priority = 2;
+      return priority;
     });
+
+    node.body = flatten(values(nodePriorities).reverse());
   }
 };

lib/babel/transformation/transformers/internal/declarations.js

@@ -1,7 +1,6 @@
 "use strict";
 
-var useStrict = require("../../helpers/use-strict");
-var t         = require("../../../types");
+var t = require("../../../types");
 
 exports.secondPass = true;
 
@@ -12,25 +11,23 @@ exports.Program = function (node, parent, scope, file) {
   var kinds = {};
   var kind;
 
-  useStrict.wrap(node, function () {
-    for (var i in node._declarations) {
-      var declar = node._declarations[i];
+  for (var i in node._declarations) {
+    var declar = node._declarations[i];
 
-      kind = declar.kind || "var";
-      var declarNode = t.variableDeclarator(declar.id, declar.init);
+    kind = declar.kind || "var";
+    var declarNode = t.variableDeclarator(declar.id, declar.init);
 
-      if (declar.init) {
-        node.body.unshift(file.attachAuxiliaryComment(t.variableDeclaration(kind, [declarNode])));
-      } else {
-        kinds[kind] = kinds[kind] || [];
-        kinds[kind].push(declarNode);
-      }
+    if (declar.init) {
+      node.body.unshift(file.attachAuxiliaryComment(t.variableDeclaration(kind, [declarNode])));
+    } else {
+      kinds[kind] = kinds[kind] || [];
+      kinds[kind].push(declarNode);
     }
+  }
 
-    for (kind in kinds) {
-      node.body.unshift(file.attachAuxiliaryComment(t.variableDeclaration(kind, kinds[kind])));
-    }
-  });
+  for (kind in kinds) {
+    node.body.unshift(file.attachAuxiliaryComment(t.variableDeclaration(kind, kinds[kind])));
+  }
 
   node._declarations = null;
 };

lib/babel/transformation/transformers/internal/module-formatter.js

@@ -1,13 +1,9 @@
 "use strict";
 
-var useStrict = require("../../helpers/use-strict");
-
 exports.Program = function (program, parent, scope, file) {
   if (!file.transformers["es6.modules"].canRun()) return;
 
-  useStrict.wrap(program, function () {
-    program.body = file.dynamicImports.concat(program.body);
-  });
+  program.body = file.dynamicImports.concat(program.body);
 
   if (file.moduleFormatter.transform) {
     file.moduleFormatter.transform(program);

lib/babel/transformation/transformers/internal/modules.js

@@ -24,6 +24,9 @@ exports.ImportDeclaration = resolveModuleSource;
 exports.ExportDeclaration = function (node, parent, scope) {
   resolveModuleSource.apply(null, arguments);
 
+  // flow type
+  if (node.isType) return;
+
   var declar = node.declaration;
 
   if (node.default) {

lib/babel/transformation/transformers/other/react.js

@@ -3,6 +3,29 @@
 var react = require("../../helpers/react");
 var t     = require("../../../types");
 
+var JSX_ANNOTATION_REGEX = /^\*\s*@jsx\s+([^\s]+)/;
+
+exports.Program = function (node, parent, scope, file) {
+  var id = "React.createElement";
+
+  for (var i = 0; i < file.ast.comments.length; i++) {
+    var comment = file.ast.comments[i];
+    var matches = JSX_ANNOTATION_REGEX.exec(comment.value);
+    if (matches) {
+      id = matches[1];
+      if (id === "React.DOM") {
+        throw file.errorWithNode(comment, "The @jsx React.DOM pragma has been deprecated as of React 0.12");
+      } else {
+        break;
+      }
+    }
+  }
+
+  file.set("jsxIdentifier", id.split(".").map(t.identifier).reduce(function (object, property) {
+    return t.memberExpression(object, property);
+  }));
+};
+
 require("../../helpers/build-react-transformer")(exports, {
   pre: function (state) {
     var tagName = state.tagName;
@@ -14,7 +37,7 @@ require("../../helpers/build-react-transformer")(exports, {
     }
   },
 
-  post: function (state) {
-    state.callee = t.memberExpression(t.identifier("React"), t.identifier("createElement"));
+  post: function (state, file) {
+    state.callee = file.get("jsxIdentifier");
   }
 });

lib/babel/transformation/transformers/other/runtime.js

@@ -82,7 +82,7 @@ exports.Program = function (node, parent, scope, file) {
 };
 
 exports.pre = function (file) {
-  file.setDynamic("runtimeIdentifier", function () {
+  file.setDynamic("helpersNamespace", function () {
     return file.addImport("babel-runtime/helpers", "babelHelpers");
   });
 

lib/babel/transformation/transformers/other/use-strict.js

@@ -1,15 +1,19 @@
 "use strict";
 
-var useStrict = require("../../helpers/use-strict");
-var messages  = require("../../../messages");
-var t         = require("../../../types");
+var messages = require("../../../messages");
+var t        = require("../../../types");
 
 exports.Program = function (program) {
-  if (!useStrict.has(program)) {
-    program.body.unshift(t.expressionStatement(t.literal("use strict")));
+  var first = program.body[0];
+  if (t.isExpressionStatement(first) && t.isLiteral(first.expression, { value: "use strict" })) {
+    program.body.shift();
   }
 };
 
+exports.post = function (file) {
+  file.ast.program.body.unshift(t.expressionStatement(t.literal("use strict")));
+};
+
 exports.FunctionDeclaration =
 exports.FunctionExpression = function () {
   this.skip();

lib/babel/transformation/transformers/spec/function-name.js

@@ -1,53 +1,5 @@
 "use strict";
 
-var util = require("../../../util");
-var t    = require("../../../types");
+var nameMethod = require("../../helpers/name-method");
 
-var propertyFunctionVisitor = {
-  enter: function (node, parent, scope, state) {
-    if (t.isReferencedIdentifier(node, parent, { name: state.name }) && scope.getBindingIdentifier(node.name) === state.binding) {
-      return state.getOuter();
-    }
-  }
-};
-
-exports.FunctionExpression = function (node, parent, scope, file) {
-  if (node.id) return;
-  var id;
-  if (t.isProperty(parent)) {
-    id = parent.key;
-  } else if (t.isVariableDeclarator(parent)) {
-    id = parent.id;
-  } else {
-    return;
-  }
-  var binding = scope.getBindingIdentifier(id.name);
-  var outerId, selfGlobalId;
-  scope.traverse(node, propertyFunctionVisitor, {
-    name: id.name,
-    binding: binding,
-
-    getOuter: function () {
-      if (!binding) {
-        return t.memberExpression(
-          selfGlobalId || (selfGlobalId = file.addHelper("self-global")),
-          id
-        );
-      }
-      return t.callExpression(
-        outerId || (outerId = scope.generateUidIdentifier("getOuter")),
-        []
-      );
-    }
-  });
-  node.id = id;
-  if (outerId) {
-    return util.template("named-func", {
-      GET_OUTER_ID: outerId,
-      ID:           id,
-      FUNCTION:     node
-    });
-  }
-};
-
-exports.optional = true;
+exports.FunctionExpression = nameMethod.bare;

lib/babel/types/alias-keys.json

@@ -19,7 +19,7 @@
   "PrivateDeclaration":  ["Statement", "Declaration"],
 
   "ArrowFunctionExpression": ["Scopable", "Function", "Expression"],
-  "FunctionDeclaration":     ["Statement", "Declaration", "Scopable", "Function"],
+  "FunctionDeclaration":     ["Scopable", "Function", "Statement", "Declaration"],
   "FunctionExpression":      ["Scopable", "Function", "Expression"],
 
   "ImportSpecifier": ["ModuleSpecifier"],
@@ -39,16 +39,15 @@
   "ClassDeclaration": ["Statement", "Declaration", "Class"],
   "ClassExpression":  ["Class", "Expression"],
 
-  "ForOfStatement": ["Statement", "For", "Scopable", "Loop"],
-  "ForInStatement": ["Statement", "For", "Scopable", "Loop"],
-  "ForStatement":   ["Statement", "For", "Scopable", "Loop"],
+  "ForOfStatement": ["Scopable", "Statement", "For", "Loop"],
+  "ForInStatement": ["Scopable", "Statement", "For", "Loop"],
+  "ForStatement":   ["Scopable", "Statement", "For", "Loop"],
 
   "ObjectPattern":     ["Pattern"],
   "ArrayPattern":      ["Pattern"],
   "AssignmentPattern": ["Pattern"],
 
   "Property":   ["UserWhitespacable"],
-  "JSXElement": ["UserWhitespacable", "Expression"],
 
   "ArrayExpression":           ["Expression"],
   "AssignmentExpression":      ["Expression"],
@@ -74,7 +73,7 @@
 
   "JSXAttribute":           ["JSX"],
   "JSXClosingElement":      ["JSX"],
-  "JSXElement":             ["JSX"],
+  "JSXElement":             ["JSX", "Expression"],
   "JSXEmptyExpression":     ["JSX"],
   "JSXExpressionContainer": ["JSX"],
   "JSXIdentifier":          ["JSX"],

lib/babel/util.js

@@ -56,6 +56,12 @@ exports.arrayify = function (val) {
   throw new TypeError("illegal type for arrayify");
 };
 
+exports.booleanify = function (val) {
+  if (val === "true") return true;
+  if (val === "false") return false;
+  return val;
+};
+
 var templateVisitor = {
   enter: function (node, parent, scope, nodes) {
     if (t.isExpressionStatement(node)) {

package.json

@@ -1,7 +1,7 @@
 {
   "name": "babel",
   "description": "Turn ES6 code into readable vanilla ES5 with source maps",
-  "version": "4.3.0",
+  "version": "4.4.6",
   "author": "Sebastian McKenzie <sebmck@gmail.com>",
   "homepage": "https://babeljs.io/",
   "repository": "babel/babel",
@@ -12,11 +12,9 @@
   },
   "bin": {
     "6to5": "./bin/deprecated/6to5",
-    "6to5-minify": "./bin/deprecated/6to5-minify",
     "6to5-node": "./bin/deprecated/6to5-node",
     "6to5-runtime": "./bin/deprecated/6to5-runtime",
     "babel": "./bin/babel/index.js",
-    "babel-minify": "./bin/babel-minify",
     "babel-node": "./bin/babel-node",
     "babel-external-helpers": "./bin/babel-external-helpers"
   },
@@ -38,12 +36,12 @@
     "test": "make test"
   },
   "dependencies": {
-    "acorn-babel": "0.11.1-33",
+    "acorn-babel": "0.11.1-34",
     "ast-types": "~0.6.1",
-    "chalk": "^0.5.1",
+    "chalk": "^1.0.0",
     "chokidar": "^0.12.6",
     "commander": "^2.6.0",
-    "core-js": "^0.5.4",
+    "core-js": "^0.6.1",
     "debug": "^2.1.1",
     "detect-indent": "^3.0.0",
     "estraverse": "^1.9.1",
@@ -51,13 +49,14 @@
     "fs-readdir-recursive": "^0.1.0",
     "globals": "^6.2.0",
     "is-integer": "^1.0.4",
-    "js-tokenizer": "^1.3.3",
+    "js-tokens": "0.4.1",
     "leven": "^1.0.1",
+    "line-numbers": "0.2.0",
     "lodash": "^3.2.0",
     "output-file-sync": "^1.1.0",
     "path-is-absolute": "^1.0.0",
     "private": "^0.1.6",
-    "regenerator-babel": "0.8.10-2",
+    "regenerator-babel": "0.8.13-1",
     "regexpu": "^1.1.1",
     "repeating": "^1.1.2",
     "shebang-regex": "^1.0.0",

packages/babel-runtime/package.json

@@ -1,7 +1,7 @@
 {
   "name": "babel-runtime",
   "description": "babel selfContained runtime",
-  "version": "4.2.1",
+  "version": "4.4.5",
   "repository": "babel/babel",
   "author": "Sebastian McKenzie <sebmck@gmail.com>"
 }

test/fixtures/esnext/es6-object-concise/method-to-string.js

@@ -1,10 +0,0 @@
-var a = {
-  b() {
-    return b;
-  }
-};
-
-assert.ok(
-  /return b/.test(a.b.toString()),
-  'toString contains body'
-);

test/fixtures/generation/comments/2-space-multi-comment-with-space/expected.js

@@ -1,10 +1,8 @@
 function test() {
 
-
   /*
    * this is comment
    */
 
-
   var i = 20;
 }

test/fixtures/generation/comments/simple-a-lot-of-line-comment/expected.js

@@ -20,11 +20,8 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 function test() {}
 
-
-
 // Copyright (C) 2012 Yusuke Suzuki <utatane.tea@gmail.com>
 //
 // Redistribution and use in source and binary forms, with or without

test/fixtures/transformation/es6-arrow-functions/arguments/expected.js

@@ -2,6 +2,7 @@
 
 function one() {
   var _arguments = arguments;
+
   var inner = function () {
     return _arguments;
   };
@@ -11,12 +12,14 @@ one(1, 2);
 
 function two() {
   var _arguments = arguments;
+
   var inner = function () {
     return _arguments;
   };
 
-  var another = function () {
+  var another = function another() {
     var _arguments2 = arguments;
+
     var inner2 = function () {
       return _arguments2;
     };
@@ -28,6 +31,7 @@ two(1, 2);
 
 function three() {
   var _arguments = arguments;
+
   var fn = function () {
     return _arguments[0] + "bar";
   };
@@ -37,6 +41,7 @@ three("foo");
 
 function four() {
   var _arguments = arguments;
+
   var fn = function () {
     return _arguments[0].foo + "bar";
   };
@@ -54,7 +59,7 @@ five({ arguments: ["foo"] });
 
 function six(obj) {
   var fn = function () {
-    var fn2 = function () {
+    var fn2 = function fn2() {
       return arguments[0];
     };
     return fn2("foobar");

test/fixtures/transformation/es6-arrow-functions/default-parameters/expected.js

@@ -2,6 +2,7 @@
 
 var some = function () {
   var count = arguments[0] === undefined ? "30" : arguments[0];
+
   console.log("count", count);
 };
 

test/fixtures/transformation/es6-arrow-functions/nested/expected.js

@@ -1,8 +1,9 @@
 "use strict";
 
 module.exports = {
-  init: function () {
+  init: function init() {
     var _this = this;
+
     return new Promise(function (resolve, reject) {
       MongoClient.connect(config.mongodb, function (err, db) {
         if (err) {

test/fixtures/transformation/es6-arrow-functions/this/expected.js

@@ -2,6 +2,7 @@
 
 function b() {
   var _this = this;
+
   var t = function (x) {
     return _this.x + x;
   };

test/fixtures/transformation/es6-block-scoping/for-break-continue-return/expected.js

@@ -20,8 +20,10 @@
     switch (_ret) {
       case "continue":
         continue;
+
       case "break":
         break;
+
       default:
         if (typeof _ret === "object") return _ret.v;
     }

test/fixtures/transformation/es6-block-scoping/hoisting/expected.js

@@ -2,9 +2,11 @@
 
 for (var _iterator = [1, 2, 3][Symbol.iterator](), _step; !(_step = _iterator.next()).done;) {
   var x;
+
   (function () {
     var i = _step.value;
     x = 5;
+
     fns.push(function () {
       return i * x;
     });

test/fixtures/transformation/es6-classes-loose/accessing-super-class/expected.js

@@ -1,6 +1,7 @@
 "use strict";
 
 var _slice = Array.prototype.slice;
+
 var _inherits = function (subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; };
 
 var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } };
@@ -8,6 +9,7 @@ var _classCallCheck = function (instance, Constructor) { if (!(instance instance
 var Test = (function (Foo) {
   function Test() {
     var _Foo$prototype$test, _Foo$prototype$test2;
+
     _classCallCheck(this, Test);
 
     woops["super"].test();
@@ -25,6 +27,7 @@ var Test = (function (Foo) {
 
   Test.prototype.test = function test() {
     var _Foo$prototype$test, _Foo$prototype$test2;
+
     Foo.prototype.test.call(this);
     (_Foo$prototype$test = Foo.prototype.test).call.apply(_Foo$prototype$test, [this].concat(_slice.call(arguments)));
     (_Foo$prototype$test2 = Foo.prototype.test).call.apply(_Foo$prototype$test2, [this, "test"].concat(_slice.call(arguments)));
@@ -32,10 +35,11 @@ var Test = (function (Foo) {
 
   Test.foo = function foo() {
     var _Foo$foo, _Foo$foo2;
+
     Foo.foo.call(this);
     (_Foo$foo = Foo.foo).call.apply(_Foo$foo, [this].concat(_slice.call(arguments)));
     (_Foo$foo2 = Foo.foo).call.apply(_Foo$foo2, [this, "test"].concat(_slice.call(arguments)));
   };
 
   return Test;
-})(Foo);
+})(Foo);

test/fixtures/transformation/es6-classes/accessing-super-class/expected.js

@@ -1,6 +1,7 @@
 "use strict";
 
 var _slice = Array.prototype.slice;
+
 var _prototypeProperties = function (child, staticProps, instanceProps) { if (staticProps) Object.defineProperties(child, staticProps); if (instanceProps) Object.defineProperties(child.prototype, instanceProps); };
 
 var _get = function get(object, property, receiver) { var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc && desc.writable) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
@@ -12,6 +13,7 @@ var _classCallCheck = function (instance, Constructor) { if (!(instance instance
 var Test = (function (Foo) {
   function Test() {
     var _get2, _get3;
+
     _classCallCheck(this, Test);
 
     woops["super"].test();
@@ -31,6 +33,7 @@ var Test = (function (Foo) {
     foo: {
       value: function foo() {
         var _get2;
+
         _get(Object.getPrototypeOf(Test), "foo", this).call(this);
         _get(Object.getPrototypeOf(Test), "foo", this).apply(this, arguments);
         (_get2 = _get(Object.getPrototypeOf(Test), "foo", this)).call.apply(_get2, [this, "test"].concat(_slice.call(arguments)));
@@ -42,6 +45,7 @@ var Test = (function (Foo) {
     test: {
       value: function test() {
         var _get2;
+
         _get(Object.getPrototypeOf(Test.prototype), "test", this).call(this);
         _get(Object.getPrototypeOf(Test.prototype), "test", this).apply(this, arguments);
         (_get2 = _get(Object.getPrototypeOf(Test.prototype), "test", this)).call.apply(_get2, [this, "test"].concat(_slice.call(arguments)));
@@ -52,4 +56,4 @@ var Test = (function (Foo) {
   });
 
   return Test;
-})(Foo);
+})(Foo);

test/fixtures/transformation/es6-classes/super-class-anonymous/actual.js

@@ -0,0 +1,20 @@
+class TestEmpty extends (class {}) {
+}
+
+class TestConstructorOnly extends (class { constructor() {} }) {
+}
+
+class TestMethodOnly extends (class { method() {} }) {
+}
+
+class TestConstructorAndMethod extends (class {
+    constructor() {}
+    method() {}
+}) {
+}
+
+class TestMultipleMethods extends (class {
+    m1() {}
+    m2() {}
+}) {
+}

test/fixtures/transformation/es6-classes/super-class-anonymous/expected.js

@@ -0,0 +1,129 @@
+"use strict";
+
+var _prototypeProperties = function (child, staticProps, instanceProps) { if (staticProps) Object.defineProperties(child, staticProps); if (instanceProps) Object.defineProperties(child.prototype, instanceProps); };
+
+var _inherits = function (subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; };
+
+var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } };
+
+var TestEmpty = (function (_ref) {
+    function TestEmpty() {
+        _classCallCheck(this, TestEmpty);
+
+        if (_ref != null) {
+            _ref.apply(this, arguments);
+        }
+    }
+
+    _inherits(TestEmpty, _ref);
+
+    return TestEmpty;
+})(function _class() {
+    _classCallCheck(this, _class);
+});
+
+var TestConstructorOnly = (function (_ref2) {
+    function TestConstructorOnly() {
+        _classCallCheck(this, TestConstructorOnly);
+
+        if (_ref2 != null) {
+            _ref2.apply(this, arguments);
+        }
+    }
+
+    _inherits(TestConstructorOnly, _ref2);
+
+    return TestConstructorOnly;
+})(function _class2() {
+    _classCallCheck(this, _class2);
+});
+
+var TestMethodOnly = (function (_ref3) {
+    function TestMethodOnly() {
+        _classCallCheck(this, TestMethodOnly);
+
+        if (_ref3 != null) {
+            _ref3.apply(this, arguments);
+        }
+    }
+
+    _inherits(TestMethodOnly, _ref3);
+
+    return TestMethodOnly;
+})((function () {
+    var _class3 = function () {
+        _classCallCheck(this, _class3);
+    };
+
+    _prototypeProperties(_class3, null, {
+        method: {
+            value: function method() {},
+            writable: true,
+            configurable: true
+        }
+    });
+
+    return _class3;
+})());
+
+var TestConstructorAndMethod = (function (_ref4) {
+    function TestConstructorAndMethod() {
+        _classCallCheck(this, TestConstructorAndMethod);
+
+        if (_ref4 != null) {
+            _ref4.apply(this, arguments);
+        }
+    }
+
+    _inherits(TestConstructorAndMethod, _ref4);
+
+    return TestConstructorAndMethod;
+})((function () {
+    var _class4 = function () {
+        _classCallCheck(this, _class4);
+    };
+
+    _prototypeProperties(_class4, null, {
+        method: {
+            value: function method() {},
+            writable: true,
+            configurable: true
+        }
+    });
+
+    return _class4;
+})());
+
+var TestMultipleMethods = (function (_ref5) {
+    function TestMultipleMethods() {
+        _classCallCheck(this, TestMultipleMethods);
+
+        if (_ref5 != null) {
+            _ref5.apply(this, arguments);
+        }
+    }
+
+    _inherits(TestMultipleMethods, _ref5);
+
+    return TestMultipleMethods;
+})((function () {
+    var _class5 = function () {
+        _classCallCheck(this, _class5);
+    };
+
+    _prototypeProperties(_class5, null, {
+        m1: {
+            value: function m1() {},
+            writable: true,
+            configurable: true
+        },
+        m2: {
+            value: function m2() {},
+            writable: true,
+            configurable: true
+        }
+    });
+
+    return _class5;
+})());
+

test/fixtures/transformation/es6-constants/destructuring/expected.js

@@ -1,18 +1,12 @@
 "use strict";
 
-var _ref = [1, 2];
-
-var a = _ref[0];
-var b = _ref[1];
-var _ref2 = [3, 4];
-
-var c = _ref2[0];
-var d = _ref2[1];
-var _ref3 = { e: 5, f: 6 };
-
-var e = _ref3.e;
-var f = _ref3.f;
-var _ref4 = { a: 7, b: 8 };
-
-var g = _ref4.a;
-var h = _ref4.b;
+var a = 1;
+var b = 2;
+var c = 3;
+var d = 4;
+var _ref = { e: 5, f: 6 };
+var e = _ref.e;
+var f = _ref.f;
+var _ref2 = { a: 7, b: 8 };
+var g = _ref2.a;
+var h = _ref2.b;

test/fixtures/transformation/es6-destructuring/array-unpack-optimisation/actual.js

@@ -0,0 +1,9 @@
+// opt
+var [a, b] = [1, 2];
+var [[a, b]] = [[1, 2]];
+var [a, b, ...c] = [1, 2, 3, 4];
+var [[a, b, ...c]] = [[1, 2, 3, 4]];
+
+// deopt
+var [a, b] = [1, 2, 3];
+var [[a, b]] = [[1, 2, 3]];

test/fixtures/transformation/es6-destructuring/array-unpack-optimisation/expected.js

@@ -0,0 +1,21 @@
+"use strict";
+
+// opt
+var a = 1;
+var b = 2;
+var a = 1;
+var b = 2;
+var a = 1;
+var b = 2;
+var c = [3, 4];
+var a = 1;
+var b = 2;
+var c = [3, 4];
+
+// deopt
+var _ref = [1, 2, 3];
+var a = _ref[0];
+var b = _ref[1];
+var _ref2 = [1, 2, 3];
+var a = _ref2[0];
+var b = _ref2[1];

test/fixtures/transformation/es6-destructuring/array/actual.js

@@ -1 +1 @@
-var [a, [b], [c], d] = ["hello", [", ", "junk"], ["world"]];
+var [a, [b], [c]] = ["hello", [", ", "junk"], ["world"]];

test/fixtures/transformation/es6-destructuring/array/expected.js

@@ -1,14 +1,6 @@
 "use strict";
 
-var _slicedToArray = function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { var _arr = []; for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) { _arr.push(_step.value); if (i && _arr.length === i) break; } return _arr; } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } };
-
-var _ref = ["hello", [", ", "junk"], ["world"]];
-
-var a = _ref[0];
-var _ref$1 = _slicedToArray(_ref[1], 1);
-
-var b = _ref$1[0];
-var _ref$2 = _slicedToArray(_ref[2], 1);
-
-var c = _ref$2[0];
-var d = _ref[3];
+var a = "hello";
+var _ref = [", ", "junk"];
+var b = _ref[0];
+var c = "world";

test/fixtures/transformation/es6-destructuring/assignment-expression/expected.js

@@ -1,6 +1,7 @@
 "use strict";
 
 var _temp, _temp2;
+
 var _slicedToArray = function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { var _arr = []; for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) { _arr.push(_step.value); if (i && _arr.length === i) break; } return _arr; } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } };
 
 console.log((_temp = [123], _temp2 = _slicedToArray(_temp, 1), x = _temp2[0], _temp));

test/fixtures/transformation/es6-destructuring/assignment-statement/expected.js

@@ -8,4 +8,5 @@ var _ref2 = _slicedToArray(_ref, 2);
 
 a = _ref2[0];
 b = _ref2[1];
+
 ;

test/fixtures/transformation/es6-destructuring/empty/expected.js

@@ -3,11 +3,12 @@
 var _slicedToArray = function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { var _arr = []; for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) { _arr.push(_step.value); if (i && _arr.length === i) break; } return _arr; } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } };
 
 var _ref = ["foo", "hello", [", ", "junk"], ["world"]];
-
 var a = _ref[1];
+
 var _ref$2 = _slicedToArray(_ref[2], 1);
 
 var b = _ref$2[0];
+
 var _ref$3 = _slicedToArray(_ref[3], 1);
 
 var c = _ref$3[0];

test/fixtures/transformation/es6-destructuring/es7-object-rest/expected.js

@@ -5,9 +5,11 @@ var _objectWithoutProperties = function (obj, keys) { var target = {}; for (var
 var x = _objectWithoutProperties(z, []);
 
 var x = z.x;
+
 var y = _objectWithoutProperties(z, ["x"]);
 
 (function (_ref) {
   var x = _ref.x;
+
   var y = _objectWithoutProperties(_ref, ["x"]);
-});
+});

test/fixtures/transformation/es6-destructuring/for-in/expected.js

@@ -7,5 +7,6 @@ for (var _ref in obj) {
 
   var name = _ref2[0];
   var value = _ref2[1];
+
   print("Name: " + name + ", Value: " + value);
 }

test/fixtures/transformation/es6-destructuring/known-array/expected.js

@@ -5,4 +5,5 @@ var _toArray = function (arr) { return Array.isArray(arr) ? arr : Array.from(arr
 var _z = _toArray(z);
 
 var x = _z[0];
+
 var y = _z.slice(1);

test/fixtures/transformation/es6-destructuring/member-expression/expected.js

@@ -8,4 +8,5 @@ var _ref2 = _slicedToArray(_ref, 2);
 
 foo.foo = _ref2[0];
 foo.bar = _ref2[1];
+
 ;

test/fixtures/transformation/es6-destructuring/mixed/expected.js

@@ -6,6 +6,7 @@ var _rect$topLeft = _slicedToArray(rect.topLeft, 2);
 
 var x1 = _rect$topLeft[0];
 var y1 = _rect$topLeft[1];
+
 var _rect$bottomRight = _slicedToArray(rect.bottomRight, 2);
 
 var x2 = _rect$bottomRight[0];

test/fixtures/transformation/es6-destructuring/parameters/expected.js

@@ -14,22 +14,25 @@ function somethingAdvanced(_ref) {
 function unpackObject(_ref) {
   var title = _ref.title;
   var author = _ref.author;
+
   return title + " " + author;
 }
 
 console.log(unpackObject({ title: "title", author: "author" }));
 
-var unpackArray = function (_ref, _ref3) {
+var unpackArray = function unpackArray(_ref, _ref3) {
   var _ref2 = _slicedToArray(_ref, 3);
 
   var a = _ref2[0];
   var b = _ref2[1];
   var c = _ref2[2];
+
   var _ref32 = _slicedToArray(_ref3, 3);
 
   var x = _ref32[0];
   var y = _ref32[1];
   var z = _ref32[2];
+
   return a + b + c;
 };
 

test/fixtures/transformation/es6-destructuring/spread/expected.js

@@ -7,6 +7,7 @@ var isSorted = function (_ref) {
 
   var x = _ref2[0];
   var y = _ref2[1];
+
   var wow = _ref2.slice(2);
 
   if (!zs.length) return true;

test/fixtures/transformation/es6-for-of-loose/break/actual.js

@@ -0,0 +1,29 @@
+// labels
+
+foo: for (let x of foo()) {
+  while (true) {
+    break foo;
+  }
+}
+
+foo: for (let x of foo()) {
+  while (true) {
+    break;
+  }
+}
+
+foo: for (let x of foo()) {
+  break foo;
+}
+
+// basic
+
+for (let x of foo()) {
+  break;
+}
+
+for (let x of foo()) {
+  while (true) {
+    break;
+  }
+}

test/fixtures/transformation/es6-for-of-loose/break/expected.js

@@ -0,0 +1,100 @@
+"use strict";
+
+// labels
+
+foo: for (var _iterator = foo(), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+  var _ref;
+
+  if (_isArray) {
+    if (_i >= _iterator.length) break;
+    _ref = _iterator[_i++];
+  } else {
+    _i = _iterator.next();
+    if (_i.done) break;
+    _ref = _i.value;
+  }
+
+  var x = _ref;
+
+  while (true) {
+    if (!_isArray && _iterator["return"]) _iterator["return"]();
+
+    break foo;
+  }
+}
+
+foo: for (var _iterator2 = foo(), _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+  var _ref2;
+
+  if (_isArray2) {
+    if (_i2 >= _iterator2.length) break;
+    _ref2 = _iterator2[_i2++];
+  } else {
+    _i2 = _iterator2.next();
+    if (_i2.done) break;
+    _ref2 = _i2.value;
+  }
+
+  var x = _ref2;
+
+  while (true) {
+    break;
+  }
+}
+
+foo: for (var _iterator3 = foo(), _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
+  var _ref3;
+
+  if (_isArray3) {
+    if (_i3 >= _iterator3.length) break;
+    _ref3 = _iterator3[_i3++];
+  } else {
+    _i3 = _iterator3.next();
+    if (_i3.done) break;
+    _ref3 = _i3.value;
+  }
+
+  var x = _ref3;
+  if (!_isArray3 && _iterator3["return"]) _iterator3["return"]();
+
+  break foo;
+}
+
+// basic
+
+for (var _iterator4 = foo(), _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) {
+  var _ref4;
+
+  if (_isArray4) {
+    if (_i4 >= _iterator4.length) break;
+    _ref4 = _iterator4[_i4++];
+  } else {
+    _i4 = _iterator4.next();
+    if (_i4.done) break;
+    _ref4 = _i4.value;
+  }
+
+  var x = _ref4;
+  if (!_isArray4 && _iterator4["return"]) _iterator4["return"]();
+
+  break;
+}
+
+for (var _iterator5 = foo(), _isArray5 = Array.isArray(_iterator5), _i5 = 0, _iterator5 = _isArray5 ? _iterator5 : _iterator5[Symbol.iterator]();;) {
+  var _ref5;
+
+  if (_isArray5) {
+    if (_i5 >= _iterator5.length) break;
+    _ref5 = _iterator5[_i5++];
+  } else {
+    _i5 = _iterator5.next();
+    if (_i5.done) break;
+    _ref5 = _i5.value;
+  }
+
+  var x = _ref5;
+
+  while (true) {
+    break;
+  }
+}

test/fixtures/transformation/es6-for-of-loose/let/expected.js

@@ -2,6 +2,7 @@
 
 for (var _iterator = arr, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
   var _ref;
+
   if (_isArray) {
     if (_i >= _iterator.length) break;
     _ref = _iterator[_i++];
@@ -10,5 +11,6 @@ for (var _iterator = arr, _isArray = Array.isArray(_iterator), _i = 0, _iterator
     if (_i.done) break;
     _ref = _i.value;
   }
+
   var i = _ref;
-}
+}

test/fixtures/transformation/es6-for-of-loose/member-expression/actual.js

@@ -0,0 +1,3 @@
+for (obj.prop of arr) {
+
+}

test/fixtures/transformation/es6-for-of-loose/member-expression/expected.js

@@ -0,0 +1,12 @@
+"use strict";
+
+for (var _iterator = arr, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+  if (_isArray) {
+    if (_i >= _iterator.length) break;
+    obj.prop = _iterator[_i++];
+  } else {
+    _i = _iterator.next();
+    if (_i.done) break;
+    obj.prop = _i.value;
+  }
+}

test/fixtures/transformation/es6-for-of-loose/multiple/expected.js

@@ -2,6 +2,7 @@
 
 for (var _iterator = arr, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
   var _ref;
+
   if (_isArray) {
     if (_i >= _iterator.length) break;
     _ref = _iterator[_i++];
@@ -10,11 +11,13 @@ for (var _iterator = arr, _isArray = Array.isArray(_iterator), _i = 0, _iterator
     if (_i.done) break;
     _ref = _i.value;
   }
+
   var i = _ref;
 }
 
 for (var _iterator2 = numbers, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
   var _ref2;
+
   if (_isArray2) {
     if (_i2 >= _iterator2.length) break;
     _ref2 = _iterator2[_i2++];
@@ -23,5 +26,6 @@ for (var _iterator2 = numbers, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _
     if (_i2.done) break;
     _ref2 = _i2.value;
   }
+
   var i = _ref2;
-}
+}

test/fixtures/transformation/es6-for-of-loose/var/expected.js

@@ -2,6 +2,7 @@
 
 for (var _iterator = arr, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
   var _ref;
+
   if (_isArray) {
     if (_i >= _iterator.length) break;
     _ref = _iterator[_i++];
@@ -10,5 +11,6 @@ for (var _iterator = arr, _isArray = Array.isArray(_iterator), _i = 0, _iterator
     if (_i.done) break;
     _ref = _i.value;
   }
+
   var i = _ref;
-}
+}

test/fixtures/transformation/es6-for-of/break/actual.js

@@ -0,0 +1,29 @@
+// labels
+
+foo: for (let x of foo()) {
+  while (true) {
+    break foo;
+  }
+}
+
+foo: for (let x of foo()) {
+  while (true) {
+    break;
+  }
+}
+
+foo: for (let x of foo()) {
+  break foo;
+}
+
+// basic
+
+for (let x of foo()) {
+  break;
+}
+
+for (let x of foo()) {
+  while (true) {
+    break;
+  }
+}

test/fixtures/transformation/es6-for-of/break/expected.js

@@ -0,0 +1,45 @@
+"use strict";
+
+// labels
+
+foo: for (var _iterator = foo()[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) {
+  var x = _step.value;
+
+  while (true) {
+    if (_iterator["return"]) _iterator["return"]();
+
+    break foo;
+  }
+}
+
+foo: for (var _iterator2 = foo()[Symbol.iterator](), _step2; !(_step2 = _iterator2.next()).done;) {
+  var x = _step2.value;
+
+  while (true) {
+    break;
+  }
+}
+
+foo: for (var _iterator3 = foo()[Symbol.iterator](), _step3; !(_step3 = _iterator3.next()).done;) {
+  var x = _step3.value;
+  if (_iterator3["return"]) _iterator3["return"]();
+
+  break foo;
+}
+
+// basic
+
+for (var _iterator4 = foo()[Symbol.iterator](), _step4; !(_step4 = _iterator4.next()).done;) {
+  var x = _step4.value;
+  if (_iterator4["return"]) _iterator4["return"]();
+
+  break;
+}
+
+for (var _iterator5 = foo()[Symbol.iterator](), _step5; !(_step5 = _iterator5.next()).done;) {
+  var x = _step5.value;
+
+  while (true) {
+    break;
+  }
+}

test/fixtures/transformation/es6-for-of/illegal-left/actual.js

@@ -1,3 +0,0 @@
-for (foo.bar of test) {
-
-}

test/fixtures/transformation/es6-for-of/illegal-left/options.json

@@ -1,3 +0,0 @@
-{
-  "throws": "Unknown node type \"MemberExpression\" in ForStatement"
-}

test/fixtures/transformation/es6-for-of/member-expression/actual.js

@@ -0,0 +1,3 @@
+for (obj.prop of arr) {
+
+}

test/fixtures/transformation/es6-for-of/member-expression/expected.js

@@ -0,0 +1,5 @@
+"use strict";
+
+for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) {
+  obj.prop = _step.value;
+}

test/fixtures/transformation/es6-modules-amd/exports-default/expected.js

@@ -1,6 +1,6 @@
-define(["exports", "module"], function (exports, module) {
-  "use strict";
+"use strict";
 
+define(["exports", "module"], function (exports, module) {
   var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } };
 
   module.exports = foo;
@@ -8,6 +8,7 @@ define(["exports", "module"], function (exports, module) {
   module.exports = {};
   module.exports = [];
   module.exports = foo;
+
   module.exports = function () {};
 
   var _default = function _default() {
@@ -16,6 +17,7 @@ define(["exports", "module"], function (exports, module) {
 
   module.exports = _default;
   function foo() {}
+
   var Foo = function Foo() {
     _classCallCheck(this, Foo);
   };

test/fixtures/transformation/es6-modules-amd/exports-from/expected.js

@@ -1,6 +1,6 @@
-define(["exports", "foo"], function (exports, _foo) {
-  "use strict";
+"use strict";
 
+define(["exports", "foo"], function (exports, _foo) {
   var _interopRequireWildcard = function (obj) { return obj && obj.__esModule ? obj : { "default": obj }; };
 
   var _defaults = function (obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; };

test/fixtures/transformation/es6-modules-amd/exports-named/expected.js

@@ -1,6 +1,6 @@
-define(["exports"], function (exports) {
-  "use strict";
+"use strict";
 
+define(["exports"], function (exports) {
   exports.foo = foo;
   exports.foo = foo;
   exports.bar = bar;

test/fixtures/transformation/es6-modules-amd/exports-variable/expected.js

@@ -1,18 +1,19 @@
-define(["exports"], function (exports) {
-  "use strict";
+"use strict";
 
+define(["exports"], function (exports) {
   var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } };
 
   exports.foo7 = foo7;
   var foo = exports.foo = 1;
   var foo = exports.foo = 1;
   var bar = exports.bar = 2;
-  var foo2 = exports.foo2 = function () {};
+  var foo2 = exports.foo2 = function foo2() {};
   var foo3 = exports.foo3 = undefined;
   var foo4 = exports.foo4 = 2;
   var foo5 = exports.foo5 = undefined;
   var foo6 = exports.foo6 = 3;
   function foo7() {}
+
   var foo8 = exports.foo8 = function foo8() {
     _classCallCheck(this, foo8);
   };

test/fixtures/transformation/es6-modules-amd/get-module-name-option/expected.js

@@ -0,0 +1,3 @@
+"use strict";
+
+define("my custom module name", ["exports"], function (exports) {});

test/fixtures/transformation/es6-modules-amd/get-module-name-option/options.json

@@ -0,0 +1,4 @@
+{
+  "moduleIds": true,
+  "moduleId": "my custom module name"
+}

test/fixtures/transformation/es6-modules-amd/hoist-function-exports/expected.js

@@ -1,6 +1,6 @@
-define(["exports", "./evens"], function (exports, _evens) {
-  "use strict";
+"use strict";
 
+define(["exports", "./evens"], function (exports, _evens) {
   exports.nextOdd = nextOdd;
   var isEven = _evens.isEven;
   function nextOdd(n) {

test/fixtures/transformation/es6-modules-amd/imports-default/expected.js

@@ -1,6 +1,6 @@
-define(["exports", "foo"], function (exports, _foo) {
-  "use strict";
+"use strict";
 
+define(["exports", "foo"], function (exports, _foo) {
   var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; };
 
   var foo = _interopRequire(_foo);