v5.0.2

Incorrect package path

.gitignore

@@ -11,7 +11,6 @@ test/core/tmp
 coverage
 dist
 .package.json
-packages/babel-runtime/*.js
 packages/babel-runtime/helpers/*.js
 packages/babel-runtime/regenerator/*.js
 lib

.npmignore

@@ -1,16 +1,15 @@
-node_modules
 *.log
 *.cache
-lib/babel/transformation/templates
-test
-benchmark
-Makefile
 .*
-dist
-tests.json
-CHANGELOG.md
-.package.json
-coverage
-vendor
-packages
-src
+/lib/babel/transformation/templates
+/test
+/benchmark
+/Makefile
+/dist
+/tests.json
+/CHANGELOG.md
+/.package.json
+/coverage
+/vendor
+/packages
+/src

.travis.yml

@@ -4,10 +4,6 @@ node_js:
   - "0.12"
   - "iojs"
 
-branches:
-  except:
-   - experimental
-
 before_script: "npm install -g codeclimate-test-reporter"
 script: "make test-travis"
 

CHANGELOG.md

@@ -13,6 +13,56 @@ _Note: Gaps between patch versions are faulty/broken releases._
 
 See [CHANGELOG - 6to5](CHANGELOG-6to5.md) for the pre-4.0.0 version changelog.
 
+## 5.0.1
+
+ * **Bug Fix**
+  * Fix duplicate declaration regression.
+  * Fix not being able to call non-writable methods.
+
+## 5.0.0
+
+ * **New Feature**
+  * Decorators based on [@wycat's](https://github.com/wycats) [stage 1 proposal](https://github.com/wycats/javascript-decorators).
+  * Class property initializers based on [@jeffmo's](https://github.com/jeffmo) [stage 0 proposal](https://gist.github.com/jeffmo/054df782c05639da2adb).
+  * Export extensions based on [@leebyron's](https://github.com/leebyron) [stage 1 proposal](https://github.com/leebyron/ecmascript-more-export-from).
+  * UMD module formatter now supports globals.
+  * Add `es3.runtime`, `optimisation.react.inlineElements` and `optimisation.react.constantElements` transformers.
+  * Add stage option that replaces the experimental one.
+  * Allow ES7 transformer to be enabled via `optional` instead of only via `stage`.
+  * Infer string quotes to use in the code generator.
+  * Consider `export { foo as default  };` to be the same as `export default foo;`.
+  * Add `nonStandard` option that can be set to `false` to remove parser support for JSX and Flow.
+  * Add `jsxPragma` option.
+  * Automatically generate CLI options based on internal API options.
+  * Add support for `.babelrc` on absolute paths.
+  * Plugin API!
+ * **Internal**
+  * Export `options` in browser API.
+  * Rewritten parser.
+  * Don't block hoist when runtime transformer is enabled in system module formatter.
+  * Rewritten the internal traversal and node replacement API to use "paths" that abstracts out node relationships.
+ * **Polish**
+  * JSX output is now more inline with the official JSX transformer.
+  * Hoist block scoping IIFE - this improves memory usage and performance.
+  * Better IIFE detection - references are now checked to see if they're referencing the binding we're searching for.
+  * Check for import reassignments in constants transformer.
+  * Make method definitions with expression bodies illegal.
+  * Save register cache on tick instead of `SIGINT`.
+  * Enable strict mode on babel-node eval flag.
+ * **Bug Fixes**
+  * Add support for live bindings. This change also increases the reliablity of export specifier renaming.
+  * Add support for super update and non equals assignment expressions.
+  * Rename shadow constructor binding in classes.
+  * Seed next iteration bindings with previous fresh bindings when reassinging loop block scoped variables.
+  * Fix new expression spread referencing the wrong constructor.
+  * Call `resolveModuleSource` on dynamic imports.
+  * Added `param` to list of duplicate declaration kinds.
+ * **Breaking Changes**
+  * The Babel playground has been removed.
+  * ES7 Abstract References have been removed.
+  * Experimental option has been removed in favor of a stage option.
+  * Rename `returnUsedHelpers` to `metadataUsedHelpers`.
+
 ## 4.7.16
 
  * **Bug Fix**

CONTRIBUTING.md

@@ -20,7 +20,7 @@ Then you need to run:
 $ make watch-core
 ```
 
-This will compile babel and then sit in the background and on file modification
+This will compile Babel and then sit in the background and on file modification
 recompile the necessary files.
 
 #### Running tests
@@ -31,8 +31,6 @@ You can run tests via:
 $ make test
 ```
 
-This will usually take around two minutes as it's compiling the entire
-[test262](https://github.com/tc39/test262) test suite and validating its AST.
 This is mostly overkill and you can limit the tests to a select few by directly
 running them with `mocha`:
 

Makefile

@@ -1,3 +1,4 @@
+MAKEFLAGS = -j1
 BROWSERIFY_CMD = node_modules/browserify/bin/cmd.js
 ISTANBUL_CMD = node_modules/istanbul/lib/cli.js cover
 UGLIFY_CMD = node_modules/uglify-js/bin/uglifyjs
@@ -31,13 +32,13 @@ build:
 	node $(BROWSERIFY_CMD) lib/babel/api/browser.js -s babel >dist/babel.js
 	node $(UGLIFY_CMD) dist/babel.js >dist/babel.min.js
 
-	node bin/babel-external-helpers >dist/external-helpers.js
+	node packages/babel-cli/bin/babel-external-helpers >dist/external-helpers.js
 	node $(UGLIFY_CMD) dist/external-helpers.js >dist/external-helpers.min.js
 
 	rm -rf templates.json
 
 clean:
-	rm -rf coverage templates.json test/tmp dist
+	rm -rf coverage templates.json test/tmp dist lib
 
 test-clean:
 	rm -rf test/tmp
@@ -86,11 +87,11 @@ publish:
 	node tools/cache-templates
 	test -f templates.json
 
-	npm publish --tag beta
+	npm publish
 
 	git push --follow-tags
 
-	make publish-core
+	make publish-cli
 	make publish-runtime
 
 	rm -rf templates.json browser.js browser-polyfill.js external-helpers.js
@@ -99,20 +100,18 @@ publish-runtime:
 	cd packages; \
 	node build-runtime.js; \
 	cd babel-runtime; \
-	npm publish --tag beta
+	npm publish
 
-publish-core:
-	tools/generate-core-package-json >package2.json
-	mv package.json .package.json
-	mv package2.json package.json
-
-	npm publish --tag beta
-
-	rm -rf package.json
-	mv .package.json package.json
+publish-cli:
+	cd packages; \
+	node build-cli.js; \
+	cd babel-cli; \
+	npm publish
 
 bootstrap:
 	npm install
+	npm link
+	cd packages/babel-cli && npm install && npm link
 	git submodule update --init
 	cd vendor/regenerator && npm install
 	cd vendor/compat-table && npm install object-assign

README.md

@@ -5,11 +5,11 @@
 </p>
 
 <p align="center">
-  <strong>Babel</strong> is a transpiler for writing next generation JavaScript.
+  <strong>Babel</strong> is a compiler for writing next generation JavaScript.
 </p>
 
 <p align="center">
-  For questions and support please visit the <a href="https://gitter.im/babel/babel">gitter room</a> before creating an issue.
+  For questions and support please visit the <a href="https://gitter.im/babel/babel">gitter room</a> or <a href="stackoverflow.com">StackOverflow</a>. The Babel issue tracker is <strong>exclusively</strong> for bug reports and future requests.
 </p>
 
 <p align="center">

bin/deprecated/6to5

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

bin/deprecated/6to5-node

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

bin/deprecated/6to5-runtime

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

package.json

@@ -1,23 +1,14 @@
 {
-  "name": "babel",
+  "name": "babel-core",
   "description": "Turn ES6 code into readable vanilla ES5 with source maps",
-  "version": "5.0.0-beta2",
+  "version": "5.0.2",
   "author": "Sebastian McKenzie <sebmck@gmail.com>",
   "homepage": "https://babeljs.io/",
   "repository": "babel/babel",
-  "preferGlobal": true,
   "main": "lib/babel/api/node.js",
   "browser": {
     "./lib/babel/api/register/node.js": "./lib/babel/api/register/browser.js"
   },
-  "bin": {
-    "6to5": "./bin/deprecated/6to5",
-    "6to5-node": "./bin/deprecated/6to5-node",
-    "6to5-runtime": "./bin/deprecated/6to5-runtime",
-    "babel": "./bin/babel/index.js",
-    "babel-node": "./bin/babel-node",
-    "babel-external-helpers": "./bin/babel-external-helpers"
-  },
   "keywords": [
     "harmony",
     "classes",
@@ -38,10 +29,8 @@
   "dependencies": {
     "ast-types": "~0.7.0",
     "chalk": "^1.0.0",
-    "chokidar": "^0.12.6",
-    "commander": "^2.6.0",
     "convert-source-map": "^0.5.0",
-    "core-js": "^0.6.1",
+    "core-js": "^0.8.0",
     "debug": "^2.1.1",
     "detect-indent": "^3.0.0",
     "estraverse": "^1.9.1",

packages/README.md

@@ -1,6 +0,0 @@
-# What is this?
-
-This is a folder containing additional packages that are built whenever
-a new version of babel is released.
-
-**TODO:** Move `babel-core` into here.

packages/babel-cli/bin/_babel-node

@@ -3,10 +3,10 @@
 var pathIsAbsolute = require("path-is-absolute");
 var commander      = require("commander");
 var Module         = require("module");
-var babel          = require("../lib/babel/api/node");
+var babel          = require("babel-core");
 var path           = require("path");
 var repl           = require("repl");
-var util           = require("../lib/babel/util");
+var util           = require("babel-core").util;
 var vm             = require("vm");
 var _              = require("lodash");
 
@@ -16,7 +16,7 @@ program.option("-e, --eval [script]", "Evaluate script");
 program.option("-p, --print [code]", "Evaluate script and print result");
 program.option("-i, --ignore [regex]", "Ignore all files that match this regex when using the require hook");
 program.option("-x, --extensions [extensions]", "List of extensions to hook into [.es6,.js,.es,.jsx]");
-program.option("-r, --experimental", "Enable experimental support for proposed ES7 features");
+program.option("-r, --stage [stage]", "Enable support for specific ECMAScript stages");
 program.option("-w, --whitelist [whitelist]", "Whitelist of transformers to ONLY use", util.list);
 program.option("-b, --blacklist [blacklist]", "Blacklist of transformers to NOT use", util.list);
 program.option("-o, --optional [optional]", "List of optional transformers to enable", util.list);
@@ -29,12 +29,12 @@ program.parse(process.argv);
 //
 
 babel.register({
-  experimental: program.experimental,
   extensions:   program.extensions,
   blacklist:    program.blacklist,
   whitelist:    program.whitelist,
   optional:     program.optional,
-  ignore:       program.ignore
+  ignore:       program.ignore,
+  stage:        program.stage,
 });
 
 //
@@ -47,7 +47,7 @@ var _eval = function (code, filename) {
     blacklist: program.blacklist,
     whitelist: program.whitelist,
     optional: program.optional,
-    experimental: program.experimental
+    stage: program.stage
   }).code;
 
   return vm.runInThisContext(code, {

packages/babel-cli/bin/babel-external-helpers

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 var commander = require("commander");
-var util      = require("../lib/babel/util");
-var runtime   = require("../lib/babel/tools/build-external-helpers");
+var util      = require("babel-core").util;
+var runtime   = require("babel-core").buildExternalHelpers;
 
 commander.option("-l, --whitelist [whitelist]", "Whitelist of helpers to ONLY include", util.list);
 commander.option("-t, --output-type [type]", "Type of output (global|umd|var)", "global");

packages/babel-cli/bin/babel/index.js

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
 
 var commander = require("commander");
-var transform = require("../../lib/babel/transformation");
+var transform = require("babel-core").transform;
 var kebabCase = require("lodash/string/kebabCase");
-var File      = require("../../lib/babel/transformation/file");
-var util      = require("../../lib/babel/util");
+var options   = require("babel-core").options;
+var util      = require("babel-core").util;
 var each      = require("lodash/collection/each");
 var keys      = require("lodash/object/keys");
 var fs        = require("fs");
 
-each(File.options, function (option, key) {
+each(options, function (option, key) {
   if (option.hidden) return;
 
   var arg = kebabCase(key);
@@ -19,7 +19,7 @@ each(File.options, function (option, key) {
   }
 
   if (option.type === "boolean" && option.default === true) {
-    arg = "no-" + key;
+    arg = "no-" + arg;
   }
 
   arg = "--" + arg;
@@ -28,7 +28,11 @@ each(File.options, function (option, key) {
     arg = "-" + option.shorthand + ", " + arg;
   }
 
-  commander.option(arg, option.description);
+  var desc = [];
+  if (option.deprecated) desc.push("[DEPRECATED] " + option.deprecated);
+  if (option.description) desc.push(option.description);
+
+  commander.option(arg, desc.join(" "));
 })
 
 commander.option("-w, --watch", "Recompile files on changes");
@@ -100,7 +104,7 @@ if (errors.length) {
 
 exports.opts = {};
 
-each(File.options, function (opt, key) {
+each(options, function (opt, key) {
   exports.opts[key] = commander[key];
 });
 

packages/babel-cli/bin/babel/util.js

@@ -1,7 +1,7 @@
 var readdir = require("fs-readdir-recursive");
 var index   = require("./index");
-var babel   = require("../../lib/babel/api/node");
-var util    = require("../../lib/babel/util");
+var babel   = require("babel-core");
+var util    = require("babel-core").util;
 var path    = require("path");
 var fs      = require("fs");
 var _       = require("lodash");

packages/babel-cli/index.js

@@ -0,0 +1 @@
+module.exports = require("babel-core");

packages/babel-cli/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "babel",
+  "description": "Turn ES6 code into readable vanilla ES5 with source maps",
+  "version": "5.0.1",
+  "author": "Sebastian McKenzie <sebmck@gmail.com>",
+  "homepage": "https://babeljs.io/",
+  "repository": "babel/babel",
+  "preferGlobal": true,
+  "dependencies": {
+    "chokidar": "^0.12.6",
+    "babel-core": "^5.0.1",
+    "commander": "^2.6.0",
+    "fs-readdir-recursive": "^0.1.0",
+    "output-file-sync": "^1.1.0",
+    "lodash": "^3.2.0",
+    "convert-source-map": "^0.5.0",
+    "source-map": "^0.4.0",
+    "path-is-absolute": "^1.0.0"
+  },
+  "bin": {
+    "babel": "./bin/babel/index.js",
+    "babel-node": "./bin/babel-node",
+    "babel-external-helpers": "./bin/babel-external-helpers"
+  }
+}

packages/babel-cli/polyfill.js

@@ -0,0 +1 @@
+module.exports = require("babel-core/polyfill");

packages/babel-cli/register.js

@@ -0,0 +1 @@
+module.exports = require("babel-core/register");

packages/babel-runtime/core-js.js

@@ -0,0 +1,4 @@
+module.exports = {
+  "default": require("core-js/library"),
+  __esModule: true
+};

packages/babel-runtime/package.json

@@ -1,10 +1,10 @@
 {
   "name": "babel-runtime",
   "description": "babel selfContained runtime",
-  "version": "5.0.0-beta1",
+  "version": "5.0.1",
   "repository": "babel/babel",
   "author": "Sebastian McKenzie <sebmck@gmail.com>",
   "dependencies": {
-    "core-js": "^0.6.1"
+    "core-js": "^0.8.0"
   }
 }

packages/build-cli.js

@@ -0,0 +1,11 @@
+var outputFile = require("output-file-sync");
+
+var pkgLoc = __dirname + "/babel-cli/package.json";
+var pkg    = require(pkgLoc);
+
+var mainPkg = require("../package.json");
+
+pkg.version = mainPkg.version;
+pkg.dependencies["babel-core"] = "^" + mainPkg.version;
+
+outputFile(pkgLoc, JSON.stringify(pkg, null, 2));

packages/build-runtime.js

@@ -1,24 +1,19 @@
 "use strict";
 
-var transform = require("../lib/babel/transformation");
-var each      = require("lodash/collection/each");
-var File      = require("../lib/babel/transformation/file");
-var util      = require("../lib/babel/util");
-var fs        = require("fs");
-var t         = require("../lib/babel/types");
-var _         = require("lodash");
+var outputFile = require("output-file-sync");
+var transform  = require("../lib/babel/transformation");
+var each       = require("lodash/collection/each");
+var File       = require("../lib/babel/transformation/file");
+var util       = require("../lib/babel/util");
+var fs         = require("fs");
+var t          = require("../lib/babel/types");
+var _          = require("lodash");
 
-var relative = function (filename) {
+function relative(filename) {
   return __dirname + "/babel-runtime/" + filename;
-};
+}
 
-var writeFile = function (filename, content) {
-  filename = relative(filename);
-  console.log(filename);
-  fs.writeFileSync(filename, content);
-};
-
-var readFile = function (filename, defaultify) {
+function readFile(filename, defaultify) {
   var file = fs.readFileSync(require.resolve(filename), "utf8");
 
   if (defaultify) {
@@ -26,25 +21,36 @@ var readFile = function (filename, defaultify) {
   }
 
   return file;
-};
+}
 
-var updatePackage = function () {
+function updatePackage() {
   var pkgLoc = relative("package.json");
   var pkg    = require(pkgLoc);
 
   var mainPkg = require("../package.json");
   pkg.version = mainPkg.version;
 
-  writeFile("package.json", JSON.stringify(pkg, null, 2));
-};
+  writeRootFile("package.json", JSON.stringify(pkg, null, 2));
+}
 
-var selfContainify = function (code) {
+function writeRootFile(filename, content) {
+  filename = relative(filename);
+  console.log(filename);
+  outputFile(filename, content);
+}
+
+
+function writeFile(filename, content) {
+  return writeRootFile(filename, content);
+}
+
+function selfContainify(code) {
   return transform(code, {
     optional: ["runtime"]
   }).code;
-};
+}
 
-var buildHelper = function (helperName) {
+function buildHelper(helperName) {
   var tree = t.program(
     util.template("self-contained-helpers-head", {
       HELPER: util.template("helper-" + helperName)
@@ -54,13 +60,13 @@ var buildHelper = function (helperName) {
   return transform.fromAst(tree, null, {
     optional: ["runtime"]
   }).code;
-};
+}
 
 each(File.helpers, function (helperName) {
   writeFile("helpers/" + helperName + ".js", buildHelper(helperName));
 });
 
-writeFile("core-js.js", readFile("core-js/library", true));
 writeFile("regenerator/index.js", readFile("regenerator-babel/runtime-module", true));
 writeFile("regenerator/runtime.js", selfContainify(readFile("regenerator-babel/runtime")));
+
 updatePackage();

src/acorn/plugins/flow.js

@@ -215,6 +215,7 @@ pp.flow_parseObjectTypeIndexer = function (node, isStatic) {
   this.expect(tt.colon)
   node.value = this.flow_parseType()
 
+  this.flow_objectTypeSemicolon()
   return this.finishNode(node, "ObjectTypeIndexer")
 }
 
@@ -251,6 +252,7 @@ pp.flow_parseObjectTypeMethod = function (start, isStatic, key) {
   node.static = isStatic
   node.key = key
   node.optional = false
+  this.flow_objectTypeSemicolon()
   return this.finishNode(node, "ObjectTypeProperty")
 }
 
@@ -258,6 +260,7 @@ pp.flow_parseObjectTypeCallProperty = function (node, isStatic) {
   var valueNode = this.startNode()
   node.static = isStatic
   node.value = this.flow_parseObjectTypeMethodish(valueNode)
+    this.flow_objectTypeSemicolon()
   return this.finishNode(node, "ObjectTypeCallProperty")
 }
 
@@ -307,13 +310,10 @@ pp.flow_parseObjectType = function (allowStatic) {
         node.value = this.flow_parseType()
         node.optional = optional
         node.static = isStatic
+        this.flow_objectTypeSemicolon()
         nodeStart.properties.push(this.finishNode(node, "ObjectTypeProperty"))
       }
     }
-
-    if (!this.eat(tt.semi) && this.type !== tt.braceR) {
-      this.unexpected()
-    }
   }
 
   this.expect(tt.braceR)
@@ -321,6 +321,12 @@ pp.flow_parseObjectType = function (allowStatic) {
   return this.finishNode(nodeStart, "ObjectTypeAnnotation")
 }
 
+pp.flow_objectTypeSemicolon = function () {
+  if (!this.eat(tt.semi) && this.type !== tt.braceR) {
+    this.unexpected()
+  }
+}
+
 pp.flow_parseGenericType = function (start, id) {
   var node = this.startNodeAt(start)
 

src/acorn/src/expression.js

@@ -272,11 +272,13 @@ pp.parseExprAtom = function(refShorthandDefaultPos) {
         // arrow functions
         if (this.type === tt.parenL) {
           let expr = this.parseParenAndDistinguishExpression(start, true)
-          if (expr.type === "ArrowFunctionExpression") {
+          if (expr && expr.type === "ArrowFunctionExpression") {
             return expr
           } else {
             node.callee = id
-            if (expr.type === "SequenceExpression") {
+            if (!expr) {
+              node.arguments = []
+            } else if (expr.type === "SequenceExpression") {
               node.arguments = expr.expressions
             } else {
               node.arguments = [expr]
@@ -410,7 +412,13 @@ pp.parseParenAndDistinguishExpression = function(start, isAsync) {
       return this.parseParenArrowList(start, exprList, isAsync)
     }
 
-    if (!exprList.length) this.unexpected(this.lastTokStart)
+    if (!exprList.length) {
+      if (isAsync) {
+        return
+      } else {
+        this.unexpected(this.lastTokStart)
+      }
+    }
     if (spreadStart) this.unexpected(spreadStart)
     if (refShorthandDefaultPos.start) this.unexpected(refShorthandDefaultPos.start)
 

src/acorn/src/statement.js

@@ -474,7 +474,7 @@ pp.parseClass = function(node, isStatement) {
   while (!this.eat(tt.braceR)) {
     if (this.eat(tt.semi)) continue
     if (this.type === tt.at) {
-      this.parseDecorator()
+      this.decorators.push(this.parseDecorator())
       continue;
     }
     var method = this.startNode()
@@ -558,14 +558,34 @@ pp.parseClassSuper = function(node) {
 pp.parseExport = function(node) {
   this.next()
   // export * from '...'
-  if (this.eat(tt.star)) {
-    this.expectContextual("from")
-    node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected()
-    this.semicolon()
-    this.checkExport(node)
-    return this.finishNode(node, "ExportAllDeclaration")
-  }
-  if (this.eat(tt._default)) { // export default ...
+  if (this.type === tt.star) {
+    let specifier = this.startNode()
+    this.next()
+    if (this.options.features["es7.exportExtensions"] && this.eatContextual("as")) {
+      specifier.exported = this.parseIdent()
+      node.specifiers = [this.finishNode(specifier, "ExportNamespaceSpecifier")]
+      this.parseExportSpecifiersMaybe(node)
+      this.parseExportFrom(node)
+    } else {
+      this.parseExportFrom(node)
+      return this.finishNode(node, "ExportAllDeclaration")
+    }
+  } else if (this.isExportDefaultSpecifier()) {
+    let specifier = this.startNode()
+    specifier.exported = this.parseIdent(true)
+    node.specifiers = [this.finishNode(specifier, "ExportDefaultSpecifier")]
+    if (this.type === tt.comma && this.lookahead().type === tt.star) {
+      this.expect(tt.comma)
+      let specifier = this.startNode()
+      this.expect(tt.star)
+      this.expectContextual("as")
+      specifier.exported = this.parseIdent()
+      node.specifiers.push(this.finishNode(specifier, "ExportNamespaceSpecifier"))
+    } else {
+      this.parseExportSpecifiersMaybe(node)
+    }
+    this.parseExportFrom(node)
+  } else if (this.eat(tt._default)) { // export default ...
     let expr = this.parseMaybeAssign()
     let needsSemi = true
     if (expr.type == "FunctionExpression" ||
@@ -581,9 +601,7 @@ pp.parseExport = function(node) {
     if (needsSemi) this.semicolon()
     this.checkExport(node)
     return this.finishNode(node, "ExportDefaultDeclaration")
-  }
-  // export var|const|let|function|class ...
-  if (this.type.keyword || this.shouldParseExportDeclaration()) {
+  } else if (this.type.keyword || this.shouldParseExportDeclaration()) {
     node.declaration = this.parseStatement(true)
     node.specifiers = []
     node.source = null
@@ -601,6 +619,32 @@ pp.parseExport = function(node) {
   return this.finishNode(node, "ExportNamedDeclaration")
 }
 
+pp.isExportDefaultSpecifier = function () {
+  if (this.type === tt.name) {
+    return this.value !== "type" && this.value !== "async"
+  }
+
+  if (this.type !== tt._default) {
+    return false
+  }
+
+  var lookahead = this.lookahead()
+  return lookahead.type === tt.comma || (lookahead.type === tt.name && lookahead.value === "from")
+}
+
+pp.parseExportSpecifiersMaybe = function (node) {
+  if (this.eat(tt.comma)) {
+    node.specifiers = node.specifiers.concat(this.parseExportSpecifiers())
+  }
+}
+
+pp.parseExportFrom = function(node) {
+  this.expectContextual("from")
+  node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected()
+  this.semicolon()
+  this.checkExport(node)
+}
+
 pp.shouldParseExportDeclaration = function() {
   return this.options.features["es7.asyncFunctions"] && this.isContextual("async")
 }

src/babel/api/browser.js

@@ -1,5 +1,6 @@
 var transform = module.exports = require("../transformation");
 
+transform.options = require("../transformation/file/options");
 transform.version = require("../../../package").version;
 
 transform.transform = transform;

src/babel/api/node.js

@@ -4,10 +4,10 @@ import * as acorn from "../../acorn";
 import * as util from "../util";
 import fs from "fs";
 
-export { util };
+export { util, acorn };
 export { canCompile } from "../util";
 
-export { acorn } from "../../acorn";
+export { default as options } from "../transformation/file/options";
 export { default as Transformer } from "../transformation/transformer";
 export { default as transform } from "../transformation";
 export { default as traverse } from "../traversal";

src/babel/api/register/cache.js

@@ -2,7 +2,11 @@ import path from "path";
 import os from "os";
 import fs from "fs";
 
-const FILENAME = process.env.BABEL_CACHE_PATH || path.join(os.tmpdir(), "babel.json");
+function getUserHome() {
+  return process.env.HOME || process.env.HOMEPATH || process.env.USERPROFILE;
+}
+
+const FILENAME = process.env.BABEL_CACHE_PATH || path.join(getUserHome() || os.tmpdir(), ".babel.json");
 var data = {};
 
 export function save() {

src/babel/api/register/node.js

@@ -161,7 +161,7 @@ export default function (opts = {}) {
 
 try {
   var runtimePackage = require("babel-runtime/package");
-  var version = require("../../package").version;
+  var version = require("../../../../package").version;
   if (runtimePackage.version !== version) {
     throw new ReferenceError(`The verison of babel-runtime of ${runtimePackage.runtime} that you have installed does not match the babel verison of ${version}`);
   }

src/babel/generation/generators/classes.js

@@ -1,8 +1,5 @@
 export function ClassDeclaration(node, print) {
-  if (node.decorators && node.decorators.length) {
-    print.list(node.decorators);
-  }
-
+  print.list(node.decorators);
   this.push("class");
 
   if (node.id) {
@@ -44,10 +41,24 @@ export function ClassBody(node, print) {
   }
 }
 
-export function MethodDefinition(node, print) {
-  if (node.decorators && node.decorators.length) {
-    print.list(node.decorators);
+
+export function ClassProperty(node, print) {
+  print.list(node.decorators);
+
+  if (node.static) this.push("static ");
+  print(node.key);
+  print(node.typeAnnotation);
+  if (node.value) {
+    this.space();
+    this.push("=");
+    this.space();
+    print(node.value);
   }
+  this.semicolon();
+}
+
+export function MethodDefinition(node, print) {
+  print.list(node.decorators);
 
   if (node.static) {
     this.push("static ");

src/babel/generation/generators/flow.js

@@ -14,13 +14,6 @@ export function BooleanTypeAnnotation(node) {
   this.push("bool");
 }
 
-export function ClassProperty(node, print) {
-  if (node.static) this.push("static ");
-  print(node.key);
-  print(node.typeAnnotation);
-  this.semicolon();
-}
-
 export function DeclareClass(node, print) {
   this.push("declare class ");
   this._interfaceish(node, print);
@@ -167,11 +160,24 @@ export { TypeParameterInstantiation as TypeParameterDeclaration };
 export function ObjectTypeAnnotation(node, print) {
   this.push("{");
   var props = node.properties.concat(node.callProperties, node.indexers);
+
   if (props.length) {
     this.space();
-    print.list(props, { indent: true, separator: "; " });
+
+    print.list(props, {
+      separator: false,
+      indent: true,
+      iterator: () => {
+        if (props.length !== 1) {
+          this.semicolon();
+          this.space();
+        }
+      }
+    });
+
     this.space();
   }
+
   this.push("}");
 }
 

src/babel/generation/generators/modules.js

@@ -13,6 +13,10 @@ export function ImportDefaultSpecifier(node, print) {
   print(node.local);
 }
 
+export function ExportDefaultSpecifier(node, print) {
+  print(node.exported);
+}
+
 export function ExportSpecifier(node, print) {
   print(node.local);
   if (node.exported && node.local !== node.exported) {
@@ -21,8 +25,18 @@ export function ExportSpecifier(node, print) {
   }
 }
 
+export function ExportNamespaceSpecifier(node, print) {
+  this.push("* as ");
+  print(node.exported);
+}
+
 export function ExportAllDeclaration(node, print) {
-  this.push("export * from ");
+  this.push("export *");
+  if (node.exported) {
+    this.push(" as ");
+    print(node.exported);
+  }
+  this.push(" from ");
   print(node.source);
   this.semicolon();
 }
@@ -41,16 +55,29 @@ function ExportDeclaration(node, print) {
   var specifiers = node.specifiers;
 
   if (node.declaration) {
-    print(node.declaration);
-    if (t.isStatement(node.declaration)) return;
+    var declar = node.declaration;
+    print(declar);
+    if (t.isStatement(declar) || t.isFunction(declar) || t.isClass(declar)) return;
   } else {
-    this.push("{");
-    if (specifiers.length) {
-      this.space();
-      print.join(specifiers, { separator: ", " });
-      this.space();
+    var first = specifiers[0];
+    var hasSpecial = false;
+    if (t.isExportDefaultSpecifier(first) || t.isExportNamespaceSpecifier(first)) {
+      hasSpecial = true;
+      print(specifiers.shift());
+      if (specifiers.length) {
+        this.push(", ");
+      }
+    }
+
+    if (specifiers.length || (!specifiers.length && !hasSpecial)) {
+      this.push("{");
+      if (specifiers.length) {
+        this.space();
+        print.join(specifiers, { separator: ", " });
+        this.space();
+      }
+      this.push("}");
     }
-    this.push("}");
 
     if (node.source) {
       this.push(" from ");
@@ -70,25 +97,20 @@ export function ImportDeclaration(node, print) {
 
   var specfiers = node.specifiers;
   if (specfiers && specfiers.length) {
-    var foundImportSpecifier = false;
-
-    for (var i = 0; i < node.specifiers.length; i++) {
-      var spec = node.specifiers[i];
-
-      if (i > 0) {
+    var first = node.specifiers[0];
+    if (t.isImportDefaultSpecifier(first) || t.isImportNamespaceSpecifier(first)) {
+      print(node.specifiers.shift());
+      if (node.specifiers.length) {
         this.push(", ");
       }
-
-      if (!t.isImportDefaultSpecifier(spec) && !t.isImportNamespaceSpecifier(spec) && !foundImportSpecifier) {
-        foundImportSpecifier = true;
-        this.push("{ ");
-      }
-
-      print(spec);
     }
 
-    if (foundImportSpecifier) {
-      this.push(" }");
+    if (node.specifiers.length) {
+      this.push("{");
+      this.space()
+      print.join(node.specifiers, { separator: ", " });
+      this.space()
+      this.push("}");
     }
 
     this.push(" from ");

src/babel/generation/generators/statements.js

@@ -199,9 +199,11 @@ export function VariableDeclaration(node, print, parent) {
 
   print.list(node.declarations, { separator: sep });
 
-  if (!t.isFor(parent)) {
-    this.semicolon();
+  if (t.isFor(parent)) {
+    if (parent.left === node || parent.init === node) return;
   }
+
+  this.semicolon();
 }
 
 export function VariableDeclarator(node, print) {

src/babel/generation/generators/types.js

@@ -99,5 +99,12 @@ export function _stringLiteral(val) {
     return "\\u" + ("0000" + c.charCodeAt(0).toString(16)).slice(-4);
   });
 
+  if (this.format.quotes === "single") {
+    val = val.slice(1, -1);
+    val = val.replace(/\\"/g, '"');
+    val = val.replace(/'/g, "\\'");
+    val = `'${val}'`;
+  }
+
   this.push(val);
 }

src/babel/generation/index.js

@@ -16,7 +16,7 @@ class CodeGenerator {
 
     this.comments = ast.comments || [];
     this.tokens   = ast.tokens || [];
-    this.format   = CodeGenerator.normalizeOptions(code, opts);
+    this.format   = CodeGenerator.normalizeOptions(code, opts, this.tokens);
     this.opts     = opts;
     this.ast      = ast;
 
@@ -26,7 +26,7 @@ class CodeGenerator {
     this.buffer     = new Buffer(this.position, this.format);
   }
 
-  static normalizeOptions(code, opts) {
+  static normalizeOptions(code, opts, tokens) {
     var style = "  ";
     if (code) {
       var indent = detectIndent(code).indent;
@@ -36,6 +36,7 @@ class CodeGenerator {
     var format = {
       comments: opts.comments == null || opts.comments,
       compact: opts.compact,
+      quotes: CodeGenerator.findCommonStringDelimeter(code, tokens),
       indent: {
         adjustMultilineComment: true,
         style: style,
@@ -54,6 +55,36 @@ class CodeGenerator {
     return format;
   }
 
+  static findCommonStringDelimeter(code, tokens) {
+    var occurences = {
+      single: 0,
+      double: 0
+    };
+
+    var checked = 0;
+
+    for (var i = 0; i < tokens.length; i++) {
+      var token = tokens[i];
+      if (token.type.label !== "string") continue;
+      if (checked >= 3) continue;
+
+      var raw = code.slice(token.start, token.end);
+      if (raw[0] === "'") {
+        occurences.single++;
+      } else {
+        occurences.double++;
+      }
+
+      checked++;
+    }
+
+    if (occurences.single > occurences.double) {
+      return "single";
+    } else {
+      return "double";
+    }
+  }
+
   static generators = {
     templateLiterals: require("./generators/template-literals"),
     comprehensions:   require("./generators/comprehensions"),
@@ -100,7 +131,7 @@ class CodeGenerator {
     };
 
     print.list = function (items, opts = {}) {
-      opts.separator ||= ", ";
+      if (opts.separator == null) opts.separator = ", ";
       print.join(items, opts);
     };
 

src/babel/helpers/parse.js

@@ -22,8 +22,10 @@ export default function (opts, code, callback) {
       ranges:                      true
     };
 
-    parseOpts.plugins.jsx = true;
-    parseOpts.plugins.flow = true;
+    if (opts.nonStandard) {
+      parseOpts.plugins.jsx = true;
+      parseOpts.plugins.flow = true;
+    }
 
     var ast = acorn.parse(code, parseOpts);
 

src/babel/messages.js

@@ -21,7 +21,8 @@ export const MESSAGES = {
   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.",
   missingTemplatesDirectory: "no templates directory - this is most likely the result of a broken `npm publish`. Please report to https://github.com/babel/babel/issues",
-  unsupportedOutputType: "Unsupported output type $1"
+  unsupportedOutputType: "Unsupported output type $1",
+  illegalMethodName: "Illegal method name $1"
 };
 
 export function get(key: String, ...args) {

src/babel/patch.js

@@ -28,6 +28,11 @@ def("RestElement")
   .build("argument")
   .field("argument", def("expression"));
 
+def("DoExpression")
+  .bases("Expression")
+  .build("body")
+  .field("body", [def("Statement")]);
+
 def("ExportDefaultDeclaration")
   .bases("Declaration")
   .build("declaration")

src/babel/tools/build-external-helpers.js

@@ -50,9 +50,9 @@ function buildVar(namespace, builder) {
   return t.program(body);
 }
 
-function buildHelpers(body, namespace, whitelist = []) {
+function buildHelpers(body, namespace, whitelist) {
   each(File.helpers, function (name) {
-    if (whitelist.length && whitelist.indexOf(name) === -1) return;
+    if (whitelist && whitelist.indexOf(name) === -1) return;
 
     var key = t.identifier(t.toIdentifier(name));
     body.push(t.expressionStatement(

src/babel/transformation/file/index.js

@@ -80,7 +80,8 @@ export default class File {
     "object-destructuring-empty",
     "temporal-undefined",
     "temporal-assert-defined",
-    "self-global"
+    "self-global",
+    "default-props"
   ];
 
   static options = require("./options");
@@ -106,6 +107,11 @@ export default class File {
 
       var val = opts[key];
       if (!val && option.optional) continue;
+
+      if (val && option.deprecated) {
+        throw new Error("Deprecated option " + key + ": " + option.deprecated);
+      }
+
       if (val == null) val = option.default || val;
 
       var optionParser = optionParsers[option.type];
@@ -167,20 +173,15 @@ export default class File {
     return includes(this.opts.loose, key);
   }
 
-  buildPlugins(stack) {
-
-  }
-
   buildTransformers() {
     var file = this;
 
-    var transformers = {};
+    var transformers = this.transformers = {};
 
     var secondaryStack = [];
     var stack = [];
 
-    this.buildPlugins(stack);
-
+    // build internal transformers
     each(transform.transformers, function (transformer, key) {
       var pass = transformers[key] = transformer.buildPass(file);
 
@@ -197,15 +198,23 @@ export default class File {
       }
     });
 
+    // init plugins!
+    var beforePlugins = [];
+    var afterPlugins = [];
+    for (var i = 0; i < file.opts.plugins.length; i++) {
+      this.addPlugin(file.opts.plugins[i], beforePlugins, afterPlugins);
+    }
+    stack = beforePlugins.concat(stack, afterPlugins);
+
+    // register
     this.transformerStack = stack.concat(secondaryStack);
-    this.transformers = transformers;
   }
 
   getModuleFormatter(type: string) {
     var ModuleFormatter = isFunction(type) ? type : transform.moduleFormatters[type];
 
     if (!ModuleFormatter) {
-      var loc = util.resolve(type);
+      var loc = util.resolveRelative(type);
       if (loc) ModuleFormatter = require(loc);
     }
 
@@ -216,6 +225,57 @@ export default class File {
     return new ModuleFormatter(this);
   }
 
+  addPlugin(name, before, after) {
+    var position = "before";
+    var plugin;
+
+    if (name) {
+      if (typeof name === "string") {
+        // this is a plugin in the form of "foobar" or "foobar:after"
+        // where the optional colon is the delimiter for plugin position in the transformer stack
+
+        [name, position = "before"] = name.split(":");
+
+        var loc = util.resolveRelative(name) || util.resolveRelative(`babel-plugin-${name}`);
+        if (loc) {
+          plugin = require(loc)
+        } else {
+          throw new ReferenceError(`Unknown plugin ${JSON.stringify(name)}`);
+        }
+      } else {
+        // not a string so we'll just assume that it's a direct Transformer instance, if not then
+        // the checks later on will complain
+        plugin = name;
+      }
+    } else {
+      throw new TypeError(`Ilegal kind ${typeof name} for plugin name ${JSON.stringify(name)}`);
+    }
+
+    // validate position
+    if (position !== "before" && position !== "after") {
+      throw new TypeError(`Plugin ${JSON.stringify(name)} has an illegal position of ${JSON.stringify(position)}`);
+    }
+
+    // validate transformer key
+    var key = plugin.key;
+    if (this.transformers[key]) {
+      throw new ReferenceError(`The key for plugin ${JSON.stringify(name)} of ${key} collides with an existing plugin`);
+    }
+
+    // validate Transformer instance
+    if (!plugin.buildPass || plugin.constructor.name !== "Transformer") {
+      throw new TypeError(`Plugin ${JSON.stringify(name)} didn't export default a Transformer instance`);
+    }
+
+    // build!
+    var pass = this.transformers[key] = plugin.buildPass(this);
+    if (pass.canTransform()) {
+      var stack = before;
+      if (position === "after") stack = after;
+      stack.push(pass);
+    }
+  }
+
   parseInputSourceMap(code: string) {
     var opts = this.opts;
 
@@ -286,6 +346,7 @@ export default class File {
 
       if (this.transformers["es6.modules"].canTransform()) {
         this.moduleFormatter.importSpecifier(specifiers[0], declar, this.dynamicImports);
+        this.moduleFormatter.hasLocalImports = true;
       } else {
         this.dynamicImports.push(declar);
       }
@@ -380,9 +441,10 @@ export default class File {
   parse(code: string) {
     if (this.shouldIgnore()) {
       return {
-        code: code,
-        map:  null,
-        ast:  null
+        metadata: {},
+        code:     code,
+        map:      null,
+        ast:      null
       };
     }
 
@@ -394,6 +456,7 @@ export default class File {
 
     var parseOpts = {
       highlightCode: opts.highlightCode,
+      nonStandard:   opts.nonStandard,
       filename:      opts.filename,
       plugins:       {}
     };
@@ -514,13 +577,14 @@ export default class File {
     var ast  = this.ast;
 
     var result = {
-      code: "",
-      map:  null,
-      ast:  null
+      metadata: {},
+      code:     "",
+      map:      null,
+      ast:      null
     };
 
-    if (this.opts.returnUsedHelpers) {
-      result.usedHelpers = Object.keys(this.usedHelpers);
+    if (this.opts.metadataUsedHelpers) {
+      result.metadata.usedHelpers = Object.keys(this.usedHelpers);
     }
 
     if (opts.ast) result.ast = ast;
@@ -535,7 +599,9 @@ export default class File {
       result.code = `${this.shebang}\n${result.code}`;
     }
 
-    result.map = this.mergeSourceMap(result.map);
+    if (result.map) {
+      result.map = this.mergeSourceMap(result.map);
+    }
 
     if (opts.sourceMaps === "inline" || opts.sourceMaps === "both") {
       result.code += "\n" + convertSourceMap.fromObject(result.map).toComment();

src/babel/transformation/file/option-parsers.js

@@ -11,6 +11,10 @@ export function transformerList(key, val) {
   return transform._ensureTransformerNames(key, val);
 }
 
+export function number(key, val) {
+  return +val;
+}
+
 export function boolean(key, val) {
   return !!val;
 }

src/babel/transformation/file/options.json

@@ -1,7 +1,7 @@
 {
   "filename": {
     "type": "string",
-    "description": "Filename to use when reading from stdin - this will be used in source-maps, errors etc",
+    "description": "filename to use when reading from stdin - this will be used in source-maps, errors etc",
     "default": "unknown",
     "shorthand": "f"
   },
@@ -16,11 +16,18 @@
   },
 
   "moduleId": {
-
+    "description": "specify a custom name for module ids",
+    "type": "string"
   },
 
-  "highlightTheme": {
-    "hidden": true
+  "nonStandard": {
+    "type": "boolean",
+    "default": true,
+    "description": "enable support for JSX and Flow"
+  },
+
+  "experimental": {
+    "deprecated": "use `--stage 0`/`{ stage: 0 }` instead"
   },
 
   "highlightCode": {
@@ -39,34 +46,34 @@
     "hidden": true
   },
 
-  "experimental": {
-    "description": "Enable all ES7+ transformers",
+  "stage": {
+    "description": "ECMAScript proposal stage version to allow [0-4]",
     "shorthand": "e",
-    "type": "boolean",
-    "default": false
+    "type": "number",
+    "default": 2
   },
 
   "blacklist": {
     "type": "transformerList",
-    "description": "Blacklist of transformers to NOT use",
+    "description": "blacklist of transformers to NOT use",
     "shorthand": "b"
   },
 
   "whitelist": {
     "type": "transformerList",
     "optional": true,
-    "description": "Whitelist of transformers to ONLY use",
+    "description": "whitelist of transformers to ONLY use",
     "shorthand": "l"
   },
 
   "optional": {
     "type": "transformerList",
-    "description": "List of optional transformers to enable"
+    "description": "list of optional transformers to enable"
   },
 
   "modules": {
     "type": "string",
-    "description": "Module formatter type to use [common]",
+    "description": "module formatter type to use [common]",
     "default": "common",
     "shorthand": "m"
   },
@@ -74,21 +81,36 @@
   "moduleIds": {
     "type": "boolean",
     "default": false,
-    "shorthand": "M"
+    "shorthand": "M",
+    "description": "insert an explicit id for modules"
   },
 
   "loose": {
     "type": "transformerList",
-    "description": "List of transformers to enable loose mode ON",
+    "description": "list of transformers to enable loose mode ON",
     "shorthand": "L"
   },
 
+  "jsxPragma": {
+    "type": "string",
+    "description": "custom pragma to use with JSX (same functionality as @jsx comments)",
+    "default": "React.createElement",
+    "shorthand": "P"
+  },
+
+  "plugins": {
+    "type": "list",
+    "description": ""
+  },
+
   "ignore": {
-    "type": "list"
+    "type": "list",
+    "description": "list of glob paths to **not** compile"
   },
 
   "only": {
-    "type": "list"
+    "type": "list",
+    "description": "list of glob paths to **only** compile"
   },
 
   "code": {
@@ -105,17 +127,19 @@
 
   "comments": {
     "type": "boolean",
-    "default": true
+    "default": true,
+    "description": "output comments in generated output"
   },
 
   "compact": {
-    "type": "string",
-    "default": "auto"
+    "type": "booleanString",
+    "default": "auto",
+    "description": "do not include superfluous whitespace characters and line terminators [true|false|auto]"
   },
 
   "keepModuleIdExtensions": {
     "type": "boolean",
-    "description": "Keep extensions when generating module ids",
+    "description": "keep extensions when generating module ids",
     "default": false,
     "shorthand": "k"
   },
@@ -123,16 +147,18 @@
   "auxiliaryComment": {
     "type": "string",
     "default": "",
-    "shorthand": "a"
+    "shorthand": "a",
+    "description": "attach a comment before all helper declarations and auxiliary code"
   },
 
   "externalHelpers": {
     "type": "string",
     "default": false,
-    "shorthand": "r"
+    "shorthand": "r",
+    "description": "uses a reference to `babelHelpers` instead of placing helpers at the top of your code."
   },
 
-  "returnUsedHelpers": {
+  "metadataUsedHelpers": {
     "type": "boolean",
     "default": false,
     "hidden": true
@@ -145,23 +171,28 @@
 
   "sourceMaps": {
     "type": "booleanString",
+    "description": "[true|false|inline]",
     "default": false,
     "shorthand": "s"
   },
 
   "sourceMapName": {
-    "type": "string"
+    "type": "string",
+    "description": "set `file` on returned source map"
   },
 
   "sourceFileName": {
-    "type": "string"
+    "type": "string",
+    "description": "set `sources[0]` on returned source map"
   },
 
   "sourceRoot": {
-    "type": "string"
+    "type": "string",
+    "description": "the root from which all sources are relative"
   },
 
   "moduleRoot": {
-    "type": "string"
+    "type": "string",
+    "description": "optional prefix for the AMD module formatter that will be prepend to the filename on module definitions"
   }
 }

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

@@ -144,23 +144,14 @@ export default function (exports, opts) {
   };
 
   exports.JSXElement = {
+    enter(node) {
+      node.children = react.buildChildren(node);
+    },
+
     exit(node) {
       var callExpr = node.openingElement;
 
-      for (var i = 0; i < node.children.length; i++) {
-        var child = node.children[i];
-
-        if (t.isLiteral(child) && typeof child.value === "string") {
-          cleanJSXElementLiteralChild(child, callExpr.arguments);
-          continue;
-        } else if (t.isJSXEmptyExpression(child)) {
-          continue;
-        }
-
-        callExpr.arguments.push(child);
-      }
-
-      callExpr.arguments = flatten(callExpr.arguments);
+      callExpr.arguments = callExpr.arguments.concat(node.children);
 
       if (callExpr.arguments.length >= 3) {
         callExpr._prettyCall = true;
@@ -170,69 +161,6 @@ export default function (exports, opts) {
     }
   };
 
-  var isStringLiteral = function (node) {
-    return t.isLiteral(node) && isString(node.value);
-  };
-
-  var flatten = function (args) {
-    var flattened = [];
-    var last;
-
-    for (var i = 0; i < args.length; i++) {
-      var arg = args[i];
-      if (isStringLiteral(arg) && isStringLiteral(last)) {
-        last.value += arg.value;
-      } else {
-        last = arg;
-        flattened.push(arg);
-      }
-    }
-
-    return flattened;
-  };
-
-  var cleanJSXElementLiteralChild = function (child, args) {
-    var lines = child.value.split(/\r\n|\n|\r/);
-
-    var lastNonEmptyLine = 0;
-    var i;
-
-    for (i = 0; i < lines.length; i++) {
-      if (lines[i].match(/[^ \t]/)) {
-        lastNonEmptyLine = i;
-      }
-    }
-
-    for (i = 0; i < lines.length; i++) {
-      var line = lines[i];
-
-      var isFirstLine = i === 0;
-      var isLastLine = i === lines.length - 1;
-      var isLastNonEmptyLine = i === lastNonEmptyLine;
-
-      // replace rendered whitespace tabs with spaces
-      var trimmedLine = line.replace(/\t/g, " ");
-
-      // trim whitespace touching a newline
-      if (!isFirstLine) {
-        trimmedLine = trimmedLine.replace(/^[ ]+/, "");
-      }
-
-      // trim whitespace touching an endline
-      if (!isLastLine) {
-        trimmedLine = trimmedLine.replace(/[ ]+$/, "");
-      }
-
-      if (trimmedLine) {
-        if (!isLastNonEmptyLine) {
-          trimmedLine += " ";
-        }
-
-        args.push(t.literal(trimmedLine));
-      }
-    }
-  };
-
   // display names
 
   var addDisplayName = function (id, call) {

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

@@ -25,13 +25,12 @@ var wrap = function (state, method, id, scope) {
     var template = util.template(templateName, {
       FUNCTION: method,
       FUNCTION_ID: id,
-      FUNCTION_KEY: scope.generateUidIdentifier(id.name),
-      WRAPPER_KEY: scope.generateUidIdentifier(id.name + "Wrapper")
+      FUNCTION_KEY: scope.generateUidIdentifier(id.name)
     });
 
     // shim in dummy params to retain function arity, if you try to read the
     // source then you'll get the original since it's proxied so it's all good
-    var params = template.callee.body.body[0].declarations[0].init.params;
+    var params = template.callee.body.body[0].params;
     for (var i = 0, len = getFunctionArity(method); i < len; i++) {
       params.push(scope.generateUidIdentifier("x"));
     }
@@ -55,7 +54,7 @@ var visit = function (node, name, scope) {
   // 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 = null; // todo: proper scope not being passed in es6/classes // scope.getOwnBindingInfo(name);
+  var bindingInfo = scope.getOwnBindingInfo(name);
 
   if (bindingInfo) {
     if (bindingInfo.kind === "param") {

src/babel/transformation/helpers/react.js

@@ -1,3 +1,4 @@
+import isString from "lodash/lang/isString";
 import * as t from "../../types";
 
 var isCreateClassCallExpression = t.buildMatchMemberExpression("React.createClass");
@@ -24,3 +25,73 @@ export var isReactComponent = t.buildMatchMemberExpression("React.Component");
 export function isCompatTag(tagName) {
   return tagName && /^[a-z]|\-/.test(tagName);
 }
+
+function isStringLiteral(node) {
+  return t.isLiteral(node) && isString(node.value);
+}
+
+function cleanJSXElementLiteralChild(child, args) {
+  var lines = child.value.split(/\r\n|\n|\r/);
+
+  var lastNonEmptyLine = 0;
+  var i;
+
+  for (i = 0; i < lines.length; i++) {
+    if (lines[i].match(/[^ \t]/)) {
+      lastNonEmptyLine = i;
+    }
+  }
+
+  var str = "";
+
+  for (i = 0; i < lines.length; i++) {
+    var line = lines[i];
+
+    var isFirstLine = i === 0;
+    var isLastLine = i === lines.length - 1;
+    var isLastNonEmptyLine = i === lastNonEmptyLine;
+
+    // replace rendered whitespace tabs with spaces
+    var trimmedLine = line.replace(/\t/g, " ");
+
+    // trim whitespace touching a newline
+    if (!isFirstLine) {
+      trimmedLine = trimmedLine.replace(/^[ ]+/, "");
+    }
+
+    // trim whitespace touching an endline
+    if (!isLastLine) {
+      trimmedLine = trimmedLine.replace(/[ ]+$/, "");
+    }
+
+    if (trimmedLine) {
+      if (!isLastNonEmptyLine) {
+        trimmedLine += " ";
+      }
+
+      str += trimmedLine;
+    }
+  }
+
+  if (str) args.push(t.literal(str));
+}
+
+export function buildChildren(node) {
+  var elems = [];
+
+  for (var i = 0; i < node.children.length; i++) {
+    var child = node.children[i];
+
+    if (t.isLiteral(child) && typeof child.value === "string") {
+      cleanJSXElementLiteralChild(child, elems);
+      continue;
+    }
+
+    if (t.isJSXExpressionContainer(child)) child = child.expression;
+    if (t.isJSXEmptyExpression(child)) continue;
+
+    elems.push(child);
+  }
+
+  return elems;
+}

src/babel/transformation/helpers/replace-supers.js

@@ -1,9 +1,6 @@
-module.exports = ReplaceSupers;
-
 import * as messages from "../../messages";
 import * as t from "../../types";
 
-
 function isIllegalBareSuper(node, parent) {
   if (!t.isSuper(node)) return false;
   if (t.isMemberExpression(parent, { computed: false })) return false;
@@ -11,6 +8,10 @@ function isIllegalBareSuper(node, parent) {
   return true;
 }
 
+function isMemberExpressionSuper(node) {
+  return t.isMemberExpression(node) && t.isSuper(node.object);
+}
+
 var visitor = {
   enter(node, parent, scope, state) {
     var topLevel = state.topLevel;
@@ -18,7 +19,7 @@ var visitor = {
 
     if (t.isFunction(node) && !t.isArrowFunctionExpression(node)) {
       // we need to call traverseLevel again so we're context aware
-      self.traverseLevel(node, false);
+      self.traverseLevel(this, false);
       return this.skip();
     }
 
@@ -35,7 +36,10 @@ var visitor = {
 
     var callback = self.specHandle;
     if (self.isLoose) callback = self.looseHandle;
-    return callback.call(self, this, getThisReference);
+    var result = callback.call(self, this, getThisReference);
+    if (result) this.hasSuper = true;
+    if (result === true) return;
+    return result;
   }
 };
 
@@ -47,6 +51,7 @@ export default class ReplaceSupers {
 
   constructor(opts: Object, inClass?: boolean = false) {
     this.topLevelThisReference = opts.topLevelThisReference;
+    this.methodPath            = opts.methodPath;
     this.methodNode            = opts.methodNode;
     this.superRef              = opts.superRef;
     this.isStatic              = opts.isStatic;
@@ -118,16 +123,16 @@ export default class ReplaceSupers {
    */
 
   replace() {
-    this.traverseLevel(this.methodNode.value, true);
+    this.traverseLevel(this.methodPath.get("value"), true);
   }
 
   /**
    * Description
    */
 
