v5.4.4

correct cli source map file: value, honor sourceRoot when using -o opion

.gitmodules

@@ -1,6 +1,3 @@
 [submodule "vendor/traceur"]
 	path = vendor/traceur
 	url = https://github.com/google/traceur-compiler
-[submodule "vendor/compat-table"]
-	path = vendor/compat-table
-	url = https://github.com/kangax/compat-table

CHANGELOG.md

@@ -13,6 +13,200 @@ _Note: Gaps between patch versions are faulty/broken releases._
 
 See [CHANGELOG - 6to5](CHANGELOG-6to5.md) for the pre-4.0.0 version changelog.
 
+## 5.4.4
+
+ * **Bug Fix**
+  * Fix bug where replacing variable declarations in the head of a `for` loop would turn them into `ExpressionStatement`s.
+  * Fix renaming of assignment expressions that were non-identifiers ie. patterns.
+  * Force space before `class` `id` to avoid breaking named classes when using `compact` mode.
+  * Add assignment pattern explosion to avoid initial duplicate nodes.
+  * Ignore this and arguments when performing TCO on shadowed functions.
+ * **Polish**
+  * Rename `sourceMapName` option to `sourceMapTarget`. Thanks [@getify](https://github.com/getify)!
+  * Better detection of completion records, ignore those in `Function`s.
+  * Clarified descriptions of the options that are enabled by default.
+  * Resolve `\`babel-plugin-${name}\`` plugin names **before** just checking the `name`. Thanks [@jquense](https://github.com/jquense)!
+  * Update AMD module formatter to add import default remapping.
+
+## 5.4.3
+
+ * **Bug Fix**
+  * Fix `module` being incorrectly rewritten when used as in an export declaration.
+  * When performing single-reference inlining, ensure that the single reference isn't a child of the binding itself.
+  * Fix a bug in `minification.deadCodeElimination` where a new binding instance was being created for local class bindings instead of just inheriting the parent one.
+  * Fix bug with paren printing in `compact` and `retainLines` mode where a left paren was already printed before catching up.
+ * **Internal**
+  * Handle contexts for paths much better. This will ensure that the path node location info is in sync.
+
+## 5.4.2
+
+ * **Polish**
+  * `ignore` and `only` patterns are now **very** liberal. The pattern can now exist anywhere in the path.
+
+## 5.4.1
+
+ * **Bug Fix**
+  * Add missing `slash` dependency. Thanks [@browncolyn](https://github.com/browncolyn)!
+ * **Polish**
+  * Clean up `shouldIgnore` algorithm to work how you'd expect rather than being a hacky piece of shit. It now crawls the entire path, checking each section of it against the input ignore/only patterns. This means that the pattern `foo` will ignore the paths `foo/bar.js`, `bar/foo` etc.
+
+## 5.4.0
+
+ * **New Feature**
+  * Added [function bind syntax](https://github.com/zenparsing/es-function-bind) behind stage 0. Thanks [@RReverser](https://github.com/rreverser)!
+  * Added `env` option. Especially handy when using the `.babelrc`.
+ * **Bug Fix**
+  * Fix files not properly being ignored when `babel.transform` ignores them when using `$ babel`.
+  * Fix scope tracking registering loop head bindings to their `VariableDeclaration` instead of `VariableDeclarator`.
+ * **Polish**
+  * Normalise path separators for souce map paths when using `$ babel`.
+  * Rework `PathHoister` to ignore global references and to not deopt on reassignments to referenced bindings, instead it tries to hoist to the highest scope.
+  * Added missing exponential operator inlining. Thanks [@nkt](https://github.com/nkt)!
+  * Optimise `regenerator` transformer. Thanks [@benjamn](https://github.com/benjamn)!
+
+## 5.3.3
+
+ * **Bug Fix**
+  * Fix `minification.deadCodeElimination` transformer incorrectly trying to inline import declarations.
+  * Fix `minification.inlineExpression` transformer getting into an infinite loop.
+
+## 5.3.2
+
+ * **Bug Fix**
+  * Fix patterns not being considered when hoisting variables in the `es6.blockScoping` transformer.
+
+## 5.3.1
+
+ * **Bug Fix**
+  * Fix unique export specifiers not being cloned when exploding class and function exports,
+ * **Polish**
+  * Turn import remaps to sequence expressions to remove their context and improve performance.
+
+## 5.3.0
+
+**Speeeeeeed**
+
+![gifs lol](https://31.media.tumblr.com/568205a0e37ae15eca510fa639589a59/tumblr_n8kw8kpcSb1sg6cg8o1_500.gif)
+
+ * **Spec Compliancy**
+  * Allow trailing param commas for methods when using the `es7.trailingCommas` transformer.
+ * **Bug Fix**
+  * Fix `es6.blockScoping` transformer not properly ignoring `break` in `SwitchCase`.
+  * Fix lookahead context saving to avoid weird tokenizer state.
+  * Explode duplicate identifiers in export/import specifiers and property shorthand to create unique objects.
+  * Skip loose mode for class methods when they have decorators.
+  * When removing nodes, share their comments with their siblings.
+  * Properly hoist temp param declarations when doing TCO.
+ * **Internal**
+  * Add `--harmony_generators` flag to `$ babel-node`.
+  * Internal AST traversals have been minimised **drastically**. Transformers have been grouped together which means entire tree traversals are much fewer. Visiting nodes is now also skipped if the traversal context can detect that the handler is a noop. This sames precious cycles as it avoids constructing traversal paths and creating a new traversal context. See issues [#1472](https://github.com/babel/babel/issues/1472) and [#1486](https://github.com/babel/babel/issues/1486) for related discussion.
+ * **Polish**
+  * Move many `utility` transformers to `minification`.
+
+## 5.2.17
+
+ * **Bug Fix**
+  * Fix auxiliary comments not properly being attached to function declaration helpers.
+  * Add `Super` node type to `ast-types` patch.
+  * Ignore parameter bindings when attempting to inline them in the `minification.deadCodeElimination` transformer.
+  * Correct `extensions` arguments when using the Babel CLI.
+
+## 5.2.16
+
+ * **Bug Fix**
+  * Fix plugins being disabled when using the whitelist.
+  * Fix correct function scope being passed to `nameMethod.property` when inferring the function name for class methods.
+  * Fix incorrect extensions reference causing weird issues when using the Babel CLI.
+  * Fix destructuring param reference replacements not inheriting from their original param.
+ * **Spec Compliancy**
+  * Fix order that method decorators are ran in.
+
+## 5.2.15
+
+ * **Bug Fix**
+  * Fix initializer descriptor add attempt if it doesn't exist.
+
+## 5.2.14
+
+ * **Bug Fix**
+  * Fix bug with initializer decorators where the descriptors weren't being defined if there was no `initializer` property.
+ * **Internal**
+  * Expose `retainLines` option to CLI.
+  * Fix `retainLines` option not being taken into consideration when doing multiple variable declaration declarators generation.
+  * Expose minified and unminified copies of dist scripts.
+
+## 5.2.13
+
+ * **Bug Fix**
+  * Fix `ExportDeclaration`s being incorrectly removed when using the `utility.deadCodeElimination` transformer.
+  * Fix position of `utility` transformers.
+ * **New Feature**
+  * Add built-in `esquery` support.
+ * **Internal**
+  * Consolidate notion of "virtual types".
+
+## 5.2.12
+
+ * **Polish**
+  * Make UID generation based on module declarations **much** nicer.
+ * **Internal**
+  * Remove internal check for traversal path replacement of self. This is a pattern that **could** come up in the wild and it could lead to pretty nasty code and may lead to internal regressions as the test coverage isn't 100% :( Instead, just put it in the fast path.
+
+## 5.2.11
+
+ * **Internal**
+  * Rename `getModuleName` option to `getModuleId`, doh.
+
+## 5.2.10
+
+ * **Bug Fix**
+  * Fix numerous issues in `replaceWithSourceString`. Thanks [@pangratz](https://github.com/pangratz)!
+ * **New Feature**
+  * Add `getModuleName` option. Thanks [@jayphelps](https://github.com/jayphelps)!
+
+## 5.2.9
+
+ * **Bug Fix**
+  * Fix `_blockHoist` transformer incorrectly sorting nodes on shitty environments that aren't spec compliant in their key order.
+  * Fix broken `parse` API method reference to an undeclared import.
+
+## 5.2.7
+
+ * **Bug Fix**
+  * Move `utility.deadCodeElimination` transformer up to avoid race conditions.
+  * Fix shorthand property scope binding renaming.
+ * **Polish**
+  * Turn helper variable declarations into function declarations if possible.
+ * **Internal**
+  * Removed native inheritance support from classes.
+  * Added `replaceWithSourceString` path API.
+  * Split up `es3.propertyLiterals` and `es3.memberExpressionLiterals` transformers to `minfication.propertyLiterals` and `es3.memberExpressionLiterals`.
+
+## 5.2.6
+
+ * **Internal**
+  * Fix transformer aliases being accidently set as deprecated ones.
+  * Expose `Pipeline` as `TransformerPipeline` instead.
+
+## 5.2.5
+
+ * **Bug Fix**
+  * Fix `parse` API not adding all the correct pipeline transformers.
+
+## 5.2.4
+
+ * **Bug Fix**
+  * Fix race condition with the Node API being loaded awkwardly and not being able to initialise itself when used in the browser.
+ * **Internal**
+  * Expose `transform.pipeline`.
+
+## 5.2.3
+
+ * **Bug Fix**
+  * Fix plugin containers being called with an undefined import. Thanks [@timbur](https://github.com/timbur)!
+  * Allow Flow object separators to be commas. Thanks [@monsanto](https://github.com/monsanto)!
+  * Add missing `Statement` and `Declaration` node aliases to flow types.
+
 ## 5.2.2
 
  * **Internal**

Makefile

@@ -3,7 +3,6 @@ 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
 #UGLIFY_CMD = node_modules/uglify-js/bin/uglifyjs --mangle sort
-JSHINT_CMD = node_modules/jshint/bin/jshint
 MOCHA_CMD = node_modules/mocha/bin/_mocha
 BABEL_CMD = node_modules/babel/bin/babel
 
@@ -83,9 +82,15 @@ publish:
 	npm version $$version --message "v%s"
 
 	make build
-	cp dist/babel.min.js browser.js
-	cp dist/polyfill.min.js browser-polyfill.js
-	cp dist/external-helpers.min.js external-helpers.js
+
+	cp dist/babel.js browser.js
+	cp dist/babel.min.js browser.min.js
+
+	cp dist/polyfill.js browser-polyfill.js
+	cp dist/polyfill.min.js browser-polyfill.min.js
+
+	cp dist/external-helpers.js external-helpers.js
+	cp dist/external-helpers.min.js external-helpers.min.js
 
 	node tools/cache-templates
 	test -f templates.json
@@ -97,7 +102,7 @@ publish:
 	make publish-cli
 	make publish-runtime
 
-	rm -rf templates.json browser.js browser-polyfill.js external-helpers.js
+	rm -rf templates.json browser.js browser.min.js browser-polyfill.js browser-polyfill.min.js external-helpers.js external-helpers.min.js
 
 publish-runtime:
 	cd packages; \
@@ -117,5 +122,4 @@ bootstrap:
 	npm link
 	cd packages/babel-cli && npm install && npm link && npm link babel-core
 	git submodule update --init
-	cd vendor/compat-table && npm install object-assign
 	make build

package.json

@@ -1,9 +1,10 @@
 {
   "name": "babel-core",
-  "description": "Turn ES6 code into readable vanilla ES5 with source maps",
-  "version": "5.2.2",
+  "description": "A compiler for writing next generation JavaScript",
+  "version": "5.4.4",
   "author": "Sebastian McKenzie <sebmck@gmail.com>",
   "homepage": "https://babeljs.io/",
+  "license": "MIT",
   "repository": "babel/babel",
   "main": "lib/babel/api/node.js",
   "browser": {
@@ -27,16 +28,20 @@
     "test": "make test"
   },
   "dependencies": {
+    "acorn-jsx": "^1.0.0",
     "ast-types": "~0.7.0",
+    "bluebird": "^2.9.25",
     "chalk": "^1.0.0",
     "convert-source-map": "^1.1.0",
     "core-js": "^0.9.0",
     "debug": "^2.1.1",
     "detect-indent": "^3.0.0",
-    "estraverse": "^3.0.0",
+    "esquery": "^0.4.0",
+    "estraverse": "^4.0.0",
     "esutils": "^2.0.0",
     "fs-readdir-recursive": "^0.1.0",
     "globals": "^6.4.0",
+    "home-or-tmp": "^1.0.0",
     "is-integer": "^1.0.4",
     "js-tokens": "1.0.0",
     "leven": "^1.0.1",
@@ -49,17 +54,17 @@
     "regenerator": "^0.8.20",
     "regexpu": "^1.1.2",
     "repeating": "^1.1.2",
+    "resolve": "^1.1.6",
     "shebang-regex": "^1.0.0",
     "slash": "^1.0.0",
     "source-map": "^0.4.0",
     "source-map-support": "^0.2.10",
     "strip-json-comments": "^1.0.2",
     "to-fast-properties": "^1.0.0",
-    "trim-right": "^1.0.0",
-    "user-home": "^1.1.1"
+    "trim-right": "^1.0.0"
   },
   "devDependencies": {
-    "babel": "5.1.13",
+    "babel": "5.3.1",
     "browserify": "^9.0.8",
     "chai": "^2.2.0",
     "eslint": "^0.18.0",

packages/babel-cli/bin/babel-node

@@ -55,6 +55,8 @@ babelArgs.forEach(function(arg){
     case "--harmony_classes":
     case "--harmony_object_literals":
     case "--harmony_templates":
+    case "--harmony_rest_parameters":
+    case "--harmony_generators":
     case "--compiled_keyed_generic_loads":
     case "--pretenuring_call_new":
     case "--allocation_site_pretenuring":

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

@@ -1,5 +1,6 @@
 var outputFileSync = require("output-file-sync");
 var chokidar       = require("chokidar");
+var slash          = require("slash");
 var path           = require("path");
 var util           = require("./util");
 var fs             = require("fs");
@@ -13,8 +14,10 @@ module.exports = function (commander, filenames, opts) {
     var dest = path.join(commander.outDir, relative);
 
     var data = util.compile(src, {
-      sourceFileName: path.relative(dest + "/..", src)
+      sourceFileName: slash(path.relative(dest + "/..", src)),
+      sourceMapTarget: path.basename(relative)
     });
+    if (data.ignored) return;
 
     if (commander.sourceMaps && commander.sourceMaps !== "inline") {
       var mapLoc = dest + ".map";
@@ -30,7 +33,7 @@ module.exports = function (commander, filenames, opts) {
   var handleFile = function (src, filename) {
     if (util.shouldIgnore(src)) return;
 
-    if (util.canCompile(filename)) {
+    if (util.canCompile(filename, commander.extensions)) {
       write(src, filename);
     } else if (commander.copyFiles) {
       outputFileSync(path.join(commander.outDir, filename), fs.readFileSync(src));

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

@@ -1,6 +1,7 @@
 var convertSourceMap = require("convert-source-map");
 var sourceMap        = require("source-map");
 var chokidar         = require("chokidar");
+var slash            = require("slash");
 var path             = require("path");
 var util             = require("./util");
 var fs               = require("fs");
@@ -15,7 +16,8 @@ module.exports = function (commander, filenames, opts) {
 
   var buildResult = function () {
     var map = new sourceMap.SourceMapGenerator({
-      file: commander.outFile || "stdout"
+      file: path.basename(commander.outFile) || "stdout",
+      sourceRoot: opts.sourceRoot
     });
 
     var code = "";
@@ -28,8 +30,14 @@ module.exports = function (commander, filenames, opts) {
       if (result.map) {
         var consumer = new sourceMap.SourceMapConsumer(result.map);
 
-        map._sources.add(filename);
-        map.setSourceContent(filename, result.actual);
+        var sourceFilename = filename;
+        if (commander.outFile) {
+          sourceFilename = path.relative(path.dirname(commander.outFile), sourceFilename);
+        }
+        sourceFilename = slash(sourceFilename);
+
+        map._sources.add(sourceFilename);
+        map.setSourceContent(sourceFilename, result.actual);
 
         consumer.eachMapping(function (mapping) {
           map._mappings.add({
@@ -37,7 +45,7 @@ module.exports = function (commander, filenames, opts) {
             generatedColumn: mapping.generatedColumn,
             originalLine: mapping.originalLine,
             originalColumn: mapping.originalColumn,
-            source: filename
+            source: sourceFilename
           });
         });
 
@@ -109,7 +117,9 @@ module.exports = function (commander, filenames, opts) {
     _.each(_filenames, function (filename) {
       if (util.shouldIgnore(filename)) return;
 
-      results.push(util.compile(filename));
+      var data = util.compile(filename);
+      if (data.ignored) return;
+      results.push(data);
     });
 
     output();

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

@@ -1,14 +1,15 @@
 #!/usr/bin/env node
 
-var commander = require("commander");
-var transform = require("babel-core").transform;
-var kebabCase = require("lodash/string/kebabCase");
-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");
-var glob      = require("glob");
+var moduleFormatters = require("babel-core/lib/babel/transformation/modules");
+var commander        = require("commander");
+var transform        = require("babel-core").transform;
+var kebabCase        = require("lodash/string/kebabCase");
+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");
+var glob             = require("glob");
 
 each(options, function (option, key) {
   if (option.hidden) return;
@@ -36,6 +37,7 @@ each(options, function (option, key) {
   commander.option(arg, desc.join(" "));
 })
 
+commander.option("-x, --extensions [extensions]", "List of extensions to compile when a directory has been input [.es6,.js,.es,.jsx]");
 commander.option("-w, --watch", "Recompile files on changes");
 commander.option("-o, --out-file [out]", "Compile all input files into a single file");
 commander.option("-d, --out-dir [out]", "Compile an input directory of modules into an output directory");
@@ -57,8 +59,8 @@ commander.on("--help", function () {
     console.log();
   };
 
-  outKeys("Transformers", transform.transformers);
-  outKeys("Module formatters", transform.moduleFormatters);
+  outKeys("Transformers", transform.pipeline.transformers);
+  outKeys("Module formatters", moduleFormatters);
 });
 
 var pkg = require("../../package.json");
@@ -68,6 +70,12 @@ commander.parse(process.argv);
 
 //
 
+if (commander.extensions) {
+  commander.extensions = util.arrayify(commander.extensions);
+}
+
+//
+
 var errors = [];
 
 var filenames = commander.args.reduce(function (globbed, input) {

packages/babel-cli/package.json

@@ -1,13 +1,14 @@
 {
   "name": "babel",
   "description": "Turn ES6 code into readable vanilla ES5 with source maps",
-  "version": "5.2.1",
+  "version": "5.4.3",
   "author": "Sebastian McKenzie <sebmck@gmail.com>",
   "homepage": "https://babeljs.io/",
+  "license": "MIT",
   "repository": "babel/babel",
   "preferGlobal": true,
   "dependencies": {
-    "babel-core": "^5.2.1",
+    "babel-core": "^5.4.3",
     "chokidar": "^1.0.0",
     "commander": "^2.6.0",
     "convert-source-map": "^1.1.0",
@@ -16,7 +17,8 @@
     "lodash": "^3.2.0",
     "output-file-sync": "^1.1.0",
     "path-is-absolute": "^1.0.0",
-    "source-map": "^0.4.0"
+    "source-map": "^0.4.0",
+    "slash": "^1.0.0"
   },
   "bin": {
     "babel": "./bin/babel/index.js",

packages/babel-runtime/package.json

@@ -1,7 +1,8 @@
 {
   "name": "babel-runtime",
   "description": "babel selfContained runtime",
-  "version": "5.2.1",
+  "version": "5.4.3",
+  "license": "MIT",
   "repository": "babel/babel",
   "author": "Sebastian McKenzie <sebmck@gmail.com>",
   "dependencies": {

sebmck-bjs.nfo

@@ -0,0 +1,48 @@
+
+                          ======                             ==========M=
+                     =============        ==    ======O=   ======= MM  ==
+                   M==+===      ==M      ===  ====     ==  ===        ==
+                  =D  ===      ===      ====MM ==M    ==M ==M        ===
+                     ===M    ====M     ====    =D   ===M ===   ===   ==
+                     ==7   ====M     ==M ==   ========  =========M  ==M
+                    ===========     ======M  ===MMM === ==M         ==
+                   =======MM==========MM==  ==M     ==M===         ==
+                   ==M       === M==   ==M  ==    === ===          =D        =
+                  ==M      ===+  ==    ==  ==  ==$M   =========== ============M
+                 ===     ====M  ==    ==M ===M==     ====?MMMM       M M
+                 ==   =====   ==M     == ==MM         M
+                ==M===M=M     =M     =MM  M           M
+               ==MM=M                ==
+              MMM                   =M
+               M
+
+                              > ú B ú A ú B ú E ú L ú <
+    ÕÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÑÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ͸
+    ³ SOFTWARE .. : JavaScript Compiler  ³ COMPANY ... : N/A                     ³
+    ³ SUPPLIER .. : N/A                  ³ CRACKER ... : Sebastian McKenzie      ³
+    ³ RATING .... : depends..            ³ PACKAGER .. : Sebastian McKenzie      ³
+    ³ ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ ³
+    ³ GRAFIX .... : -                    ³ SOUND ..... : -                       ³
+    ÔÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÏÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ;
+
+     Babel is a JavaScript compiler and transformation platform for writing NeXt
+     GeNeRaTiOn JavaScript.
+
+     ÆÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÏÍÍÍÍÍÍÍÍÍÍÍÍÍÍÏÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÏÍÍÍÍÍÍÍÏÍÍÍÍÍÍÍÍÍÍÍ͵
+     ³                                :: Greets ::                              ³
+     ³                                                                          ³
+     ³  sebmck, thejameskyle, RReverser, zloirock, monsanto, gaearon, zertosh,  ³
+     ³  stefanpenner, eventualbuddha, AluisioASG, Apoxx, Couto, dominicbarnes,  ³
+     ³    es128, gordonkristan, hkjels, jmeas, josh, loganfsmyth, nightire,     ³
+     ³           Rich-Harris, shinnn, shuhei, sindresorhus, tricknotes          ³
+     ³                                                                          ³
+     ÔÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ;
+
+                  -*- JavaScripts for all , All for JavaScripts ! -*-
+
+    ÕÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ͸
+    ³  If you want to Contact us, call 555-720-4228, Use the Handle "BABEL"  w/  ³
+    ³  password : VISITOR and leave a mail to Sebastian or James.                ³
+    ÔÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ;
+
+                               -=- We LoVe fun Too! -=-

src/acorn/index.js

@@ -1,3 +1,6 @@
 export * from "./src/index";
 import "./plugins/flow";
-import "./plugins/jsx";
+
+import inject from "acorn-jsx/inject";
+import * as acorn from "./src/index";
+inject(acorn);

src/acorn/plugins/flow.js

@@ -153,10 +153,15 @@ pp.flow_parseTypeAlias = function (node) {
     node.typeParameters = null
   }
 
+  var oldInType = this.inType;
+  this.inType = true;
+
   this.expect(tt.eq)
 
   node.right = this.flow_parseType()
 
+  this.inType = oldInType;
+
   this.semicolon()
 
   return this.finishNode(node, "TypeAlias")
@@ -322,7 +327,7 @@ pp.flow_parseObjectType = function (allowStatic) {
 }
 
 pp.flow_objectTypeSemicolon = function () {
-  if (!this.eat(tt.semi) && this.type !== tt.braceR) {
+  if (!this.eat(tt.semi) && !this.eat(tt.comma) && this.type !== tt.braceR) {
     this.unexpected()
   }
 }

src/acorn/plugins/jsx.js

@@ -1,658 +0,0 @@
-var acorn = require("../src/index")
-
-var tt = acorn.tokTypes;
-var tc = acorn.tokContexts;
-
-tc.j_oTag = new acorn.TokContext("<tag", false);
-tc.j_cTag = new acorn.TokContext("</tag", false);
-tc.j_expr = new acorn.TokContext("<tag>...</tag>", true, true);
-
-tt.jsxName = new acorn.TokenType("jsxName");
-tt.jsxText = new acorn.TokenType("jsxText", {beforeExpr: true});
-tt.jsxTagStart = new acorn.TokenType("jsxTagStart");
-tt.jsxTagEnd = new acorn.TokenType("jsxTagEnd");
-
-tt.jsxTagStart.updateContext = function() {
-  this.context.push(tc.j_expr); // treat as beginning of JSX expression
-  this.context.push(tc.j_oTag); // start opening tag context
-  this.exprAllowed = false;
-};
-tt.jsxTagEnd.updateContext = function(prevType) {
-  var out = this.context.pop();
-  if (out === tc.j_oTag && prevType === tt.slash || out === tc.j_cTag) {
-    this.context.pop();
-    this.exprAllowed = this.curContext() === tc.j_expr;
-  } else {
-    this.exprAllowed = true;
-  }
-};
-
-var pp = acorn.Parser.prototype;
-
-// Reads inline JSX contents token.
-
-pp.jsx_readToken = function() {
-  var out = "", chunkStart = this.pos;
-  for (;;) {
-    if (this.pos >= this.input.length)
-      this.raise(this.start, "Unterminated JSX contents");
-    var ch = this.input.charCodeAt(this.pos);
-
-    switch (ch) {
-    case 60: // '<'
-    case 123: // '{'
-      if (this.pos === this.start) {
-        if (ch === 60 && this.exprAllowed) {
-          ++this.pos;
-          return this.finishToken(tt.jsxTagStart);
-        }
-        return this.getTokenFromCode(ch);
-      }
-      out += this.input.slice(chunkStart, this.pos);
-      return this.finishToken(tt.jsxText, out);
-
-    case 38: // '&'
-      out += this.input.slice(chunkStart, this.pos);
-      out += this.jsx_readEntity();
-      chunkStart = this.pos;
-      break;
-
-    default:
-      if (acorn.isNewLine(ch)) {
-        out += this.input.slice(chunkStart, this.pos);
-        ++this.pos;
-        if (ch === 13 && this.input.charCodeAt(this.pos) === 10) {
-          ++this.pos;
-          out += "\n";
-        } else {
-          out += String.fromCharCode(ch);
-        }
-        if (this.options.locations) {
-          ++this.curLine;
-          this.lineStart = this.pos;
-        }
-        chunkStart = this.pos;
-      } else {
-        ++this.pos;
-      }
-    }
-  }
-};
-
-pp.jsx_readString = function(quote) {
-  var out = "", chunkStart = ++this.pos;
-  for (;;) {
-    if (this.pos >= this.input.length)
-      this.raise(this.start, "Unterminated string constant");
-    var ch = this.input.charCodeAt(this.pos);
-    if (ch === quote) break;
-    if (ch === 38) { // '&'
-      out += this.input.slice(chunkStart, this.pos);
-      out += this.jsx_readEntity();
-      chunkStart = this.pos;
-    } else {
-      ++this.pos;
-    }
-  }
-  out += this.input.slice(chunkStart, this.pos++);
-  return this.finishToken(tt.string, out);
-};
-
-var XHTMLEntities = {
-  quot: '\u0022',
-  amp: '&',
-  apos: '\u0027',
-  lt: '<',
-  gt: '>',
-  nbsp: '\u00A0',
-  iexcl: '\u00A1',
-  cent: '\u00A2',
-  pound: '\u00A3',
-  curren: '\u00A4',
-  yen: '\u00A5',
-  brvbar: '\u00A6',
-  sect: '\u00A7',
-  uml: '\u00A8',
-  copy: '\u00A9',
-  ordf: '\u00AA',
-  laquo: '\u00AB',
-  not: '\u00AC',
-  shy: '\u00AD',
-  reg: '\u00AE',
-  macr: '\u00AF',
-  deg: '\u00B0',
-  plusmn: '\u00B1',
-  sup2: '\u00B2',
-  sup3: '\u00B3',
-  acute: '\u00B4',
-  micro: '\u00B5',
-  para: '\u00B6',
-  middot: '\u00B7',
-  cedil: '\u00B8',
-  sup1: '\u00B9',
-  ordm: '\u00BA',
-  raquo: '\u00BB',
-  frac14: '\u00BC',
-  frac12: '\u00BD',
-  frac34: '\u00BE',
-  iquest: '\u00BF',
-  Agrave: '\u00C0',
-  Aacute: '\u00C1',
-  Acirc: '\u00C2',
-  Atilde: '\u00C3',
-  Auml: '\u00C4',
-  Aring: '\u00C5',
-  AElig: '\u00C6',
-  Ccedil: '\u00C7',
-  Egrave: '\u00C8',
-  Eacute: '\u00C9',
-  Ecirc: '\u00CA',
-  Euml: '\u00CB',
-  Igrave: '\u00CC',
-  Iacute: '\u00CD',
-  Icirc: '\u00CE',
-  Iuml: '\u00CF',
-  ETH: '\u00D0',
-  Ntilde: '\u00D1',
-  Ograve: '\u00D2',
-  Oacute: '\u00D3',
-  Ocirc: '\u00D4',
-  Otilde: '\u00D5',
-  Ouml: '\u00D6',
-  times: '\u00D7',
-  Oslash: '\u00D8',
-  Ugrave: '\u00D9',
-  Uacute: '\u00DA',
-  Ucirc: '\u00DB',
-  Uuml: '\u00DC',
-  Yacute: '\u00DD',
-  THORN: '\u00DE',
-  szlig: '\u00DF',
-  agrave: '\u00E0',
-  aacute: '\u00E1',
-  acirc: '\u00E2',
-  atilde: '\u00E3',
-  auml: '\u00E4',
-  aring: '\u00E5',
-  aelig: '\u00E6',
-  ccedil: '\u00E7',
-  egrave: '\u00E8',
-  eacute: '\u00E9',
-  ecirc: '\u00EA',
-  euml: '\u00EB',
-  igrave: '\u00EC',
-  iacute: '\u00ED',
-  icirc: '\u00EE',
-  iuml: '\u00EF',
-  eth: '\u00F0',
-  ntilde: '\u00F1',
-  ograve: '\u00F2',
-  oacute: '\u00F3',
-  ocirc: '\u00F4',
-  otilde: '\u00F5',
-  ouml: '\u00F6',
-  divide: '\u00F7',
-  oslash: '\u00F8',
-  ugrave: '\u00F9',
-  uacute: '\u00FA',
-  ucirc: '\u00FB',
-  uuml: '\u00FC',
-  yacute: '\u00FD',
-  thorn: '\u00FE',
-  yuml: '\u00FF',
-  OElig: '\u0152',
-  oelig: '\u0153',
-  Scaron: '\u0160',
-  scaron: '\u0161',
-  Yuml: '\u0178',
-  fnof: '\u0192',
-  circ: '\u02C6',
-  tilde: '\u02DC',
-  Alpha: '\u0391',
-  Beta: '\u0392',
-  Gamma: '\u0393',
-  Delta: '\u0394',
-  Epsilon: '\u0395',
-  Zeta: '\u0396',
-  Eta: '\u0397',
-  Theta: '\u0398',
-  Iota: '\u0399',
-  Kappa: '\u039A',
-  Lambda: '\u039B',
-  Mu: '\u039C',
-  Nu: '\u039D',
-  Xi: '\u039E',
-  Omicron: '\u039F',
-  Pi: '\u03A0',
-  Rho: '\u03A1',
-  Sigma: '\u03A3',
-  Tau: '\u03A4',
-  Upsilon: '\u03A5',
-  Phi: '\u03A6',
-  Chi: '\u03A7',
-  Psi: '\u03A8',
-  Omega: '\u03A9',
-  alpha: '\u03B1',
-  beta: '\u03B2',
-  gamma: '\u03B3',
-  delta: '\u03B4',
-  epsilon: '\u03B5',
-  zeta: '\u03B6',
-  eta: '\u03B7',
-  theta: '\u03B8',
-  iota: '\u03B9',
-  kappa: '\u03BA',
-  lambda: '\u03BB',
-  mu: '\u03BC',
-  nu: '\u03BD',
-  xi: '\u03BE',
-  omicron: '\u03BF',
-  pi: '\u03C0',
-  rho: '\u03C1',
-  sigmaf: '\u03C2',
-  sigma: '\u03C3',
-  tau: '\u03C4',
-  upsilon: '\u03C5',
-  phi: '\u03C6',
-  chi: '\u03C7',
-  psi: '\u03C8',
-  omega: '\u03C9',
-  thetasym: '\u03D1',
-  upsih: '\u03D2',
-  piv: '\u03D6',
-  ensp: '\u2002',
-  emsp: '\u2003',
-  thinsp: '\u2009',
-  zwnj: '\u200C',
-  zwj: '\u200D',
-  lrm: '\u200E',
-  rlm: '\u200F',
-  ndash: '\u2013',
-  mdash: '\u2014',
-  lsquo: '\u2018',
-  rsquo: '\u2019',
-  sbquo: '\u201A',
-  ldquo: '\u201C',
-  rdquo: '\u201D',
-  bdquo: '\u201E',
-  dagger: '\u2020',
-  Dagger: '\u2021',
-  bull: '\u2022',
-  hellip: '\u2026',
-  permil: '\u2030',
-  prime: '\u2032',
-  Prime: '\u2033',
-  lsaquo: '\u2039',
-  rsaquo: '\u203A',
-  oline: '\u203E',
-  frasl: '\u2044',
-  euro: '\u20AC',
-  image: '\u2111',
-  weierp: '\u2118',
-  real: '\u211C',
-  trade: '\u2122',
-  alefsym: '\u2135',
-  larr: '\u2190',
-  uarr: '\u2191',
-  rarr: '\u2192',
-  darr: '\u2193',
-  harr: '\u2194',
-  crarr: '\u21B5',
-  lArr: '\u21D0',
-  uArr: '\u21D1',
-  rArr: '\u21D2',
-  dArr: '\u21D3',
-  hArr: '\u21D4',
-  forall: '\u2200',
-  part: '\u2202',
-  exist: '\u2203',
-  empty: '\u2205',
-  nabla: '\u2207',
-  isin: '\u2208',
-  notin: '\u2209',
-  ni: '\u220B',
-  prod: '\u220F',
-  sum: '\u2211',
-  minus: '\u2212',
-  lowast: '\u2217',
-  radic: '\u221A',
-  prop: '\u221D',
-  infin: '\u221E',
-  ang: '\u2220',
-  and: '\u2227',
-  or: '\u2228',
-  cap: '\u2229',
-  cup: '\u222A',
-  'int': '\u222B',
-  there4: '\u2234',
-  sim: '\u223C',
-  cong: '\u2245',
-  asymp: '\u2248',
-  ne: '\u2260',
-  equiv: '\u2261',
-  le: '\u2264',
-  ge: '\u2265',
-  sub: '\u2282',
-  sup: '\u2283',
-  nsub: '\u2284',
-  sube: '\u2286',
-  supe: '\u2287',
-  oplus: '\u2295',
-  otimes: '\u2297',
-  perp: '\u22A5',
-  sdot: '\u22C5',
-  lceil: '\u2308',
-  rceil: '\u2309',
-  lfloor: '\u230A',
-  rfloor: '\u230B',
-  lang: '\u2329',
-  rang: '\u232A',
-  loz: '\u25CA',
-  spades: '\u2660',
-  clubs: '\u2663',
-  hearts: '\u2665',
-  diams: '\u2666'
-};
-
-var hexNumber = /^[\da-fA-F]+$/;
-var decimalNumber = /^\d+$/;
-
-pp.jsx_readEntity = function() {
-  var str = "", count = 0, entity;
-  var ch = this.input[this.pos];
-  if (ch !== "&")
-    this.raise(this.pos, "Entity must start with an ampersand");
-  var startPos = ++this.pos;
-  while (this.pos < this.input.length && count++ < 10) {
-    ch = this.input[this.pos++];
-    if (ch === ";") {
-      if (str[0] === "#") {
-        if (str[1] === "x") {
-          str = str.substr(2);
-          if (hexNumber.test(str))
-            entity = String.fromCharCode(parseInt(str, 16));
-        } else {
-          str = str.substr(1);
-          if (decimalNumber.test(str))
-            entity = String.fromCharCode(parseInt(str, 10));
-        }
-      } else {
-        entity = XHTMLEntities[str];
-      }
-      break;
-    }
-    str += ch;
-  }
-  if (!entity) {
-    this.pos = startPos;
-    return "&";
-  }
-  return entity;
-};
-
-
-// Read a JSX identifier (valid tag or attribute name).
-//
-// Optimized version since JSX identifiers can't contain
-// escape characters and so can be read as single slice.
-// Also assumes that first character was already checked
-// by isIdentifierStart in readToken.
-
-pp.jsx_readWord = function() {
-  var ch, start = this.pos;
-  do {
-    ch = this.input.charCodeAt(++this.pos);
-  } while (acorn.isIdentifierChar(ch) || ch === 45); // '-'
-  return this.finishToken(tt.jsxName, this.input.slice(start, this.pos));
-};
-
-// Transforms JSX element name to string.
-
-function getQualifiedJSXName(object) {
-  if (object.type === "JSXIdentifier")
-    return object.name;
-
-  if (object.type === "JSXNamespacedName")
-    return object.namespace.name + ':' + object.name.name;
-
-  if (object.type === "JSXMemberExpression")
-    return getQualifiedJSXName(object.object) + '.' +
-    getQualifiedJSXName(object.property);
-}
-
-// Parse next token as JSX identifier
-
-pp.jsx_parseIdentifier = function() {
-  var node = this.startNode();
-  if (this.type === tt.jsxName)
-    node.name = this.value;
-  else if (this.type.keyword)
-    node.name = this.type.keyword;
-  else
-    this.unexpected();
-  this.next();
-  return this.finishNode(node, "JSXIdentifier");
-};
-
-// Parse namespaced identifier.
-
-pp.jsx_parseNamespacedName = function() {
-  var start = this.markPosition();
-  var name = this.jsx_parseIdentifier();
-  if (!this.eat(tt.colon)) return name;
-  var node = this.startNodeAt(start);
-  node.namespace = name;
-  node.name = this.jsx_parseIdentifier();
-  return this.finishNode(node, "JSXNamespacedName");
-};
-
-// Parses element name in any form - namespaced, member
-// or single identifier.
-
-pp.jsx_parseElementName = function() {
-  var start = this.markPosition();
-  var node = this.jsx_parseNamespacedName();
-  while (this.eat(tt.dot)) {
-    var newNode = this.startNodeAt(start);
-    newNode.object = node;
-    newNode.property = this.jsx_parseIdentifier();
-    node = this.finishNode(newNode, "JSXMemberExpression");
-  }
-  return node;
-};
-
-// Parses any type of JSX attribute value.
-
-pp.jsx_parseAttributeValue = function() {
-  switch (this.type) {
-  case tt.braceL:
-    var node = this.jsx_parseExpressionContainer();
-    if (node.expression.type === "JSXEmptyExpression")
-      this.raise(node.start, "JSX attributes must only be assigned a non-empty expression");
-    return node;
-
-  case tt.jsxTagStart:
-  case tt.string:
-    return this.parseExprAtom();
-
-  default:
-    this.raise(this.start, "JSX value should be either an expression or a quoted JSX text");
-  }
-};
-
-// JSXEmptyExpression is unique type since it doesn't actually parse anything,
-// and so it should start at the end of last read token (left brace) and finish
-// at the beginning of the next one (right brace).
-
-pp.jsx_parseEmptyExpression = function() {
-  var tmp = this.start;
-  this.start = this.lastTokEnd;
-  this.lastTokEnd = tmp;
-
-  tmp = this.startLoc;
-  this.startLoc = this.lastTokEndLoc;
-  this.lastTokEndLoc = tmp;
-
-  return this.finishNode(this.startNode(), "JSXEmptyExpression");
-};
-
-// Parses JSX expression enclosed into curly brackets.
-
-
-pp.jsx_parseExpressionContainer = function() {
-  var node = this.startNode();
-  this.next();
-  node.expression = this.type === tt.braceR
-    ? this.jsx_parseEmptyExpression()
-    : this.parseExpression();
-  this.expect(tt.braceR);
-  return this.finishNode(node, "JSXExpressionContainer");
-};
-
-// Parses following JSX attribute name-value pair.
-
-pp.jsx_parseAttribute = function() {
-  var node = this.startNode();
-  if (this.eat(tt.braceL)) {
-    this.expect(tt.ellipsis);
-    node.argument = this.parseMaybeAssign();
-    this.expect(tt.braceR);
-    return this.finishNode(node, "JSXSpreadAttribute");
-  }
-  node.name = this.jsx_parseNamespacedName();
-  node.value = this.eat(tt.eq) ? this.jsx_parseAttributeValue() : null;
-  return this.finishNode(node, "JSXAttribute");
-};
-
-// Parses JSX opening tag starting after '<'.
-
-pp.jsx_parseOpeningElementAt = function(start) {
-  var node = this.startNodeAt(start);
-  node.attributes = [];
-  node.name = this.jsx_parseElementName();
-  while (this.type !== tt.slash && this.type !== tt.jsxTagEnd)
-    node.attributes.push(this.jsx_parseAttribute());
-  node.selfClosing = this.eat(tt.slash);
-  this.expect(tt.jsxTagEnd);
-  return this.finishNode(node, "JSXOpeningElement");
-};
-
-// Parses JSX closing tag starting after '</'.
-
-pp.jsx_parseClosingElementAt = function(start) {
-  var node = this.startNodeAt(start);
-  node.name = this.jsx_parseElementName();
-  this.expect(tt.jsxTagEnd);
-  return this.finishNode(node, "JSXClosingElement");
-};
-
-// Parses entire JSX element, including it's opening tag
-// (starting after '<'), attributes, contents and closing tag.
-
-pp.jsx_parseElementAt = function(start) {
-  var node = this.startNodeAt(start);
-  var children = [];
-  var openingElement = this.jsx_parseOpeningElementAt(start);
-  var closingElement = null;
-
-  if (!openingElement.selfClosing) {
-    contents: for (;;) {
-      switch (this.type) {
-      case tt.jsxTagStart:
-        start = this.markPosition();
-        this.next();
-        if (this.eat(tt.slash)) {
-          closingElement = this.jsx_parseClosingElementAt(start);
-          break contents;
-        }
-        children.push(this.jsx_parseElementAt(start));
-        break;
-
-      case tt.jsxText:
-        children.push(this.parseExprAtom());
-        break;
-
-      case tt.braceL:
-        children.push(this.jsx_parseExpressionContainer());
-        break;
-
-      default:
-        this.unexpected();
-      }
-    }
-    if (getQualifiedJSXName(closingElement.name) !== getQualifiedJSXName(openingElement.name))
-      this.raise(
-        closingElement.start,
-        "Expected corresponding JSX closing tag for <" + getQualifiedJSXName(openingElement.name) + ">");
-  }
-
-  node.openingElement = openingElement;
-  node.closingElement = closingElement;
-  node.children = children;
-  return this.finishNode(node, "JSXElement");
-};
-
-// Parses entire JSX element from current position.
-
-pp.jsx_parseElement = function() {
-  var start = this.markPosition();
-  this.next();
-  return this.jsx_parseElementAt(start);
-};
-
-acorn.plugins.jsx = function(instance) {
-  instance.extend("parseExprAtom", function(inner) {
-    return function(refShortHandDefaultPos) {
-      if (this.type === tt.jsxText)
-        return this.parseLiteral(this.value);
-      else if (this.type === tt.jsxTagStart)
-        return this.jsx_parseElement();
-      else
-        return inner.call(this, refShortHandDefaultPos);
-    };
-  });
-
-  instance.extend("readToken", function(inner) {
-    return function(code) {
-      var context = this.curContext();
-
-      if (context === tc.j_expr) return this.jsx_readToken();
-
-      if (context === tc.j_oTag || context === tc.j_cTag) {
-        if (acorn.isIdentifierStart(code)) return this.jsx_readWord();
-
-        if (code == 62) {
-          ++this.pos;
-          return this.finishToken(tt.jsxTagEnd);
-        }
-
-        if ((code === 34 || code === 39) && context == tc.j_oTag)
-          return this.jsx_readString(code);
-      }
-
-      if (code === 60 && this.exprAllowed) {
-        ++this.pos;
-        return this.finishToken(tt.jsxTagStart);
-      }
-      return inner.call(this, code);
-    };
-  });
-
-  instance.extend("updateContext", function(inner) {
-    return function(prevType) {
-      if (this.type == tt.braceL) {
-        var curContext = this.curContext();
-        if (curContext == tc.j_oTag) this.context.push(tc.b_expr);
-        else if (curContext == tc.j_expr) this.context.push(tc.b_tmpl);
-        else inner.call(this, prevType);
-        this.exprAllowed = true;
-      } else if (this.type === tt.slash && prevType === tt.jsxTagStart) {
-        this.context.length -= 2; // do not consider JSX expr -> JSX open tag -> ... anymore
-        this.context.push(tc.j_cTag); // reconsider as closing tag context
-        this.exprAllowed = false;
-      } else {
-        return inner.call(this, prevType);
-      }
-    };
-  });
-}

src/acorn/src/expression.js

@@ -214,7 +214,12 @@ pp.parseExprSubscripts = function(refShorthandDefaultPos) {
 }
 
 pp.parseSubscripts = function(base, start, noCalls) {
-  if (this.eat(tt.dot)) {
+  if (!noCalls && this.eat(tt.doubleColon)) {
+    let node = this.startNodeAt(start)
+    node.object = base
+    node.callee = this.parseNoCallExpr()
+    return this.parseSubscripts(this.finishNode(node, "BindExpression"), start, noCalls)
+  } else if (this.eat(tt.dot)) {
     let node = this.startNodeAt(start)
     node.object = base
     node.property = this.parseIdent(true)
@@ -240,6 +245,13 @@ pp.parseSubscripts = function(base, start, noCalls) {
   } return base
 }
 
+// Parse a no-call expression (like argument of `new` or `::` operators).
+
+pp.parseNoCallExpr = function() {
+  let start = this.markPosition()
+  return this.parseSubscripts(this.parseExprAtom(), start, true)
+}
+
 // Parse an atomic expression — either a single token that is an
 // expression, an expression started by a keyword like `function` or
 // `new`, or an expression wrapped in punctuation like `()`, `[]`,
@@ -363,6 +375,15 @@ pp.parseExprAtom = function(refShorthandDefaultPos) {
   case tt.backQuote:
     return this.parseTemplate()
 
+  case tt.doubleColon:
+    node = this.startNode()
+    this.next()
+    node.object = null
+    let callee = node.callee = this.parseNoCallExpr()
+    if (callee.type !== "MemberExpression")
+      this.raise(callee.start, "Binding should be performed on object property.")
+    return this.finishNode(node, "BindExpression")
+
   default:
     this.unexpected()
   }
@@ -472,9 +493,11 @@ pp.parseNew = function() {
       this.raise(node.property.start, "The only valid meta property for new is new.target")
     return this.finishNode(node, "MetaProperty")
   }
-  let start = this.markPosition()
-  node.callee = this.parseSubscripts(this.parseExprAtom(), start, true)
-  if (this.eat(tt.parenL)) node.arguments = this.parseExprList(tt.parenR, false)
+  node.callee = this.parseNoCallExpr()
+  if (this.eat(tt.parenL)) node.arguments = this.parseExprList(
+    tt.parenR,
+    this.options.features["es7.trailingFunctionCommas"]
+  )
   else node.arguments = empty
   return this.finishNode(node, "NewExpression")
 }
@@ -632,7 +655,7 @@ pp.parseMethod = function(isGenerator, isAsync) {
   let node = this.startNode()
   this.initFunction(node, isAsync)
   this.expect(tt.parenL)
-  node.params = this.parseBindingList(tt.parenR, false, false)
+  node.params = this.parseBindingList(tt.parenR, false, this.options.features["es7.trailingFunctionCommas"])
   if (this.options.ecmaVersion >= 6) {
     node.generator = isGenerator
   }

src/acorn/src/lookahead.js

@@ -14,7 +14,11 @@ var STATE_KEYS = [
   "pos",
   "end",
   "type",
-  "value"
+  "value",
+  "exprAllowed",
+  "potentialArrowAt",
+  "currLine",
+  "input"
 ];
 
 pp.getState = function () {
@@ -23,6 +27,7 @@ pp.getState = function () {
     var key = STATE_KEYS[i]
     state[key] = this[key]
   }
+  state.context = this.context.slice()
   return state
 };
 

src/acorn/src/statement.js

@@ -504,7 +504,7 @@ pp.parseClass = function(node, isStatement) {
       this.parsePropertyName(method)
     }
     method.kind = "method"
-    if (!method.computed && !isGenerator) {
+    if (!method.computed && !isGenerator && !isAsync) {
       if (method.key.type === "Identifier") {
         if (this.type !== tt.parenL && (method.key.name === "get" || method.key.name === "set")) {
           method.kind = method.key.name

src/acorn/src/tokenize.js

@@ -283,7 +283,7 @@ pp.readToken_lt_gt = function(code) { // '<>'
   }
   if (next == 33 && code == 60 && this.input.charCodeAt(this.pos + 2) == 45 &&
       this.input.charCodeAt(this.pos + 3) == 45) {
-    if (this.inModule) unexpected()
+    if (this.inModule) this.unexpected()
     // `<!--`, an XML-style comment that should be interpreted as a line comment
     this.skipLineComment(4)
     this.skipSpace()
@@ -320,7 +320,13 @@ pp.getTokenFromCode = function(code) {
   case 93: ++this.pos; return this.finishToken(tt.bracketR)
   case 123: ++this.pos; return this.finishToken(tt.braceL)
   case 125: ++this.pos; return this.finishToken(tt.braceR)
-  case 58: ++this.pos; return this.finishToken(tt.colon)
+
+  case 58:
+    if (this.options.features["es7.functionBind"] && this.input.charCodeAt(this.pos + 1) === 58)
+      return this.finishOp(tt.doubleColon, 2)
+    ++this.pos
+    return this.finishToken(tt.colon)
+
   case 63: ++this.pos; return this.finishToken(tt.question)
   case 64: ++this.pos; return this.finishToken(tt.at)
 

src/acorn/src/tokentype.js

@@ -54,6 +54,7 @@ export const types = {
   comma: new TokenType(",", beforeExpr),
   semi: new TokenType(";", beforeExpr),
   colon: new TokenType(":", beforeExpr),
+  doubleColon: new TokenType("::", beforeExpr),
   dot: new TokenType("."),
   question: new TokenType("?", beforeExpr),
   arrow: new TokenType("=>", beforeExpr),

src/babel/api/browser.js

@@ -1,3 +1,4 @@
+require("./node");
 var transform = module.exports = require("../transformation");
 
 transform.options = require("../transformation/file/options");

src/babel/api/node.js

@@ -5,10 +5,12 @@ import * as util from "../util";
 import fs from "fs";
 
 export { util, acorn, transform };
+export { pipeline } from "../transformation";
 export { canCompile } from "../util";
 
 export { default as options } from "../transformation/file/options";
 export { default as Transformer } from "../transformation/transformer";
+export { default as TransformerPipeline } from "../transformation/transformer-pipeline";
 export { default as traverse } from "../traversal";
 export { default as buildExternalHelpers } from "../tools/build-external-helpers";
 export { version } from "../../../package";
@@ -51,19 +53,20 @@ export function transformFile(filename: string, opts?: Object, callback: Functio
 
 export function transformFileSync(filename: string, opts?: Object = {}) {
   opts.filename = filename;
-  return transform(fs.readFileSync(filename), opts);
+  return transform(fs.readFileSync(filename, "utf8"), opts);
 }
 
 export function parse(code, opts = {}) {
+  opts.allowHashBang = true;
   opts.sourceType = "module";
   opts.ecmaVersion = Infinity;
   opts.plugins = {
-    flow: true,
-    jsx:  true
+    jsx:  true,
+    flow: true
   };
   opts.features = {};
 
-  for (var key in transform.transformers) {
+  for (var key in transform.pipeline.transformers) {
     opts.features[key] = true;
   }
 

src/babel/api/register/cache.js

@@ -1,9 +1,9 @@
 import path from "path";
 import os from "os";
 import fs from "fs";
-import userHome from "user-home";
+import homeOrTmp from "home-or-tmp";
 
-const FILENAME = process.env.BABEL_CACHE_PATH || path.join(userHome || os.tmpdir(), ".babel.json");
+const FILENAME = process.env.BABEL_CACHE_PATH || path.join(homeOrTmp, ".babel.json");
 var data = {};
 
 export function save() {

src/babel/api/register/node.js

@@ -53,6 +53,9 @@ var compile = function (filename) {
 
   var cacheKey = `${filename}:${JSON.stringify(opts)}:${babel.version}`;
 
+  var env = process.env.BABEL_ENV || process.env.NODE_ENV;
+  if (env) cacheKey += `:${env}`;
+
   if (cache) {
     var cached = cache[cacheKey];
     if (cached && cached.mtime === mtime(filename)) {
@@ -87,7 +90,7 @@ var shouldIgnore = function (filename) {
 
 var istanbulMonkey = {};
 
-if (process.env.running_under_istanbul) { // jshint ignore:line
+if (process.env.running_under_istanbul) {
   // we need to monkey patch fs.readFileSync so we can hook into
   // what istanbul gets, it's extremely dirty but it's the only way
   var _readFileSync = fs.readFileSync;
@@ -117,7 +120,7 @@ var registerExtension = function (ext) {
   var old = oldHandlers[ext] || oldHandlers[".js"];
 
   var loader = normalLoader;
-  if (process.env.running_under_istanbul) loader = istanbulLoader; // jshint ignore:line
+  if (process.env.running_under_istanbul) loader = istanbulLoader;
 
   require.extensions[ext] = function (m, filename) {
     if (shouldIgnore(filename)) {

src/babel/generation/buffer.js

@@ -117,8 +117,9 @@ export default class Buffer {
 
   _removeSpacesAfterLastNewline() {
     var lastNewlineIndex = this.buf.lastIndexOf("\n");
-    if (lastNewlineIndex === -1)
+    if (lastNewlineIndex === -1) {
       return;
+    }
 
     var index = this.buf.length - 1;
     while (index > lastNewlineIndex) {

src/babel/generation/generators/classes.js

@@ -3,7 +3,7 @@ export function ClassDeclaration(node, print) {
   this.push("class");
 
   if (node.id) {
-    this.space();
+    this.push(" ");
     print(node.id);
   }
 

src/babel/generation/generators/expressions.js

@@ -133,6 +133,12 @@ export function AssignmentExpression(node, print) {
   print(node.right);
 }
 
+export function BindExpression(node, print) {
+  print(node.object);
+  this.push("::");
+  print(node.callee);
+}
+
 export {
   AssignmentExpression as BinaryExpression,
   AssignmentExpression as LogicalExpression,

src/babel/generation/generators/jsx.js

@@ -43,13 +43,13 @@ export function JSXElement(node, print) {
   if (open.selfClosing) return;
 
   this.indent();
-  each(node.children, (child) => {
+  for (var child of (node.children: Array)) {
     if (t.isLiteral(child)) {
       this.push(child.value, true);
     } else {
       print(child);
     }
-  });
+  }
   this.dedent();
 
   print(node.closingElement);

src/babel/generation/generators/modules.js

@@ -3,7 +3,7 @@ import * as t from "../../types";
 
 export function ImportSpecifier(node, print) {
   print(node.imported);
-  if (node.local && node.local !== node.imported) {
+  if (node.local && node.local.name !== node.imported.name) {
     this.push(" as ");
     print(node.local);
   }
@@ -19,7 +19,7 @@ export function ExportDefaultSpecifier(node, print) {
 
 export function ExportSpecifier(node, print) {
   print(node.local);
-  if (node.exported && node.local !== node.exported) {
+  if (node.exported && node.local.name !== node.exported.name) {
     this.push(" as ");
     print(node.exported);
   }

src/babel/generation/generators/statements.js

@@ -182,8 +182,8 @@ export function VariableDeclaration(node, print, parent) {
   var hasInits = false;
   // don't add whitespace to loop heads
   if (!t.isFor(parent)) {
-    for (var i = 0; i < node.declarations.length; i++) {
-      if (node.declarations[i].init) {
+    for (var declar of (node.declarations: Array)) {
+      if (declar.init) {
         // has an init so let's split it up over multiple lines
         hasInits = true;
       }
@@ -191,7 +191,7 @@ export function VariableDeclaration(node, print, parent) {
   }
 
   var sep = ",";
-  if (!this.format.compact && hasInits) {
+  if (!this.format.compact && !this.format.concise && hasInits && !this.format.retainLines) {
     sep += `\n${repeating(" ", node.kind.length + 1)}`;
   } else {
     sep += " ";

src/babel/generation/generators/template-literals.js

@@ -15,15 +15,15 @@ export function TemplateLiteral(node, print) {
   var quasis = node.quasis;
   var len    = quasis.length;
 
-  each(quasis, (quasi, i) => {
-    print(quasi);
+  for (var i = 0; i < len; i++) {
+    print(quasis[i]);
 
     if (i + 1 < len) {
       this.push("${ ");
       print(node.expressions[i]);
       this.push(" }");
     }
-  });
+  }
 
   this._push("`");
 }

src/babel/generation/generators/types.js

@@ -1,4 +1,5 @@
 import each from "lodash/collection/each";
+import * as t from "../../types";
 
 export function Identifier(node) {
   this.push(node.name);
@@ -38,8 +39,21 @@ export function Property(node, print) {
       print(node.key);
       this.push("]");
     } else {
+      // print `({ foo: foo = 5 } = {})` as `({ foo = 5 } = {});`
+      if (t.isAssignmentPattern(node.value) && t.isIdentifier(node.key) && node.key.name === node.value.left.name) {
+        print(node.value);
+        return;
+      }
+
       print(node.key);
-      if (node.shorthand) return;
+
+      // shorthand!
+      if (node.shorthand &&
+        (t.isIdentifier(node.key) &&
+         t.isIdentifier(node.value) &&
+         node.key.name === node.value.name)) {
+        return;
+      }
     }
 
     this.push(":");
@@ -54,7 +68,8 @@ export function ArrayExpression(node, print) {
 
   this.push("[");
 
-  each(elems, (elem, i) => {
+  for (var i = 0; i < elems.length; i++) {
+    var elem = elems[i];
     if (!elem) {
       // If the array expression ends with a hole, that hole
       // will be ignored by the interpreter, but if it ends with
@@ -67,7 +82,7 @@ export function ArrayExpression(node, print) {
       print(elem);
       if (i < len - 1) this.push(",");
     }
-  });
+  }
 
   this.push("]");
 }

src/babel/generation/index.js

@@ -37,7 +37,7 @@ class CodeGenerator {
       retainLines: opts.retainLines,
       comments: opts.comments == null || opts.comments,
       compact: opts.compact,
-      quotes: CodeGenerator.findCommonStringDelimeter(code, tokens),
+      quotes: CodeGenerator.findCommonStringDelimiter(code, tokens),
       indent: {
         adjustMultilineComment: true,
         style: style,
@@ -56,7 +56,7 @@ class CodeGenerator {
     return format;
   }
 
-  static findCommonStringDelimeter(code, tokens) {
+  static findCommonStringDelimiter(code, tokens) {
     var occurences = {
       single: 0,
       double: 0
@@ -105,11 +105,13 @@ class CodeGenerator {
 
     this.print(ast);
 
-    var comments = [];
-    each(ast.comments, function (comment) {
-      if (!comment._displayed) comments.push(comment);
-    });
-    this._printComments(comments);
+    if (ast.comments) {
+      var comments = [];
+      for (var comment of (ast.comments: Array)) {
+        if (!comment._displayed) comments.push(comment);
+      }
+      this._printComments(comments);
+    }
 
     return {
       map:  this.map.get(),
@@ -147,11 +149,12 @@ class CodeGenerator {
     return print;
   }
 
-  catchUp(node, parent) {
+  catchUp(node, parent, leftParenPrinted) {
     // catch up to this nodes newline if we're behind
     if (node.loc && this.format.retainLines && this.buffer.buf) {
       var needsParens = false;
-      if (parent && this.position.line < node.loc.start.line && t.isTerminatorless(parent)) {
+      if (!leftParenPrinted && parent &&
+          this.position.line < node.loc.start.line && t.isTerminatorless(parent)) {
         needsParens = true;
         this._push("(");
       }
@@ -214,7 +217,7 @@ class CodeGenerator {
 
       this.printLeadingComments(node, parent);
 
-      var needsParensFromCatchup = this.catchUp(node, parent);
+      var needsParensFromCatchup = this.catchUp(node, parent, needsParens);
 
       newline(true);
 
@@ -232,14 +235,14 @@ class CodeGenerator {
       this.map.mark(node, "end");
       if (opts.after) opts.after();
 
+      this.format.concise = oldConcise;
+
       newline(false);
 
       this.printTrailingComments(node, parent);
     } else {
       throw new ReferenceError(`unknown node of type ${JSON.stringify(node.type)} with constructor ${JSON.stringify(node && node.constructor.name)}`);
     }
-
-    this.format.concise = oldConcise;
   }
 
   printJoin(print, nodes, opts = {}) {
@@ -249,7 +252,8 @@ class CodeGenerator {
 
     if (opts.indent) this.indent();
 
-    each(nodes, (node, i) => {
+    for (var i = 0; i < nodes.length; i++) {
+      var node = nodes[i];
       print(node, {
         statement: opts.statement,
         addNewlines: opts.addNewlines,
@@ -263,7 +267,7 @@ class CodeGenerator {
           }
         }
       });
-    });
+    }
 
     if (opts.indent) this.dedent();
   }
@@ -314,9 +318,9 @@ class CodeGenerator {
       nodes.push(node.argument);
     }
 
-    each(nodes, (node) => {
+    for (var node of (nodes: Array)) {
       comments = comments.concat(this._getComments(key, node));
-    });
+    }
 
     return comments;
   }
@@ -327,23 +331,24 @@ class CodeGenerator {
 
   _printComments(comments) {
     if (this.format.compact) return;
-
     if (!this.format.comments) return;
     if (!comments || !comments.length) return;
 
-    each(comments, (comment) => {
+    for (var comment of (comments: Array)) {
       var skip = false;
 
-      // find the original comment in the ast and set it as displayed
-      each(this.ast.comments, function (origComment) {
-        if (origComment.start === comment.start) {
-          // comment has already been output
-          if (origComment._displayed) skip = true;
+      if (this.ast.comments) {
+        // find the original comment in the ast and set it as displayed
+        for (var origComment of (this.ast.comments: Array)) {
+          if (origComment.start === comment.start) {
+            // comment has already been output
+            if (origComment._displayed) skip = true;
 
-          origComment._displayed = true;
-          return false;
+            origComment._displayed = true;
+            break;
+          }
         }
-      });
+      }
 
       if (skip) return;
 
@@ -387,7 +392,7 @@ class CodeGenerator {
 
       // whitespace after
       this.newline(this.whitespace.getNewlinesAfter(comment));
-    });
+    }
   }
 }
 

src/babel/generation/source-map.js

@@ -8,7 +8,7 @@ export default class SourceMap {
 
     if (opts.sourceMaps) {
       this.map = new sourceMap.SourceMapGenerator({
-        file: opts.sourceMapName,
+        file: opts.sourceMapTarget,
         sourceRoot: opts.sourceRoot
       });
 

src/babel/helpers/merge.js

@@ -0,0 +1,17 @@
+import merge from "lodash/object/merge";
+
+export default function (dest, src) {
+  if (!dest || !src) return;
+
+  return merge(dest, src, function(a, b) {
+    if (Array.isArray(a)) {
+      var c = a.slice(0);
+      for (var v of b) {
+        if (a.indexOf(v) < 0) {
+          c.push(v);
+        }
+      }
+      return c;
+    }
+  });
+}

src/babel/helpers/parse.js

@@ -1,65 +1,33 @@
 import normalizeAst from "./normalize-ast";
 import estraverse from "estraverse";
-import codeFrame from "./code-frame";
 import * as acorn from "../../acorn";
 
-export default function (opts, code, callback) {
-  try {
-    var comments = [];
-    var tokens   = [];
+export default function (code, opts = {}) {
+  var comments = [];
+  var tokens   = [];
 
-    var parseOpts = {
-      allowImportExportEverywhere: opts.looseModules,
-      allowReturnOutsideFunction:  opts.looseModules,
-      ecmaVersion:                 6,
-      strictMode:                  opts.strictMode,
-      sourceType:                  opts.sourceType,
-      onComment:                   comments,
-      locations:                   true,
-      features:                    opts.features || {},
-      plugins:                     opts.plugins || {},
-      onToken:                     tokens,
-      ranges:                      true
-    };
+  var parseOpts = {
+    allowImportExportEverywhere: opts.looseModules,
+    allowReturnOutsideFunction:  opts.looseModules,
+    allowHashBang:               true,
+    ecmaVersion:                 6,
+    strictMode:                  opts.strictMode,
+    sourceType:                  opts.sourceType,
+    locations:                   true,
+    onComment:                   comments,
+    features:                    opts.features || {},
+    plugins:                     opts.plugins || {},
+    onToken:                     tokens,
+    ranges:                      true
+  };
 
-    if (opts.nonStandard) {
-      parseOpts.plugins.jsx = true;
-      parseOpts.plugins.flow = true;
-    }
-
-    var ast = acorn.parse(code, parseOpts);
-
-    estraverse.attachComments(ast, comments, tokens);
-
-    ast = normalizeAst(ast, comments, tokens);
-
-    if (callback) {
-      return callback(ast);
-    } else {
-      return ast;
-    }
-  } catch (err) {
-    if (!err._babel) {
-      err._babel = true;
-
-      var message = err.message = `${opts.filename}: ${err.message}`;
-
-      var loc = err.loc;
-      if (loc) {
-        err.codeFrame = codeFrame(code, loc.line, loc.column + 1, opts);
-        message += "\n" + err.codeFrame;
-      }
-
-      if (err.stack) {
-        var newStack = err.stack.replace(err.message, message);
-        try {
-          err.stack = newStack;
-        } catch (e) {
-          // `err.stack` may be a readonly property in some environments
-        }
-      }
-    }
-
-    throw err;
+  if (opts.nonStandard) {
+    parseOpts.plugins.jsx = true;
+    parseOpts.plugins.flow = true;
   }
-};
+
+  var ast = acorn.parse(code, parseOpts);
+  estraverse.attachComments(ast, comments, tokens);
+  ast = normalizeAst(ast, comments, tokens);
+  return ast;
+}

src/babel/messages.js

@@ -18,15 +18,16 @@ export const MESSAGES = {
   modulesIllegalExportName: "Illegal export $1",
   unknownForHead: "Unknown node type $1 in ForStatement",
   didYouMean: "Did you mean $1?",
-  evalInStrictMode: "eval is not allowed in strict mode",
   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",
   illegalMethodName: "Illegal method name $1",
+  lostTrackNodePath: "We lost track of this nodes position, likely because the AST was directly manipulated",
+
   traverseNeedsParent: "Must pass a scope and parentPath unless traversing a Program/File got a $1 node",
   traverseVerifyRootFunction: "You passed `traverse()` a function when it expected a visitor object, are you sure you didn't mean `{ enter: Function }`?",
-  traverseVerifyVisitorFunction: "Hey! You passed \`traverse()\` a visitor object with the key $1 that's a straight up `Function` instead of `{ enter: Function }`. You need to normalise it with `traverse.explode(visitor)`.",
   traverseVerifyVisitorProperty: "You passed `traverse()` a visitor object with the property $1 that has the invalid property $2",
+  traverseVerifyNodeType: "You gave us a visitor for the node type $1 but it's not a valid type",
 
   pluginIllegalKind: "Illegal kind $1 for plugin $2",
   pluginIllegalPosition: "Illegal position $1 for plugin $2",

src/babel/patch.js

@@ -33,6 +33,9 @@ def("DoExpression")
   .build("body")
   .field("body", [def("Statement")]);
 
+def("Super")
+  .bases("Expression");
+
 def("ExportDefaultDeclaration")
   .bases("Declaration")
   .build("declaration")
@@ -69,4 +72,10 @@ def("ExportAllDeclaration")
   .field("exported", def("Identifier"))
   .field("source", def("Literal"));
 
+def("BindExpression")
+  .bases("Expression")
+  .build("object", "callee")
+  .field("object", or(def("Expression"), null))
+  .field("callee", def("Expression"));
+
 types.finalize();

src/babel/tools/resolve-rc.js

@@ -1,5 +1,5 @@
 import stripJsonComments from "strip-json-comments";
-import merge from "lodash/object/merge";
+import merge from "../helpers/merge";
 import path from "path";
 import fs from "fs";
 
@@ -42,17 +42,7 @@ export default function (loc, opts = {}) {
       opts.babelrc.push(file);
 
       if (json.breakConfig) return;
-      merge(opts, json, function(a, b) {
-        if (Array.isArray(a)) {
-          var c = a.slice(0);
-          for (var v of b) {
-            if (a.indexOf(v) < 0) {
-              c.push(v);
-            }
-          }
-          return c;
-        }
-      });
+      merge(opts, json);
     }
 
     var up = path.dirname(start);

src/babel/transformation/file/index.js

@@ -1,14 +1,17 @@
 import convertSourceMap from "convert-source-map";
 import * as optionParsers from "./option-parsers";
+import moduleFormatters from "../modules";
 import PluginManager from "./plugin-manager";
 import shebangRegex from "shebang-regex";
 import TraversalPath from "../../traversal/path";
+import Transformer from "../transformer";
 import isFunction from "lodash/lang/isFunction";
 import isAbsolute from "path-is-absolute";
 import resolveRc from "../../tools/resolve-rc";
 import sourceMap from "source-map";
 import transform from "./../index";
 import generate from "../../generation";
+import codeFrame from "../../helpers/code-frame";
 import defaults from "lodash/object/defaults";
 import includes from "lodash/collection/includes";
 import traverse from "../../traversal";
@@ -16,29 +19,18 @@ import assign from "lodash/object/assign";
 import Logger from "./logger";
 import parse from "../../helpers/parse";
 import Scope from "../../traversal/scope";
+import merge from "../../helpers/merge";
 import slash from "slash";
 import clone from "lodash/lang/clone";
 import * as util from  "../../util";
 import * as api from  "../../api/node";
 import path from "path";
-import each from "lodash/collection/each";
 import * as t from "../../types";
 
-var checkTransformerVisitor = {
-  exit(node, parent, scope, state) {
-    checkPath(state.stack, this);
-  }
-};
-
-function checkPath(stack, path) {
-  each(stack, function (pass) {
-    if (pass.shouldRun || pass.ran) return;
-    pass.checkPath(path);
-  });
-}
-
 export default class File {
-  constructor(opts = {}) {
+  constructor(opts = {}, pipeline) {
+    this.transformerDependencies = {};
+
     this.dynamicImportTypes = {};
     this.dynamicImportIds   = {};
     this.dynamicImports     = [];
@@ -46,12 +38,13 @@ export default class File {
     this.declarations = {};
     this.usedHelpers  = {};
     this.dynamicData  = {};
+    this.metadata     = {};
     this.data         = {};
-    this.uids         = {};
 
-    this.log  = new Logger(this, opts.filename || "unknown");
-    this.opts = this.normalizeOptions(opts);
-    this.ast  = {};
+    this.pipeline = pipeline;
+    this.log      = new Logger(this, opts.filename || "unknown");
+    this.opts     = this.normalizeOptions(opts);
+    this.ast      = {};
 
     this.buildTransformers();
   }
@@ -93,10 +86,7 @@ export default class File {
     "interop-require",
   ];
 
-  static soloHelpers = [
-    "ludicrous-proxy-create",
-    "ludicrous-proxy-directory"
-  ];
+  static soloHelpers = [];
 
   static options = require("./options");
 
@@ -118,6 +108,9 @@ export default class File {
       if (!option) this.log.error(`Unknown option: ${key}`, ReferenceError);
     }
 
+    var envKey = process.env.BABEL_ENV || process.env.NODE_ENV || "development";
+    if (opts.env) merge(opts, opts.env[envKey]);
+
     for (let key in File.options) {
       let option = File.options[key];
 
@@ -133,7 +126,7 @@ export default class File {
       }
 
       var optionParser = optionParsers[option.type];
-      if (optionParser) val = optionParser(key, val);
+      if (optionParser) val = optionParser(key, val, this.pipeline);
 
       if (option.alias) {
         opts[option.alias] = opts[option.alias] || val;
@@ -175,7 +168,7 @@ export default class File {
 
     defaults(opts, {
       sourceFileName: opts.filenameRelative,
-      sourceMapName:  opts.filenameRelative
+      sourceMapTarget:  opts.filenameRelative
     });
 
     //
@@ -200,7 +193,8 @@ export default class File {
     var stack = [];
 
     // build internal transformers
-    each(transform.transformers, function (transformer, key) {
+    for (var key in this.pipeline.transformers) {
+      var transformer = this.pipeline.transformers[key];
       var pass = transformers[key] = transformer.buildPass(file);
 
       if (pass.canTransform()) {
@@ -214,7 +208,7 @@ export default class File {
           transformer.manipulateOptions(file.opts, file);
         }
       }
-    });
+    }
 
     // init plugins!
     var beforePlugins = [];
@@ -230,50 +224,55 @@ export default class File {
     }
     stack = beforePlugins.concat(stack, afterPlugins);
 
-    // register
-    this.transformerStack = stack.concat(secondaryStack);
-  }
+    // build transformer stack
+    this.uncollapsedTransformerStack = stack = stack.concat(secondaryStack);
 
-  getModuleFormatter(type: string) {
-    var ModuleFormatter = isFunction(type) ? type : transform.moduleFormatters[type];
-
-    if (!ModuleFormatter) {
-      var loc = util.resolveRelative(type);
-      if (loc) ModuleFormatter = require(loc);
-    }
-
-    if (!ModuleFormatter) {
-      throw new ReferenceError(`Unknown module formatter type ${JSON.stringify(type)}`);
-    }
-
-    return new ModuleFormatter(this);
-  }
-
-  parseInputSourceMap(code: string) {
-    var opts = this.opts;
-
-    if (opts.inputSourceMap !== false) {
-      var inputMap = convertSourceMap.fromSource(code);
-      if (inputMap) {
-        opts.inputSourceMap = inputMap.toObject();
-        code = convertSourceMap.removeComments(code);
+    // build dependency graph
+    for (var pass of (stack: Array)) {
+      for (var dep of (pass.transformer.dependencies: Array)) {
+        this.transformerDependencies[dep] = pass.key;
       }
     }
 
-    return code;
+    // collapse stack categories
+    this.transformerStack = this.collapseStack(stack);
   }
 
-  parseShebang(code: string) {
-    var shebangMatch = shebangRegex.exec(code);
+  collapseStack(_stack) {
+    var stack  = [];
+    var ignore = [];
 
-    if (shebangMatch) {
-      this.shebang = shebangMatch[0];
+    for (let pass of (_stack: Array)) {
+      // been merged
+      if (ignore.indexOf(pass) >= 0) continue;
 
-      // remove shebang
-      code = code.replace(shebangRegex, "");
+      var group = pass.transformer.metadata.group;
+
+      // can't merge
+      if (!pass.canTransform() || !group) {
+        stack.push(pass);
+        continue;
+      }
+
+      var mergeStack = [];
+      for (let pass of (_stack: Array)) {
+        if (pass.transformer.metadata.group === group) {
+          mergeStack.push(pass);
+          ignore.push(pass);
+        }
+      }
+
+      var visitors = [];
+      for (let pass of (mergeStack: Array)) {
+        visitors.push(pass.handlers);
+      }
+      var visitor = traverse.visitors.merge(visitors);
+      var mergeTransformer = new Transformer(group, visitor);
+      //console.log(mergeTransformer);
+      stack.push(mergeTransformer.buildPass(this));
     }
 
-    return code;
+    return stack;
   }
 
   set(key: string, val): any {
@@ -368,13 +367,25 @@ export default class File {
     }
 
     var ref = util.template("helper-" + name);
-    ref._compact = true;
+
     var uid = this.declarations[name] = this.scope.generateUidIdentifier(name);
-    this.scope.push({
-      id: uid,
-      init: ref,
-      unique: true
-    });
+
+    if (t.isFunctionExpression(ref) && !ref.id) {
+      ref.body._compact = true;
+      ref._generated = true;
+      ref.id = uid;
+      ref.type = "FunctionDeclaration";
+      this.attachAuxiliaryComment(ref);
+      this.path.unshiftContainer("body", ref);
+    } else {
+      ref._compact = true;
+      this.scope.push({
+        id: uid,
+        init: ref,
+        unique: true
+      });
+    }
+
     return uid;
   }
 
@@ -385,127 +396,6 @@ export default class File {
     return err;
   }
 
-  addCode(code: string) {
-    code = (code || "") + "";
-    code = this.parseInputSourceMap(code);
-    this.code = code;
-    return this.parseShebang(code);
-  }
-
-  shouldIgnore() {
-    var opts = this.opts;
-    return util.shouldIgnore(opts.filename, opts.ignore, opts.only);
-  }
-
-  parse(code: string) {
-    if (this.shouldIgnore()) {
-      return {
-        metadata: {},
-        code:     code,
-        map:      null,
-        ast:      null
-      };
-    }
-
-    code = this.addCode(code);
-
-    var opts = this.opts;
-
-    //
-
-    var parseOpts = {
-      highlightCode: opts.highlightCode,
-      nonStandard:   opts.nonStandard,
-      filename:      opts.filename,
-      plugins:       {}
-    };
-
-    var features = parseOpts.features = {};
-    for (var key in this.transformers) {
-      var transformer = this.transformers[key];
-      features[key] = transformer.canTransform();
-    }
-
-    parseOpts.looseModules = this.isLoose("es6.modules");
-    parseOpts.strictMode = features.strict;
-    parseOpts.sourceType = "module";
-
-    this.log.debug("Parse start");
-
-    //
-
-    return parse(parseOpts, code, (tree) => {
-      this.log.debug("Parse stop");
-      this.transform(tree);
-      return this.generate();
-    });
-  }
-
-  setAst(ast) {
-    this.path  = TraversalPath.get(null, null, ast, ast, "program", this);
-    this.scope = this.path.scope;
-    this.ast   = ast;
-
-    this.path.traverse({
-      enter(node, parent, scope) {
-        if (this.isScope()) {
-          for (var key in scope.bindings) {
-            scope.bindings[key].setTypeAnnotation();
-          }
-        }
-      }
-    });
-  }
-
-  transform(ast) {
-    this.log.debug("Start set AST");
-    this.setAst(ast);
-    this.log.debug("End set AST");
-
-    this.log.debug("Start prepass");
-    this.checkPath(this.path);
-    this.log.debug("End prepass");
-
-    this.log.debug("Start module formatter init");
-    var modFormatter = this.moduleFormatter = this.getModuleFormatter(this.opts.modules);
-    if (modFormatter.init && this.transformers["es6.modules"].canTransform()) {
-      modFormatter.init();
-    }
-    this.log.debug("End module formatter init");
-
-    this.call("pre");
-    each(this.transformerStack, function (pass) {
-      pass.transform();
-    });
-    this.call("post");
-  }
-
-  call(key: string) {
-    var stack = this.transformerStack;
-    for (var i = 0; i < stack.length; i++) {
-      var transformer = stack[i].transformer;
-      var fn = transformer[key];
-      if (fn) fn(this);
-    }
-  }
-
-  checkPath(path) {
-    if (Array.isArray(path)) {
-      for (var i = 0; i < path.length; i++) {
-        this.checkPath(path[i]);
-      }
-      return;
-    }
-
-    var stack = this.transformerStack;
-
-    checkPath(stack, path);
-
-    path.traverse(checkTransformerVisitor, {
-      stack: stack
-    });
-  }
-
   mergeSourceMap(map: Object) {
     var opts = this.opts;
 
@@ -528,6 +418,165 @@ export default class File {
     return map;
   }
 
+
+  getModuleFormatter(type: string) {
+    var ModuleFormatter = isFunction(type) ? type : moduleFormatters[type];
+
+    if (!ModuleFormatter) {
+      var loc = util.resolveRelative(type);
+      if (loc) ModuleFormatter = require(loc);
+    }
+
+    if (!ModuleFormatter) {
+      throw new ReferenceError(`Unknown module formatter type ${JSON.stringify(type)}`);
+    }
+
+    return new ModuleFormatter(this);
+  }
+
+  parse(code: string) {
+    var opts = this.opts;
+
+    //
+
+    var parseOpts = {
+      highlightCode: opts.highlightCode,
+      nonStandard:   opts.nonStandard,
+      filename:      opts.filename,
+      plugins:       {}
+    };
+
+    var features = parseOpts.features = {};
+    for (var key in this.transformers) {
+      var transformer = this.transformers[key];
+      features[key] = transformer.canTransform();
+    }
+
+    parseOpts.looseModules = this.isLoose("es6.modules");
+    parseOpts.strictMode = features.strict;
+    parseOpts.sourceType = "module";
+
+    this.log.debug("Parse start");
+    var tree = parse(code, parseOpts);
+    this.log.debug("Parse stop");
+    return tree;
+  }
+
+  _addAst(ast) {
+    this.path  = TraversalPath.get(null, ast, ast, "program", this).setContext(null, this);
+    this.scope = this.path.scope;
+    this.ast   = ast;
+  }
+
+  addAst(ast) {
+    this.log.debug("Start set AST");
+    this._addAst(ast);
+    this.log.debug("End set AST");
+
+    this.log.debug("Start module formatter init");
+    var modFormatter = this.moduleFormatter = this.getModuleFormatter(this.opts.modules);
+    if (modFormatter.init && this.transformers["es6.modules"].canTransform()) {
+      modFormatter.init();
+    }
+    this.log.debug("End module formatter init");
+
+    this.call("pre");
+    for (var pass of (this.transformerStack: Array)) {
+      pass.transform();
+    }
+    this.call("post");
+  }
+
+  wrap(code, callback) {
+    code = code + "";
+
+    try {
+      if (this.shouldIgnore()) {
+        return {
+          metadata: this.metadata,
+          ignored:  true,
+          code:     code,
+          map:      null,
+          ast:      null
+        };
+      }
+
+      callback();
+
+      return this.generate();
+    } catch (err) {
+      if (err._babel) {
+        throw err;
+      } else {
+        err._babel = true;
+      }
+
+      var message = err.message = `${this.opts.filename}: ${err.message}`;
+
+      var loc = err.loc;
+      if (loc) {
+        err.codeFrame = codeFrame(code, loc.line, loc.column + 1, this.opts);
+        message += "\n" + err.codeFrame;
+      }
+
+      if (err.stack) {
+        var newStack = err.stack.replace(err.message, message);
+        try {
+          err.stack = newStack;
+        } catch (e) {
+          // `err.stack` may be a readonly property in some environments
+        }
+      }
+
+      throw err;
+    }
+  }
+
+  addCode(code: string, parseCode?) {
+    code = (code || "") + "";
+    code = this.parseInputSourceMap(code);
+    this.code = code;
+
+    if (parseCode) {
+      this.parseShebang();
+      this.addAst(this.parse(this.code));
+    }
+  }
+
+  shouldIgnore() {
+    var opts = this.opts;
+    return util.shouldIgnore(opts.filename, opts.ignore, opts.only);
+  }
+
+  call(key: string) {
+    for (var pass of (this.uncollapsedTransformerStack: Array)) {
+      var fn = pass.transformer[key];
+      if (fn) fn(this);
+    }
+  }
+
+  parseInputSourceMap(code: string) {
+    var opts = this.opts;
+
+    if (opts.inputSourceMap !== false) {
+      var inputMap = convertSourceMap.fromSource(code);
+      if (inputMap) {
+        opts.inputSourceMap = inputMap.toObject();
+        code = convertSourceMap.removeComments(code);
+      }
+    }
+
+    return code;
+  }
+
+  parseShebang() {
+    var shebangMatch = shebangRegex.exec(this.code);
+    if (shebangMatch) {
+      this.shebang = shebangMatch[0];
+      this.code = this.code.replace(shebangRegex, "");
+    }
+  }
+
   generate(): {
     usedHelpers?: Array<string>;
     code: string;
@@ -538,7 +587,7 @@ export default class File {
     var ast  = this.ast;
 
     var result = {
-      metadata: {},
+      metadata: this.metadata,
       code:     "",
       map:      null,
       ast:      null

src/babel/transformation/file/logger.js

@@ -1,4 +1,7 @@
-import * as util from  "../../util";
+import buildDebug from "debug/node";
+
+var verboseDebug = buildDebug("babel:verbose");
+var generalDebug = buildDebug("babel");
 
 export default class Logger {
   constructor(file: File, filename: string) {
@@ -22,11 +25,15 @@ export default class Logger {
     }
   }
 
+  verbose(msg: string) {
+    if (verboseDebug.enabled) verboseDebug(this._buildMessage(msg));
+  }
+
   debug(msg: string) {
-    util.debug(this._buildMessage(msg));
+    if (generalDebug.enabled) generalDebug(this._buildMessage(msg));
   }
 
   deopt(node: Object, msg: string) {
-    util.debug(this._buildMessage(msg));
+    this.debug(msg);
   }
 }

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

@@ -1,14 +1,13 @@
-import transform from "./../index";
 import * as util from  "../../util";
 
-export function transformerList(key, val) {
+export function transformerList(key, val, pipeline) {
   val = util.arrayify(val);
 
   if (val.indexOf("all") >= 0 || val.indexOf(true) >= 0) {
-    val = Object.keys(transform.transformers);
+    val = Object.keys(pipeline.transformers);
   }
 
-  return transform._ensureTransformerNames(key, val);
+  return pipeline._ensureTransformerNames(key, val);
 }
 
 export function number(key, val) {

src/babel/transformation/file/options.json

@@ -20,13 +20,21 @@
     "default": {}
   },
 
+  "env": {
+    "hidden": true,
+    "default": {}
+  },
+
   "moduleId": {
     "description": "specify a custom name for module ids",
     "type": "string"
   },
 
+  "getModuleId": {
+    "hidden": true
+  },
+
   "retainLines": {
-    "hidden": true,
     "type": "boolean",
     "default": false,
     "description": "retain line numbers - will result in really ugly code"
@@ -35,7 +43,7 @@
   "nonStandard": {
     "type": "boolean",
     "default": true,
-    "description": "enable support for JSX and Flow"
+    "description": "enable/disable support for JSX and Flow (on by default)"
   },
 
   "experimental": {
@@ -43,7 +51,7 @@
   },
 
   "highlightCode": {
-    "description": "ANSI syntax highlight code frames",
+    "description": "enable/disable ANSI syntax highlighting of code frames (on by default)",
     "type": "boolean",
     "default": true
   },
@@ -140,7 +148,7 @@
   "comments": {
     "type": "boolean",
     "default": true,
-    "description": "output comments in generated output"
+    "description": "strip/output comments in generated output (on by default)"
   },
 
   "compact": {
@@ -189,6 +197,11 @@
   },
 
   "sourceMapName": {
+    "alias": "sourceMapTarget",
+    "description": "DEPRECATED - Please use sourceMapTarget"
+  },
+
+  "sourceMapTarget": {
     "type": "string",
     "description": "set `file` on returned source map"
   },

src/babel/transformation/file/plugin-manager.js

@@ -1,3 +1,4 @@
+import * as node from  "../../api/node";
 import * as messages from "../../messages";
 import * as util from  "../../util";
 
@@ -34,7 +35,7 @@ export default class PluginManager {
     var match = name.match(/^(.*?):(after|before)$/);
     if (match) [, name, position] = match;
 
-    var loc = util.resolveRelative(name) || util.resolveRelative(`babel-plugin-${name}`);
+    var loc = util.resolveRelative(`babel-plugin-${name}`) || util.resolveRelative(name);
     if (loc) {
       return {
         position: position,
@@ -56,6 +57,9 @@ export default class PluginManager {
     if (!plugin.buildPass || plugin.constructor.name !== "Transformer") {
       throw new TypeError(messages.get("pluginNotTransformer", name));
     }
+
+    // register as a plugin
+    plugin.metadata.plugin = true;
   }
 
   add(name) {
@@ -64,7 +68,7 @@ export default class PluginManager {
 
     if (name) {
       if (typeof name === "object" && name.transformer) {
-        ({ plugin: name, position } = name);
+        ({ transformer: plugin, position } = name);
       } else if (typeof name !== "string") {
         // not a string so we'll just assume that it's a direct Transformer instance, if not then
         // the checks later on will complain

src/babel/transformation/helpers/build-binary-assignment-operator-transformer.js

@@ -1,7 +1,9 @@
 import explode from "./explode-assignable-expression";
 import * as t from "../../types";
 
-export default function (exports, opts) {
+export default function (opts) {
+  var exports = {};
+
   var isAssignment = function (node) {
     return node.operator === opts.operator + "=";
   };
@@ -10,10 +12,6 @@ export default function (exports, opts) {
     return t.assignmentExpression("=", left, right);
   };
 
-  exports.shouldVisit = function (node) {
-    return node.operator && (node.operator === opts.operator || node.operator === opts.operator + "=");
-  };
-
   exports.ExpressionStatement = function (node, parent, scope, file) {
     // hit the `AssignmentExpression` one below
     if (this.isCompletionRecord()) return;
@@ -44,4 +42,6 @@ export default function (exports, opts) {
     if (node.operator !== opts.operator) return;
     return opts.build(node.left, node.right);
   };
+
+  return exports;
 };

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

@@ -10,14 +10,8 @@ import * as react from "./react";
 import * as t from "../../types";
 
 export default function (exports, opts) {
-  exports.check = function (node) {
-    if (t.isJSX(node)) return true;
-    if (react.isCreateClass(node)) return true;
-    return false;
-  };
-
   exports.JSXIdentifier = function (node, parent) {
-    if (node.name === "this" && t.isReferenced(node, parent)) {
+    if (node.name === "this" && this.isReferenced()) {
       return t.thisExpression();
     } else if (esutils.keyword.isIdentifierNameES6(node.name)) {
       node.type = "Identifier";

src/babel/transformation/helpers/define-map.js

@@ -26,7 +26,7 @@ export function push(mutatorMap, node, kind, file) {
 
   if (node.decorators) {
     var decorators = map.decorators = map.decorators || t.arrayExpression([]);
-    decorators.elements = decorators.elements.concat(node.decorators.map(dec => dec.expression));
+    decorators.elements = decorators.elements.concat(node.decorators.map(dec => dec.expression).reverse());
   }
 
   if (map.value || map.initializer) {

src/babel/transformation/helpers/explode-assignable-expression.js

@@ -26,7 +26,7 @@ var getObjRef = function (node, nodes, file, scope) {
     throw new Error(`We can't explode this node type ${node.type}`);
   }
 
-  var temp = scope.generateUidBasedOnNode(ref);
+  var temp = scope.generateUidIdentifierBasedOnNode(ref);
   nodes.push(t.variableDeclaration("var", [
     t.variableDeclarator(temp, ref)
   ]));
@@ -38,7 +38,7 @@ var getPropRef = function (node, nodes, file, scope) {
   var key = t.toComputedKey(node, prop);
   if (t.isLiteral(key)) return key;
 
-  var temp = scope.generateUidBasedOnNode(prop);
+  var temp = scope.generateUidIdentifierBasedOnNode(prop);
   nodes.push(t.variableDeclaration("var", [
     t.variableDeclarator(temp, prop)
   ]));

src/babel/transformation/helpers/memoise-decorators.js

@@ -6,7 +6,7 @@ export default function (decorators, scope) {
     var expression = decorator.expression;
     if (!t.isMemberExpression(expression)) continue;
 
-    var temp = scope.generateMemoisedReference(expression.object);
+    var temp = scope.maybeGenerateMemoised(expression.object);
     var ref;
 
     var nodes = [];

src/babel/transformation/helpers/remap-async-to-generator.js

@@ -19,7 +19,7 @@ var awaitVisitor = {
 var referenceVisitor = {
   enter(node, parent, scope, state) {
     var name = state.id.name;
-    if (t.isReferencedIdentifier(node, parent, { name: name }) && scope.bindingIdentifierEquals(name, state.id)) {
+    if (this.isReferencedIdentifier({ name: name }) && scope.bindingIdentifierEquals(name, state.id)) {
       return state.ref = state.ref || scope.generateUidIdentifier(name);
     }
   }

src/babel/transformation/index.js

@@ -1,68 +1,41 @@
-import normalizeAst from "../helpers/normalize-ast";
-import Transformer from "./transformer";
-import object from "../helpers/object";
-import File from "./file";
-import each from "lodash/collection/each";
+import Pipeline from "./transformer-pipeline";
 
-export default function transform(code: string, opts?: Object) {
-  var file = new File(opts);
-  return file.parse(code);
+var pipeline = new Pipeline;
+
+//
+
+import transformers from "./transformers";
+
+for (var key in transformers) {
+  var transformer = transformers[key];
+  var metadata = transformer.metadata = transformer.metadata || {};
+  metadata.group = metadata.group || "builtin-basic";
 }
 
-transform.fromAst = function (ast, code, opts) {
-  ast = normalizeAst(ast);
+pipeline.addTransformers(transformers);
 
-  var file = new File(opts);
-  file.addCode(code);
-  file.transform(ast);
-  return file.generate();
-};
+//
 
-transform._ensureTransformerNames = function (type: string, rawKeys: Array<string>) {
-  var keys = [];
+import deprecated from "./transformers/deprecated";
+pipeline.addDeprecated(deprecated);
 
-  for (var i = 0; i < rawKeys.length; i++) {
-    var key = rawKeys[i];
+//
 
-    var deprecatedKey = transform.deprecatedTransformerMap[key];
-    var aliasKey = transform.aliasTransformerMap[key];
-    if (aliasKey) {
-      keys.push(aliasKey);
-    } else if (deprecatedKey) {
-      // deprecated key, remap it to the new one
-      console.error(`The transformer ${key} has been renamed to ${deprecatedKey}`);
-      rawKeys.push(deprecatedKey);
-    } else if (transform.transformers[key]) {
-      // valid key
-      keys.push(key);
-    } else if (transform.namespaces[key]) {
-      // namespace, append all transformers within this namespace
-      keys = keys.concat(transform.namespaces[key]);
-    } else {
-      // invalid key
-      throw new ReferenceError(`Unknown transformer ${key} specified in ${type}`);
-    }
-  }
+import aliases from "./transformers/aliases";
+pipeline.addAliases(aliases);
 
-  return keys;
-};
+//
 
-transform.transformerNamespaces = object();
-transform.transformers          = object();
-transform.namespaces            = object();
+import * as filters from "./transformers/filters";
+pipeline.addFilter(filters.internal);
+pipeline.addFilter(filters.blacklist);
+pipeline.addFilter(filters.whitelist);
+pipeline.addFilter(filters.stage);
+pipeline.addFilter(filters.optional);
 
-transform.deprecatedTransformerMap = require("./transformers/deprecated");
-transform.aliasTransformerMap = require("./transformers/aliases");
-transform.moduleFormatters = require("./modules");
+//
 
-import rawTransformers from "./transformers";
-
-each(rawTransformers, function (transformer, key) {
-  var namespace = key.split(".")[0];
-
-  transform.namespaces[namespace] = transform.namespaces[namespace] || [];
-  transform.namespaces[namespace].push(key);
-  transform.transformerNamespaces[key] = namespace;
-
-  transform.transformers[key] = new Transformer(key, transformer);
-});
+var transform = pipeline.transform.bind(pipeline);
+transform.fromAst = pipeline.transformFromAst.bind(pipeline);
+transform.pipeline = pipeline;
+export default transform;

src/babel/transformation/modules/_default.js

@@ -7,57 +7,65 @@ import * as t from "../../types";
 
 var remapVisitor = {
   enter(node, parent, scope, formatter) {
-    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;
-      }
-    }
-
-    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 (node._skipModulesRemap) {
       return this.skip();
     }
   },
 
-  exit(node, parent, scope, formatter) {
-    if (t.isAssignmentExpression(node) && !node._ignoreModulesRemap) {
-      var exported = formatter.getExport(node.left, scope);
-      if (exported) {
-        return formatter.remapExportAssignment(node, exported);
+  ReferencedIdentifier(node, parent, scope, formatter) {
+    var remap = formatter.internalRemap[node.name];
+
+    if (remap && node !== remap) {
+      if (!scope.hasBinding(node.name) || scope.bindingIdentifierEquals(node.name, formatter.localImports[node.name])) {
+        if (this.key === "callee" && this.parentPath.isCallExpression()) {
+          return t.sequenceExpression([t.literal(0), remap]);
+        } else {
+          return remap;
+        }
       }
     }
+  },
+
+  AssignmentExpression: {
+    exit(node, parent, scope, formatter) {
+      if (!node._ignoreModulesRemap) {
+        var exported = formatter.getExport(node.left, scope);
+        if (exported) {
+          return formatter.remapExportAssignment(node, exported);
+        }
+      }
+    }
+  },
+
+  UpdateExpression(node, parent, scope, formatter) {
+    var exported = formatter.getExport(node.argument, scope);
+    if (!exported) return;
+
+    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);
   }
 };
 
@@ -70,7 +78,7 @@ var importsVisitor = {
   }
 };
 
-var exportsVisitor = traverse.explode({
+var exportsVisitor = {
   ExportDeclaration: {
     enter(node, parent, scope, formatter) {
       formatter.hasLocalExports = true;
@@ -102,7 +110,7 @@ var exportsVisitor = traverse.explode({
       }
     }
   }
-});
+};
 
 export default class DefaultFormatter {
   constructor(file) {
@@ -184,7 +192,10 @@ export default class DefaultFormatter {
 
   getModuleName() {
     var opts = this.file.opts;
-    if (opts.moduleId) return opts.moduleId;
+    // moduleId is n/a if a `getModuleId()` is provided
+    if (opts.moduleId && !opts.getModuleId) {
+      return opts.moduleId;
+    }
 
     var filenameRelative = opts.filenameRelative;
     var moduleName = "";
@@ -213,7 +224,12 @@ export default class DefaultFormatter {
     // normalize path separators
     moduleName = moduleName.replace(/\\/g, "/");
 
-    return moduleName;
+    if (opts.getModuleId) {
+      // If return is falsy, assume they want us to use our generated default name
+      return opts.getModuleId(moduleName) || moduleName;
+    } else {
+      return moduleName;
+    }
   }
 
   _pushStatement(ref, nodes) {

src/babel/transformation/modules/amd.js

@@ -6,8 +6,8 @@ import * as util from  "../../util";
 import * as t from "../../types";
 
 export default class AMDFormatter extends DefaultFormatter {
-  init() {
-    CommonFormatter.prototype._init.call(this, this.hasNonDefaultExports);
+  setup() {
+    CommonFormatter.prototype._setup.call(this, this.hasNonDefaultExports);
   }
 
   buildDependencyLiterals() {
@@ -23,7 +23,7 @@ export default class AMDFormatter extends DefaultFormatter {
    */
 
   transform(program) {
-    DefaultFormatter.prototype.transform.apply(this, arguments);
+    CommonFormatter.prototype.transform.apply(this, arguments);
 
     var body = program.body;
 
@@ -92,9 +92,9 @@ export default class AMDFormatter extends DefaultFormatter {
       // import foo from "foo";
       var uid = this.scope.generateUidIdentifier(specifier.local.name);
       nodes.push(t.variableDeclaration("var", [
-        t.variableDeclarator(uid, t.callExpression(this.file.addHelper("interop-require"), [ref]))
+        t.variableDeclarator(uid, t.callExpression(this.file.addHelper("interop-require-default"), [ref]))
       ]));
-      ref = uid;
+      ref = t.memberExpression(uid, t.identifier("default"));
     } else {
       // import { foo } from "foo";
       var imported = specifier.imported;
@@ -108,12 +108,16 @@ export default class AMDFormatter extends DefaultFormatter {
   exportSpecifier(specifier, node, nodes) {
     if (this.doDefaultExportInterop(specifier)) {
       this.passModuleArg = true;
-      nodes.push(util.template("exports-default-assign", {
-        VALUE: specifier.local
-      }, true));
-    } else {
-      CommonFormatter.prototype.exportSpecifier.apply(this, arguments);
+
+      if (specifier.exported !== specifier.local && !node.source) {
+        nodes.push(util.template("exports-default-assign", {
+          VALUE: specifier.local
+        }, true));
+        return;
+      }
     }
+
+    CommonFormatter.prototype.exportSpecifier.apply(this, arguments);
   }
 
   exportDeclaration(node, nodes) {

src/babel/transformation/modules/common.js

@@ -4,11 +4,11 @@ import * as util from  "../../util";
 import * as t from "../../types";
 
 export default class CommonJSFormatter extends DefaultFormatter {
-  init() {
-    this._init(this.hasLocalExports);
+  setup() {
+    this._setup(this.hasLocalExports);
   }
 
-  _init(conditional) {
+  _setup(conditional) {
     var file  = this.file;
     var scope = file.scope;
 
@@ -52,7 +52,7 @@ export default class CommonJSFormatter extends DefaultFormatter {
       } else if (this.noInteropRequireImport) {
         this.internalRemap[variableName.name] = t.memberExpression(ref, t.identifier("default"));
       } else {
-        var uid = this.scope.generateUidBasedOnNode(node, "import");
+        var uid = this.scope.generateUidIdentifierBasedOnNode(node, "import");
 
         nodes.push(t.variableDeclaration("var", [
           t.variableDeclarator(uid, t.callExpression(this.file.addHelper("interop-require-default"), [ref]))
@@ -111,7 +111,7 @@ export default class CommonJSFormatter extends DefaultFormatter {
     } else if (this.isModuleType(node, "absoluteDefault")) {
       call = t.memberExpression(call, t.identifier("default"));
     } else {
-      uid = this.scope.generateUidBasedOnNode(node, "import");
+      uid = this.scope.generateUidIdentifierBasedOnNode(node, "import");
     }
 
     uid = uid || node.specifiers[0].local;

src/babel/transformation/modules/system.js

@@ -1,5 +1,6 @@
 import DefaultFormatter from "./_default";
 import AMDFormatter from "./amd";
+import object from  "../../helpers/object";
 import * as util from  "../../util";
 import last from "lodash/array/last";
 import each from "lodash/collection/each";
@@ -7,41 +8,39 @@ import map from "lodash/collection/map";
 import * as t from "../../types";
 
 var hoistVariablesVisitor = {
-  enter(node, parent, scope, state) {
-    if (t.isFunction(node)) {
-      // nothing inside is accessible
-      return this.skip();
+  Function() {
+    // nothing inside is accessible
+    this.skip();
+  },
+
+  VariableDeclaration(node, parent, scope, state) {
+    if (node.kind !== "var" && !t.isProgram(parent)) { // let, const
+      // can't be accessed
+      return;
     }
 
-    if (t.isVariableDeclaration(node)) {
-      if (node.kind !== "var" && !t.isProgram(parent)) { // let, const
-        // can't be accessed
-        return;
+    // ignore block hoisted nodes as these can be left in
+    if (state.formatter._canHoist(node)) return;
+
+    var nodes = [];
+
+    for (var i = 0; i < node.declarations.length; i++) {
+      var declar = node.declarations[i];
+      state.hoistDeclarators.push(t.variableDeclarator(declar.id));
+      if (declar.init) {
+        // no initializer so we can just hoist it as-is
+        var assign = t.expressionStatement(t.assignmentExpression("=", declar.id, declar.init));
+        nodes.push(assign);
       }
-
-      // ignore block hoisted nodes as these can be left in
-      if (state.formatter.canHoist(node)) return;
-
-      var nodes = [];
-
-      for (var i = 0; i < node.declarations.length; i++) {
-        var declar = node.declarations[i];
-        state.hoistDeclarators.push(t.variableDeclarator(declar.id));
-        if (declar.init) {
-          // no initializer so we can just hoist it as-is
-          var assign = t.expressionStatement(t.assignmentExpression("=", declar.id, declar.init));
-          nodes.push(assign);
-        }
-      }
-
-      // for (var i in test)
-      // for (var i = 0;;)
-      if (t.isFor(parent) && parent.left === node) {
-        return node.declarations[0].id;
-      }
-
-      return nodes;
     }
+
+    // for (var i in test)
+    // for (var i = 0;;)
+    if (t.isFor(parent) && (parent.left === node || parent.init === node)) {
+      return node.declarations[0].id;
+    }
+
+    return nodes;
   }
 };
 
@@ -49,7 +48,7 @@ var hoistFunctionsVisitor = {
   enter(node, parent, scope, state) {
     if (t.isFunction(node)) this.skip();
 
-    if (t.isFunctionDeclaration(node) || state.formatter.canHoist(node)) {
+    if (t.isFunctionDeclaration(node) || state.formatter._canHoist(node)) {
       state.handlerBody.push(node);
       this.remove();
     }
@@ -60,12 +59,12 @@ var runnerSettersVisitor = {
   enter(node, parent, scope, state) {
     if (node._importSource === state.source) {
       if (t.isVariableDeclaration(node)) {
-        each(node.declarations, function (declar) {
+        for (var declar of (node.declarations: Array)) {
           state.hoistDeclarators.push(t.variableDeclarator(declar.id));
           state.nodes.push(t.expressionStatement(
             t.assignmentExpression("=", declar.id, declar.init)
           ));
-        });
+        }
       } else {
         state.nodes.push(node);
       }
@@ -100,14 +99,14 @@ export default class SystemFormatter extends AMDFormatter {
     var right = objectIdentifier;
 
     var block = t.blockStatement([
-      t.expressionStatement(this.buildExportCall(leftIdentifier, valIdentifier))
+      t.expressionStatement(this._buildExportCall(leftIdentifier, valIdentifier))
     ]);
 
     return this._addImportSource(t.forInStatement(left, right, block), node);
   }
 
   buildExportsAssignment(id, init, node) {
-    var call = this.buildExportCall(t.literal(id.name), init, true);
+    var call = this._buildExportCall(t.literal(id.name), init, true);
     return this._addImportSource(call, node);
   }
 
@@ -119,13 +118,13 @@ export default class SystemFormatter extends AMDFormatter {
     var assign = node;
 
     for (var i = 0; i < exported.length; i++) {
-      assign = this.buildExportCall(t.literal(exported[i].name), assign);
+      assign = this._buildExportCall(t.literal(exported[i].name), assign);
     }
 
     return assign;
   }
 
-  buildExportCall(id, init, isStatement) {
+  _buildExportCall(id, init, isStatement) {
     var call = t.callExpression(this.exportIdentifier, [id, init]);
     if (isStatement) {
       return t.expressionStatement(call);
@@ -143,12 +142,12 @@ export default class SystemFormatter extends AMDFormatter {
       ]));
     }
 
-    this.internalRemap = {};
+    this.internalRemap = object();
 
     this._addImportSource(last(nodes), node);
   }
 
-  buildRunnerSetters(block, hoistDeclarators) {
+  _buildRunnerSetters(block, hoistDeclarators) {
     var scope = this.file.scope;
 
     return t.arrayExpression(map(this.ids, function (uid, source) {
@@ -164,7 +163,7 @@ export default class SystemFormatter extends AMDFormatter {
     }));
   }
 
-  canHoist(node) {
+  _canHoist(node) {
     return node._blockHoist && !this.file.dynamicImports.length;
   }
 
@@ -181,7 +180,7 @@ export default class SystemFormatter extends AMDFormatter {
       MODULE_DEPENDENCIES: t.arrayExpression(this.buildDependencyLiterals()),
       EXPORT_IDENTIFIER:   this.exportIdentifier,
       MODULE_NAME:         moduleNameLiteral,
-      SETTERS:             this.buildRunnerSetters(block, hoistDeclarators),
+      SETTERS:             this._buildRunnerSetters(block, hoistDeclarators),
       EXECUTE:             t.functionExpression(null, [], block)
     }, true);
 

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

@@ -28,8 +28,9 @@
 
     if (descriptor.initializer) {
       descriptor.value = descriptor.initializer.call(target);
-      Object.defineProperty(target, key, descriptor);
     }
+
+    Object.defineProperty(target, key, descriptor);
   }
 
   return target;

src/babel/transformation/templates/helper-define-decorated-property-descriptor.js

@@ -1,12 +1,12 @@
 (function (target, key, descriptors) {
   var _descriptor = descriptors[key];
+  if (!_descriptor) return;
 
   // clone it
   var descriptor = {};
   for (var _key in _descriptor) descriptor[_key] = _descriptor[_key];
 
   // initialize it
-  if (!descriptor.initializer) return;
   descriptor.value = descriptor.initializer.call(target);
 
   Object.defineProperty(target, key, descriptor);

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

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

src/babel/transformation/templates/helper-ludicrous-proxy-create.js

@@ -1,4 +0,0 @@
-(function (proxy, directory) {
-  directory.push(proxy);
-  return proxy;
-})

src/babel/transformation/templates/helper-ludicrous-proxy-directory.js

@@ -1 +0,0 @@
-[];

src/babel/transformation/templates/rest.js

@@ -1,3 +1,3 @@
-for (var LEN = ARGUMENTS.length, ARRAY = Array(ARRAY_LEN), KEY = START; KEY < LEN; KEY++) {
+for (var LEN = ARGUMENTS.length, ARRAY: ARRAY_TYPE = Array(ARRAY_LEN), KEY = START; KEY < LEN; KEY++) {
   ARRAY[ARRAY_KEY] = ARGUMENTS[KEY];
 }

src/babel/transformation/transformer-pass.js

@@ -8,57 +8,26 @@ import traverse from "../traversal";
 
 export default class TransformerPass {
   constructor(file: File, transformer: Transformer) {
-    this.shouldTransform = !transformer.shouldVisit;
-    this.transformer     = transformer;
-    this.handlers        = transformer.handlers;
-    this.skipKey         = transformer.skipKey;
-    this.file            = file;
-    this.ran             = false;
+    this.transformer = transformer;
+    this.handlers    = transformer.handlers;
+    this.file        = file;
+    this.ran         = false;
+    this.key         = transformer.key;
   }
 
   canTransform(): boolean {
-    var transformer = this.transformer;
-
-    var opts = this.file.opts;
-    var key  = transformer.key;
-
-    // internal
-    if (key[0] === "_") return true;
-
-    // blacklist
-    var blacklist = opts.blacklist;
-    if (blacklist.length && includes(blacklist, key)) return false;
-
-    // whitelist
-    var whitelist = opts.whitelist;
-    if (whitelist) return includes(whitelist, key);
-
-    // 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;
-
-    return true;
-  }
-
-  checkPath(path: TraversalPath): boolean {
-    if (this.shouldTransform || this.ran) return;
-
-    this.shouldTransform = this.transformer.shouldVisit(path.node);
+    return this.file.transformerDependencies[this.key] ||
+           this.file.pipeline.canTransform(this.transformer, this.file.opts);
   }
 
   transform() {
-    if (!this.shouldTransform) return;
-
     var file = this.file;
 
-    file.log.debug(`Start transformer ${this.transformer.key}`);
+    file.log.debug(`Start transformer ${this.key}`);
 
     traverse(file.ast, this.handlers, file.scope, file);
 
-    file.log.debug(`Finish transformer ${this.transformer.key}`);
+    file.log.debug(`Finish transformer ${this.key}`);
 
     this.ran = true;
   }

src/babel/transformation/transformer-pipeline.js

@@ -0,0 +1,105 @@
+import Transformer from "./transformer";
+import normalizeAst from "../helpers/normalize-ast";
+import assign from "lodash/object/assign";
+import object from "../helpers/object";
+import File from "./file";
+
+export default class TransformerPipeline {
+  constructor() {
+    this.transformers = object();
+    this.namespaces   = object();
+    this.deprecated   = object();
+    this.aliases      = object();
+    this.filters      = [];
+  }
+
+  addTransformers(transformers) {
+    for (var key in transformers) {
+      this.addTransformer(key, transformers[key]);
+    }
+    return this;
+  }
+
+  addTransformer(key, transformer) {
+    if (this.transformers[key]) throw new Error(); // todo: error
+
+    var namespace = key.split(".")[0];
+    this.namespaces[namespace] = this.namespaces[namespace] || [];
+    this.namespaces[namespace].push(key);
+    this.namespaces[key] = namespace;
+
+    this.transformers[key] = new Transformer(key, transformer);
+  }
+
+  addAliases(names) {
+    assign(this.aliases, names);
+    return this;
+  }
+
+  addDeprecated(names) {
+    assign(this.deprecated, names);
+    return this;
+  }
+
+  addFilter(filter: Function) {
+    this.filters.push(filter);
+    return this;
+  }
+
+  canTransform(transformer, fileOpts) {
+    if (transformer.metadata.plugin) return true;
+
+    for (var filter of (this.filters: Array)) {
+      var result = filter(transformer, fileOpts);
+      if (result != null) return result;
+    }
+
+    return true;
+  }
+
+  transform(code: string, opts?: Object) {
+    var file = new File(opts, this);
+    return file.wrap(code, function () {
+      file.addCode(code, true);
+    });
+  }
+
+  transformFromAst(ast, code, opts) {
+    ast = normalizeAst(ast);
+
+    var file = new File(opts, this);
+    return file.wrap(code, function () {
+      file.addCode(code);
+      file.addAst(ast);
+    });
+  }
+
+  _ensureTransformerNames(type: string, rawKeys: Array<string>) {
+    var keys = [];
+
+    for (var i = 0; i < rawKeys.length; i++) {
+      var key = rawKeys[i];
+
+      var deprecatedKey = this.deprecated[key];
+      var aliasKey = this.aliases[key];
+      if (aliasKey) {
+        keys.push(aliasKey);
+      } else if (deprecatedKey) {
+        // deprecated key, remap it to the new one
+        console.error(`[BABEL] The transformer ${key} has been renamed to ${deprecatedKey}`);
+        rawKeys.push(deprecatedKey);
+      } else if (this.transformers[key]) {
+        // valid key
+        keys.push(key);
+      } else if (this.namespaces[key]) {
+        // namespace, append all transformers within this namespace
+        keys = keys.concat(this.namespaces[key]);
+      } else {
+        // invalid key
+        throw new ReferenceError(`Unknown transformer ${key} specified in ${type}`);
+      }
+    }
+
+    return keys;
+  }
+}

src/babel/transformation/transformer.js

@@ -15,7 +15,7 @@ import each from "lodash/collection/each";
  */
 
 export default class Transformer {
-  constructor(transformerKey: string, transformer: Object, opts: Object) {
+  constructor(transformerKey: string, transformer: Object) {
     transformer = assign({}, transformer);
 
     var take = function (key) {
@@ -25,8 +25,8 @@ export default class Transformer {
     };
 
     this.manipulateOptions = take("manipulateOptions");
-    this.shouldVisit       = take("shouldVisit");
     this.metadata          = take("metadata") || {};
+    this.dependencies      = this.metadata.dependencies || [];
     this.parser            = take("parser");
     this.post              = take("post");
     this.pre               = take("pre");
@@ -40,20 +40,7 @@ export default class Transformer {
     //
 
     this.handlers = this.normalize(transformer);
-    this.opts     = this.opts || {};
     this.key      = transformerKey;
-
-    //
-
-    if (!this.shouldVisit) {
-      var types = Object.keys(this.handlers);
-      this.shouldVisit = function (node) {
-        for (var i = 0; i < types.length; i++) {
-          if (node.type === types[i]) return true;
-        }
-        return false;
-      };
-    }
   }
 
   normalize(transformer: Object): Object {

src/babel/transformation/transformers/deprecated.json

@@ -5,7 +5,8 @@
   "es6.symbols": "es6.spec.symbols",
   "es6.blockScopingTDZ": "es6.spec.blockScoping",
 
-  "minification.deadCodeElimination": "utility.deadCodeElimination",
-  "minification.removeConsoleCalls": "utility.removeConsole",
-  "minification.removeDebugger": "utility.removeDebugger"
+  "utility.inlineExpressions": "minification.inlineExpressions",
+  "utility.deadCodeElimination": "minification.deadCodeElimination",
+  "utility.removeConsoleCalls": "minification.removeConsole",
+  "utility.removeDebugger": "minification.removeDebugger"
 }

src/babel/transformation/transformers/es3/member-expression-literals.js

@@ -1,14 +1,16 @@
 import * as t from "../../../types";
 
-export function MemberExpression(node) {
-  var prop = node.property;
-  if (node.computed && t.isLiteral(prop) && t.isValidIdentifier(prop.value)) {
-    // foo["bar"] => foo.bar
-    node.property = t.identifier(prop.value);
-    node.computed = false;
-  } else if (!node.computed && t.isIdentifier(prop) && !t.isValidIdentifier(prop.name)) {
-    // foo.default -> foo["default"]
-    node.property = t.literal(prop.name);
-    node.computed = true;
+export var metadata = {
+  group: "builtin-trailing"
+};
+
+export var MemberExpression = {
+  exit(node) {
+    var prop = node.property;
+    if (!node.computed && t.isIdentifier(prop) && !t.isValidIdentifier(prop.name)) {
+      // foo.default -> foo["default"]
+      node.property = t.literal(prop.name);
+      node.computed = true;
+    }
   }
-}
+};

src/babel/transformation/transformers/es3/property-literals.js

@@ -1,13 +1,15 @@
 import * as t from "../../../types";
 
-export function Property(node) {
-  var key = node.key;
-  if (t.isLiteral(key) && t.isValidIdentifier(key.value)) {
-    // "foo": "bar" -> foo: "bar"
-    node.key = t.identifier(key.value);
-    node.computed = false;
-  } else if (!node.computed && t.isIdentifier(key) && !t.isValidIdentifier(key.name)) {
-    // default: "bar" -> "default": "bar"
-    node.key = t.literal(key.name);
+export var metadata = {
+  group: "builtin-trailing"
+};
+
+export var Property = {
+  exit(node) {
+    var key = node.key;
+    if (!node.computed && t.isIdentifier(key) && !t.isValidIdentifier(key.name)) {
+      // default: "bar" -> "default": "bar"
+      node.key = t.literal(key.name);
+    }
   }
-}
+};

src/babel/transformation/transformers/es5/properties.mutators.js

@@ -1,10 +1,6 @@
 import * as defineMap from "../../helpers/define-map";
 import * as t from "../../../types";
 
-export function shouldVisit(node) {
-  return t.isProperty(node) && (node.kind === "get" || node.kind === "set");
-}
-
 export function ObjectExpression(node, parent, scope, file) {
   var mutatorMap = {};
   var hasAny = false;

src/babel/transformation/transformers/es6/arrow-functions.js

@@ -1,13 +1,9 @@
 import * as t from "../../../types";
 
-export var shouldVisit = t.isArrowFunctionExpression;
-
 export function ArrowFunctionExpression(node) {
   t.ensureBlock(node);
 
   node.expression = false;
   node.type = "FunctionExpression";
   node.shadow = true;
-
-  return node;
 }

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

@@ -32,14 +32,14 @@ function isVar(node, parent) {
 }
 
 function standardizeLets(declars) {
-  for (var i = 0; i < declars.length; i++) {
-    delete declars[i]._let;
+  for (var declar of (declars: Array)) {
+    delete declar._let;
   }
 }
 
-export function shouldVisit(node) {
-  return t.isVariableDeclaration(node) && (node.kind === "let" || node.kind === "const");
-}
+export var metadata = {
+  group: "builtin-advanced"
+};
 
 export function VariableDeclaration(node, parent, scope, file) {
   if (!isLet(node, parent)) return;
@@ -84,8 +84,6 @@ export function BlockStatement(block, parent, scope, file) {
 export { BlockStatement as Program };
 
 function replace(node, parent, scope, remaps) {
-  if (!t.isReferencedIdentifier(node, parent)) return;
-
   var remap = remaps[node.name];
   if (!remap) return;
 
@@ -100,28 +98,33 @@ function replace(node, parent, scope, remaps) {
 }
 
 var replaceVisitor = {
-  enter: replace
+  ReferencedIdentifier: replace,
+
+  AssignmentExpression(node, parent, scope, remaps) {
+    var ids = this.getBindingIdentifiers();
+    for (var name in ids) {
+      replace(ids[name], node, scope, remaps);
+    }
+  },
 };
 
 function traverseReplace(node, parent, scope, remaps) {
-  replace(node, parent, scope, remaps);
+  if (t.isIdentifier(node)) {
+    replace(node, parent, scope, remaps);
+  }
+
   scope.traverse(node, replaceVisitor, remaps);
 }
 
 var letReferenceBlockVisitor = {
-  enter(node, parent, scope, state) {
-    if (this.isFunction()) {
-      this.traverse(letReferenceFunctionVisitor, state);
-      return this.skip();
-    }
+  Function(node, parent, scope, state) {
+    this.traverse(letReferenceFunctionVisitor, state);
+    return this.skip();
   }
 };
 
 var letReferenceFunctionVisitor = {
-  enter(node, parent, scope, state) {
-    // not a direct reference
-    if (!this.isReferencedIdentifier()) return;
-
+  ReferencedIdentifier(node, parent, scope, state) {
     var ref = state.letReferences[node.name];
 
     // not a part of our scope
@@ -159,10 +162,8 @@ var hoistVarDeclarationsVisitor = {
 };
 
 var loopLabelVisitor = {
-  enter(node, parent, scope, state) {
-    if (this.isLabeledStatement()) {
-      state.innerLabels.push(node.label.name);
-    }
+  LabeledStatement(node, parent, scope, state) {
+    state.innerLabels.push(node.label.name);
   }
 };
 
@@ -187,19 +188,28 @@ var loopNodeTo = function (node) {
 };
 
 var loopVisitor = {
+  Loop(node, parent, scope, state) {
+    var oldIgnoreLabeless = state.ignoreLabeless;
+    state.ignoreLabeless = true;
+    this.traverse(loopVisitor, state);
+    state.ignoreLabeless = oldIgnoreLabeless;
+    this.skip();
+  },
+
+  Function() {
+    this.skip();
+  },
+
+  SwitchCase(node, parent, scope, state) {
+    var oldInSwitchCase = state.inSwitchCase;
+    state.inSwitchCase = true;
+    this.traverse(loopVisitor, state);
+    state.inSwitchCase = oldInSwitchCase;
+    this.skip();
+  },
+
   enter(node, parent, scope, state) {
     var replace;
-
-    if (this.isLoop()) {
-      state.ignoreLabeless = true;
-      this.traverse(loopVisitor, state);
-      state.ignoreLabeless = false;
-    }
-
-    if (this.isFunction() || this.isLoop()) {
-      return this.skip();
-    }
-
     var loopText = loopNodeTo(node);
 
     if (loopText) {
@@ -215,6 +225,9 @@ var loopVisitor = {
         // they don't refer to the actual loop we're scopifying
         if (state.ignoreLabeless) return;
 
+        //
+        if (state.inSwitchCase) return;
+
         // break statements mean something different in this context
         if (t.isBreakStatement(node) && t.isSwitchCase(parent)) return;
       }
@@ -233,6 +246,7 @@ var loopVisitor = {
 
     if (replace) {
       replace = t.returnStatement(replace);
+      this.skip();
       return t.inherits(replace, node);
     }
   }
@@ -467,18 +481,17 @@ class BlockScoping {
     var block = this.block;
 
     var declarators = block._letDeclarators || [];
-    var declar;
 
     //
     for (let i = 0; i < declarators.length; i++) {
-      declar = declarators[i];
+      let declar = declarators[i];
       extend(this.outsideLetReferences, t.getBindingIdentifiers(declar));
     }
 
     //
     if (block.body) {
       for (let i = 0; i < block.body.length; i++) {
-        declar = block.body[i];
+        let declar = block.body[i];
         if (isLet(declar, block)) {
           declarators = declarators.concat(declar.declarations);
         }
@@ -487,7 +500,7 @@ class BlockScoping {
 
     //
     for (let i = 0; i < declarators.length; i++) {
-      declar = declarators[i];
+      let declar = declarators[i];
       var keys = t.getBindingIdentifiers(declar);
       extend(this.letReferences, keys);
       this.hasLetReferences = true;
@@ -524,6 +537,7 @@ class BlockScoping {
     var state = {
       hasBreakContinue: false,
       ignoreLabeless:   false,
+      inSwitchCase:     false,
       innerLabels:      [],
       hasReturn:        false,
       isLoop:           !!this.loop,
@@ -551,9 +565,13 @@ class BlockScoping {
    */
 
   pushDeclar(node: { type: "VariableDeclaration" }): Array<Object> {
-    this.body.push(t.variableDeclaration(node.kind, node.declarations.map(function (declar) {
-      return t.variableDeclarator(declar.id);
-    })));
+    var declars = [];
+    var names = t.getBindingIdentifiers(node);
+    for (var name in names) {
+      declars.push(t.variableDeclarator(names[name]));
+    }
+
+    this.body.push(t.variableDeclaration(node.kind, declars));
 
     var replace = [];
 

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

@@ -11,8 +11,6 @@ import * as t from "../../../types";
 
 const PROPERTY_COLLISION_METHOD_NAME = "__initializeProperties";
 
-export var shouldVisit = t.isClass;
-
 export function ClassDeclaration(node, parent, scope, file) {
   return t.variableDeclaration("let", [
     t.variableDeclarator(node.id, t.toExpression(node))
@@ -37,7 +35,7 @@ var collectPropertyReferencesVisitor = {
   }
 };
 
-var constructorVisitor = traverse.explode({
+var constructorVisitor = {
   ThisExpression: {
     enter(node, parent, scope, ref) {
       return ref;
@@ -51,9 +49,9 @@ var constructorVisitor = traverse.explode({
       }
     }
   }
-});
+};
 
-var verifyConstructorVisitor = traverse.explode({
+var verifyConstructorVisitor = {
   MethodDefinition: {
     enter() {
       this.skip();
@@ -96,13 +94,9 @@ var verifyConstructorVisitor = traverse.explode({
       if (state.hasSuper && !state.hasBareSuper) {
         throw this.errorWithNode("'this' is not allowed before super()");
       }
-
-      if (state.isNativeSuper) {
-        return state.nativeSuperRef;
-      }
     }
   }
-});
+};
 
 class ClassTransformer {
 
@@ -154,15 +148,6 @@ class ClassTransformer {
 
     //
 
-    var superClass = this.node.superClass;
-    this.isNativeSuper = superClass && t.isIdentifier(superClass) && t.NATIVE_TYPE_NAMES.indexOf(superClass.name) >= 0;
-
-    if (this.isNativeSuper) {
-      this.nativeSuperRef = this.scope.generateUidIdentifier("this");
-    }
-
-    //
-
     var body = this.body;
 
     //
@@ -188,7 +173,7 @@ class ClassTransformer {
     if (this.hasSuper) {
       closureArgs.push(superName);
 
-      superName = this.scope.generateUidBasedOnNode(superName);
+      superName = this.scope.generateUidIdentifierBasedOnNode(superName);
       closureParams.push(superName);
 
       this.superName = superName;
@@ -234,12 +219,6 @@ class ClassTransformer {
       }
     }
 
-    if (this.isNativeSuper) {
-      // we've determined this is inheriting from a native class so return the constructed
-      // instance
-      constructorBody.body.push(t.returnStatement(this.nativeSuperRef));
-    }
-
     if (this.className) {
       // named class with only a constructor
       if (body.length === 1) return t.toExpression(body[0]);
@@ -333,7 +312,7 @@ class ClassTransformer {
         if (isConstructor) {
           this.pushConstructor(node, path);
         } else {
-          this.pushMethod(node);
+          this.pushMethod(node, path);
         }
       } else if (t.isClassProperty(node)) {
         this.pushProperty(node);
@@ -344,9 +323,7 @@ class ClassTransformer {
     if (!this.hasConstructor && this.hasSuper) {
       var helperName = "class-super-constructor-call";
       if (this.isLoose) helperName += "-loose";
-      if (this.isNativeSuper) helperName = "class-super-native-constructor-call";
       constructorBody.body.push(util.template(helperName, {
-        NATIVE_REF: this.nativeSuperRef,
         CLASS_NAME: this.classRef,
         SUPER_NAME: this.superName
       }, true));
@@ -433,7 +410,7 @@ class ClassTransformer {
       this.pushMethod(t.methodDefinition(
         t.identifier(PROPERTY_COLLISION_METHOD_NAME),
         t.functionExpression(null, [], t.blockStatement(body))
-      ), true);
+      ), null, true);
 
       if (this.hasSuper) {
         this.bareSuper.insertAfter(call);
@@ -475,12 +452,10 @@ class ClassTransformer {
 
    verifyConstructor(path: TraversalPath) {
     var state = {
-      nativeSuperRef: this.nativeSuperRef,
-      isNativeSuper:  this.isNativeSuper,
-      hasBareSuper:   false,
-      bareSuper:      null,
-      hasSuper:       this.hasSuper,
-      file:           this.file
+      hasBareSuper: false,
+      bareSuper:    null,
+      hasSuper:     this.hasSuper,
+      file:         this.file
     };
 
     path.get("value").traverse(verifyConstructorVisitor, state);
@@ -490,36 +465,21 @@ class ClassTransformer {
     if (!state.hasBareSuper && this.hasSuper) {
       throw path.errorWithNode("Derived constructor must call super()");
     }
-
-    if (this.isNativeSuper && this.bareSuper) {
-      this.bareSuper.replaceWithMultiple([
-        t.variableDeclaration("var", [
-          t.variableDeclarator(this.nativeSuperRef, t.newExpression(this.superName, this.bareSuper.node.arguments))
-        ]),
-
-        t.expressionStatement(t.assignmentExpression(
-          "=",
-          t.memberExpression(this.nativeSuperRef, t.identifier("__proto__")),
-          t.memberExpression(this.classRef, t.identifier("prototype"))
-        )),
-        t.expressionStatement(this.nativeSuperRef)
-      ]);
-    }
-   }
+  }
 
   /**
    * Push a method to its respective mutatorMap.
    */
 
-  pushMethod(node: { type: "MethodDefinition" }, allowedIllegal?) {
+  pushMethod(node: { type: "MethodDefinition" }, path?: TraversalPath, 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);
+      nameMethod.property(node, this.file, path ? path.get("value").scope : this.scope);
 
-      if (this.isLoose) {
+      if (this.isLoose && !node.decorators) {
         // use assignments instead of define properties for loose classes
 
         var classRef = this.classRef;
@@ -605,10 +565,6 @@ class ClassTransformer {
       fnPath.scope.rename(this.classRef.name);
     }
 
-    if (this.isNativeSuper) {
-      fnPath.traverse(constructorVisitor, this.nativeSuperRef);
-    }
-
     var construct = this.constructor;
     var fn        = method.value;
 

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

@@ -1,48 +1,31 @@
 import * as messages from "../../../messages";
 import * as t from "../../../types";
 
-export function shouldVisit(node) {
-  return t.isVariableDeclaration(node, { kind: "const" }) || t.isImportDeclaration(node);
-}
+export function AssignmentExpression(node, parent, scope, file) {
+  var ids = this.getBindingIdentifiers();
 
-var visitor = {
-  enter(node, parent, scope, state) {
-    if (this.isAssignmentExpression() || this.isUpdateExpression()) {
-      var ids = this.getBindingIdentifiers();
+  for (var name in ids) {
+    var id = ids[name];
 
-      for (var name in ids) {
-        var id = ids[name];
+    var binding = scope.getBinding(name);
 
-        var constant = state.constants[name];
+    // no binding exists
+    if (!binding) continue;
 
-        // no constant exists
-        if (!constant) continue;
+    // not a constant
+    if (binding.kind !== "const" && binding.kind !== "module") continue;
 
-        var constantIdentifier = constant.identifier;
+    // check if the assignment id matches the constant declaration id
+    // if it does then it was the id used to initially declare the
+    // constant so we can just ignore it
+    if (binding.identifier === id) continue;
 
-        // check if the assignment id matches the constant declaration id
-        // if it does then it was the id used to initially declare the
-        // constant so we can just ignore it
-        if (id === constantIdentifier) continue;
-
-        // check if there's been a local binding that shadows this constant
-        if (!scope.bindingIdentifierEquals(name, constantIdentifier)) continue;
-
-        throw state.file.errorWithNode(id, messages.get("readOnly", name));
-      }
-    } else if (this.isScope()) {
-      this.skip();
-    }
+    throw file.errorWithNode(id, messages.get("readOnly", name));
   }
-};
-
-export function Scopable(node, parent, scope, file) {
-  this.traverse(visitor, {
-    constants: scope.getAllBindingsOfKind("const", "module"),
-    file:      file
-  });
 }
 
+export { AssignmentExpression as UpdateExpression };
+
 export function VariableDeclaration(node) {
   if (node.kind === "const") node.kind = "let";
 }

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

@@ -1,7 +1,9 @@
 import * as messages from "../../../messages";
 import * as t from "../../../types";
 
-export var shouldVisit = t.isPattern;
+export var metadata = {
+  group: "builtin-advanced"
+};
 
 export function ForOfStatement(node, parent, scope, file) {
   var left = node.left;
@@ -53,7 +55,7 @@ export function ForOfStatement(node, parent, scope, file) {
 
 export { ForOfStatement as ForInStatement };
 
-exports.Function = function (node, parent, scope, file) {
+export function Func/*tion*/(node, parent, scope, file) {
   var nodes = [];
 
   var hasDestructuring = false;
@@ -63,6 +65,7 @@ exports.Function = function (node, parent, scope, file) {
 
     hasDestructuring = true;
     var ref = scope.generateUidIdentifier("ref");
+    t.inherits(ref, pattern);
 
     var destructuring = new DestructuringTransformer({
       blockHoist: node.params.length - i,
@@ -82,8 +85,7 @@ exports.Function = function (node, parent, scope, file) {
 
   var block = node.body;
   block.body = nodes.concat(block.body);
-  return node;
-};
+}
 
 export function CatchClause(node, parent, scope, file) {
   var pattern = node.param;
@@ -103,8 +105,6 @@ export function CatchClause(node, parent, scope, file) {
   destructuring.init(pattern, ref);
 
   node.body.body = nodes.concat(node.body.body);
-
-  return node;
 }
 
 export function ExpressionStatement(node, parent, scope, file) {
@@ -179,7 +179,7 @@ export function VariableDeclaration(node, parent, scope, file) {
       file:  file
     });
 
-    if (t.isPattern(pattern) && patternId) {
+    if (t.isPattern(pattern)) {
       destructuring.init(pattern, patternId);
 
       if (+i !== node.declarations.length - 1) {
@@ -295,7 +295,7 @@ class DestructuringTransformer {
     // we need to assign the current value of the assignment to avoid evaluating
     // it more than once
 
-    var tempValueRef = this.scope.generateUidBasedOnNode(valueRef);
+    var tempValueRef = this.scope.generateUidIdentifierBasedOnNode(valueRef);
 
     var declar = t.variableDeclaration("var", [
       t.variableDeclarator(tempValueRef, valueRef)
@@ -377,7 +377,7 @@ class DestructuringTransformer {
     // only evaluated once
 
     if (pattern.properties.length > 1 && t.isMemberExpression(objRef)) {
-      var temp = this.scope.generateUidBasedOnNode(objRef, this.file);
+      var temp = this.scope.generateUidIdentifierBasedOnNode(objRef, this.file);
       this.nodes.push(this.buildVariableDeclaration(temp, objRef));
       objRef = temp;
     }
@@ -461,7 +461,7 @@ class DestructuringTransformer {
       // array
       arrayRef = toArray;
     } else {
-      arrayRef = this.scope.generateUidBasedOnNode(arrayRef);
+      arrayRef = this.scope.generateUidIdentifierBasedOnNode(arrayRef);
       this.arrays[arrayRef.name] = true;
       this.nodes.push(this.buildVariableDeclaration(arrayRef, toArray));
     }
@@ -500,7 +500,7 @@ class DestructuringTransformer {
 
     var shouldMemoise = true;
     if (!t.isArrayExpression(ref) && !t.isMemberExpression(ref)) {
-      var memo = this.scope.generateMemoisedReference(ref, true);
+      var memo = this.scope.maybeGenerateMemoised(ref, true);
       if (memo) {
         this.nodes.push(this.buildVariableDeclaration(memo, ref));
         ref = memo;

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

@@ -2,8 +2,6 @@ import * as messages from "../../../messages";
 import * as util from  "../../../util";
 import * as t from "../../../types";
 
-export var shouldVisit = t.isForOfStatement;
-
 export function ForOfStatement(node, parent, scope, file) {
   if (this.get("right").isArrayExpression()) {
     return _ForOfStatementArray.call(this, node, scope, file);
@@ -35,7 +33,7 @@ export function ForOfStatement(node, parent, scope, file) {
     this.parentPath.replaceWithMultiple(build.node);
     this.remove();
   } else {
-    this.replaceWithMultiple(build.node);
+    return build.node;
   }
 }
 

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

@@ -1,7 +1,5 @@
 import * as t from "../../../types";
 
-export { check } from "../internal/modules";
-
 function keepBlockHoist(node, nodes) {
   if (node._blockHoist) {
     for (let i = 0; i < nodes.length; i++) {
@@ -10,6 +8,10 @@ function keepBlockHoist(node, nodes) {
   }
 }
 
+export var metadata = {
+  group: "builtin-modules"
+};
+
 export function ImportDeclaration(node, parent, scope, file) {
   // flow type
   if (node.isType) return;

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

@@ -1,33 +1,20 @@
 import ReplaceSupers from "../../helpers/replace-supers";
 import * as t from "../../../types";
 
-export var shouldVisit = t.isSuper;
-
 function Property(path, node, scope, getObjectRef, file) {
-  if (!node.method) return;
-
-  var value = node.value;
-  var thisExpr = scope.generateUidIdentifier("this");
+  if (!node.method && node.kind === "init") return;
+  if (!t.isFunction(node.value)) return;
 
   var replaceSupers = new ReplaceSupers({
-    topLevelThisReference: thisExpr,
-    getObjectRef:          getObjectRef,
-    methodNode:            node,
-    methodPath:            path,
-    isStatic:              true,
-    scope:                 scope,
-    file:                  file
+    getObjectRef: getObjectRef,
+    methodNode:   node,
+    methodPath:   path,
+    isStatic:     true,
+    scope:        scope,
+    file:         file
   });
 
   replaceSupers.replace();
-
-  if (replaceSupers.hasSuper) {
-    value.body.body.unshift(
-      t.variableDeclaration("var", [
-        t.variableDeclarator(thisExpr, t.thisExpression())
-      ])
-    );
-  }
 }
 
 export function ObjectExpression(node, parent, scope, file) {

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

@@ -1,11 +1,8 @@
 import callDelegate from "../../helpers/call-delegate";
 import * as util from  "../../../util";
+import traverse from  "../../../traversal";
 import * as t from "../../../types";
 
-export function shouldVisit(node) {
-  return t.isFunction(node) && hasDefaults(node);
-}
-
 var hasDefaults = function (node) {
   for (var i = 0; i < node.params.length; i++) {
     if (!t.isIdentifier(node.params[i])) return true;
@@ -14,17 +11,18 @@ var hasDefaults = function (node) {
 };
 
 var iifeVisitor = {
-  enter(node, parent, scope, state) {
-    if (!this.isReferencedIdentifier()) return;
-    if (!state.scope.hasOwnBinding(node.name)) return;
-    if (state.scope.bindingIdentifierEquals(node.name, node)) return;
+  ReferencedIdentifier(node, parent, scope, state) {
+    if (node.name !== "eval") {
+      if (!state.scope.hasOwnBinding(node.name)) return;
+      if (state.scope.bindingIdentifierEquals(node.name, node)) return;
+    }
 
     state.iife = true;
     this.stop();
   }
 };
 
-exports.Function = function (node, parent, scope, file) {
+export function Func/*tion*/(node, parent, scope, file) {
   if (!hasDefaults(node)) return;
 
   t.ensureBlock(node);
@@ -96,6 +94,4 @@ exports.Function = function (node, parent, scope, file) {
   } else {
     node.body.body = body.concat(node.body.body);
   }
-
-  return node;
-};
+}

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

@@ -2,8 +2,6 @@ import isNumber from "lodash/lang/isNumber";
 import * as util from  "../../../util";
 import * as t from "../../../types";
 
-export var shouldVisit = t.isRestElement;
-
 var memberExpressionOptimisationVisitor = {
   enter(node, parent, scope, state) {
     // check if this scope has a local binding that will shadow the rest parameter
@@ -55,10 +53,11 @@ var hasRest = function (node) {
   return t.isRestElement(node.params[node.params.length - 1]);
 };
 
-exports.Function = function (node, parent, scope, file) {
+export function Func/*tion*/(node, parent, scope, file) {
   if (!hasRest(node)) return;
 
-  var rest = node.params.pop().argument;
+  var restParam = node.params.pop();
+  var rest = restParam.argument;
 
   var argsId = t.identifier("arguments");
 
@@ -96,7 +95,7 @@ exports.Function = function (node, parent, scope, file) {
       candidate.replaceWith(argsId);
       optimizeMemberExpression(candidate.parent, node.params.length);
     }
-    return node;
+    return;
   }
 
   //
@@ -127,15 +126,15 @@ exports.Function = function (node, parent, scope, file) {
   }
 
   var loop = util.template("rest", {
-    ARGUMENTS: argsId,
-    ARRAY_KEY: arrKey,
-    ARRAY_LEN: arrLen,
-    START:     start,
-    ARRAY:     rest,
-    KEY:       key,
-    LEN:       len
+    ARRAY_TYPE: restParam.typeAnnotation,
+    ARGUMENTS:  argsId,
+    ARRAY_KEY:  arrKey,
+    ARRAY_LEN:  arrLen,
+    START:      start,
+    ARRAY:      rest,
+    KEY:        key,
+    LEN:        len
   });
   loop._blockHoist = node.params.length + 1;
   node.body.body.unshift(loop);
-  return node;
-};
+}

src/babel/transformation/transformers/es6/properties.computed.js

@@ -16,27 +16,13 @@ function loose(node, body, objId) {
 
 function spec(node, body, objId, initProps, file) {
   var props = node.properties;
-  var prop, key;
-
-  // normalize key
-
-  for (var i = 0; i < props.length; i++) {
-    prop = props[i];
-    if (prop.kind !== "init") continue;
-
-    key = prop.key;
-
-    if (!prop.computed && t.isIdentifier(key)) {
-      prop.key = t.literal(key.name);
-    }
-  }
 
   // add all non-computed properties and `__proto__` properties to the initializer
 
   var broken = false;
 
-  for (i = 0; i < props.length; i++) {
-    prop = props[i];
+  for (let i = 0; i < props.length; i++) {
+    let prop = props[i];
 
     if (prop.computed) {
       broken = true;
@@ -51,24 +37,17 @@ function spec(node, body, objId, initProps, file) {
   // add a simple assignment for all Symbol member expressions due to symbol polyfill limitations
   // otherwise use Object.defineProperty
 
-  for (i = 0; i < props.length; i++) {
-    prop = props[i];
+  for (let i = 0; i < props.length; i++) {
+    let prop = props[i];
     if (!prop) continue;
 
-    key = prop.key;
-    var bodyNode;
-
-    if (prop.computed && t.isMemberExpression(key) && t.isIdentifier(key.object, { name: "Symbol" })) {
-      // { [Symbol.iterator]: "foo" }
-      bodyNode = t.assignmentExpression(
-        "=",
-        t.memberExpression(objId, key, true),
-        prop.value
-      );
-    } else {
-      bodyNode = t.callExpression(file.addHelper("define-property"), [objId, key, prop.value]);
+    let key = prop.key;
+    if (t.isIdentifier(key) && !prop.computed) {
+      key = t.literal(key.name);
     }
 
+    var bodyNode = t.callExpression(file.addHelper("define-property"), [objId, key, prop.value]);
+
     body.push(t.expressionStatement(bodyNode));
   }
 
@@ -84,42 +63,40 @@ function spec(node, body, objId, initProps, file) {
   }
 }
 
-export function shouldVisit(node) {
-  return t.isProperty(node) && node.computed;
-}
+export var ObjectExpression = {
+  exit(node, parent, scope, file) {
+    var hasComputed = false;
 
-export function ObjectExpression(node, parent, scope, file) {
-  var hasComputed = false;
+    for (var prop of (node.properties: Array)) {
+      hasComputed = t.isProperty(prop, { computed: true, kind: "init" });
+      if (hasComputed) break;
+    }
 
-  for (var i = 0; i < node.properties.length; i++) {
-    hasComputed = t.isProperty(node.properties[i], { computed: true, kind: "init" });
-    if (hasComputed) break;
+    if (!hasComputed) return;
+
+    var initProps = [];
+    var objId = scope.generateUidIdentifierBasedOnNode(parent);
+
+    //
+
+    var body = [];
+
+    //
+
+    var callback = spec;
+    if (file.isLoose("es6.properties.computed")) callback = loose;
+
+    var result = callback(node, body, objId, initProps, file);
+    if (result) return result;
+
+    //
+
+    body.unshift(t.variableDeclaration("var", [
+      t.variableDeclarator(objId, t.objectExpression(initProps))
+    ]));
+
+    body.push(t.expressionStatement(objId));
+
+    return body;
   }
-
-  if (!hasComputed) return;
-
-  var initProps = [];
-  var objId = scope.generateUidBasedOnNode(parent);
-
-  //
-
-  var body = [];
-
-  //
-
-  var callback = spec;
-  if (file.isLoose("es6.properties.computed")) callback = loose;
-
-  var result = callback(node, body, objId, initProps, file);
-  if (result) return result;
-
-  //
-
-  body.unshift(t.variableDeclaration("var", [
-    t.variableDeclarator(objId, t.objectExpression(initProps))
-  ]));
-
-  body.push(t.expressionStatement(objId));
-
-  return body;
-}
+};

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

@@ -1,9 +1,3 @@
-import * as t from "../../../types";
-
-export function shouldVisit(node) {
-  return t.isProperty(node) && (node.method || node.shorthand);
-}
-
 export function Property(node) {
   if (node.method) {
     node.method = false;
@@ -11,6 +5,5 @@ export function Property(node) {
 
   if (node.shorthand) {
     node.shorthand = false;
-    node.key = t.removeComments(t.clone(node.key));
   }
 }

src/babel/transformation/transformers/es6/regex.sticky.js

@@ -1,10 +1,6 @@
 import * as regex from "../../helpers/regex";
 import * as t from "../../../types";
 
-export function shouldVisit(node) {
-  return regex.is(node, "y");
-}
-
 export function Literal(node) {
   if (!regex.is(node, "y")) return;
   return t.newExpression(t.identifier("RegExp"), [

src/babel/transformation/transformers/es6/regex.unicode.js

@@ -1,10 +1,6 @@
 import rewritePattern from "regexpu/rewrite-pattern";
 import * as regex from "../../helpers/regex";
 
-export function shouldVisit(node) {
-  return regex.is(node, "u");
-}
-
 export function Literal(node) {
   if (!regex.is(node, "u")) return;
   node.regex.pattern = rewritePattern(node.regex.pattern, node.regex.flags);

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

@@ -1,8 +1,8 @@
+import traverse from "../../../traversal";
 import * as t from "../../../types";
 
 var visitor = {
-  enter(node, parent, scope, state) {
-    if (!this.isReferencedIdentifier()) return;
+  ReferencedIdentifier(node, parent, scope, state) {
     if (t.isFor(parent) && parent.left === node) return;
 
     var declared = state.letRefs[node.name];
@@ -28,17 +28,20 @@ var visitor = {
 };
 
 export var metadata = {
-  optional: true
+  optional: true,
+  group: "builtin-advanced"
 };
 
-export function BlockStatement(node, parent, scope, file) {
-  var letRefs = node._letReferences;
-  if (!letRefs) return;
+export var BlockStatement = {
+  exit(node, parent, scope, file) {
+    var letRefs = node._letReferences;
+    if (!letRefs) return;
 
-  this.traverse(visitor, {
-    letRefs: letRefs,
-    file:    file
-  });
-}
+    this.traverse(visitor, {
+      letRefs: letRefs,
+      file:    file
+    });
+  }
+};
 
 export { BlockStatement as Program, BlockStatement as Loop };

src/babel/transformation/transformers/es6/spec.symbols.js

@@ -33,3 +33,5 @@ export function BinaryExpression(node, parent, scope, file) {
 export function VariableDeclaration(node) {
   if (node._generated) this.skip();
 }
+
+export { VariableDeclaration as FunctionDeclaration };

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

@@ -44,8 +44,6 @@ function build(props, scope) {
   return nodes;
 }
 
-export var shouldVisit = t.isSpreadElement;
-
 export function ArrayExpression(node, parent, scope) {
   var elements = node.elements;
   if (!hasSpread(elements)) return;
@@ -86,7 +84,7 @@ export function CallExpression(node, parent, scope) {
   var callee = node.callee;
 
   if (this.get("callee").isMemberExpression()) {
-    var temp = scope.generateMemoisedReference(callee.object);
+    var temp = scope.maybeGenerateMemoised(callee.object);
     if (temp) {
       callee.object = t.assignmentExpression("=", temp, callee.object);
       contextLiteral = temp;

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

@@ -1,86 +1,59 @@
 import reduceRight from "lodash/collection/reduceRight";
 import * as messages from "../../../messages";
 import flatten from "lodash/array/flatten";
+import traverse from "../../../traversal";
 import * as util from  "../../../util";
 import map from "lodash/collection/map";
 import * as t from "../../../types";
 
-exports.Function = function (node, parent, scope, file) {
+export var metadata = {
+  group: "builtin-trailing"
+};
+
+export function Func/*tion*/(node, parent, scope, file) {
   if (node.generator || node.async) return;
   var tailCall = new TailCallTransformer(this, scope, file);
   tailCall.run();
-};
+}
 
 function returnBlock(expr) {
   return t.blockStatement([t.returnStatement(expr)]);
 }
 
-// looks for and replaces tail recursion calls
-var firstPass = {
+var visitor = {
   enter(node, parent, scope, state) {
-    if (this.isIfStatement()) {
-      if (this.get("alternate").isReturnStatement()) {
-        t.ensureBlock(node, "alternate");
-      }
-
-      if (this.get("consequent").isReturnStatement()) {
-        t.ensureBlock(node, "consequent");
-      }
-    } else if (this.isReturnStatement()) {
-      this.skip();
-      return state.subTransform(node.argument);
-    } else if (t.isTryStatement(parent)) {
+    if (t.isTryStatement(parent)) {
       if (node === parent.block) {
         this.skip();
       } else if (parent.finalizer && node !== parent.finalizer) {
         this.skip();
       }
-    } else if (this.isFunction()) {
-      this.skip();
-    } else if (this.isVariableDeclaration()) {
-      this.skip();
-      state.vars.push(node);
     }
-  }
-};
+  },
 
-// hoists up function declarations, replaces `this` and `arguments` and marks
-// them as needed
-var secondPass = {
-  enter(node, parent, scope, state) {
-    if (this.isThisExpression()) {
+  ReturnStatement(node, parent, scope, state) {
+    return state.subTransform(node.argument);
+  },
+
+  Function(node, parent, scope, state) {
+    this.skip();
+  },
+
+  VariableDeclaration(node, parent, scope, state) {
+    state.vars.push(node);
+  },
+
+  ThisExpression(node, parent, scope, state) {
+    if (!state.isShadowed) {
       state.needsThis = true;
-      return state.getThisId();
-    } else if (this.isReferencedIdentifier({ name: "arguments" })) {
-      state.needsArguments = true;
-      return state.getArgumentsId();
-    } else if (this.isFunction()) {
-      this.skip();
-      if (this.isFunctionDeclaration()) {
-        node = t.variableDeclaration("var", [
-          t.variableDeclarator(node.id, t.toExpression(node))
-        ]);
-        node._blockHoist = 2;
-        return node;
-      }
+      state.thisPaths.push(this);
     }
-  }
-};
+  },
 
-// optimizes recursion by removing `this` and `arguments` if they aren't used
-var thirdPass = {
-  enter(node, parent, scope, state) {
-    if (!this.isExpressionStatement()) return;
-
-    var expr = node.expression;
-    if (!t.isAssignmentExpression(expr)) return;
-
-    if (!state.needsThis && expr.left === state.getThisId()) {
-      this.remove();
-    } else if (!state.needsArguments && expr.left === state.getArgumentsId() && t.isArrayExpression(expr.right)) {
-      return map(expr.right.elements, function (elem) {
-        return t.expressionStatement(elem);
-      });
+  ReferencedIdentifier(node, parent, scope, state) {
+    if (node.name === "arguments" && !state.isShadowed) {
+      state.needsArguments = true;
+      state.argumentsPaths.push(this);
     }
   }
 };
@@ -88,11 +61,17 @@ var thirdPass = {
 class TailCallTransformer {
   constructor(path, scope, file) {
     this.hasTailRecursion = false;
-    this.needsArguments   = false;
-    this.setsArguments    = false;
-    this.needsThis        = false;
-    this.ownerId          = path.node.id;
-    this.vars             = [];
+
+    this.needsArguments = false;
+    this.argumentsPaths = [];
+    this.setsArguments  = false;
+
+    this.needsThis = false;
+    this.thisPaths = [];
+
+    this.isShadowed = path.isArrowFunctionExpression() || path.is("shadow");
+    this.ownerId    = path.node.id;
+    this.vars       = [];
 
     this.scope = scope;
     this.path  = path;
@@ -158,10 +137,12 @@ class TailCallTransformer {
     if (!ownerId) return;
 
     // traverse the function and look for tail recursion
-    this.path.traverse(firstPass, this);
+    this.path.traverse(visitor, this);
 
+    // has no tail call recursion
     if (!this.hasTailRecursion) return;
 
+    // the function binding isn't constant so we can't be sure that it's the same function :(
     if (this.hasDeopt()) {
       this.file.log.deopt(node, messages.get("tailCallReassignmentDeopt"));
       return;
@@ -169,21 +150,27 @@ class TailCallTransformer {
 
     //
 
-    this.path.traverse(secondPass, this);
-
-    if (!this.needsThis || !this.needsArguments) {
-      this.path.traverse(thirdPass, this);
-    }
-
     var body = t.ensureBlock(node).body;
 
+    for (var i = 0; i < body.length; i++) {
+      var bodyNode = body[i];
+      if (!t.isFunctionDeclaration(bodyNode)) continue;
+
+      bodyNode = body[i] = t.variableDeclaration("var", [
+        t.variableDeclarator(bodyNode.id, t.toExpression(bodyNode))
+      ]);
+      bodyNode._blockHoist = 2;
+    }
+
     if (this.vars.length > 0) {
       var declarations = flatten(map(this.vars, function (decl) {
         return decl.declarations;
       }));
+
       var assignment = reduceRight(declarations, function (expr, decl) {
         return t.assignmentExpression("=", decl.id, expr);
       }, t.identifier("undefined"));
+
       var statement = t.expressionStatement(assignment);
       statement._blockHoist = Infinity;
       body.unshift(statement);
@@ -191,7 +178,9 @@ class TailCallTransformer {
 
     var paramDecls = this.paramDecls;
     if (paramDecls.length > 0) {
-      body.unshift(t.variableDeclaration("var", paramDecls));
+      var paramDecl = t.variableDeclaration("var", paramDecls);
+      paramDecl._blockHoist = Infinity;
+      body.unshift(paramDecl);
     }
 
     body.unshift(t.expressionStatement(
@@ -199,22 +188,28 @@ class TailCallTransformer {
     );
 
     node.body = util.template("tail-call-body", {
-      AGAIN_ID:      this.getAgainId(),
-      THIS_ID:       this.thisId,
-      ARGUMENTS_ID:  this.argumentsId,
-      FUNCTION_ID:   this.getFunctionId(),
-      BLOCK:         node.body
+      FUNCTION_ID: this.getFunctionId(),
+      AGAIN_ID:    this.getAgainId(),
+      BLOCK:       node.body
     });
 
     var topVars = [];
 
     if (this.needsThis) {
+      for (var path of (this.thisPaths: Array)) {
+        path.replaceWith(this.getThisId());
+      }
+
       topVars.push(t.variableDeclarator(this.getThisId(), t.thisExpression()));
     }
 
     if (this.needsArguments || this.setsArguments) {
-      var decl = t.variableDeclarator(this.getArgumentsId());
-      if (this.needsArguments) {
+      for (var path of (this.argumentsPaths: Array)) {
+        path.replaceWith(this.argumentsId);
+      }
+
+      var decl = t.variableDeclarator(this.argumentsId);
+      if (this.argumentsId) {
         decl.init = t.identifier("arguments");
       }
       topVars.push(decl);
@@ -327,7 +322,7 @@ class TailCallTransformer {
 
     var body = [];
 
-    if (!t.isThisExpression(thisBinding)) {
+    if (this.needsThis && !t.isThisExpression(thisBinding)) {
       body.push(t.expressionStatement(t.assignmentExpression(
         "=",
         this.getThisId(),
@@ -340,29 +335,35 @@ class TailCallTransformer {
     }
 
     var argumentsId = this.getArgumentsId();
-    var params = this.getParams();
+    var params      = this.getParams();
 
-    body.push(t.expressionStatement(t.assignmentExpression(
-      "=",
-      argumentsId,
-      args
-    )));
-
-    var i, param;
+    if (this.needsArguments) {
+      body.push(t.expressionStatement(t.assignmentExpression(
+        "=",
+        argumentsId,
+        args
+      )));
+    }
 
     if (t.isArrayExpression(args)) {
       var elems = args.elements;
-      for (i = 0; i < elems.length && i < params.length; i++) {
-        param = params[i];
+      for (let i = 0; i < elems.length && i < params.length; i++) {
+        let param = params[i];
         var elem = elems[i] || (elems[i] = t.identifier("undefined"));
         if (!param._isDefaultPlaceholder) {
           elems[i] = t.assignmentExpression("=", param, elem);
         }
       }
+
+      if (!this.needsArguments) {
+        for (var elem of (elems: Array)) {
+          body.push(t.expressionStatement(elem));
+        }
+      }
     } else {
       this.setsArguments = true;
-      for (i = 0; i < params.length; i++) {
-        param = params[i];
+      for (let i = 0; i < params.length; i++) {
+        let param = params[i];
         if (!param._isDefaultPlaceholder) {
           body.push(t.expressionStatement(t.assignmentExpression(
             "=",
@@ -376,6 +377,7 @@ class TailCallTransformer {
     body.push(t.expressionStatement(
       t.assignmentExpression("=", this.getAgainId(), t.literal(true))
     ));
+
     body.push(t.continueStatement(this.getFunctionId()));
 
     return body;

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

@@ -4,10 +4,6 @@ var buildBinaryExpression = function (left, right) {
   return t.binaryExpression("+", left, right);
 };
 
-export function shouldVisit(node) {
-  return t.isTemplateLiteral(node) || t.isTaggedTemplateExpression(node);
-}
-
 export function TaggedTemplateExpression(node, parent, scope, file) {
   var quasi = node.quasi;
   var args  = [];

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

@@ -1,7 +1,3 @@
 export var metadata = {
   stage: 1
 };
-
-export function shouldVisit() {
-  return false;
-}

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

@@ -1,7 +1,4 @@
 export var metadata = {
-  stage: 0
+  stage: 0,
+  dependencies: ["es6.classes"]
 };
-
-export function shouldVisit() {
-  return false;
-}

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

@@ -26,7 +26,7 @@ function generator(node) {
 }
 
 function array(node, parent, scope, file) {
-  var uid = scope.generateUidBasedOnNode(parent);
+  var uid = scope.generateUidIdentifierBasedOnNode(parent);
 
   var container = util.template("array-comprehension-container", {
     KEY: uid

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

@@ -3,14 +3,11 @@ import * as defineMap from "../../helpers/define-map";
 import * as t from "../../../types";
 
 export var metadata = {
+  dependencies: ["es6.classes"],
   optional: true,
   stage: 1
 };
 
-export function shouldVisit(node) {
-  return !!node.decorators;
-}
-
 export function ObjectExpression(node, parent, scope, file) {
   var hasDecorators = false;
   for (var i = 0; i < node.properties.length; i++) {

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

@@ -5,8 +5,6 @@ export var metadata = {
   stage: 0
 };
 
-export var shouldVisit = t.isDoExpression;
-
 export function DoExpression(node) {
   var body = node.body.body;
   if (body.length) {

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

@@ -9,10 +9,20 @@ export var metadata = {
 
 var MATH_POW = t.memberExpression(t.identifier("Math"), t.identifier("pow"));
 
-build(exports, {
+var {
+  ExpressionStatement,
+  AssignmentExpression,
+  BinaryExpression
+} = build({
   operator: "**",
 
   build(left, right) {
     return t.callExpression(MATH_POW, [left, right]);
   }
 });
+
+export {
+  ExpressionStatement,
+  AssignmentExpression,
+  BinaryExpression
+};

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

@@ -6,10 +6,6 @@ export var metadata = {
   stage: 1
 };
 
-export function shouldVisit(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;

src/babel/transformation/transformers/es7/function-bind.js

@@ -0,0 +1,51 @@
+// https://github.com/zenparsing/es-function-bind
+
+import * as t from "../../../types";
+
+export var metadata = {
+  optional: true,
+  stage: 0
+};
+
+function getTempId(scope) {
+  var id = scope.path.getData("functionBind");
+  if (id) return id;
+
+  id = scope.generateDeclaredUidIdentifier("context");
+  return scope.path.setData("functionBind", id);
+}
+
+function getStaticContext(bind, scope) {
+  var object = bind.object || bind.callee.object;
+  return scope.isStatic(object) && object;
+}
+
+function inferBindContext(bind, scope) {
+  var staticContext = getStaticContext(bind, scope);
+  if (staticContext) return staticContext;
+
+  var tempId = getTempId(scope);
+  if (bind.object) {
+    bind.callee = t.sequenceExpression([
+      t.assignmentExpression("=", tempId, bind.object),
+      bind.callee
+    ]);
+  } else {
+    bind.callee.object = t.assignmentExpression("=", tempId, bind.callee.object);
+  }
+  return tempId;
+}
+
+export function CallExpression(node, parent, scope, file) {
+  var bind = node.callee;
+  if (!t.isBindExpression(bind)) return;
+
+  var context = inferBindContext(bind, scope);
+  node.callee = t.memberExpression(bind.callee, t.identifier("call"));
+  node.arguments.unshift(context);
+}
+
+export function BindExpression(node, parent, scope, file) {
+  var context = inferBindContext(node, scope);
+  return t.callExpression(t.memberExpression(node.callee, t.identifier("bind")), [context]);
+}

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

@@ -3,13 +3,10 @@
 import * as t from "../../../types";
 
 export var metadata = {
-  stage: 1
+  stage: 1,
+  dependencies: ["es6.destructuring"]
 };
 
-export function manipulateOptions(opts) {
-  if (opts.whitelist) opts.whitelist.push("es6.destructuring");
-}
-
 var hasSpread = function (node) {
   for (var i = 0; i < node.properties.length; i++) {
     if (t.isSpreadProperty(node.properties[i])) {

src/babel/transformation/transformers/es7/trailing-function-commas.js

@@ -1,7 +1,3 @@
 export var metadata = {
   stage: 1
 };
-
-export function shouldVisit() {
-  return false;
-}

src/babel/transformation/transformers/filters.js

@@ -0,0 +1,24 @@
+import includes from "lodash/collection/includes";
+
+export function internal(transformer, opts) {
+  if (transformer.key[0] === "_") return true;
+}
+
+export function blacklist(transformer, opts) {
+  var blacklist = opts.blacklist;
+  if (blacklist.length && includes(blacklist, transformer.key)) return false;
+}
+
+export function whitelist(transformer, opts) {
+  var whitelist = opts.whitelist;
+  if (whitelist) return includes(whitelist, transformer.key);
+}
+
+export function stage(transformer, opts) {
+  var stage = transformer.metadata.stage;
+  if (stage != null && stage >= opts.stage) return true;
+}
+
+export function optional(transformer, opts) {
+  if (transformer.metadata.optional && !includes(opts.optional, transformer.key)) return false;
+}

src/babel/transformation/transformers/index.js

@@ -1,120 +1,86 @@
 export default {
+  //- builtin-setup
+  strict:                                  require("./other/strict"),
+  _explode:                                require("./internal/explode"),
+  _validation:                             require("./internal/validation"),
+  _hoistDirectives:                        require("./internal/hoist-directives"),
+  "minification.removeDebugger":           require("./minification/remove-debugger"),
+  "minification.removeConsole":            require("./minification/remove-console"),
+  "utility.inlineEnvironmentVariables":    require("./utility/inline-environment-variables"),
+  "minification.inlineExpressions":        require("./minification/inline-expressions"),
+  "minification.deadCodeElimination":      require("./minification/dead-code-elimination"),
   _modules:                                require("./internal/modules"),
+  "spec.functionName":                     require("./spec/function-name"),
 
+  //- builtin-basic
+  // this is where the bulk of the ES6 transformations take place, none of them require traversal state
+  // so they can all be concatenated together for performance
   "es7.classProperties":                   require("./es7/class-properties"),
   "es7.trailingFunctionCommas":            require("./es7/trailing-function-commas"),
   "es7.asyncFunctions":                    require("./es7/async-functions"),
   "es7.decorators":                        require("./es7/decorators"),
-
-  strict:                                  require("./other/strict"),
-
-  _validation:                             require("./internal/validation"),
-
   "validation.undeclaredVariableCheck":    require("./validation/undeclared-variable-check"),
   "validation.react":                      require("./validation/react"),
-
-  // this goes at the start so we only transform the original user code
-  "spec.functionName":                     require("./spec/function-name"),
-
-  // needs to be before `_shadowFunctions`
   "es6.arrowFunctions":                    require("./es6/arrow-functions"),
-
   "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"),
-
-  // needs to be before `regenerator` due to generator comprehensions
-  // needs to be before `_shadowFunctions`
   "es7.comprehensions":                    require("./es7/comprehensions"),
-
   "es6.classes":                           require("./es6/classes"),
-
   asyncToGenerator:                        require("./other/async-to-generator"),
   bluebirdCoroutines:                      require("./other/bluebird-coroutines"),
-
   "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"),
   "es6.properties.shorthand":              require("./es6/properties.shorthand"),
-
-  // needs to be before `_shadowFunctions` due to define property closure
   "es6.properties.computed":               require("./es6/properties.computed"),
-
   "optimisation.flow.forOf":               require("./optimisation/flow.for-of"),
   "es6.forOf":                             require("./es6/for-of"),
-
   "es6.regex.sticky":                      require("./es6/regex.sticky"),
   "es6.regex.unicode":                     require("./es6/regex.unicode"),
-
   "es6.constants":                         require("./es6/constants"),
-
-  // needs to be before `es6.parameters.default` as default parameters will destroy the rest param
   "es6.parameters.rest":                   require("./es6/parameters.rest"),
-
-  // needs to be after `es6.parameters.rest` as we use `toArray` and avoid turning an already known array into one
   "es6.spread":                            require("./es6/spread"),
-
-  // needs to be before `es6.blockScoping` as default parameters have a TDZ
   "es6.parameters.default":                require("./es6/parameters.default"),
+  "es7.exportExtensions":                  require("./es7/export-extensions"),
+  "spec.protoToAssign":                    require("./spec/proto-to-assign"),
+  "es7.doExpressions":                     require("./es7/do-expressions"),
+  "es6.spec.symbols":                      require("./es6/spec.symbols"),
+  "es7.functionBind":                      require("./es7/function-bind"),
+  "spec.undefinedToVoid":                  require("./spec/undefined-to-void"),
+  jscript:                                 require("./other/jscript"),
+  flow:                                    require("./other/flow"),
 
-  // needs to be before `es6.blockScoping` as let variables may be produced
+  //- builtin-advanced
   "es6.destructuring":                     require("./es6/destructuring"),
-
-  // needs to be before `_shadowFunctions` due to block scopes sometimes being wrapped in a
-  // closure
   "es6.blockScoping":                      require("./es6/block-scoping"),
-
-  // needs to be after `es6.blockScoping` due to needing `letReferences` set on blocks
   "es6.spec.blockScoping":                 require("./es6/spec.block-scoping"),
+  reactCompat:                             require("./other/react-compat"),
+  react:                                   require("./other/react"),
 
-  // needs to be after `es6.parameters.*` and `es6.blockScoping` due to needing pure
-  // identifiers in parameters and variable declarators
-  "es6.tailCall":                          require("./es6/tail-call"),
+  // es6 syntax transformation is **forbidden** past this point since regenerator will chuck a massive
+  // hissy fit
 
+  //- regenerator
   regenerator:                             require("./other/regenerator"),
 
-  // needs to be after `regenerator` due to needing `regeneratorRuntime` references
-  // needs to be after `es6.forOf` due to needing `Symbol.iterator` references
-  // needs to be before `es6.modules` due to dynamic imports
-  runtime:                                require("./other/runtime"),
-
-  // needs to be before `_blockHoist` due to function hoisting etc
-  "es7.exportExtensions":                  require("./es7/export-extensions"),
+  //- builtin-modules
+  runtime:                                 require("./other/runtime"),
   "es6.modules":                           require("./es6/modules"),
-
-  _blockHoist:                             require("./internal/block-hoist"),
-
-  "spec.protoToAssign":                    require("./spec/proto-to-assign"),
-
-  _shadowFunctions:                        require("./internal/shadow-functions"),
-
-  "es7.doExpressions":                     require("./es7/do-expressions"),
-
-  "es6.spec.symbols":                      require("./es6/spec.symbols"),
-  ludicrous:                               require("./other/ludicrous"),
-  "spec.undefinedToVoid":                  require("./spec/undefined-to-void"),
-
-  _strict:                                 require("./internal/strict"),
   _moduleFormatter:                        require("./internal/module-formatter"),
 
+  //- builtin-trailing
+  // these clean up the output and do finishing up transformations, it's important to note that by this
+  // stage you can't import any new modules or insert new ES6 as all those transformers have already
+  // been ran
+  "es6.tailCall":                          require("./es6/tail-call"),
+  _shadowFunctions:                        require("./internal/shadow-functions"),
   "es3.propertyLiterals":                  require("./es3/property-literals"),
   "es3.memberExpressionLiterals":          require("./es3/member-expression-literals"),
-
-  "utility.removeDebugger":                require("./utility/remove-debugger"),
-  "utility.removeConsole":                 require("./utility/remove-console"),
-
-  "utility.inlineEnvironmentVariables":    require("./utility/inline-environment-variables"),
-  "utility.inlineExpressions":             require("./utility/inline-expressions"),
-  "utility.deadCodeElimination":           require("./utility/dead-code-elimination"),
-
-  jscript:                                 require("./other/jscript"),
-  flow:                                    require("./other/flow")
+  "minification.memberExpressionLiterals": require("./minification/member-expression-literals"),
+  "minification.propertyLiterals":         require("./minification/property-literals"),
+  _blockHoist:                             require("./internal/block-hoist"),
 };

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

@@ -1,6 +1,8 @@
-import groupBy from "lodash/collection/groupBy";
-import flatten from "lodash/array/flatten";
-import values from "lodash/object/values";
+import sortBy from "lodash/collection/sortBy";
+
+export var metadata = {
+  group: "builtin-trailing"
+};
 
 // Priority:
 //
@@ -18,14 +20,14 @@ export var BlockStatement = {
     }
     if (!hasChange) return;
 
-    var nodePriorities = groupBy(node.body, function (bodyNode) {
+    node.body = sortBy(node.body, function(bodyNode){
       var priority = bodyNode && bodyNode._blockHoist;
       if (priority == null) priority = 1;
       if (priority === true) priority = 2;
-      return priority;
-    });
 
-    node.body = flatten(values(nodePriorities).reverse());
+      // Higher priorities should move toward the top.
+      return -1 * priority;
+    });
   }
 };
 

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

@@ -0,0 +1,33 @@
+import clone from "lodash/lang/clone";
+import * as t from "../../../types";
+
+export var metadata = {
+  group: "builtin-setup"
+};
+
+function buildClone(bindingKey, refKey, check?) {
+  return function (node) {
+    if (node[bindingKey] === node[refKey] || (check && check(node))) {
+      node[refKey] = t.removeComments(clone(node[refKey]));
+    }
+  };
+}
+
+function buildListClone(listKey, bindingKey, refKey) {
+  var clone = buildClone(bindingKey, refKey);
+
+  return function (node) {
+    if (!node[listKey]) return;
+
+    for (var subNode of (node[listKey]: Array)) {
+      clone(subNode);
+    }
+  };
+}
+
+export var Property = buildClone("value", "key", function (node) {
+  return t.isAssignmentPattern(node.value) && node.value.left === node.key;
+});
+
+export var ExportDeclaration = buildListClone("specifiers", "local", "exported");
+export var ImportDeclaration = buildListClone("specifiers", "local", "imported");