-  traverseLevel(node: Object, topLevel: boolean) {
+  traverseLevel(path: TraversalPath, topLevel: boolean) {
     var state = { self: this, topLevel: topLevel };
-    this.scope.traverse(node, visitor, state);
+    path.traverse(visitor, state);
   }
 
   /**
@@ -190,7 +195,6 @@ export default class ReplaceSupers {
   looseHandle(path: TraversalPath, getThisReference: Function) {
     var node = path.node;
     if (path.isSuper()) {
-      this.hasSuper = true;
       return this.getLooseSuperProperty(node, path.parent);
     } else if (path.isCallExpression()) {
       var callee = node.callee;
@@ -198,9 +202,31 @@ export default class ReplaceSupers {
       if (!t.isSuper(callee.object)) return;
 
       // super.test(); -> objectRef.prototype.MethodName.call(this);
-      this.hasSuper = true;
       t.appendToMemberExpression(callee, t.identifier("call"));
       node.arguments.unshift(getThisReference());
+      return true;
+    }
+  }
+
+  /**
+   * Description
+   */
+
+  specHandleAssignmentExpression(ref, path, node, getThisReference) {
+    if (node.operator === "=") {
+      // super.name = "val"; -> _set(Object.getPrototypeOf(objectRef.prototype), "name", this);
+      return this.setSuperProperty(node.left.property, node.right, node.left.computed, getThisReference());
+    } else {
+      // super.age += 2; -> var _ref = super.age; super.age = _ref + 2;
+      ref ||= path.scope.generateUidIdentifier("ref");
+      return [
+        t.variableDeclaration("var", [
+          t.variableDeclarator(ref, node.left)
+        ]),
+        t.expressionStatement(
+          t.assignmentExpression("=", node.left, t.binaryExpression(node.operator[0], ref, node.right))
+        )
+      ];
     }
   }
 
@@ -237,7 +263,7 @@ export default class ReplaceSupers {
           var methodName = methodNode.key.name || "METHOD_NAME";
           throw this.file.errorWithNode(node, messages.get("classesIllegalSuperCall", methodName));
         }
-      } else if (t.isMemberExpression(callee) && t.isSuper(callee.object)) {
+      } else if (isMemberExpressionSuper(callee)) {
         // super.test(); -> _get(Object.getPrototypeOf(objectRef.prototype), "test", this).call(this);
         property = callee.property;
         computed = callee.computed;
@@ -247,16 +273,22 @@ export default class ReplaceSupers {
       // super.name; -> _get(Object.getPrototypeOf(objectRef.prototype), "name", this);
       property = node.property;
       computed = node.computed;
-    } else if (t.isAssignmentExpression(node) && t.isSuper(node.left.object) && methodNode.kind === "set") {
-      // super.name = "val"; -> _set(Object.getPrototypeOf(objectRef.prototype), "name", this);
-      this.hasSuper = true;
-      return this.setSuperProperty(node.left.property, node.right, node.left.computed, getThisReference());
+    } else if (t.isUpdateExpression(node) && isMemberExpressionSuper(node.argument)) {
+      var binary = t.binaryExpression(node.operator[0], node.argument, t.literal(1))
+      if (node.prefix) {
+        // ++super.foo; -> super.foo += 1;
+        return this.specHandleAssignmentExpression(null, path, binary, getThisReference);
+      } else {
+        // super.foo++; -> var _ref = super.foo; super.foo = _ref + 1;
+        var ref = path.scope.generateUidIdentifier("ref");
+        return this.specHandleAssignmentExpression(ref, path, binary, getThisReference).concat(t.expressionStatement(ref));
+      }
+    } else if (t.isAssignmentExpression(node) && isMemberExpressionSuper(node.left)) {
+      return this.specHandleAssignmentExpression(null, path, node, getThisReference);
     }
 
     if (!property) return;
 
-    this.hasSuper = true;
-
     thisReference = getThisReference();
     var superProperty = this.getSuperProperty(property, computed, thisReference);
     if (args) {

src/babel/transformation/modules/_default.js

@@ -7,37 +7,51 @@ import * as t from "../../types";
 
 var remapVisitor = {
   enter(node, parent, scope, formatter) {
-    if (t.isUpdateExpression(node) && formatter.isLocalReference(node.argument, scope)) {
-      this.skip();
-
-      // expand to long file assignment expression
-      var assign = t.assignmentExpression(node.operator[0] + "=", node.argument, t.literal(1));
-
-      // remap this assignment expression
-      var remapped = formatter.remapExportAssignment(assign);
-
-      // we don't need to change the result
-      if (t.isExpressionStatement(parent) || node.prefix) {
-        return remapped;
+    var remap = formatter.internalRemap[node.name];
+    if (this.isReferencedIdentifier() && remap) {
+      if (!scope.hasBinding(node.name) || scope.bindingIdentifierEquals(node.name, formatter.localImports[node.name])) {
+        return remap;
       }
-
-      var nodes = [];
-      nodes.push(remapped);
-
-      var operator;
-      if (node.operator === "--") {
-        operator = "+";
-      } else { // "++"
-        operator = "-";
-      }
-      nodes.push(t.binaryExpression(operator, node.argument, t.literal(1)));
-
-      return t.sequenceExpression(nodes);
     }
 
-    if (t.isAssignmentExpression(node) && formatter.isLocalReference(node.left, scope)) {
-      this.skip();
-      return formatter.remapExportAssignment(node);
+    if (t.isUpdateExpression(node)) {
+      var exported = formatter.getExport(node.argument, scope);
+
+      if (exported) {
+        this.skip();
+
+        // expand to long file assignment expression
+        var assign = t.assignmentExpression(node.operator[0] + "=", node.argument, t.literal(1));
+
+        // remap this assignment expression
+        var remapped = formatter.remapExportAssignment(assign, exported);
+
+        // we don't need to change the result
+        if (t.isExpressionStatement(parent) || node.prefix) {
+          return remapped;
+        }
+
+        var nodes = [];
+        nodes.push(remapped);
+
+        var operator;
+        if (node.operator === "--") {
+          operator = "+";
+        } else { // "++"
+          operator = "-";
+        }
+        nodes.push(t.binaryExpression(operator, node.argument, t.literal(1)));
+
+        return t.sequenceExpression(nodes);
+      }
+    }
+
+    if (t.isAssignmentExpression(node)) {
+      var exported = formatter.getExport(node.left, scope);
+      if (exported) {
+        this.skip();
+        return formatter.remapExportAssignment(node, exported);
+      }
     }
   }
 };
@@ -59,11 +73,28 @@ var exportsVisitor = traverse.explode({
 
       var declar = this.get("declaration");
       if (declar.isStatement()) {
-        extend(formatter.localExports, declar.getBindingIdentifiers());
+        var bindings = declar.getBindingIdentifiers()
+        for (var name in bindings) {
+          var binding = bindings[name];
+          formatter._addExport(name, binding);
+        }
+      }
+
+      if (this.isExportNamedDeclaration() && node.specifiers) {
+        for (var i = 0; i < node.specifiers.length; i++) {
+          var specifier = node.specifiers[i];
+          var local = specifier.local;
+          if (!local) continue;
+
+          formatter._addExport(local.name, specifier.exported);
+        }
       }
 
       if (!t.isExportDefaultDeclaration(node)) {
-        formatter.hasNonDefaultExports = true;
+        var onlyDefault = node.specifiers && node.specifiers.length === 1 && t.isSpecifierDefault(node.specifiers[0]);
+        if (!onlyDefault) {
+          formatter.hasNonDefaultExports = true;
+        }
       }
 
       if (node.source) {
@@ -75,9 +106,12 @@ var exportsVisitor = traverse.explode({
 
 export default class DefaultFormatter {
   constructor(file) {
-    this.scope = file.scope;
-    this.file  = file;
-    this.ids   = object();
+    this.internalRemap = {};
+
+    this.defaultIds = object();
+    this.scope      = file.scope;
+    this.file       = file;
+    this.ids        = object();
 
     this.hasNonDefaultExports = false;
 
@@ -90,12 +124,14 @@ export default class DefaultFormatter {
 
     this.getLocalExports();
     this.getLocalImports();
+  }
 
+  transform() {
     this.remapAssignments();
   }
 
   doDefaultExportInterop(node) {
-    return t.isExportDefaultDeclaration(node) && !this.noInteropRequireExport && !this.hasNonDefaultExports;
+    return (t.isExportDefaultDeclaration(node) || t.isSpecifierDefault(node)) && !this.noInteropRequireExport && !this.hasNonDefaultExports;
   }
 
   bumpImportOccurences(node) {
@@ -121,27 +157,35 @@ export default class DefaultFormatter {
     }
   }
 
-  isLocalReference(node) {
-    var localImports = this.localImports;
-    return t.isIdentifier(node) && localImports[node.name] && localImports[node.name] !== node;
+  remapExportAssignment(node, exported) {
+    var assign = node;
+
+    for (var i = 0; i < exported.length; i++) {
+      assign = t.assignmentExpression(
+        "=",
+        t.memberExpression(t.identifier("exports"), exported[i]),
+        assign
+      );
+    }
+
+    return assign;
   }
 
-  remapExportAssignment(node) {
-    return t.assignmentExpression(
-      "=",
-      node.left,
-      t.assignmentExpression(
-        node.operator,
-        t.memberExpression(t.identifier("exports"), node.left),
-        node.right
-      )
-    );
+  _addExport(name, exported) {
+    var info = this.localExports[name] ||= {
+      binding: this.scope.getBindingIdentifier(name),
+      exported: []
+    };
+    info.exported.push(exported);
   }
 
-  isLocalReference(node, scope) {
-    var localExports = this.localExports;
-    var name = node.name;
-    return t.isIdentifier(node) && localExports[name] && localExports[name] === scope.getBindingIdentifier(name);
+  getExport(node, scope) {
+    if (!t.isIdentifier(node)) return;
+
+    var local = this.localExports[node.name];
+    if (local && local.binding === scope.getBindingIdentifier(node.name)) {
+      return local.exported;
+    }
   }
 
   getModuleName() {
@@ -219,6 +263,10 @@ export default class DefaultFormatter {
     nodes.push(this.buildExportsWildcard(ref, node));
   }
 
+  isLoose() {
+    return this.file.isLoose("es6.modules");
+  }
+
   exportSpecifier(specifier, node, nodes) {
     if (node.source) {
       var ref = this.getExternalReference(node, nodes);
@@ -228,6 +276,11 @@ export default class DefaultFormatter {
         ref = t.callExpression(this.file.addHelper("interop-require"), [ref]);
       } else {
         ref = t.memberExpression(ref, specifier.local);
+
+        if (!this.isLoose()) {
+          nodes.push(this.buildExportsFromAssignment(specifier.exported, ref, node));
+          return;
+        }
       }
 
       // export { foo } from "test";
@@ -245,6 +298,14 @@ export default class DefaultFormatter {
     ]));
   }
 
+  buildExportsFromAssignment(id, init) {
+    this.checkExportIdentifier(id);
+    return util.template("exports-from-assign", {
+      INIT: init,
+      ID:   t.literal(id.name)
+    }, true);
+  }
+
   buildExportsAssignment(id, init) {
     this.checkExportIdentifier(id);
     return util.template("exports-assign", {

src/babel/transformation/modules/amd.js

@@ -21,6 +21,8 @@ export default class AMDFormatter extends DefaultFormatter {
    */
 
   transform(program) {
+    DefaultFormatter.prototype.transform.apply(this, arguments);
+
     var body = program.body;
 
     // build an array of module names
@@ -69,8 +71,13 @@ export default class AMDFormatter extends DefaultFormatter {
   }
 
   importSpecifier(specifier, node, nodes) {
+    var key = node.source.value;
     var ref = this.getExternalReference(node);
 
+    if (t.isImportNamespaceSpecifier(specifier) || t.isImportDefaultSpecifier(specifier)) {
+      this.defaultIds[key] = specifier.local;
+    }
+
     if (includes(this.file.dynamicImportedNoDefault, node)) {
       // Prevent unnecessary renaming of dynamic imports.
       this.ids[node.source.value] = ref;
@@ -78,7 +85,11 @@ export default class AMDFormatter extends DefaultFormatter {
       // import * as bar from "foo";
     } else if (!includes(this.file.dynamicImported, node) && t.isSpecifierDefault(specifier) && !this.noInteropRequireImport) {
       // import foo from "foo";
-      ref = t.callExpression(this.file.addHelper("interop-require"), [ref]);
+      var uid = this.scope.generateUidIdentifier(specifier.local.name);
+      nodes.push(t.variableDeclaration("var", [
+        t.variableDeclarator(uid, t.callExpression(this.file.addHelper("interop-require"), [ref]))
+      ]));
+      ref = uid;
     } else {
       // import { foo } from "foo";
       var imported = specifier.imported;
@@ -86,9 +97,11 @@ export default class AMDFormatter extends DefaultFormatter {
       ref = t.memberExpression(ref, imported);
     }
 
-    nodes.push(t.variableDeclaration("var", [
-      t.variableDeclarator(specifier.local, ref)
-    ]));
+    this.internalRemap[specifier.local.name] = ref;
+  }
+
+  exportSpecifier() {
+    CommonFormatter.prototype.exportSpecifier.apply(this, arguments);
   }
 
   exportDeclaration(node) {

src/babel/transformation/modules/common.js

@@ -9,13 +9,16 @@ export default class CommonJSFormatter extends DefaultFormatter {
     var scope = file.scope;
 
     scope.rename("module");
+    scope.rename("exports");
 
     if (!this.noInteropRequireImport && this.hasNonDefaultExports) {
       var templateName = "exports-module-declaration";
       if (this.file.isLoose("es6.modules")) templateName += "-loose";
-      file.ast.program.body.unshift(util.template(templateName, true));
+      var declar = util.template(templateName, true);
+      declar._blockHoist = 3;
+      file.ast.program.body.unshift(declar);
     }
-  };
+  }
 
   importSpecifier(specifier, node, nodes) {
     var variableName = specifier.local;
@@ -24,14 +27,17 @@ export default class CommonJSFormatter extends DefaultFormatter {
 
     // import foo from "foo";
     if (t.isSpecifierDefault(specifier)) {
-      if (!includes(this.file.dynamicImportedNoDefault, node)) {
-        if (this.noInteropRequireImport || includes(this.file.dynamicImported, node)) {
-          ref = t.memberExpression(ref, t.identifier("default"));
-        } else {
-          ref = t.callExpression(this.file.addHelper("interop-require"), [ref]);
+      if (includes(this.file.dynamicImportedNoDefault, node)) {
+        this.internalRemap[variableName.name] = ref;
+      } else {
+        if (this.noInteropRequireImport) {
+          this.internalRemap[variableName.name] = t.memberExpression(ref, t.identifier("default"))
+        } else if (!includes(this.file.dynamicImported, node)) {
+          nodes.push(t.variableDeclaration("var", [
+            t.variableDeclarator(variableName, t.callExpression(this.file.addHelper("interop-require"), [ref]))
+          ]));
         }
       }
-      nodes.push(t.variableDeclaration("var", [t.variableDeclarator(variableName, ref)]));
     } else {
       if (t.isImportNamespaceSpecifier(specifier)) {
         if (!this.noInteropRequireImport) {
@@ -44,12 +50,7 @@ export default class CommonJSFormatter extends DefaultFormatter {
         ]));
       } else {
         // import { foo } from "foo";
-        nodes.push(t.variableDeclaration("var", [
-          t.variableDeclarator(
-            variableName,
-            t.memberExpression(ref, specifier.imported)
-          )
-        ]));
+        this.internalRemap[variableName.name] = t.memberExpression(ref, specifier.imported);
       }
     }
   }
@@ -61,6 +62,17 @@ export default class CommonJSFormatter extends DefaultFormatter {
     }, true));
   }
 
+  exportSpecifier(specifier, node, nodes) {
+    if (this.doDefaultExportInterop(specifier)) {
+      nodes.push(util.template("exports-default-assign", {
+        VALUE: specifier.local
+      }, true));
+      return;
+    } else {
+      DefaultFormatter.prototype.exportSpecifier.apply(this, arguments);
+    }
+  }
+
   exportDeclaration(node, nodes) {
     if (this.doDefaultExportInterop(node)) {
       var declar = node.declaration;
@@ -82,16 +94,21 @@ export default class CommonJSFormatter extends DefaultFormatter {
 
   _getExternalReference(node, nodes) {
     var source = node.source.value;
-    var call = t.callExpression(t.identifier("require"), [node.source]);
 
-    if (this.localImportOccurences[source] > 1) {
-      var uid = this.scope.generateUidIdentifier(source);
-      nodes.push(t.variableDeclaration("var", [
-        t.variableDeclarator(uid, call)
-      ]));
-      return uid;
+    var call = t.callExpression(t.identifier("require"), [node.source]);
+    var uid;
+
+    if (includes(this.file.dynamicImported, node) && !includes(this.file.dynamicImportedNoDefault, node)) {
+      call = t.memberExpression(call, t.identifier("default"));
+      uid = node.specifiers[0].local;
     } else {
-      return call;
+      uid = this.scope.generateUidBasedOnNode(node, "import");
     }
+
+    var declar = t.variableDeclaration("var", [
+      t.variableDeclarator(uid, call)
+    ]);
+    nodes.push(declar);
+    return uid;
   }
 }

src/babel/transformation/modules/system.js

@@ -6,6 +6,10 @@ import each from "lodash/collection/each";
 import map from "lodash/collection/map";
 import * as t from "../../types";
 
+var canHoist = function (node, file) {
+  return node._blockHoist && !file.transformers.runtime.canTransform();
+}
+
 var hoistVariablesVisitor = {
   enter(node, parent, scope, hoistDeclarators) {
     if (t.isFunction(node)) {
@@ -20,7 +24,7 @@ var hoistVariablesVisitor = {
       }
 
       // ignore block hoisted nodes as these can be left in
-      if (node._blockHoist) return;
+      if (canHoist(node, scope.file)) return;
 
       var nodes = [];
 
@@ -55,7 +59,7 @@ var hoistFunctionsVisitor = {
   enter(node, parent, scope, handlerBody) {
     if (t.isFunction(node)) this.skip();
 
-    if (t.isFunctionDeclaration(node) || node._blockHoist) {
+    if (t.isFunctionDeclaration(node) || canHoist(node, scope.file)) {
       handlerBody.push(node);
       this.remove();
     }
@@ -90,10 +94,8 @@ export default class SystemFormatter extends AMDFormatter {
     DefaultFormatter.apply(this, arguments);
   }
 
-  init() {}
-
   _addImportSource(node, exportNode) {
-    node._importSource = exportNode.source && exportNode.source.value;
+    if (node) node._importSource = exportNode.source && exportNode.source.value;
     return node;
   }
 
@@ -119,8 +121,18 @@ export default class SystemFormatter extends AMDFormatter {
     return this._addImportSource(call, node);
   }
 
-  remapExportAssignment(node) {
-    return this.buildExportCall(t.literal(node.left.name), node);
+  buildExportsFromAssignment() {
+    return this.buildExportsAssignment(...arguments);
+  }
+
+  remapExportAssignment(node, exported) {
+    var assign = node;
+
+    for (var i = 0; i < exported.length; i++) {
+      assign = this.buildExportCall(t.literal(exported[i].name), assign);
+    }
+
+    return assign;
   }
 
   buildExportCall(id, init, isStatement) {
@@ -134,6 +146,15 @@ export default class SystemFormatter extends AMDFormatter {
 
   importSpecifier(specifier, node, nodes) {
     AMDFormatter.prototype.importSpecifier.apply(this, arguments);
+
+    for (var name in this.internalRemap) {
+      nodes.push(t.variableDeclaration("var", [
+        t.variableDeclarator(t.identifier(name), this.internalRemap[name])
+      ]));
+    }
+
+    this.internalRemap = {};
+
     this._addImportSource(last(nodes), node);
   }
 
@@ -154,6 +175,8 @@ export default class SystemFormatter extends AMDFormatter {
   }
 
   transform(program) {
+    DefaultFormatter.prototype.transform.apply(this, arguments);
+
     var hoistDeclarators = [];
     var moduleName = this.getModuleName();
     var moduleNameLiteral = t.literal(moduleName);

src/babel/transformation/modules/umd.js

@@ -1,3 +1,4 @@
+import DefaultFormatter from "./_default";
 import AMDFormatter from "./amd";
 import values from "lodash/object/values";
 import * as util from  "../../util";
@@ -5,12 +6,14 @@ import * as t from "../../types";
 
 export default class UMDFormatter extends AMDFormatter {
   transform(program) {
+    DefaultFormatter.prototype.transform.apply(this, arguments);
+
     var body = program.body;
 
     // build an array of module names
 
     var names = [];
-    for (var name in this.ids) {
+    for (let name in this.ids) {
       names.push(t.literal(name));
     }
 
@@ -44,7 +47,13 @@ export default class UMDFormatter extends AMDFormatter {
 
     // globals
 
-    //var umdArgs = [];
+    var browserArgs = [t.memberExpression(t.identifier("module"), t.identifier("exports"))];
+    if (this.passModuleArg) browserArgs.push(t.identifier("module"));
+
+    for (let name in this.ids) {
+      var id = this.defaultIds[name] || t.identifier(t.toIdentifier(name));
+      browserArgs.push(t.memberExpression(t.identifier("global"), id));
+    }
 
     //
 
@@ -54,12 +63,15 @@ export default class UMDFormatter extends AMDFormatter {
     var runner = util.template("umd-runner-body", {
       AMD_ARGUMENTS: defineArgs,
       COMMON_TEST: commonTests,
-      COMMON_ARGUMENTS: commonArgs
+      COMMON_ARGUMENTS: commonArgs,
+      BROWSER_ARGUMENTS: browserArgs,
+      GLOBAL_ARG: t.identifier(t.toIdentifier(this.file.opts.basename))
     });
 
     //
 
-    var call = t.callExpression(runner, [factory]);
-    program.body = [t.expressionStatement(call)];
+    program.body = [t.expressionStatement(
+      t.callExpression(runner, [t.thisExpression(), factory])
+    )];
   }
 }

src/babel/transformation/templates/corejs-is-iterator.js

@@ -1 +1 @@
-CORE_ID.$for.isIterable(VALUE);
+CORE_ID.isIterable(VALUE);

src/babel/transformation/templates/corejs-iterator.js

@@ -1 +1 @@
-CORE_ID.$for.getIterator(VALUE);
+CORE_ID.getIterator(VALUE);

src/babel/transformation/templates/exports-from-assign.js

@@ -0,0 +1,6 @@
+Object.defineProperty(exports, ID, {
+  enumerable: true,
+  get: function () {
+    return INIT;
+  }
+});

src/babel/transformation/templates/helper-create-decorated-class.js

@@ -23,7 +23,7 @@
             throw new TypeError("The decorator for method " + descriptor.key + " is of the invalid type " + typeof decorator);
           }
         }
-        initializers[key] = descriptor.initializer;
+        if (initializers) initializers[key] = descriptor.initializer;
       }
 
       Object.defineProperty(target, key, descriptor);

src/babel/transformation/templates/helper-default-props.js

@@ -0,0 +1,10 @@
+(function (defaultProps, props) {
+  if (defaultProps) {
+    for (var propName in defaultProps) {
+      if (typeof props[propName] === "undefined") {
+        props[propName] = defaultProps[propName];
+      }
+    }
+  }
+  return props;
+})

src/babel/transformation/templates/helper-get.js

@@ -9,7 +9,7 @@
     } else {
       return get(parent, property, receiver);
     }
-  } else if ("value" in desc && desc.writable) {
+  } else if ("value" in desc) {
     return desc.value;
   } else {
     var getter = desc.get;

src/babel/transformation/templates/helper-set.js

@@ -5,15 +5,17 @@
     var parent = Object.getPrototypeOf(object);
 
     if (parent !== null) {
-      return set(parent, property, value, receiver);
+      set(parent, property, value, receiver);
     }
   } else if ("value" in desc && desc.writable) {
-    return desc.value = value;
+    desc.value = value;
   } else {
     var setter = desc.set;
 
     if (setter !== undefined) {
-      return setter.call(receiver, value);
+      setter.call(receiver, value);
     }
   }
+
+  return value;
 });

src/babel/transformation/templates/ludicrous-in.js

@@ -0,0 +1 @@
+Object(RIGHT)[LEFT] !== undefined;

src/babel/transformation/templates/property-method-assignment-wrapper-generator.js

@@ -1,11 +1,11 @@
 (function (FUNCTION_KEY) {
-  var WRAPPER_KEY = function* FUNCTION_ID() {
-    return yield* FUNCTION_KEY.apply(this, arguments);
+  function* FUNCTION_ID() {
+    return yield* FUNCTION_ID.apply(this, arguments);
+  }
+
+  FUNCTION_ID.toString = function () {
+    return FUNCTION_ID.toString();
   };
 
-  WRAPPER_KEY.toString = function () {
-    return FUNCTION_KEY.toString();
-  };
-
-  return WRAPPER_KEY;
+  return FUNCTION_ID;
 })(FUNCTION)

src/babel/transformation/templates/property-method-assignment-wrapper.js

@@ -1,11 +1,11 @@
 (function (FUNCTION_KEY) {
-  var WRAPPER_KEY = function FUNCTION_ID() {
+  function FUNCTION_ID() {
     return FUNCTION_KEY.apply(this, arguments);
-  };
+  }
 
-  WRAPPER_KEY.toString = function () {
-    return FUNCTION_KEY.toString();
-  };
+  FUNCTION_ID.toString = function () {
+    return FUNCTION_ID.toString();
+  }
 
-  return WRAPPER_KEY;
+  return FUNCTION_ID;
 })(FUNCTION)

src/babel/transformation/templates/umd-commonjs-strict.js

@@ -1,7 +1,7 @@
 (function (root, factory) {
   if (typeof define === "function" && define.amd) {
     define(AMD_ARGUMENTS, factory);
-  } else if (typeof exports === 'object') {
+  } else if (typeof exports === "object") {
     factory(COMMON_ARGUMENTS);
   } else {
     factory(BROWSER_ARGUMENTS);

src/babel/transformation/templates/umd-runner-body.js

@@ -1,7 +1,11 @@
-(function (factory) {
+(function (global, factory) {
   if (typeof define === "function" && define.amd) {
     define(AMD_ARGUMENTS, factory);
   } else if (COMMON_TEST) {
     factory(COMMON_ARGUMENTS);
+  } else {
+    var module = { exports: {} };
+    factory(BROWSER_ARGUMENTS);
+    global.GLOBAL_ARG = module.exports;
   }
 });

src/babel/transformation/transformer-pass.js

@@ -32,8 +32,9 @@ export default class TransformerPass {
     var whitelist = opts.whitelist;
     if (whitelist) return includes(whitelist, key);
 
-    // experimental
-    if (transformer.metadata.experimental && opts.experimental) return true;
+    // stage
+    var stage = transformer.metadata.stage;
+    if (stage != null && stage >= opts.stage) return true;
 
     // optional
     if (transformer.metadata.optional && !includes(opts.optional, key)) return false;

src/babel/transformation/transformer.js

@@ -9,7 +9,7 @@ import each from "lodash/collection/each";
 
 /**
  * This is the class responsible for normalising a transformers handlers
- * as well as constructing a `TransformerPass` that is repsonsible for
+ * as well as constructing a `TransformerPass` that is responsible for
  * actually running the transformer over the provided `File`.
  */
 
@@ -30,6 +30,10 @@ export default class Transformer {
     this.post              = take("post");
     this.pre               = take("pre");
 
+    if (this.metadata.stage != null) {
+      this.metadata.optional = true;
+    }
+
     this.handlers = this.normalize(transformer);
     this.opts     ||= {};
     this.key      = transformerKey;
@@ -65,8 +69,9 @@ export default class Transformer {
   }
 
   buildPass(file: File): TransformerPass {
+    // validate Transformer instance
     if (!(file instanceof File)) {
-      throw new Error("Multiple versions of babel are interacting, this is either due to a version mismatch in a plugin or it was resolved incorrectly");
+      throw new TypeError(`Transformer ${this.key} is resolving to a different Babel version to what is doing the actual transformation...`);
     }
 
     return new TransformerPass(file, this);

src/babel/transformation/transformers/aliases.json

@@ -1,3 +1,5 @@
 {
-  "useStrict": "strict"
+  "useStrict": "strict",
+  "es5.runtime": "runtime",
+  "es6.runtime": "runtime"
 }

src/babel/transformation/transformers/deprecated.json

@@ -1,7 +1,9 @@
 {
   "selfContained": "runtime",
   "unicode-regex": "regex.unicode",
-  "spec.typeofSymbol": "es6.symbols",
+  "spec.typeofSymbol": "es6.spec.symbols",
+  "es6.symbols": "es6.spec.symbols",
+  "es6.blockScopingTDZ": "es6.spec.blockScoping",
 
   "minification.deadCodeElimination": "utility.deadCodeElimination",
   "minification.removeConsoleCalls": "utility.removeConsole",

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

@@ -44,7 +44,7 @@ export function check(node) {
 export function VariableDeclaration(node, parent, scope, file) {
   if (!isLet(node, parent)) return;
 
-  if (isLetInitable(node) && file.transformers["es6.blockScopingTDZ"].canTransform()) {
+  if (isLetInitable(node) && file.transformers["es6.spec.blockScoping"].canTransform()) {
     var nodes = [node];
 
     for (var i = 0; i < node.declarations.length; i++) {
@@ -70,13 +70,13 @@ export function Loop(node, parent, scope, file) {
     node.body._letDeclarators = [init];
   }
 
-  var blockScoping = new BlockScoping(this, node.body, parent, scope, file);
+  var blockScoping = new BlockScoping(this, this.get("body"), parent, scope, file);
   return blockScoping.run();
 }
 
 export function BlockStatement(block, parent, scope, file) {
   if (!t.isLoop(parent)) {
-    var blockScoping = new BlockScoping(null, block, parent, scope, file);
+    var blockScoping = new BlockScoping(null, this, parent, scope, file);
     blockScoping.run();
   }
 }
@@ -122,12 +122,14 @@ var letReferenceFunctionVisitor = {
     // not a direct reference
     if (!this.isReferencedIdentifier()) return;
 
-    // this scope has a variable with the same name so it couldn't belong
-    // to our let scope
-    if (scope.hasOwnBinding(node.name)) return;
+    var ref = state.letReferences[node.name];
 
     // not a part of our scope
-    if (!state.letReferences[node.name]) return;
+    if (!ref) return;
+
+    // this scope has a variable with the same name so it couldn't belong
+    // to our let scope
+    if (scope.getBindingIdentifier(node.name) !== ref) return;
 
     state.closurify = true;
   }
@@ -159,6 +161,18 @@ var loopLabelVisitor = {
   }
 };
 
+var continuationVisitor = {
+  enter(node, parent, scope, state) {
+    if (this.isAssignmentExpression() || this.isUpdateExpression()) {
+      var bindings = this.getBindingIdentifiers();
+      for (var name in bindings) {
+        if (state.outsideReferences[name] !== scope.getBindingIdentifier(name)) continue;
+        state.reassignments[name] = true;
+      }
+    }
+  }
+};
+
 var loopNodeTo = function (node) {
   if (t.isBreakStatement(node)) {
     return "break";
@@ -225,20 +239,23 @@ class BlockScoping {
    * Description
    */
 
-  constructor(loopPath?: TraversalPath, block: Object, parent: Object, scope: Scope, file: File) {
+  constructor(loopPath?: TraversalPath, blockPath: TraversalPath, parent: Object, scope: Scope, file: File) {
     this.parent = parent;
     this.scope  = scope;
-    this.block  = block;
     this.file   = file;
 
+    this.blockPath = blockPath;
+    this.block     = blockPath.node;
+
     this.outsideLetReferences = object();
     this.hasLetReferences     = false;
-    this.letReferences        = block._letReferences = object();
+    this.letReferences        = this.block._letReferences = object();
     this.body                 = [];
 
     if (loopPath) {
       this.loopParent = loopPath.parent;
       this.loopLabel  = t.isLabeledStatement(this.loopParent) && this.loopParent.label;
+      this.loopPath   = loopPath;
       this.loop       = loopPath.node;
     }
   }
@@ -314,7 +331,7 @@ class BlockScoping {
       traverseReplace(loop.update, loop, scope, remaps);
     }
 
-    scope.traverse(this.block, replaceVisitor, remaps);
+    this.blockPath.traverse(replaceVisitor, remaps);
   }
 
   /**
@@ -352,16 +369,29 @@ class BlockScoping {
 
     // turn outsideLetReferences into an array
     var params = values(outsideRefs);
+    var args   = values(outsideRefs);
 
     // build the closure that we're going to wrap the block with
     var fn = t.functionExpression(null, params, t.blockStatement(block.body));
     fn.shadow = true;
 
+    // continuation
+    this.addContinuations(fn);
+
     // replace the current block body with the one we're going to build
     block.body = this.body;
 
+    var ref = fn;
+
+    if (this.loop) {
+      ref = this.scope.generateUidIdentifier("loop");
+      this.loopPath.insertBefore(t.variableDeclaration("var", [
+        t.variableDeclarator(ref, fn)
+      ]));
+    }
+
     // build a call and a unique id that we can assign the return value to
-    var call = t.callExpression(fn, params);
+    var call = t.callExpression(ref, args);
     var ret  = this.scope.generateUidIdentifier("ret");
 
     // handle generators
@@ -378,7 +408,50 @@ class BlockScoping {
       call = t.awaitExpression(call);
     }
 
-    this.build(ret, call);
+    this.buildClosure(ret, call);
+  }
+
+  /**
+   * Push the closure to the body.
+   */
+
+  buildClosure(ret: { type: "Identifier" }, call: { type: "CallExpression" }) {
+    var has = this.has;
+    if (has.hasReturn || has.hasBreakContinue) {
+      this.buildHas(ret, call);
+    } else {
+      this.body.push(t.expressionStatement(call));
+    }
+  }
+
+  /**
+   * If any of the outer let variables are reassigned then we need to rename them in
+   * the closure so we can get direct access to the outer variable to continue the
+   * iteration with bindings based on each iteration.
+   *
+   * Reference: https://github.com/babel/babel/issues/1078
+   */
+
+  addContinuations(fn) {
+    var state = {
+      reassignments: {},
+      outsideReferences: this.outsideLetReferences
+    };
+
+    this.scope.traverse(fn, continuationVisitor, state);
+
+    for (var i = 0; i < fn.params.length; i++) {
+      var param = fn.params[i];
+      if (!state.reassignments[param.name]) continue;
+
+      var newParam = this.scope.generateUidIdentifier(param.name);
+      fn.params[i] = newParam;
+
+      this.scope.rename(param.name, newParam.name, fn);
+
+      // assign outer reference as it's been modified internally and needs to be retained
+      fn.body.body.push(t.expressionStatement(t.assignmentExpression("=", param, newParam)));
+    }
   }
 
   /**
@@ -428,7 +501,7 @@ class BlockScoping {
 
     // traverse through this block, stopping on functions and checking if they
     // contain any local let references
-    this.scope.traverse(this.block, letReferenceBlockVisitor, state);
+    this.blockPath.traverse(letReferenceBlockVisitor, state);
 
     return state.closurify;
   }
@@ -452,8 +525,8 @@ class BlockScoping {
       map:              {}
     };
 
-    this.scope.traverse(this.block, loopLabelVisitor, state);
-    this.scope.traverse(this.block, loopVisitor, state);
+    this.blockPath.traverse(loopLabelVisitor, state);
+    this.blockPath.traverse(loopVisitor, state);
 
     return state;
   }
@@ -464,7 +537,7 @@ class BlockScoping {
    */
 
   hoistVarDeclarations() {
-    traverse(this.block, hoistVarDeclarationsVisitor, this.scope, this);
+    this.blockPath.traverse(hoistVarDeclarationsVisitor, this);
   }
 
   /**
@@ -490,19 +563,6 @@ class BlockScoping {
     return replace;
   }
 
-  /**
-   * Push the closure to the body.
-   */
-
-  build(ret: { type: "Identifier" }, call: { type: "CallExpression" }) {
-    var has = this.has;
-    if (has.hasReturn || has.hasBreakContinue) {
-      this.buildHas(ret, call);
-    } else {
-      this.body.push(t.expressionStatement(call));
-    }
-  }
-
   /**
    * Description
    */
@@ -542,7 +602,7 @@ class BlockScoping {
           single.consequent[0]
         )));
       } else {
-        // #998
+        // https://github.com/babel/babel/issues/998
         for (var i = 0; i < cases.length; i++) {
           var caseConsequent = cases[i].consequent[0];
           if (t.isBreakStatement(caseConsequent) && !caseConsequent.label) {

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

@@ -8,6 +8,8 @@ import each from "lodash/collection/each";
 import has from "lodash/object/has";
 import * as t from "../../../types";
 
+const PROPERTY_COLLISION_METHOD_NAME = "__initializeProperties";
+
 export var check = t.isClass;
 
 export function ClassDeclaration(node, parent, scope, file) {
@@ -20,6 +22,20 @@ export function ClassExpression(node, parent, scope, file) {
   return new ClassTransformer(this, file).run();
 }
 
+var collectPropertyReferencesVisitor = {
+  Identifier: {
+    enter(node, parent, scope, state) {
+      if (this.parentPath.isClassProperty({ key: node })) {
+        return;
+      }
+
+      if (this.isReferenced() && scope.getBinding(node.name) === state.scope.getBinding(node.name)) {
+        state.references[node.name] = true;;
+      }
+    }
+  }
+};
+
 var verifyConstructorVisitor = traverse.explode({
   MethodDefinition: {
     enter() {
@@ -75,6 +91,7 @@ class ClassTransformer {
     this.staticMutatorMap   = {};
 
     this.instancePropBody = [];
+    this.instancePropRefs = {};
     this.staticPropBody   = [];
     this.body             = [];
 
@@ -130,7 +147,7 @@ class ClassTransformer {
     if (this.hasSuper) {
       closureArgs.push(superName);
 
-      superName = this.scope.generateUidBasedOnNode(superName, this.file);
+      superName = this.scope.generateUidBasedOnNode(superName);
       closureParams.push(superName);
 
       this.superName = superName;
@@ -234,6 +251,8 @@ class ClassTransformer {
 
     if (node.kind === "get") kind = "get";
     if (node.kind === "set") kind = "set";
+
+    t.inheritsComments(node.value, node);
     map[kind] = node.value;
   }
 
@@ -253,11 +272,14 @@ class ClassTransformer {
 
     for (var i = 0; i < classBody.length; i++) {
       var node = classBody[i];
+      var path = classBodyPaths[i];
+
       if (t.isMethodDefinition(node)) {
         var isConstructor = node.kind === "constructor";
-        if (isConstructor) this.verifyConstructor(classBodyPaths[i]);
+        if (isConstructor) this.verifyConstructor(path);
 
         var replaceSupers = new ReplaceSupers({
+          methodPath: path,
           methodNode: node,
           objectRef:  this.classRef,
           superRef:   this.superName,
@@ -270,7 +292,7 @@ class ClassTransformer {
         replaceSupers.replace();
 
         if (isConstructor) {
-          this.pushConstructor(node);
+          this.pushConstructor(node, path);
         } else {
           this.pushMethod(node);
         }
@@ -359,8 +381,25 @@ class ClassTransformer {
 
   placePropertyInitializers() {
     var body = this.instancePropBody;
-    if (body.length) {
-      // todo: check for scope conflicts and shift into a method
+    if (!body.length) return;
+
+    if (this.hasPropertyCollision()) {
+      var call = t.expressionStatement(t.callExpression(
+        t.memberExpression(t.thisExpression(), t.identifier(PROPERTY_COLLISION_METHOD_NAME)),
+        []
+      ));
+
+      this.pushMethod(t.methodDefinition(
+        t.identifier(PROPERTY_COLLISION_METHOD_NAME),
+        t.functionExpression(null, [], t.blockStatement(body))
+      ), true);
+
+      if (this.hasSuper) {
+        this.bareSuper.insertAfter(call);
+      } else {
+        this.constructorBody.body.unshift(call);
+      }
+    } else {
       if (this.hasSuper) {
         if (this.hasConstructor) {
           this.bareSuper.insertAfter(body);
@@ -373,6 +412,22 @@ class ClassTransformer {
     }
   }
 
+  /**
+   * Description
+   */
+
+   hasPropertyCollision(): boolean {
+    if (this.userConstructorPath) {
+      for (var name in this.instancePropRefs) {
+        if (this.userConstructorPath.scope.hasOwnBinding(name)) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+   }
+
   /**
    * Description
    */
@@ -398,7 +453,11 @@ class ClassTransformer {
    * Push a method to its respective mutatorMap.
    */
 
-  pushMethod(node: { type: "MethodDefinition" }) {
+  pushMethod(node: { type: "MethodDefinition" }, allowedIllegal?) {
+    if (!allowedIllegal && t.isLiteral(t.toComputedKey(node), { value: PROPERTY_COLLISION_METHOD_NAME })) {
+      throw this.file.errorWithNode(node, messages.get("illegalMethodName", PROPERTY_COLLISION_METHOD_NAME));
+    }
+
     if (node.kind === "method") {
       nameMethod.property(node, this.file, this.scope);
 
@@ -428,6 +487,11 @@ class ClassTransformer {
 
     var key;
 
+    this.scope.traverse(node, collectPropertyReferencesVisitor, {
+      references: this.instancePropRefs,
+      scope:      this.scope
+    });
+
     if (node.decorators) {
       var body = [];
       if (node.value) body.push(t.returnStatement(node.value));
@@ -464,12 +528,19 @@ class ClassTransformer {
    * Replace the constructor body of our class.
    */
 
-  pushConstructor(method: { type: "MethodDefinition" }) {
+  pushConstructor(method: { type: "MethodDefinition" }, path: TraversalPath) {
+    // https://github.com/babel/babel/issues/1077
+    var fnPath = path.get("value");
+    if (fnPath.scope.hasOwnBinding(this.classRef.name)) {
+      fnPath.scope.rename(this.classRef.name);
+    }
+
     var construct = this.constructor;
     var fn        = method.value;
 
-    this.userConstructor = fn;
-    this.hasConstructor  = true;
+    this.userConstructorPath = fnPath;
+    this.userConstructor     = fn;
+    this.hasConstructor      = true;
 
     t.inheritsComments(construct, method);
 

src/babel/transformation/transformers/es6/constants.js

@@ -2,7 +2,7 @@ import * as messages from "../../../messages";
 import * as t from "../../../types";
 
 export function check(node) {
-  return t.isVariableDeclaration(node, { kind: "const" });
+  return t.isVariableDeclaration(node, { kind: "const" }) || t.isImportDeclaration(node);
 }
 
 var visitor = {
@@ -38,7 +38,7 @@ var visitor = {
 
 export function Scopable(node, parent, scope, file) {
   this.traverse(visitor, {
-    constants: scope.getAllBindingsOfKind("const"),
+    constants: scope.getAllBindingsOfKind("const", "module"),
     file:      file
   });
 }

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

@@ -33,8 +33,12 @@ export function ForOfStatement(node, parent, scope, file) {
 
   t.inherits(loop, node);
 
-  if (build.replaceParent) this.parentPath.replaceWithMultiple(build.node);
-  return build.node;
+  if (build.replaceParent) {
+    this.parentPath.replaceWithMultiple(build.node);
+    this.remove();
+  } else {
+    this.replaceWithMultiple(build.node);
+  }
 }
 
 export function _ForOfStatementArray(node, scope, file) {

src/babel/transformation/transformers/es6/object-super.js

@@ -3,7 +3,7 @@ import * as t from "../../../types";
 
 export var check = t.isSuper;
 
-function Property(node, scope, getObjectRef, file) {
+function Property(path, node, scope, getObjectRef, file) {
   if (!node.method) return;
 
   var value = node.value;
@@ -13,6 +13,7 @@ function Property(node, scope, getObjectRef, file) {
     topLevelThisReference: thisExpr,
     getObjectRef:          getObjectRef,
     methodNode:            node,
+    methodPath:            path,
     isStatic:              true,
     scope:                 scope,
     file:                  file
@@ -33,8 +34,9 @@ export function ObjectExpression(node, parent, scope, file) {
   var objectRef;
   var getObjectRef = () => objectRef ||= scope.generateUidIdentifier("obj");
 
+  var propPaths = this.get("properties");
   for (var i = 0; i < node.properties.length; i++) {
-    Property(node.properties[i], scope, getObjectRef, file);
+    Property(propPaths[i], node.properties[i], scope, getObjectRef, file);
   }
 
   if (objectRef) {

src/babel/transformation/transformers/es6/parameters.default.js

@@ -63,7 +63,7 @@ exports.Function = function (node, parent, scope, file) {
         param.traverse(iifeVisitor, state);
       }
 
-      if (file.transformers["es6.blockScopingTDZ"].canTransform() && param.isIdentifier()) {
+      if (file.transformers["es6.spec.blockScoping"].canTransform() && param.isIdentifier()) {
         pushDefNode(param.node, t.identifier("undefined"), i);
       }
 

src/babel/transformation/transformers/es6/spec.template-literals.js

@@ -0,0 +1,13 @@
+import * as t from "../../../types";
+
+export var metadata = {
+  optional: true
+};
+
+export function TemplateLiteral(node, parent, scope, file) {
+  if (t.isTaggedTemplateExpression(parent)) return;
+
+  for (var i = 0; i < node.expressions.length; i++) {
+    node.expressions[i] = t.callExpression(t.identifier("String"), [node.expressions[i]]);
+  }
+}

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

@@ -180,10 +180,12 @@ class TailCallTransformer {
       var declarations = flatten(map(this.vars, function (decl) {
         return decl.declarations;
       }, this));
-      var statement = reduceRight(declarations, function (expr, decl) {
+      var assignment = reduceRight(declarations, function (expr, decl) {
         return t.assignmentExpression("=", decl.id, expr);
       }, t.identifier("undefined"));
-      body.unshift(t.expressionStatement(statement));
+      var statement = t.expressionStatement(assignment);
+      statement._blockHoist = Infinity;
+      body.unshift(statement);
     }
 
     var paramDecls = this.paramDecls;

src/babel/transformation/transformers/es6/template-literals.js

@@ -1,17 +1,9 @@
 import * as t from "../../../types";
 
-var buildBinaryExpression = function (left, right, file) {
-  return t.binaryExpression("+", left, coerce(right, file));
+var buildBinaryExpression = function (left, right) {
+  return t.binaryExpression("+", left, right);
 };
 
-function coerce(node, file) {
-  if (file.isLoose("es7.templateLiterals") || (t.isLiteral(node) && typeof node.value === "string")) {
-    return node;
-  } else {
-    return t.callExpression(t.identifier("String"), [node]);
-  }
-}
-
 export function check(node) {
   return t.isTemplateLiteral(node) || t.isTaggedTemplateExpression(node);
 }
@@ -59,10 +51,10 @@ export function TemplateLiteral(node, parent, scope, file) {
     var last = nodes[nodes.length - 1];
     if (t.isLiteral(last, { value: "" })) nodes.pop();
 
-    var root = buildBinaryExpression(nodes.shift(), nodes.shift(), file);
+    var root = buildBinaryExpression(nodes.shift(), nodes.shift());
 
     for (i = 0; i < nodes.length; i++) {
-      root = buildBinaryExpression(root, nodes[i], file);
+      root = buildBinaryExpression(root, nodes[i]);
     }
 
     return root;

src/babel/transformation/transformers/es7/async-functions.js

@@ -1,6 +1,5 @@
 export var metadata = {
-  experimental: true,
-  optional: true
+  stage: 1
 };
 
 export function check() {

src/babel/transformation/transformers/es7/class-properties.js

@@ -1,6 +1,5 @@
 export var metadata = {
-  experimental: true,
-  optional: true
+  stage: 0
 };
 
 export function check() {

src/babel/transformation/transformers/es7/comprehensions.js

@@ -4,8 +4,7 @@ import * as util from  "../../../util";
 import * as t from "../../../types";
 
 export var metadata = {
-  experimental: true,
-  optional: true
+  stage: 0
 };
 
 export function ComprehensionExpression(node, parent, scope, file) {
@@ -27,7 +26,7 @@ function generator(node) {
 }
 
 function array(node, parent, scope, file) {
-  var uid = scope.generateUidBasedOnNode(parent, file);
+  var uid = scope.generateUidBasedOnNode(parent);
 
   var container = util.template("array-comprehension-container", {
     KEY: uid

src/babel/transformation/transformers/es7/decorators.js

@@ -1,4 +1,4 @@
 export var metadata = {
-  experimental: true,
-  optional: true
+  optional: true,
+  stage: 1
 };

src/babel/transformation/transformers/es7/do-expressions.js

@@ -1,8 +1,8 @@
 import * as t from "../../../types";
 
 export var metadata = {
-  experimental: true,
-  optional: true
+  optional: true,
+  stage: 0
 };
 
 export var check = t.isDoExpression;

src/babel/transformation/transformers/es7/exponentiation-operator.js

@@ -3,6 +3,10 @@
 import build from "../../helpers/build-binary-assignment-operator-transformer";
 import * as t from "../../../types";
 
+export var metadata = {
+  stage: 2
+};
+
 var MATH_POW = t.memberExpression(t.identifier("Math"), t.identifier("pow"));
 
 build(exports, {

src/babel/transformation/transformers/es7/export-extensions.js

@@ -0,0 +1,43 @@
+// https://github.com/leebyron/ecmascript-more-export-from
+
+import * as t from "../../../types";
+
+export var metadata = {
+  stage: 1
+};
+
+export function check(node) {
+  return t.isExportDefaultSpecifier(node) || t.isExportNamespaceSpecifier(node);
+}
+
+function build(node, nodes, scope) {
+  var first = node.specifiers[0];
+  if (!t.isExportNamespaceSpecifier(first) && !t.isExportDefaultSpecifier(first)) return;
+
+  var specifier = node.specifiers.shift();
+  var uid = scope.generateUidIdentifier(specifier.exported.name);
+
+  var newSpecifier;
+  if (t.isExportNamespaceSpecifier(specifier)) {
+    newSpecifier = t.importNamespaceSpecifier(uid);
+  } else {
+    newSpecifier = t.importDefaultSpecifier(uid);
+  }
+
+  nodes.push(t.importDeclaration([newSpecifier], node.source));
+  nodes.push(t.exportNamedDeclaration(null, [t.exportSpecifier(uid, specifier.exported)]));
+
+  build(node, nodes, scope);
+}
+
+export function ExportNamedDeclaration(node, parent, scope) {
+  var nodes = [];
+  build(node, nodes, scope);
+  if (!nodes.length) return;
+
+  if (node.specifiers.length >= 1) {
+    nodes.push(node);
+  }
+
+  return nodes;
+}

src/babel/transformation/transformers/es7/object-rest-spread.js

@@ -3,8 +3,7 @@
 import * as t from "../../../types";
 
 export var metadata = {
-  experimental: true,
-  optional: true
+  stage: 1
 };
 
 export function manipulateOptions(opts) {

src/babel/transformation/transformers/index.js

@@ -18,6 +18,8 @@ export default {
 
   "spec.blockScopedFunctions":             require("./spec/block-scoped-functions"),
 
+  "optimisation.react.constantElements":   require("./optimisation/react.constant-elements"),
+  "optimisation.react.inlineElements":     require("./optimisation/react.inline-elements"),
   reactCompat:                             require("./other/react-compat"),
   react:                                   require("./other/react"),
 
@@ -35,6 +37,8 @@ export default {
   "es6.objectSuper":                       require("./es6/object-super"),
   "es7.objectRestSpread":                  require("./es7/object-rest-spread"),
   "es7.exponentiationOperator":            require("./es7/exponentiation-operator"),
+
+  "es6.spec.templateLiterals":             require("./es6/spec.template-literals"),
   "es6.templateLiterals":                  require("./es6/template-literals"),
 
   "es5.properties.mutators":               require("./es5/properties.mutators"),
@@ -68,7 +72,7 @@ export default {
   "es6.blockScoping":                      require("./es6/block-scoping"),
 
   // needs to be after `es6.blockScoping` due to needing `letReferences` set on blocks
-  "es6.blockScopingTDZ":                   require("./es6/block-scoping-tdz"),
+  "es6.spec.blockScoping":                 require("./es6/spec.block-scoping"),
 
   // needs to be after `es6.parameters.*` and `es6.blockScoping` due to needing pure
   // identifiers in parameters and variable declarators
@@ -82,6 +86,7 @@ export default {
   runtime:                                require("./other/runtime"),
 
   // needs to be before `_blockHoist` due to function hoisting etc
+  "es7.exportExtensions":                  require("./es7/export-extensions"),
   "es6.modules":                           require("./es6/modules"),
 
   _blockHoist:                             require("./internal/block-hoist"),
@@ -94,7 +99,8 @@ export default {
 
   "es7.doExpressions":                     require("./es7/do-expressions"),
 
-  "es6.symbols":                           require("./es6/symbols"),
+  "es6.spec.symbols":                      require("./es6/spec.symbols"),
+  ludicrous:                               require("./other/ludicrous"),
   "spec.undefinedToVoid":                  require("./spec/undefined-to-void"),
 
   _strict:                                 require("./internal/strict"),

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

@@ -78,3 +78,19 @@ export function ExportNamedDeclaration(node, parent, scope) {
     return [declar, t.exportNamedDeclaration(null, specifiers)];
   }
 }
+
+export function Program(node) {
+  var imports = [];
+  var rest = [];
+
+  for (var i = 0; i < node.body.length; i++) {
+    var bodyNode = node.body[i];
+    if (t.isImportDeclaration(bodyNode)) {
+      imports.push(bodyNode);
+    } else {
+      rest.push(bodyNode);
+    }
+  }
+
+  node.body = imports.concat(rest);
+}

src/babel/transformation/transformers/optimisation/react.constant-elements.js

@@ -0,0 +1,42 @@
+import * as react from "../../helpers/react";
+
+export var metadata = {
+  optional: true
+};
+
+var immutabilityVisitor = {
+  enter(node, parent, scope, state) {
+    var stop = () => {
+      state.isImmutable = false;
+      this.stop();
+    };
+
+    if (this.isJSXClosingElement()) {
+      this.skip();
+      return;
+    }
+
+    if (this.isJSXIdentifier({ name: "ref" }) && this.parentPath.isJSXAttribute({ name: node })) {
+      return stop();
+    }
+
+    if (this.isJSXIdentifier() || this.isIdentifier() || this.isJSXMemberExpression()) {
+      return;
+    }
+
+    if (!this.isImmutable()) stop();
+  }
+};
+
+export function JSXElement(node, parent, scope, file) {
+  if (node._ignoreConstant) return;
+
+  var state = { isImmutable: true };
+  this.traverse(immutabilityVisitor, state);
+  this.skip();
+
+  if (state.isImmutable) {
+    this.hoist();
+    node._ignoreConstant = true;
+  }
+}

src/babel/transformation/transformers/optimisation/react.inline-elements.js

@@ -0,0 +1,74 @@
+import * as react from "../../helpers/react";
+import * as t from "../../../types";
+
+export var metadata = {
+  optional: true
+};
+
+function hasRefOrSpread(attrs) {
+  for (var i = 0; i < attrs.length; i++) {
+    var attr = attrs[i];
+    if (t.isJSXSpreadAttribute(attr)) return true;
+    if (isJSXAttributeOfName(attr, "ref")) return true;
+  }
+  return false;
+}
+
+function isJSXAttributeOfName(attr, name) {
+  return t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name, { name: name });
+}
+
+export function JSXElement(node, parent, scope, file) {
+  // filter
+  var open = node.openingElement;
+  if (hasRefOrSpread(open.attributes)) return;
+
+  // init
+  var isComponent = true;
+  var props       = t.objectExpression([]);
+  var obj         = t.objectExpression([]);
+  var key         = t.literal(null);
+  var type        = open.name;
+
+  if (t.isJSXIdentifier(type) && react.isCompatTag(type.name)) {
+    type = t.literal(type.name);
+    isComponent = false;
+  }
+
+  function pushElemProp(key, value) {
+    pushProp(obj.properties, t.identifier(key), value);
+  }
+
+  function pushProp(objProps, key, value) {
+    objProps.push(t.property("init", key, value));
+  }
+
+  // metadata
+  pushElemProp("type", type);
+  pushElemProp("ref", t.literal(null));
+
+  if (node.children.length) {
+    pushProp(props.properties, t.identifier("children"), t.arrayExpression(react.buildChildren(node)));
+  }
+
+  // props
+  for (var i = 0; i < open.attributes.length; i++) {
+    var attr = open.attributes[i];
+    if (isJSXAttributeOfName(attr, "key")) {
+      key = attr.value;
+    } else {
+      pushProp(props.properties, attr.name, attr.value);
+    }
+  }
+
+  if (isComponent) {
+    props = t.callExpression(file.addHelper("default-props"), [t.memberExpression(type, t.identifier("defaultProps")), props]);
+  }
+
+  pushElemProp("props", props);
+
+  // key
+  pushElemProp("key", key);
+
+  return obj;
+}

src/babel/transformation/transformers/other/ludicrous.js

@@ -0,0 +1,29 @@
+import * as t from "../../../types";
+import * as util from "../../../util";
+
+export var metadata = {
+  optional: true
+};
+
+export function BinaryExpression(node) {
+  if (node.operator === "in") {
+    return util.template("ludicrous-in", {
+      LEFT: node.left,
+      RIGHT: node.right
+    });
+  }
+}
+
+export function Property(node) {
+  var key = node.key;
+  if (t.isLiteral(key) && typeof key.value === "number") {
+    key.value = "" + key.value;
+  }
+}
+
+export function Literal(node) {
+  if (node.regex) {
+    node.regex.pattern = "foobar";
+    node.regex.flags = "";
+  }
+}

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

@@ -4,7 +4,7 @@ import * as t from "../../../types";
 var JSX_ANNOTATION_REGEX = /^\*\s*@jsx\s+([^\s]+)/;
 
 export function Program(node, parent, scope, file) {
-  var id = "React.createElement";
+  var id = file.opts.jsxPragma;
 
   for (var i = 0; i < file.ast.comments.length; i++) {
     var comment = file.ast.comments[i];

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

@@ -1,24 +1,24 @@
+import core from "core-js/library";
 import includes from "lodash/collection/includes";
 import * as util from  "../../../util";
-import core from "core-js/library";
 import has from "lodash/object/has";
 import * as t from "../../../types";
 
 var isSymbolIterator = t.buildMatchMemberExpression("Symbol.iterator");
 
-var coreHas = function (node) {
-  return node.name !== "_" && has(core, node.name);
-};
-
 var ALIASABLE_CONSTRUCTORS = [
-  "Symbol",
-  "Promise",
-  "Map",
-  "WeakMap",
-  "Set",
-  "WeakSet"
+"Symbol",
+"Promise",
+"Map",
+"WeakMap",
+"Set",
+"WeakSet"
 ];
 
+function coreHas(node) {
+  return node.name !== "_" && has(core, node.name);
+}
+
 var astVisitor = {
   enter(node, parent, scope, file) {
     var prop;
@@ -69,22 +69,17 @@ var astVisitor = {
   }
 };
 
-export var metadata = {
-  optional: true,
-  react: true
+exports.metadata = {
+  optional: true
 };
 
-export function manipulateOptions(opts) {
-  if (opts.whitelist) opts.whitelist.push("es6.modules");
-}
-
-export function Program(node, parent, scope, file) {
+exports.Program = function (node, parent, scope, file) {
   this.traverse(astVisitor, file);
-}
+};
 
-export function pre(file) {
+exports.pre = function (file) {
   file.set("helperGenerator", function (name) {
-    return file.addImport("babel-runtime/helpers/" + name, name);
+    return file.addImport(`babel-runtime/helpers/${name}`, name);
   });
 
   file.setDynamic("coreIdentifier", function () {
@@ -94,10 +89,10 @@ export function pre(file) {
   file.setDynamic("regeneratorIdentifier", function () {
     return file.addImport("babel-runtime/regenerator", "regeneratorRuntime");
   });
-}
+};
 
-export function Identifier(node, parent, scope, file) {
+exports.Identifier = function (node, parent, scope, file) {
   if (this.isReferencedIdentifier({ name: "regeneratorRuntime" })) {
     return file.get("regeneratorIdentifier");
   }
-}
+};