v3.0.8

Conflicts:
	package.json

.gitignore

@@ -11,3 +11,5 @@ test/tmp
 coverage
 dist
 .package.json
+packages/6to5-runtime/*.js
+packages/6to5-runtime/regenerator/*.js

.gitmodules

@@ -3,7 +3,7 @@
 	url = https://github.com/google/traceur-compiler
 [submodule "vendor/regenerator"]
 	path = vendor/regenerator
-	url = https://github.com/facebook/regenerator
+	url = https://github.com/6to5/regenerator-6to5
 [submodule "vendor/test262"]
 	path = vendor/test262
 	url = https://github.com/tc39/test262

.jscsrc

@@ -0,0 +1,60 @@
+{
+  "excludeFiles": ["lib/6to5/transformation/templates"],
+  "disallowSpacesInNamedFunctionExpression": {
+    "beforeOpeningRoundBrace": true
+  },
+  "requireSpacesInAnonymousFunctionExpression": {
+    "beforeOpeningRoundBrace": true
+  },
+  "requireSpacesInAnonymousFunctionExpression": {
+    "beforeOpeningRoundBrace": true
+  },
+  "disallowSpacesInFunctionDeclaration": {
+    "beforeOpeningRoundBrace": true
+  },
+  "disallowSpacesInsideArrayBrackets": true,
+  "disallowSpacesInsideParentheses": true,
+  "disallowQuotedKeysInObjects": true,
+  "disallowSpaceAfterObjectKeys": true,
+  "disallowSpaceAfterPrefixUnaryOperators": true,
+  "disallowSpaceBeforePostfixUnaryOperators": true,
+  "disallowSpaceBeforeBinaryOperators": [
+    ","
+  ],
+  "disallowMixedSpacesAndTabs": true,
+  "disallowTrailingWhitespace": true,
+  "disallowYodaConditions": true,
+  "disallowKeywords": [ "with" ],
+  "disallowMultipleLineBreaks": true,
+  "requireSpaceBeforeBlockStatements": true,
+  "requireParenthesesAroundIIFE": true,
+  "requireSpacesInConditionalExpression": true,
+  "requireBlocksOnNewline": 1,
+  "requireCommaBeforeLineBreak": true,
+  "requireSpaceBeforeBinaryOperators": true,
+  "requireSpaceAfterBinaryOperators": true,
+  "requireCamelCaseOrUpperCaseIdentifiers": true,
+  "requireLineFeedAtFileEnd": true,
+  "requireCapitalizedConstructors": true,
+  "requireDotNotation": true,
+  "requireSpacesInForStatement": true,
+  "requireCurlyBraces": [
+    "do"
+  ],
+  "requireSpaceAfterKeywords": [
+    "if",
+    "else",
+    "for",
+    "while",
+    "do",
+    "switch",
+    "case",
+    "return",
+    "try",
+    "catch",
+    "typeof"
+  ],
+  "validateLineBreaks": "LF",
+  "validateQuoteMarks": "\"",
+  "validateIndentation": 2
+}

.jshintignore

@@ -1,3 +1 @@
-node_modules
-test
 lib/6to5/transformation/templates

.npmignore

@@ -12,3 +12,4 @@ CHANGELOG.md
 .package.json
 coverage
 vendor
+packages

CHANGELOG.md

@@ -11,6 +11,144 @@
 
 _Note: Gaps between patch versions are faulty/broken releases._
 
+## 3.0.8
+
+ * **Bug Fix**
+  * Split up default function declaration exports due to regenerator destroying the parent export declaration.
+
+## 3.0.7
+
+ * **Internal**
+  * Upgrade `core-js` to `0.4.9`.
+ * **Bug Fix**
+  * Add id to function express scope tracking.
+
+## 3.0.6
+
+ * **Bug Fix**
+  * Fix block scope variable tracking stopping whenever it hits a new scope.
+  * Fix block scope variable tracking breaking on all block statement scopes that have a for loop parent.
+
+## 3.0.5
+
+ * **Internal**
+  * More reliable default parameter scope.
+
+## 3.0.4
+
+ * **Bug Fix**
+  * Remove traversal stops from block scope tracking.
+
+## 3.0.3
+
+ * **Internal**
+  * Ignore options starting with `_`.
+
+## 3.0.2
+
+ * **Internal**
+  * Add common plugin options to valid options list.
+
+## 3.0.1
+
+ * **Internal**
+  * Downgrade `kexec` as `1.1.0` throws compilation errors.
+
+## 3.0.0
+
+ * **Polish**
+  * Generated code autoindentation.
+  * Moved global uid registry to a scope registry resulting in nicer uids.
+  * `this` is now illegal in the top level scope when using the default `useStrict` transformer.
+  * New `asyncToGenerator` helper that's much more compact.
+  * Throw errors on unknown options.
+  * More reliable default parameter scope.
+  * Helpers are now compact and have no newlines.
+ * **Internal**
+  * Rewritten a lot of the internals to much simpler.
+  * Removed TDZ from default parameters as it was very wonky and unreliable.
+  * Upgrade `core-js` to `0.4.6`.
+  * Upgrade `acorn-6to5`.
+   * JSX support is now on-par with react-tools/esprima.
+   * Shorthand destructuring.
+ * **Bug Fix**
+  * Generators now work flawlessly with any parameter transformers.
+  * Optional async function transformers should not name their functions.
+  * Remove `unlink` event watching in `bin/6to5`.
+  * Fix regenerator variable declarations being incorrectly hoisted breaking scope.
+  * Transformers that attempted to simplify expressions that had no consequence now take into account whether it's one of the last statements/expressions in the script.
+ * **New Feature**
+  * New `selfContained` transformer.
+  * New `undeclaredVariableCheck` optional transformer.
+  * Added `--blacklist` and `--whitelist` options to `6to5-node`.
+ * **Breaking Change**
+  * Caching is now always enabled for the require hook. It also now no longer caches require resolutions.
+  * Bare `super();` only works inside of constructors.
+  * Removed the optional runtime in favor of the `selfContained` transformer.
+  * This shorthand has been removed from the playground.
+  * `6to5/polyfill` can now only be required **once**.
+  * **CLI**
+   * `--indent` option has been removed.
+   * `--include-regenerator` option has been removed.
+   * `--amd-modules-id` option has been removed, use `--module-ids` instead.
+  * **Options**
+   * `amdModuleIds` option has been removed, use `moduleIds` instead.
+   * `includeRegenerator` has been removed.
+   * `ignoreRegex` fallback has now been dropped from the require hook. `register(/foo/);`, `register({ ignoreRegex: /foo/ })` -> `register({ ignore: /foo/ })`.
+  * **Modules**
+    * Module interop now only collapses to `module.exports` when there's a **single** export that's default.
+    * Imports and exports are now illegal anywhere except the root level by default. Set `modules` to [loose mode](http://6to5.org/docs/usage/loose) to allow them everywhere.
+  * **Transformers**
+    * Optional fast transformer backwards compatibility support has been removed. Use [loose mode](https://6to5.org/docs/usage/loose).
+    * Removed the `coreAliasing` transformer in favor of `selfContained`.
+    * Renamed transformers:
+     * `specNoForInOfAssignment` -> `validation.noForInOfAssignment`
+     * `specSetters` -> `validation.setters`
+     * `specBlockScopedFunctions` -> `spec.blockScopedFunctions`
+     * `malletOperator` -> `playground.malletOperator`
+     * `methodBinding` -> `playground.methodBinding`
+     * `memoizationOperator` -> `playground.memoizationOperator`
+     * `objectGetterMemoization` -> `playground.objectGetterMemoization`
+     * `modules` -> `es6.modules`
+     * `propertyNameShorthand` -> `es6.properties.shorthand`
+     * `arrayComprehension` -> `es7.comprehensions`
+     * `generatorComprehension` -> `es7.comprehensions`
+     * `arrowFunctions` -> `es6.arrowFunctions`
+     * `classes` -> `es6.classes`
+     * `objectSpread` -> `es7.objectSpread`
+     * `exponentiationOperator` -> `es7.exponentiationOperator`
+     * `spread` -> `es6.spread`
+     * `templateLiterals` -> `es6.templateLiterals`
+     * `propertyMethodAssignment` -> `es6.properties.shorthand`
+     * `computedPropertyNames` -> `es6.properties.computed`
+     * `defaultParameters` -> `es6.parameters.default`
+     * `restParameters` -> `es6.parameters.rest`
+     * `destructuring` -> `es6.destructuring`
+     * `forOf` -> `es6.forOf`
+     * `unicodeRegex` -> `es6.unicodeRegex`
+     * `abstractReferences` -> `es7.abstractReferences`
+     * `constants` -> `es6.constants`
+     * `letScoping` -> `es6.blockScoping`
+     * `blockScopingTDZ` -> `es6.blockScopingTDZ`
+     * `generators` -> `regenerator`
+     * `protoToAssign` -> `spec.protoToAssign`
+     * `typeofSymbol` -> `spec.typeofSymbol`
+     * `coreAliasing` -> `selfContained`
+     * `undefinedToVoid` -> `spec.undefinedToVoid`
+     * `undeclaredVariableCheck` -> `validation.undeclaredVariableCheck`
+     * `specPropertyLiterals` -> `minification.propertyLiterals`
+     * `specMemberExpressionLiterals` -> `minification.memberExpressionLiterals`
+
+## 2.13.7
+
+ * **Bug Fix**
+  * Don't realias variables that are already declared in optional `coreAliasing` transformer.
+
+## 2.13.6
+
+ * **Bug Fix**
+  * Add `NewExpression` as a valid parent for parentheses insertion for `ConditionalExpression`.
+
 ## 2.13.5
 
  * **Bug Fix**

Makefile

@@ -4,15 +4,16 @@ 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
+JSCS_CMD = node_modules/jscs/bin/jscs
 
 export NODE_ENV = test
 
-.PHONY: clean test test-cov test-clean lint test-travis test-simple test-all test-browser publish build bootstrap publish-core
+.PHONY: clean test test-cov test-clean lint test-travis test-simple test-all test-browser publish build bootstrap publish-core publish-runtime
 
 build:
 	mkdir -p dist
 
-	node bin/cache-templates
+	node tools/cache-templates
 
 	node $(BROWSERIFY_CMD) -e lib/6to5/polyfill.js >dist/polyfill.js
 	node $(UGLIFY_CMD) dist/polyfill.js >dist/polyfill.min.js
@@ -20,9 +21,6 @@ build:
 	node $(BROWSERIFY_CMD) lib/6to5/browser.js -s to5 >dist/6to5.js
 	node $(UGLIFY_CMD) dist/6to5.js >dist/6to5.min.js
 
-	node bin/6to5-runtime >dist/runtime.js
-	node $(UGLIFY_CMD) dist/runtime.js >dist/runtime.min.js
-
 	rm -rf templates.json
 
 clean:
@@ -30,6 +28,7 @@ clean:
 
 lint:
 	$(JSHINT_CMD) --reporter node_modules/jshint-stylish/stylish.js lib bin
+	$(JSCS_CMD) lib bin
 
 test-clean:
 	rm -rf test/tmp
@@ -40,17 +39,17 @@ test: lint
 
 test-simple:
 	# excludes test262
-	export SIMPLE_6TO5_TESTS=1
+	export SIMPLE_6TO5_TESTS=1; \
 	make test
 
 test-all:
 	# includes traceur, esnext, regenerator
-	export ALL_6TO5_TESTS=1
+	export ALL_6TO5_TESTS=1; \
 	make test
 
 test-cov:
-	export SIMPLE_6TO5_TESTS=1
 	rm -rf coverage
+	export SIMPLE_6TO5_TESTS=1; \
 	node $(ISTANBUL_CMD) $(MOCHA_CMD) --
 
 test-travis: bootstrap
@@ -60,8 +59,8 @@ test-travis: bootstrap
 test-browser:
 	mkdir -p dist
 
-	node bin/cache-templates
-	node bin/cache-tests
+	node tools/cache-templates
+	node tools/cache-tests
 	node $(BROWSERIFY_CMD) -e test/_browser.js >dist/6to5-test.js
 	rm -rf templates.json tests.json
 
@@ -78,28 +77,35 @@ publish:
 	make build
 	cp dist/6to5.min.js browser.js
 	cp dist/polyfill.min.js browser-polyfill.js
-	cp dist/runtime.min.js runtime.js
 
-	node bin/cache-templates
+	node tools/cache-templates
 	test -f templates.json
 
 	npm publish
 
 	git push --follow-tags
 
-	# generate
-	bin/generate-core-package-json >package2.json
+	make publish-core
+	make publish-runtime
+
+	rm -rf templates.json browser.js browser-polyfill.js
+
+publish-runtime:
+	cd packages; \
+	node build-runtime.js; \
+	cd 6to5-runtime; \
+	npm publish
+
+publish-core:
+	tools/generate-core-package-json >package2.json
 	mv package.json .package.json
 	mv package2.json package.json
 
 	npm publish
 
-	# restore
 	rm -rf package.json
 	mv .package.json package.json
 
-	rm -rf templates.json browser.js runtime.js browser-polyfill.js
-
 bootstrap:
 	npm install
 	git submodule update --init

NOTES.md

@@ -1,14 +1,3 @@
 # Notes
 
  * Wildcard exports/imports wont normalise if `export default` is a non-object. See [#224](https://github.com/6to5/6to5/issues/224).
-
-## 3.0.0 breaking changes
-
- * Remove `allowImportExportEverywhere` option from acorn.
- * Remove this shorthand from playground.
- * Remove `super()` inside non-constructors - add descriptive error message.
- * Split up ES5 getter/setter transforming and ES6 property methods into separate transformers.
- * Add autoindentation.
- * Move `super` transformation from classes into a separate transformer that also supports object expressions.
- * Remove fast transformer backwards compatibility.
- * Rename let scoping transformer to block scoping.

README.md

@@ -2,28 +2,6 @@
   <img alt="6to5" src="https://raw.githubusercontent.com/6to5/logo/master/logo.png" width="546">
 </p>
 
-<p align="center">
-  <a href="https://gratipay.com/sebmck">
-    <img alt="Gratipay" src="https://img.shields.io/gratipay/sebmck.svg?style=flat">
-  </a>
-
-  <a href="https://travis-ci.org/6to5/6to5">
-    <img alt="Travis Status" src="http://img.shields.io/travis/6to5/6to5/master.svg?style=flat&amp;label=travis">
-  </a>
-
-  <a href="https://codeclimate.com/github/6to5/6to5">
-    <img alt="Code Climate Score" src="http://img.shields.io/codeclimate/github/6to5/6to5.svg?style=flat">
-  </a>
-
-  <a href="https://codeclimate.com/github/6to5/6to5">
-    <img alt="Coverage" src="http://img.shields.io/codeclimate/coverage/github/6to5/6to5.svg?style=flat">
-  </a>
-
-  <a href="https://david-dm.org/6to5/6to5">
-    <img alt="Dependency Status" src="http://img.shields.io/david/6to5/6to5.svg?style=flat">
-  </a>
-</p>
-
 <p align="center">
   <strong>6to5</strong> turns ES6+ code into vanilla ES5, so you can use next generation features <strong>today.</strong>
 </p>

bin/6to5-runtime

@@ -1,4 +0,0 @@
-#!/usr/bin/env node
-
-var runtime = require("../lib/6to5/runtime-generator");
-console.log(runtime(process.argv[2]));

bin/6to5/dir.js

@@ -51,7 +51,7 @@ module.exports = function (commander, filenames, opts) {
         ignoreInitial: true
       });
 
-      _.each(["add", "change", "unlink"], function (type) {
+      _.each(["add", "change"], function (type) {
         watcher.on(type, function (filename) {
           // chop off the dirname plus the path separator
           var relative = filename.slice(dirname.length + 1);

bin/6to5/file.js

@@ -77,7 +77,7 @@ module.exports = function (commander, filenames) {
       if (chunk !== null) code += chunk;
     });
 
-    process.stdin.on("end", function() {
+    process.stdin.on("end", function () {
       results.push(util.transform(commander.filename, code));
       output();
     });
@@ -117,7 +117,7 @@ module.exports = function (commander, filenames) {
         persistent: true,
         ignoreInitial: true
       }).on("all", function (type, filename) {
-        if (type === "add" || type === "change" || type === "unlink" ) {
+        if (type === "add" || type === "change") {
           console.log(type, filename);
           walk();
         }

bin/6to5/index.js

@@ -10,7 +10,6 @@ commander.option("-t, --source-maps-inline", "Append sourceMappingURL comment to
 commander.option("-s, --source-maps", "Save source map alongside the compiled code");
 commander.option("-f, --filename [filename]", "Filename to use when reading from stdin - this will be used in source-maps, errors etc [stdin]", "stdin");
 commander.option("-w, --watch", "Recompile files on changes");
-commander.option("-r, --runtime", "Replace 6to5 declarations with references to a runtime");
 commander.option("-e, --experimental", "Enable experimental support for proposed ES7 features");
 commander.option("-p, --playground", "Enable playground support");
 
@@ -18,18 +17,15 @@ commander.option("-m, --modules [modules]", "Module formatter type to use [commo
 commander.option("-l, --whitelist [whitelist]", "Whitelist of transformers to ONLY use", util.list);
 commander.option("-b, --blacklist [blacklist]", "Blacklist of transformers to NOT use", util.list);
 commander.option("-i, --optional [list]", "List of optional transformers to enable", util.list);
-commander.option("--loose [list]", "List of transformers to enable their loose mode", util.list);
+commander.option("-L, --loose [list]", "List of transformers to enable loose mode ON", util.list);
 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");
 commander.option("-c, --remove-comments", "Remove comments from the compiled code", false);
-commander.option("-I, --indent [width]", "Indent width [2]", 2);
-commander.option("-a, --amd-module-ids", "Insert module id in AMD modules", false); // todo: remove in 3.0.0
 commander.option("-m, --module-ids", "Insert module id in modules", false);
 commander.option("-R, --react-compat", "Makes the react transformer produce pre-v0.12 code");
-commander.option("-E, --include-regenerator", "Include the regenerator runtime if necessary", false);
 commander.option("--keep-module-id-extensions", "Keep extensions when generating module ids", false);
 
-commander.on("--help", function(){
+commander.on("--help", function () {
   var outKeys = function (title, obj) {
     console.log("  " + title + ":");
     console.log();
@@ -101,25 +97,18 @@ if (errors.length) {
 
 exports.opts = {
   keepModuleIdExtensions: commander.keepModuleIdExtensions,
-  includeRegenerator:     commander.includeRegenerator,
   sourceMapName:          commander.outFile,
   experimental:           commander.experimental,
   reactCompat:            commander.reactCompat,
   playground:             commander.playground,
-  moduleIds:              commander.amdModuleIds || commander.moduleIds,
+  moduleIds:              commander.moduleIds,
   blacklist:              commander.blacklist,
   whitelist:              commander.whitelist,
   sourceMap:              commander.sourceMaps || commander.sourceMapsInline,
   optional:               commander.optional,
   comments:               !commander.removeComments,
-  runtime:                commander.runtime,
   modules:                commander.modules,
-  loose:                  commander.loose,
-  format: {
-    indent: {
-      style:     util.repeat(parseInt(commander.indent))
-    }
-  }
+  loose:                  commander.loose
 };
 
 var fn;

bin/_6to5-node

@@ -1,40 +1,39 @@
 #!/usr/bin/env node
 
-var roadrunner = require("roadrunner");
-var commander  = require("commander");
-var Module     = require("module");
-var path       = require("path");
-var repl       = require("repl");
-var to5        = require("../lib/6to5");
-var util       = require("../lib/6to5/util");
-var vm         = require("vm");
-var _          = require("lodash");
+var commander = require("commander");
+var Module    = require("module");
+var path      = require("path");
+var repl      = require("repl");
+var to5       = require("../lib/6to5");
+var util      = require("../lib/6to5/util");
+var vm        = require("vm");
+var _         = require("lodash");
 
 var program = new commander.Command("6to5-node");
 
 program.option("-e, --eval [script]", "Evaluate script");
-program.option("-p, --print", "Evaluate script and print result");
+program.option("-p, --print [code]", "Evaluate script and print result");
 program.option("-i, --ignore [regex]", "Ignore all files that match this regex when using the require hook");
-program.option("-x, --extensions [extensions]", "List of extensions to hook into [.es6,.js]");
+program.option("-x, --extensions [extensions]", "List of extensions to hook into [.es6,.js,.es,.jsx]");
 program.option("-r, --experimental", "Enable experimental support for proposed ES7 features");
 program.option("-g, --playground", "Enable playground support");
-program.option("-c, --cache", "Cache compiled files and require paths");
+program.option("-w, --whitelist [whitelist]", "Whitelist of transformers to ONLY use", util.list);
+program.option("-b, --blacklist [blacklist]", "Blacklist of transformers to NOT use", util.list);
 
 var pkg = require("../package.json");
 program.version(pkg.version);
 program.usage("[options] [ -e script | script.js ] [arguments]");
 program.parse(process.argv);
 
-if (program.cache) roadrunner.load();
-
 //
 
 to5.register({
   experimental: program.experimental,
   extensions:   program.extensions,
   playground:   program.playground,
-  ignore:       program.ignore,
-  cache:        program.cache && roadrunner.get("6to5")
+  blacklist:    program.blacklist,
+  whitelist:    program.whitelist,
+  ignore:       program.ignore
 });
 
 //
@@ -42,15 +41,19 @@ to5.register({
 var _eval = function (code, filename) {
   code = to5.transform(code, {
     filename: filename,
-    blacklist: ["useStrict"],
+    blacklist: ["useStrict"].concat(program.blacklist || []),
+    whitelist: program.whitelist,
     experimental: program.experimental,
     playground: program.playground
   }).code;
   return vm.runInThisContext(code, filename);
 };
 
-if (program.eval) {
-  var result = _eval(program.eval, "eval");
+if (program.eval || program.print) {
+  var code = program.eval;
+  if (!code || code === true) code = program.print;
+
+  var result = _eval(code, "eval");
   if (program.print) console.log(result);
 } else {
   if (program.args.length) {
@@ -79,8 +82,6 @@ if (program.eval) {
   }
 }
 
-if (program.cache) roadrunner.save();
-
 function replStart() {
   repl.start({
     prompt: "> ",

lib/6to5/file.js

@@ -6,18 +6,25 @@ var SHEBANG_REGEX = /^\#\!.*/;
 
 var transform = require("./transformation/transform");
 var generate  = require("./generation/generator");
+var clone     = require("./helpers/clone");
 var Scope     = require("./traverse/scope");
 var util      = require("./util");
 var t         = require("./types");
 var _         = require("lodash");
 
 function File(opts) {
-  this.dynamicImports   = [];
   this.dynamicImportIds = {};
+  this.dynamicImported  = [];
+  this.dynamicImports   = [];
+
+  this.dynamicData      = {};
+  this.data             = {};
+
+  this.lastStatements   = [];
   this.opts             = File.normaliseOptions(opts);
-  this.transformers     = this.getTransformers();
-  this.uids             = {};
   this.ast              = {};
+
+  this.buildTransformers();
 }
 
 File.helpers = [
@@ -42,23 +49,51 @@ File.helpers = [
   "get"
 ];
 
-File.excludeHelpersFromRuntime = [
-  "async-to-generator",
-  "typeof",
-  "tagged-template-literal-loose"
+File.validOptions = [
+  "filename",
+  "filenameRelative",
+  "blacklist",
+  "whitelist",
+  "loose",
+  "optional",
+  "modules",
+  "sourceMap",
+  "sourceMapName",
+  "sourceFileName",
+  "sourceRoot",
+  "moduleRoot",
+  "moduleIds",
+  "comments",
+  "reactCompat",
+  "keepModuleIdExtensions",
+  "code",
+  "ast",
+  "format",
+  "playground",
+  "experimental",
+
+  // these are used by plugins
+  "ignore",
+  "only",
+  "extensions"
 ];
 
 File.normaliseOptions = function (opts) {
-  opts = _.cloneDeep(opts || {});
+  opts = clone(opts);
+
+  for (var key in opts) {
+    if (key[0] !== "_" && File.validOptions.indexOf(key) < 0) {
+      throw new ReferenceError("Unknown option: " + key);
+    }
+  }
 
   _.defaults(opts, {
     keepModuleIdExtensions: false,
-    includeRegenerator:     false,
     experimental:           false,
     reactCompat:            false,
     playground:             false,
     whitespace:             true,
-    moduleIds:              opts.amdModuleIds || false,
+    moduleIds:              false,
     blacklist:              [],
     whitelist:              [],
     sourceMap:              false,
@@ -66,7 +101,6 @@ File.normaliseOptions = function (opts) {
     comments:               true,
     filename:               "unknown",
     modules:                "common",
-    runtime:                false,
     loose:                  [],
     code:                   true,
     ast:                    true
@@ -84,17 +118,6 @@ File.normaliseOptions = function (opts) {
     opts.loose = Object.keys(transform.transformers);
   }
 
-  // todo: remove in 3.0.0
-  _.each({
-    fastForOf: "forOf",
-    classesFastSuper: "classes"
-  }, function (newTransformer, oldTransformer) {
-    if (_.contains(opts.optional, oldTransformer)) {
-      _.pull(opts.optional, oldTransformer);
-      opts.loose.push(newTransformer);
-    }
-  });
-
   _.defaults(opts, {
     moduleRoot: opts.sourceRoot
   });
@@ -112,18 +135,14 @@ File.normaliseOptions = function (opts) {
     sourceMapName:  opts.filenameRelative
   });
 
-  if (opts.runtime === true) {
-    opts.runtime = "to5Runtime";
-  }
-
   if (opts.playground) {
     opts.experimental = true;
   }
 
-  transform._ensureTransformerNames("blacklist", opts.blacklist);
-  transform._ensureTransformerNames("whitelist", opts.whitelist);
-  transform._ensureTransformerNames("optional", opts.optional);
-  transform._ensureTransformerNames("loose", opts.loose);
+  opts.blacklist = transform._ensureTransformerNames("blacklist", opts.blacklist);
+  opts.whitelist = transform._ensureTransformerNames("whitelist", opts.whitelist);
+  opts.optional = transform._ensureTransformerNames("optional", opts.optional);
+  opts.loose = transform._ensureTransformerNames("loose", opts.loose);
 
   return opts;
 };
@@ -132,17 +151,21 @@ File.prototype.isLoose = function (key) {
   return _.contains(this.opts.loose, key);
 };
 
-File.prototype.getTransformers = function () {
+File.prototype.buildTransformers = function () {
   var file = this;
-  var transformers = [];
-  var secondPassTransformers = [];
 
-  _.each(transform.transformers, function (transformer) {
-    if (transformer.canRun(file)) {
-      transformers.push(transformer);
+  var transformers = {};
 
+  var secondaryStack = [];
+  var stack = [];
+
+  _.each(transform.transformers, function (transformer, key) {
+    var pass = transformers[key] = transformer.buildPass(file);
+
+    if (pass.canRun(file)) {
+      stack.push(pass);
       if (transformer.secondPass) {
-        secondPassTransformers.push(transformer);
+        secondaryStack.push(pass);
       }
 
       if (transformer.manipulateOptions) {
@@ -151,7 +174,8 @@ File.prototype.getTransformers = function () {
     }
   });
 
-  return transformers.concat(secondPassTransformers);
+  this.transformerStack = stack.concat(secondaryStack);
+  this.transformers = transformers;
 };
 
 File.prototype.toArray = function (node, i) {
@@ -197,6 +221,26 @@ File.prototype.parseShebang = function (code) {
   return code;
 };
 
+File.prototype.set = function (key, val) {
+  return this.data[key] = val;
+};
+
+File.prototype.setDynamic = function (key, fn) {
+  this.dynamicData[key] = fn;
+};
+
+File.prototype.get = function (key) {
+  var data = this.data[key];
+  if (data) {
+    return data;
+  } else {
+    var dynamic = this.dynamicData[key];
+    if (dynamic) {
+      return this.set(key, dynamic());
+    }
+  }
+};
+
 File.prototype.addImport = function (source, name) {
   name = name || source;
   var id = this.dynamicImportIds[name];
@@ -207,12 +251,18 @@ File.prototype.addImport = function (source, name) {
     var specifiers = [t.importSpecifier(t.identifier("default"), id)];
     var declar = t.importDeclaration(specifiers, t.literal(source));
     declar._blockHoist = 3;
-    this.dynamicImports.push(declar);
+    this.dynamicImported.push(declar);
+
+    this.moduleFormatter.importSpecifier(specifiers[0], declar, this.dynamicImports);
   }
 
   return id;
 };
 
+File.prototype.isConsequenceExpressionStatement = function (node) {
+  return t.isExpressionStatement(node) && this.lastStatements.indexOf(node) >= 0;
+};
+
 File.prototype.addHelper = function (name) {
   if (!_.contains(File.helpers, name)) {
     throw new ReferenceError("unknown declaration " + name);
@@ -223,22 +273,21 @@ File.prototype.addHelper = function (name) {
   var declar = program._declarations && program._declarations[name];
   if (declar) return declar.id;
 
-  var ref;
-  var runtimeNamespace = this.opts.runtime;
-  if (runtimeNamespace && !_.contains(File.excludeHelpersFromRuntime, name)) {
+  var runtime = this.get("runtimeIdentifier");
+  if (runtime) {
     name = t.identifier(t.toIdentifier(name));
-    return t.memberExpression(t.identifier(runtimeNamespace), name);
+    return t.memberExpression(runtime, name);
   } else {
-    ref = util.template(name);
+    var ref = util.template(name);
+    ref._compact = true;
+    var uid = this.generateUidIdentifier(name);
+    this.scope.push({
+      key: name,
+      id: uid,
+      init: ref
+    });
+    return uid;
   }
-
-  var uid = this.generateUidIdentifier(name);
-  this.scope.push({
-    key: name,
-    id: uid,
-    init: ref
-  });
-  return uid;
 };
 
 File.prototype.errorWithNode = function (node, msg, Error) {
@@ -261,7 +310,11 @@ File.prototype.parse = function (code) {
 
   code = this.addCode(code);
 
-  return util.parse(this.opts, code, function (tree) {
+  var opts = this.opts;
+
+  opts.allowImportExportEverywhere = this.isLoose("modules");
+
+  return util.parse(opts, code, function (tree) {
     self.transform(tree);
     return self.generate();
   });
@@ -271,19 +324,20 @@ File.prototype.transform = function (ast) {
   var self = this;
 
   this.ast = ast;
-  this.scope = new Scope(ast.program);
+  this.lastStatements = t.getLastStatements(ast.program);
+  this.scope = new Scope(ast.program, ast, null, this);
   this.moduleFormatter = this.getModuleFormatter(this.opts.modules);
 
   var astRun = function (key) {
-    _.each(self.transformers, function (transformer) {
-      transformer.astRun(self, key);
+    _.each(self.transformerStack, function (pass) {
+      pass.astRun(key);
     });
   };
 
   astRun("enter");
 
-  _.each(this.transformers, function (transformer) {
-    transformer.transform(self);
+  _.each(this.transformerStack, function (pass) {
+    pass.transform();
   });
 
   astRun("exit");
@@ -324,8 +378,10 @@ File.prototype.generateUid = function (name, scope) {
   scope = scope || this.scope;
 
   var uid;
+  var i = 0;
   do {
-    uid = this._generateUid(name);
+    uid = this._generateUid(name, i);
+    i++;
   } while (scope.has(uid));
   return uid;
 };
@@ -337,12 +393,8 @@ File.prototype.generateUidIdentifier = function (name, scope) {
   return id;
 };
 
-File.prototype._generateUid = function (name) {
-  var uids = this.uids;
-  var i = uids[name] || 1;
-
+File.prototype._generateUid = function (name, i) {
   var id = name;
   if (i > 1) id += i;
-  uids[name] = i + 1;
   return "_" + id;
 };

lib/6to5/generation/buffer.js

@@ -68,7 +68,11 @@ Buffer.prototype.removeLast = function (cha) {
 };
 
 Buffer.prototype.newline = function (i, removeLast) {
-  if (this.format.compact) return;
+  if (this.format.compact) {
+    this.space();
+    return;
+  }
+
   removeLast = removeLast || false;
 
   if (_.isNumber(i)) {
@@ -102,13 +106,13 @@ Buffer.prototype._newline = function (removeLast) {
  * If buffer ends with a newline and some spaces after it, trim those spaces.
  */
 Buffer.prototype._removeSpacesAfterLastNewline = function () {
-  var lastNewlineIndex = this.buf.lastIndexOf('\n');
+  var lastNewlineIndex = this.buf.lastIndexOf("\n");
   if (lastNewlineIndex === -1)
     return;
 
   var index = this.buf.length - 1;
   while (index > lastNewlineIndex) {
-    if (this.buf[index] !== ' ') {
+    if (this.buf[index] !== " ") {
       break;
     }
 

lib/6to5/generation/generator.js

@@ -7,21 +7,22 @@ module.exports = function (ast, opts, code) {
 
 module.exports.CodeGenerator = CodeGenerator;
 
-var Whitespace = require("./whitespace");
-var SourceMap  = require("./source-map");
-var Position   = require("./position");
-var Buffer     = require("./buffer");
-var util       = require("../util");
-var n          = require("./node");
-var t          = require("../types");
-var _          = require("lodash");
+var detectIndent = require("detect-indent");
+var Whitespace   = require("./whitespace");
+var SourceMap    = require("./source-map");
+var Position     = require("./position");
+var Buffer       = require("./buffer");
+var util         = require("../util");
+var n            = require("./node");
+var t            = require("../types");
+var _            = require("lodash");
 
 function CodeGenerator(ast, opts, code) {
   opts = opts || {};
 
   this.comments = ast.comments || [];
   this.tokens   = ast.tokens || [];
-  this.format   = CodeGenerator.normaliseOptions(opts);
+  this.format   = CodeGenerator.normaliseOptions(code, opts);
   this.ast      = ast;
 
   this.whitespace = new Whitespace(this.tokens, this.comments);
@@ -36,14 +37,18 @@ _.each(Buffer.prototype, function (fn, key) {
   };
 });
 
-CodeGenerator.normaliseOptions = function (opts) {
+CodeGenerator.normaliseOptions = function (code, opts) {
+  var indent = detectIndent(code);
+  var style  = indent.indent;
+  if (!style || style === " ") style = "  ";
+
   return _.merge({
     parentheses: true,
     comments: opts.comments == null || opts.comments,
     compact: false,
     indent: {
       adjustMultilineComment: true,
-      style: "  ",
+      style: style,
       base: 0
     }
   }, opts.format || {});
@@ -116,6 +121,15 @@ CodeGenerator.prototype.buildPrint = function (parent) {
 CodeGenerator.prototype.print = function (node, parent, opts) {
   if (!node) return "";
 
+  if (parent && parent._compact) {
+    node._compact = true;
+  }
+
+  var oldCompact = this.format.compact;
+  if (node._compact) {
+    this.format.compact = true;
+  }
+
   var self = this;
 
   opts = opts || {};
@@ -180,6 +194,8 @@ CodeGenerator.prototype.print = function (node, parent, opts) {
   } else {
     throw new ReferenceError("unknown node of type " + JSON.stringify(node.type) + " with constructor " + JSON.stringify(node && node.constructor.name));
   }
+
+  this.format.compact = oldCompact;
 };
 
 CodeGenerator.prototype.printJoin = function (print, nodes, opts) {

lib/6to5/generation/generators/expressions.js

@@ -112,7 +112,9 @@ exports.LogicalExpression =
 exports.AssignmentPattern =
 exports.AssignmentExpression = function (node, print) {
   print(node.left);
-  this.push(" " + node.operator + " ");
+  this.space();
+  this.push(node.operator);
+  this.space();
   print(node.right);
 };
 

lib/6to5/generation/generators/jsx.js

@@ -3,7 +3,7 @@
 var t = require("../../types");
 var _ = require("lodash");
 
-exports.XJSAttribute = function (node, print) {
+exports.JSXAttribute = function (node, print) {
   print(node.name);
   if (node.value) {
     this.push("=");
@@ -11,35 +11,35 @@ exports.XJSAttribute = function (node, print) {
   }
 };
 
-exports.XJSIdentifier = function (node) {
+exports.JSXIdentifier = function (node) {
   this.push(node.name);
 };
 
-exports.XJSNamespacedName = function (node, print) {
+exports.JSXNamespacedName = function (node, print) {
   print(node.namespace);
   this.push(":");
   print(node.name);
 };
 
-exports.XJSMemberExpression = function (node, print) {
+exports.JSXMemberExpression = function (node, print) {
   print(node.object);
   this.push(".");
   print(node.property);
 };
 
-exports.XJSSpreadAttribute = function (node, print) {
+exports.JSXSpreadAttribute = function (node, print) {
   this.push("{...");
   print(node.argument);
   this.push("}");
 };
 
-exports.XJSExpressionContainer = function (node, print) {
+exports.JSXExpressionContainer = function (node, print) {
   this.push("{");
   print(node.expression);
   this.push("}");
 };
 
-exports.XJSElement = function (node, print) {
+exports.JSXElement = function (node, print) {
   var self = this;
 
   var open = node.openingElement;
@@ -59,22 +59,22 @@ exports.XJSElement = function (node, print) {
   print(node.closingElement);
 };
 
-exports.XJSOpeningElement = function (node, print) {
+exports.JSXOpeningElement = function (node, print) {
   this.push("<");
   print(node.name);
   if (node.attributes.length > 0) {
-    this.space();
+    this.push(" ");
     print.join(node.attributes, { separator: " " });
   }
   this.push(node.selfClosing ? " />" : ">");
 };
 
-exports.XJSClosingElement = function (node, print) {
+exports.JSXClosingElement = function (node, print) {
   this.push("</");
   print(node.name);
   this.push(">");
 };
 
-exports.XJSEmptyExpression = function () {
+exports.JSXEmptyExpression = function () {
 
 };

lib/6to5/generation/generators/methods.js

@@ -3,30 +3,12 @@
 var t = require("../../types");
 
 exports._params = function (node, print) {
-  var self = this;
-
   this.push("(");
 
   print.join(node.params, {
-    separator: ", ",
-    iterator: function (param, i) {
-      var def = node.defaults && node.defaults[i];
-      if (def) {
-        self.push(" = ");
-        print(def);
-      }
-    }
+    separator: ", "
   });
 
-  if (node.rest) {
-    if (node.params.length) {
-      this.push(", ");
-    }
-
-    this.push("...");
-    print(node.rest);
-  }
-
   this.push(")");
 };
 
@@ -54,7 +36,7 @@ exports._method = function (node, print) {
   }
 
   this._params(value, print);
-  this.space();
+  this.push(" ");
   print(value.body);
 };
 
@@ -63,8 +45,11 @@ exports.FunctionExpression = function (node, print) {
   if (node.async) this.push("async ");
   this.push("function");
   if (node.generator) this.push("*");
-  this.space();
-  if (node.id) print(node.id);
+  this.push(" ");
+  if (node.id) {
+    this.space();
+    print(node.id);
+  }
   this._params(node, print);
   this.space();
   print(node.body);
@@ -73,7 +58,7 @@ exports.FunctionExpression = function (node, print) {
 exports.ArrowFunctionExpression = function (node, print) {
   if (node.async) this.push("async ");
 
-  if (node.params.length === 1 && !node.defaults.length && !node.rest && t.isIdentifier(node.params[0])) {
+  if (node.params.length === 1 && t.isIdentifier(node.params[0])) {
     print(node.params[0]);
   } else {
     this._params(node, print);

lib/6to5/generation/generators/modules.js

@@ -4,8 +4,8 @@ var t = require("../../types");
 var _ = require("lodash");
 
 exports.ImportSpecifier = function (node, print) {
-  if (node.id && node.id.name === "default") {
-    print(node.name);
+  if (t.isSpecifierDefault(node)) {
+    print(t.getSpecifierName(node));
   } else {
     return exports.ExportSpecifier.apply(this, arguments);
   }
@@ -71,7 +71,7 @@ exports.ImportDeclaration = function (node, print) {
         self.push(", ");
       }
 
-      var isDefault = spec.id && spec.id.name === "default";
+      var isDefault = t.isSpecifierDefault(spec);
 
       if (!isDefault && spec.type !== "ImportBatchSpecifier" && !foundImportSpecifier) {
         foundImportSpecifier = true;

lib/6to5/generation/generators/statements.js

@@ -15,12 +15,13 @@ exports.IfStatement = function (node, print) {
   this.keyword("if");
   this.push("(");
   print(node.test);
-  this.push(") ");
+  this.push(")");
+  this.space();
 
   print.indentOnComments(node.consequent);
 
   if (node.alternate) {
-    if (this.isLast("}")) this.space();
+    if (this.isLast("}")) this.push(" ");
     this.keyword("else");
     print.indentOnComments(node.alternate);
   }
@@ -34,13 +35,13 @@ exports.ForStatement = function (node, print) {
   this.push(";");
 
   if (node.test) {
-    this.space();
+    this.push(" ");
     print(node.test);
   }
   this.push(";");
 
   if (node.update) {
-    this.space();
+    this.push(" ");
     print(node.update);
   }
 
@@ -87,7 +88,7 @@ var buildLabelStatement = function (prefix, key) {
 
     var label = node[key || "label"];
     if (label) {
-      this.space();
+      this.push(" ");
       print(label);
     }
 
@@ -144,7 +145,9 @@ exports.SwitchStatement = function (node, print) {
   this.keyword("switch");
   this.push("(");
   print(node.discriminant);
-  this.push(") {");
+  this.push(")");
+  this.space();
+  this.push("{");
   print.sequence(node.cases, { indent: true });
   this.push("}");
 };
@@ -203,7 +206,9 @@ exports.PrivateDeclaration = function (node, print) {
 exports.VariableDeclarator = function (node, print) {
   if (node.init) {
     print(node.id);
-    this.push(" = ");
+    this.space();
+    this.push("=");
+    this.space();
     print(node.init);
   } else {
     print(node.id);

lib/6to5/generation/generators/types.js

@@ -6,6 +6,7 @@ exports.Identifier = function (node) {
   this.push(node.name);
 };
 
+exports.RestElement =
 exports.SpreadElement =
 exports.SpreadProperty = function (node, print) {
   this.push("...");

lib/6to5/generation/node/parentheses.js

@@ -151,8 +151,10 @@ exports.ConditionalExpression = function (node, parent) {
     return true;
   }
 
-  if (t.isCallExpression(parent) && parent.callee === node) {
-    return true;
+  if (t.isCallExpression(parent) || t.isNewExpression(parent)) {
+    if (parent.callee === node) {
+      return true;
+    }
   }
 
   if (t.isConditionalExpression(parent) && parent.test === node) {

lib/6to5/generation/whitespace.js

@@ -101,7 +101,7 @@ Whitespace.prototype.getNewlinesBetween = function (startToken, endToken) {
   var lines = 0;
 
   for (var line = start; line < end; line++) {
-    if (typeof this.used[line] === 'undefined') {
+    if (typeof this.used[line] === "undefined") {
       this.used[line] = true;
       lines++;
     }

lib/6to5/helpers/clone.js

@@ -0,0 +1,12 @@
+"use strict";
+
+module.exports = function cloneDeep(obj) {
+  var obj2 = {};
+  if (!obj) return obj2;
+
+  for (var key in obj) {
+    obj2[key] = obj[key];
+  }
+
+  return obj2;
+};

lib/6to5/helpers/code-frame.js

@@ -0,0 +1,79 @@
+// syntax highlighting based on https://github.com/dominictarr/ansi-highlight by the fantastic Dominic Tarr
+
+var supportsColor = require("supports-color");
+var tokenize      = require("js-tokenizer");
+var chalk         = require("chalk");
+var util          = require("../util");
+
+var defs = {
+  string1:  "red",
+  string2:  "red",
+  punct:    ["white", "bold"],
+  curly:    "green",
+  parens:   ["blue", "bold"],
+  square:   ["yellow"],
+  name:     "white",
+  keyword:  ["cyan"],
+  number:   "magenta",
+  regexp:   "magenta",
+  comment1: "grey",
+  comment2: "grey"
+};
+
+var highlight = function (text) {
+  var colorize = function (str, col) {
+    if (!col) return str;
+
+    if (Array.isArray(col)) {
+      col.forEach(function (col) {
+        str = chalk[col](str);
+      });
+    } else {
+      str = chalk[col](str);
+    }
+    return str;
+  };
+
+  return tokenize(text, true).map(function (str) {
+    var type = tokenize.type(str);
+    return colorize(str, defs[type]);
+  }).join("");
+};
+
+module.exports = function (lines, lineNumber, colNumber) {
+  colNumber = Math.max(colNumber, 0);
+
+  if (supportsColor) {
+    lines = highlight(lines);
+  }
+
+  lines = lines.split("\n");
+
+  var start = Math.max(lineNumber - 3, 0);
+  var end   = Math.min(lines.length, lineNumber + 3);
+  var width = (end + "").length;
+
+  if (!lineNumber && !colNumber) {
+    start = 0;
+    end = lines.length;
+  }
+
+  return "\n" + lines.slice(start, end).map(function (line, i) {
+    var curr = i + start + 1;
+
+    var gutter = curr === lineNumber ? "> " : "  ";
+
+    var sep = curr + util.repeat(width + 1);
+    gutter += sep + "| ";
+
+    var str = gutter + line;
+
+    if (colNumber && curr === lineNumber) {
+      str += "\n";
+      str += util.repeat(gutter.length - 2);
+      str += "|" + util.repeat(colNumber) + "^";
+    }
+
+    return str;
+  }).join("\n");
+};

lib/6to5/helpers/object.js

@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = function () {
+  return Object.create(null);
+};

lib/6to5/index.js

@@ -9,8 +9,6 @@ exports.version = require("../../package").version;
 
 exports.types = require("./types");
 
-exports.runtime = require("./runtime-generator");
-
 exports.register = function (opts) {
   var register = require("./register");
   if (opts != null) register(opts);

lib/6to5/patch.js

@@ -3,22 +3,29 @@
 var t = require("./types");
 var _ = require("lodash");
 
+require("./types/node");
+
 // estraverse
 
 var estraverse = require("estraverse");
 _.extend(estraverse.VisitorKeys, t.VISITOR_KEYS);
 
-// regenerator/recast/ast-types
+// regenerator-6to5/ast-types
 
 var types = require("ast-types");
 var def   = types.Type.def;
 var or    = types.Type.or;
 
+def("File")
+  .bases("Node")
+  .build("program")
+  .field("program", def("Program"));
+
 def("AssignmentPattern")
-    .bases("Pattern")
-    .build("left", "right")
-    .field("left", def("Pattern"))
-    .field("right", def("Expression"));
+  .bases("Pattern")
+  .build("left", "right")
+  .field("left", def("Pattern"))
+  .field("right", def("Expression"));
 
 // Acorn - Same as ImportNamespaceSpecifier but `id` is `name`
 def("ImportBatchSpecifier")
@@ -26,6 +33,11 @@ def("ImportBatchSpecifier")
   .build("name")
   .field("name", def("Identifier"));
 
+def("RestElement")
+  .bases("Node")
+  .build("argument")
+  .field("argument", def("Pattern"));
+
 // Abstract references
 def("VirtualPropertyExpression")
   .bases("Expression")

lib/6to5/polyfill.js

@@ -1,4 +1,9 @@
 "use strict";
 
+if (global._6to5Polyfill) {
+  throw new Error("only one instance of 6to5/polyfill is allowed");
+}
+global._6to5Polyfill = true;
+
 require("core-js/shim");
-require("regenerator/runtime");
+require("regenerator-6to5/runtime");

lib/6to5/register-cache.js

@@ -0,0 +1,36 @@
+"use strict";
+
+var path = require("path");
+var os   = require("os");
+var fs   = require("fs");
+
+var FILENAME = path.join(os.tmpdir(), "6to5.json");
+var data = {};
+
+exports.save = function () {
+  fs.writeFileSync(FILENAME, JSON.stringify(data, null, "  "));
+};
+
+exports.load = function () {
+  if (!fs.existsSync(FILENAME)) return;
+
+  try {
+    data = JSON.parse(fs.readFileSync(FILENAME));
+  } catch (err) {
+    return;
+  }
+
+  process.on("exit", exports.save);
+
+  var sigint = function () {
+    process.removeListener("SIGINT", sigint);
+    exports.save();
+    process.kill(process.pid, "SIGINT");
+  };
+
+  process.on("SIGINT", sigint);
+};
+
+exports.get = function () {
+  return data;
+};

lib/6to5/register.js

@@ -3,7 +3,7 @@
 require("./polyfill");
 
 var sourceMapSupport = require("source-map-support");
-var roadrunner       = require("roadrunner");
+var registerCache    = require("./register-cache");
 var util             = require("./util");
 var to5              = require("./index");
 var fs               = require("fs");
@@ -23,11 +23,17 @@ sourceMapSupport.install({
   }
 });
 
+//
+
+registerCache.load();
+var cache = registerCache.get();
+
+//
+
 var transformOpts = {};
 var ignoreRegex   = /node_modules/;
 var onlyRegex;
 var whitelist     = [];
-var cache;
 var exts          = {};
 var maps          = {};
 var old           = require.extensions[".js"];
@@ -84,21 +90,18 @@ hookExtensions(util.canCompile.EXTENSIONS);
 module.exports = function (opts) {
   // normalise options
   opts = opts || {};
-  if (_.isRegExp(opts)) opts = { ignore: opts };
-  if (opts.ignoreRegex != null) opts.ignore = opts.ignoreRegex;
 
   if (opts.only != null) onlyRegex = util.regexify(opts.only);
   if (opts.ignore != null) ignoreRegex = util.regexify(opts.ignore);
 
   if (opts.extensions) hookExtensions(util.arrayify(opts.extensions));
 
-  if (opts.cache) cache = opts.cache;
   if (opts.cache === false) cache = null;
-  if (opts.cache === true) {
-    roadrunner.load();
-    roadrunner.setup();
-    cache = roadrunner.get("6to5");
-  }
+
+  delete opts.extensions;
+  delete opts.ignore;
+  delete opts.cache;
+  delete opts.only;
 
   _.extend(transformOpts, opts);
 };

lib/6to5/runtime-generator.js

@@ -1,35 +0,0 @@
-"use strict";
-
-var generator = require("./generation/generator");
-var util      = require("./util");
-var File      = require("./file");
-var t         = require("./types");
-var _         = require("lodash");
-
-module.exports = function (namespace) {
-  namespace = t.identifier(t.toIdentifier(namespace || "to5Runtime"));
-
-  var body      = [];
-  var container = t.functionExpression(null, [t.identifier("global")], t.blockStatement(body));
-  var tree      = t.program([t.expressionStatement(t.callExpression(container, [util.template("self-global")]))]);
-
-  body.push(t.variableDeclaration("var", [
-    t.variableDeclarator(
-      namespace,
-      t.assignmentExpression("=", t.memberExpression(t.identifier("global"), namespace), t.objectExpression([]))
-    )
-  ]));
-
-  _.each(File.helpers, function (name) {
-    if (_.contains(File.excludeHelpersFromRuntime, name)) {
-      return;
-    }
-
-    var key = t.identifier(t.toIdentifier(name));
-    body.push(t.expressionStatement(
-      t.assignmentExpression("=", t.memberExpression(namespace, key), util.template(name))
-    ));
-  });
-
-  return generator(tree).code;
-};

lib/6to5/transformation/helpers/build-binary-assignment-operator-transformer.js

@@ -13,6 +13,9 @@ module.exports = function (exports, opts) {
   };
 
   exports.ExpressionStatement = function (node, parent, scope, context, file) {
+    // hit the `AssignmentExpression` one below
+    if (file.isConsequenceExpressionStatement(node)) return;
+
     var expr = node.expression;
     if (!isAssignment(expr)) return;
 
@@ -27,13 +30,11 @@ module.exports = function (exports, opts) {
   };
 
   exports.AssignmentExpression = function (node, parent, scope, context, file) {
-    if (t.isExpressionStatement(parent)) return;
     if (!isAssignment(node)) return;
 
     var nodes    = [];
     var exploded = explode(node.left, nodes, file, scope);
-    nodes.push(opts.build(exploded.uid, node.right));
-    nodes.push(exploded.ref);
+    nodes.push(buildAssignment(exploded.ref, opts.build(exploded.uid, node.right)));
 
     return t.toSequenceExpression(nodes, scope);
   };

lib/6to5/transformation/helpers/build-conditional-assignment-operator-transformer.js

@@ -9,6 +9,9 @@ module.exports = function (exports, opts) {
   };
 
   exports.ExpressionStatement = function (node, parent, scope, context, file) {
+    // hit the `AssignmentExpression` one below
+    if (file.isConsequenceExpressionStatement(node)) return;
+
     var expr = node.expression;
     if (!opts.is(expr, file)) return;
 
@@ -25,7 +28,6 @@ module.exports = function (exports, opts) {
   };
 
   exports.AssignmentExpression = function (node, parent, scope, context, file) {
-    if (t.isExpressionStatement(parent)) return;
     if (!opts.is(node, file)) return;
 
     var nodes    = [];

lib/6to5/transformation/helpers/explode-assignable-expression.js

@@ -5,14 +5,30 @@ var t = require("../../types");
 var getObjRef = function (node, nodes, file, scope) {
   var ref;
   if (t.isIdentifier(node)) {
-    ref = node;
+    if (scope.has(node.name, true)) {
+      // this variable is declared in scope so we can be 100% sure
+      // that evaluating it multiple times wont trigger a getter
+      // or something else
+      return node;
+    } else {
+      // could possibly trigger a getter so we need to only evaluate
+      // it once
+      ref = node;
+    }
   } else if (t.isMemberExpression(node)) {
     ref = node.object;
+
+    if (t.isIdentifier(ref) && scope.has(ref.name)) {
+      // the object reference that we need to save is locally declared
+      // so as per the previous comment we can be 100% sure evaluating
+      // it multiple times will be safe
+      return ref;
+    }
   } else {
     throw new Error("We can't explode this node type " + node.type);
   }
 
-  var temp = scope.generateUidBasedOnNode(ref, file);
+  var temp = scope.generateUidBasedOnNode(ref);
   nodes.push(t.variableDeclaration("var", [
     t.variableDeclarator(temp, ref)
   ]));
@@ -24,7 +40,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, file);
+  var temp = scope.generateUidBasedOnNode(prop);
   nodes.push(t.variableDeclaration("var", [
     t.variableDeclarator(temp, prop)
   ]));

lib/6to5/transformation/helpers/name-method.js

@@ -4,7 +4,7 @@ var traverse = require("../../traverse");
 var util     = require("../../util");
 var t        = require("../../types");
 
-var traverser = {
+var visitor = {
   enter: function (node, parent, scope, context, state) {
     // check if this node is an identifier that matches the same as our function id
     if (!t.isIdentifier(node, { name: state.id })) return;
@@ -35,14 +35,15 @@ exports.property = function (node, file, scope) {
     outerDeclar: scope.get(id, true),
   };
 
-  traverse(node, traverser, scope, state);
+  traverse(node, visitor, scope, state);
 
   if (state.selfReference) {
+    // todo: support generators
     node.value = util.template("property-method-assignment-wrapper", {
       FUNCTION: node.value,
       FUNCTION_ID: key,
-      FUNCTION_KEY: file.generateUidIdentifier(id, scope),
-      WRAPPER_KEY: file.generateUidIdentifier(id + "Wrapper", scope)
+      FUNCTION_KEY: scope.generateUidIdentifier(id),
+      WRAPPER_KEY: scope.generateUidIdentifier(id + "Wrapper")
     });
   } else {
     node.value.id = key;

lib/6to5/transformation/helpers/remap-async-to-generator.js

@@ -3,25 +3,29 @@
 var traverse = require("../../traverse");
 var t        = require("../../types");
 
-module.exports = function (node, callId) {
+var visitor = {
+  enter: function (node, parent, scope, context) {
+    if (t.isFunction(node)) context.skip();
+
+    if (t.isAwaitExpression(node)) {
+      node.type = "YieldExpression";
+    }
+  }
+};
+
+module.exports = function (node, callId, scope) {
   node.async = false;
   node.generator = true;
 
-  traverse(node, {
-    enter: function (node, parent, scope, context) {
-      if (t.isFunction(node)) context.skip();
-
-      if (t.isAwaitExpression(node)) {
-        node.type = "YieldExpression";
-      }
-    }
-  });
+  traverse(node, visitor, scope);
 
   var call = t.callExpression(callId, [node]);
+  var id = node.id;
+  delete node.id;
 
   if (t.isFunctionDeclaration(node)) {
-    var declar = t.variableDeclaration("var", [
-      t.variableDeclarator(node.id, call)
+    var declar = t.variableDeclaration("let", [
+      t.variableDeclarator(id, call)
     ]);
     declar._blockHoist = true;
     return declar;

lib/6to5/transformation/helpers/replace-supers.js

@@ -8,20 +8,17 @@ var t        = require("../../types");
 /**
  * Description
  *
- * @param {Object} methodNode
- * @param {Object} className
- * @param {Object} superName
- * @param {Boolean} isLoose
- * @param {File} file
+ * @param {Object} opts
  */
 
-function ReplaceSupers(methodNode, className, superName, isLoose, file) {
+function ReplaceSupers(opts) {
   this.topLevelThisReference = null;
-  this.methodNode            = methodNode;
-  this.className             = className;
-  this.superName             = superName;
-  this.isLoose               = isLoose;
-  this.file                  = file;
+  this.methodNode            = opts.methodNode;
+  this.className             = opts.className;
+  this.superName             = opts.superName;
+  this.isLoose               = opts.isLoose;
+  this.scope                 = opts.scope;
+  this.file                  = opts.file;
 }
 
 /**
@@ -103,6 +100,34 @@ ReplaceSupers.prototype.replace = function () {
   this.traverseLevel(this.methodNode.value, true);
 };
 
+var visitor = {
+  enter: function (node, parent, scope, context, state) {
+    var topLevel = state.topLevel;
+    var self = state.self;
+
+    if (t.isFunction(node) && !t.isArrowFunctionExpression(node)) {
+      // we need to call traverseLevel again so we're context aware
+      self.traverseLevel(node, false);
+      return context.skip();
+    }
+
+    if (t.isProperty(node, { method: true }) || t.isMethodDefinition(node)) {
+      // break on object methods
+      return context.skip();
+    }
+
+    var getThisReference = topLevel ?
+      // top level so `this` is the instance
+      t.thisExpression :
+      // not in the top level so we need to create a reference
+      self.getThisReference;
+
+    var callback = self.specHandle;
+    if (self.isLoose) callback = self.looseHandle;
+    return callback.call(self, getThisReference, node, parent);
+  }
+};
+
 /**
  * Description
  *
@@ -111,36 +136,8 @@ ReplaceSupers.prototype.replace = function () {
  */
 
 ReplaceSupers.prototype.traverseLevel = function (node, topLevel) {
-  var self = this;
-
-  traverse(node, {
-    enter: function (node, parent, scope, context) {
-      if (t.isFunction(node) && !t.isArrowFunctionExpression(node)) {
-        // we need to call traverseLevel again so we're context aware
-        self.traverseLevel(node, false);
-        return context.skip();
-      }
-
-      if (t.isProperty(node, { method: true }) || t.isMethodDefinition(node)) {
-        // break on object methods
-        return context.skip();
-      }
-
-      var getThisReference = function () {
-        if (topLevel) {
-          // top level so `this` is the instance
-          return t.thisExpression();
-        } else {
-          // not in the top level so we need to create a reference
-          return self.getThisReference();
-        }
-      };
-
-      var callback = self.specHandle;
-      if (self.isLoose) callback = self.looseHandle;
-      return callback.call(self, getThisReference, node, parent);
-    }
-  });
+  var state = { self: this, topLevel: topLevel };
+  traverse(node, visitor, this.scope, state);
 };
 
 /**
@@ -206,6 +203,14 @@ ReplaceSupers.prototype.specHandle = function (getThisReference, node, parent) {
       property = methodNode.key;
       computed = methodNode.computed;
       args = node.arguments;
+
+      // bare `super` call is illegal inside non-constructors
+      //  - https://esdiscuss.org/topic/super-call-in-methods
+      //  - https://twitter.com/wycats/status/544553184396836864
+      if (methodNode.key.name !== "constructor") {
+        var methodName = methodNode.key.name || "METHOD_NAME";
+        throw this.file.errorWithNode(node, "Direct super call is illegal in non-constructor, use super." + methodName + "() instead");
+      }
     } else {
       if (!t.isMemberExpression(callee)) return;
       if (callee.object.name !== "super") return;

lib/6to5/transformation/modules/_default.js

@@ -3,83 +3,133 @@
 module.exports = DefaultFormatter;
 
 var traverse = require("../../traverse");
+var object   = require("../../helpers/object");
 var util     = require("../../util");
 var t        = require("../../types");
 var _        = require("lodash");
 
 function DefaultFormatter(file) {
   this.file = file;
+  this.ids  = object();
 
-  this.localExports = this.getLocalExports();
-  this.localImports = this.getLocalImports();
+  this.hasNonDefaultExports = false;
+
+  this.hasLocalExports = false;
+  this.hasLocalImports = false;
+
+  this.localImportOccurences = object();
+  this.localExports = object();
+  this.localImports = object();
+
+  this.getLocalExports();
+  this.getLocalImports();
 
   this.remapAssignments();
-
-  //this.checkCollisions();
 }
 
-var exportsTraverser = {
-  enter: function (node, parent, scope, context, localExports) {
+DefaultFormatter.prototype.doDefaultExportInterop = function (node) {
+  return node.default && !this.noInteropRequire && !this.hasNonDefaultExports;
+};
+
+DefaultFormatter.prototype.bumpImportOccurences = function (node) {
+  var source = node.source.value;
+  var occurs = this.localImportOccurences;
+  occurs[source] = occurs[source] || 0;
+  occurs[source] += node.specifiers.length;
+};
+
+var exportsVisitor = {
+  enter: function (node, parent, scope, context, formatter) {
     var declar = node && node.declaration;
-    if (t.isExportDeclaration(node) && declar && t.isStatement(declar)) {
-      _.extend(localExports, t.getIds(declar, true));
+    if (t.isExportDeclaration(node)) {
+      formatter.hasLocalImports = true;
+
+      if (declar && t.isStatement(declar)) {
+        _.extend(formatter.localExports, t.getIds(declar, true));
+      }
+
+      if (!node.default) {
+        formatter.hasNonDefaultExports = true;
+      }
+
+      if (node.source) {
+        formatter.bumpImportOccurences(node);
+      }
     }
   }
 };
 
 DefaultFormatter.prototype.getLocalExports = function () {
-  var localExports = {};
-  traverse(this.file.ast, exportsTraverser, null, localExports);
-  return localExports;
+  traverse(this.file.ast, exportsVisitor, this.file.scope, this);
 };
 
-var importsTraverser = {
-  enter: function (node, parent, scope, context, localImports) {
+var importsVisitor = {
+  enter: function (node, parent, scope, context, formatter) {
     if (t.isImportDeclaration(node)) {
-      _.extend(localImports, t.getIds(node, true));
+      formatter.hasLocalImports = true;
+      _.extend(formatter.localImports, t.getIds(node, true));
+      formatter.bumpImportOccurences(node);
     }
   }
 };
 
 DefaultFormatter.prototype.getLocalImports = function () {
-  var localImports = {};
-  traverse(this.file.ast, importsTraverser, null, localImports);
-  return localImports;
+  traverse(this.file.ast, importsVisitor, this.file.scope, this);
 };
 
-var collissionsTraverser = {
-  enter: function (node, parent, scope, context, check) {
-    if (t.isAssignmentExpression(node)) {
+var remapVisitor = {
+  enter: function (node, parent, scope, context, formatter) {
+    if (t.isUpdateExpression(node) && formatter.isLocalReference(node.argument, scope)) {
+      context.skip();
 
-      var left = node.left;
-      if (t.isMemberExpression(left)) {
-        while (left.object) left = left.object;
+      // expand to long file assignment expression
+      var assign = t.assignmentExpression(node.operator[0] + "=", node.argument, t.literal(1));
+
+      // remap this assignment expression
+      var remapped = formatter.remapExportAssignment(assign);
+
+      // we don't need to change the result
+      if (t.isExpressionStatement(parent) || node.prefix) {
+        return remapped;
       }
 
-      check(left);
-    } else if (t.isDeclaration(node)) {
-      _.each(t.getIds(node, true), check);
+      var nodes = [];
+      nodes.push(remapped);
+
+      var operator;
+      if (node.operator === "--") {
+        operator = "+";
+      } else { // "++"
+        operator = "-";
+      }
+      nodes.push(t.binaryExpression(operator, node.argument, t.literal(1)));
+
+      return t.sequenceExpression(nodes);
+    }
+
+    if (t.isAssignmentExpression(node) && formatter.isLocalReference(node.left, scope)) {
+      context.skip();
+      return formatter.remapExportAssignment(node);
     }
   }
 };
 
-DefaultFormatter.prototype.checkCollisions = function () {
-  // todo: all check export collissions
+DefaultFormatter.prototype.remapAssignments = function () {
+  if (this.hasLocalImports) {
+    traverse(this.file.ast, remapVisitor, this.file.scope, this);
+  }
+};
 
+DefaultFormatter.prototype.isLocalReference = function (node) {
   var localImports = this.localImports;
+  return t.isIdentifier(node) && localImports[node.name] && localImports[node.name] !== node;
+};
+
+DefaultFormatter.prototype.checkLocalReference = function (node) {
   var file = this.file;
-
-  var isLocalReference = function (node) {
-    return t.isIdentifier(node) && _.has(localImports, node.name) && localImports[node.name] !== node;
-  };
-
-  var check = function (node) {
-    if (isLocalReference(node)) {
-      throw file.errorWithNode(node, "Illegal assignment of module import");
-    }
-  };
-
-  traverse(file.ast, collissionsTraverser, null, check);
+  if (this.isLocalReference(node)) {
+    throw file.errorWithNode(node, "Illegal assignment of module import");
+  }
 };
 
 DefaultFormatter.prototype.remapExportAssignment = function (node) {
@@ -94,51 +144,10 @@ DefaultFormatter.prototype.remapExportAssignment = function (node) {
   );
 };
 
-DefaultFormatter.prototype.remapAssignments = function () {
+DefaultFormatter.prototype.isLocalReference = function (node, scope) {
   var localExports = this.localExports;
-  var self = this;
-
-  var isLocalReference = function (node, scope) {
-    var name = node.name;
-    return t.isIdentifier(node) && localExports[name] && localExports[name] === scope.get(name, true);
-  };
-
-  traverse(this.file.ast, {
-    enter: function (node, parent, scope, context, isLocalReference) {
-      if (t.isUpdateExpression(node) && isLocalReference(node.argument, scope)) {
-        context.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 = self.remapExportAssignment(assign);
-
-        // we don't need to change the result
-        if (t.isExpressionStatement(parent) || node.prefix) {
-          return remapped;
-        }
-
-        var nodes = [];
-        nodes.push(remapped);
-
-        var operator;
-        if (node.operator === "--") {
-          operator = "+";
-        } else { // "++"
-          operator = "-";
-        }
-        nodes.push(t.binaryExpression(operator, node.argument, t.literal(1)));
-
-        return t.sequenceExpression(nodes);
-      }
-
-      if (t.isAssignmentExpression(node) && isLocalReference(node.left, scope)) {
-        context.skip();
-        return self.remapExportAssignment(node);
-      }
-    }
-  }, null, isLocalReference);
+  var name = node.name;
+  return t.isIdentifier(node) && localExports[name] && localExports[name] === scope.get(name, true);
 };
 
 DefaultFormatter.prototype.getModuleName = function () {
@@ -192,25 +201,37 @@ DefaultFormatter.prototype._hoistExport = function (declar, assign, priority) {
   return assign;
 };
 
-DefaultFormatter.prototype._exportSpecifier = function (getRef, specifier, node, nodes) {
+DefaultFormatter.prototype.getExternalReference = function (node, nodes) {
+  var ids = this.ids;
+  var id = node.source.value;
+
+  if (ids[id]) {
+    return ids[id];
+  } else {
+    return this.ids[id] = this._getExternalReference(node, nodes);
+  }
+};
+
+DefaultFormatter.prototype.exportSpecifier = function (specifier, node, nodes) {
   var inherits = false;
   if (node.specifiers.length === 1) inherits = node;
 
   if (node.source) {
+    var ref = this.getExternalReference(node, nodes);
+
     if (t.isExportBatchSpecifier(specifier)) {
       // export * from "foo";
-      nodes.push(this._exportsWildcard(getRef(), node));
+      nodes.push(this.buildExportsWildcard(ref, node));
     } else {
-      var ref;
       if (t.isSpecifierDefault(specifier) && !this.noInteropRequire) {
         // importing a default so we need to normalise it
-        ref = t.callExpression(this.file.addHelper("interop-require"), [getRef()]);
+        ref = t.callExpression(this.file.addHelper("interop-require"), [ref]);
       } else {
-        ref = t.memberExpression(getRef(), specifier.id);
+        ref = t.memberExpression(ref, t.getSpecifierId(specifier));
       }
 
       // export { foo } from "test";
-      nodes.push(this._exportsAssign(
+      nodes.push(this.buildExportsAssignment(
         t.getSpecifierName(specifier),
         ref,
         node
@@ -218,18 +239,18 @@ DefaultFormatter.prototype._exportSpecifier = function (getRef, specifier, node,
     }
   } else {
     // export { foo };
-    nodes.push(this._exportsAssign(t.getSpecifierName(specifier), specifier.id, node));
+    nodes.push(this.buildExportsAssignment(t.getSpecifierName(specifier), specifier.id, node));
   }
 };
 
-DefaultFormatter.prototype._exportsWildcard = function (objectIdentifier) {
+DefaultFormatter.prototype.buildExportsWildcard = function (objectIdentifier) {
   return t.expressionStatement(t.callExpression(this.file.addHelper("defaults"), [
     t.identifier("exports"),
     t.callExpression(this.file.addHelper("interop-require-wildcard"), [objectIdentifier])
   ]));
 };
 
-DefaultFormatter.prototype._exportsAssign = function (id, init) {
+DefaultFormatter.prototype.buildExportsAssignment = function (id, init) {
   return util.template("exports-assign", {
     VALUE: init,
     KEY:   id
@@ -251,7 +272,7 @@ DefaultFormatter.prototype.exportDeclaration = function (node, nodes) {
     for (var i = 0; i < declar.declarations.length; i++) {
       var decl = declar.declarations[i];
 
-      decl.init = this._exportsAssign(decl.id, decl.init, node).expression;
+      decl.init = this.buildExportsAssignment(decl.id, decl.init, node).expression;
 
       var newDeclar = t.variableDeclaration(declar.kind, [decl]);
       if (i === 0) t.inherits(newDeclar, declar);
@@ -265,7 +286,7 @@ DefaultFormatter.prototype.exportDeclaration = function (node, nodes) {
       nodes.push(declar);
     }
 
-    assign = this._exportsAssign(id, ref, node);
+    assign = this.buildExportsAssignment(id, ref, node);
 
     nodes.push(assign);
 

lib/6to5/transformation/modules/_strict.js

@@ -4,7 +4,7 @@ var util = require("../../util");
 
 module.exports = function (Parent) {
   var Constructor = function () {
-    this.noInteropExport = true;
+    this.noInteropRequire = true;
     Parent.apply(this, arguments);
   };
 

lib/6to5/transformation/modules/amd.js

@@ -10,7 +10,6 @@ var _                = require("lodash");
 
 function AMDFormatter() {
   CommonFormatter.apply(this, arguments);
-  this.ids = {};
 }
 
 util.inherits(AMDFormatter, DefaultFormatter);
@@ -68,33 +67,30 @@ AMDFormatter.prototype.getModuleName = function () {
   }
 };
 
-AMDFormatter.prototype._push = function (node) {
-  var id  = node.source.value;
-  var ids = this.ids;
-
-  if (ids[id]) {
-    return ids[id];
-  } else {
-    return this.ids[id] = this.file.generateUidIdentifier(id);
-  }
+AMDFormatter.prototype._getExternalReference = function (node) {
+  return this.file.generateUidIdentifier(node.source.value);
 };
 
 AMDFormatter.prototype.importDeclaration = function (node) {
-  this._push(node);
+  this.getExternalReference(node);
 };
 
 AMDFormatter.prototype.importSpecifier = function (specifier, node, nodes) {
   var key = t.getSpecifierName(specifier);
-  var ref = this._push(node);
+  var ref = this.getExternalReference(node);
 
-  if (t.isImportBatchSpecifier(specifier)) {
+  if (_.contains(this.file.dynamicImported, node)) {
+    // Prevent unnecessary renaming of dynamic imports.
+    this.ids[node.source.value] = key;
+    return;
+  } else if (t.isImportBatchSpecifier(specifier)) {
     // import * as bar from "foo";
   } else if (t.isSpecifierDefault(specifier) && !this.noInteropRequire) {
     // import foo from "foo";
     ref = t.callExpression(this.file.addHelper("interop-require"), [ref]);
   } else {
     // import {foo} from "foo";
-    ref = t.memberExpression(ref, specifier.id, false);
+    ref = t.memberExpression(ref, t.getSpecifierId(specifier), false);
   }
 
   nodes.push(t.variableDeclaration("var", [
@@ -103,16 +99,9 @@ AMDFormatter.prototype.importSpecifier = function (specifier, node, nodes) {
 };
 
 AMDFormatter.prototype.exportDeclaration = function (node) {
-  if (node.default && !this.noInteropExport) {
+  if (this.doDefaultExportInterop(node)) {
     this.passModuleArg = true;
   }
 
   CommonFormatter.prototype.exportDeclaration.apply(this, arguments);
 };
-
-AMDFormatter.prototype.exportSpecifier = function (specifier, node, nodes) {
-  var self = this;
-  return this._exportSpecifier(function () {
-    return self._push(node);
-  }, specifier, node, nodes);
-};

lib/6to5/transformation/modules/common.js

@@ -3,20 +3,16 @@
 module.exports = CommonJSFormatter;
 
 var DefaultFormatter = require("./_default");
-var traverse         = require("../../traverse");
 var util             = require("../../util");
 var t                = require("../../types");
+var _                = require("lodash");
 
 function CommonJSFormatter(file) {
   DefaultFormatter.apply(this, arguments);
 
-  var hasNonDefaultExports = false;
-  traverse(file.ast, {
-    enter: function (node) {
-      if (t.isExportDeclaration(node) && !node.default) hasNonDefaultExports = true;
-    }
-  });
-  this.hasNonDefaultExports = hasNonDefaultExports;
+  if (this.hasNonDefaultExports) {
+    file.ast.program.body.push(util.template("exports-module-declaration", true));
+  }
 }
 
 util.inherits(CommonJSFormatter, DefaultFormatter);
@@ -24,15 +20,14 @@ util.inherits(CommonJSFormatter, DefaultFormatter);
 CommonJSFormatter.prototype.importSpecifier = function (specifier, node, nodes) {
   var variableName = t.getSpecifierName(specifier);
 
+  var ref = this.getExternalReference(node, nodes);
+
   // import foo from "foo";
   if (t.isSpecifierDefault(specifier)) {
-    nodes.push(t.variableDeclaration("var", [
-      t.variableDeclarator(variableName,
-        t.callExpression(this.file.addHelper("interop-require"), [util.template("require", {
-          MODULE_NAME: node.source
-        })])
-      )
-    ]));
+    if (!_.contains(this.file.dynamicImported, node)) {
+      ref = t.callExpression(this.file.addHelper("interop-require"), [ref]);
+    }
+    nodes.push(t.variableDeclaration("var", [t.variableDeclarator(variableName, ref)]));
   } else {
     if (specifier.type === "ImportBatchSpecifier") {
       // import * as bar from "foo";
@@ -40,17 +35,18 @@ CommonJSFormatter.prototype.importSpecifier = function (specifier, node, nodes)
         t.variableDeclarator(
           variableName,
           t.callExpression(this.file.addHelper("interop-require-wildcard"), [
-            t.callExpression(t.identifier("require"), [node.source])
+            ref
           ])
         )
       ]));
     } else {
-      // import foo from "foo";
-      nodes.push(util.template("require-assign-key", {
-        VARIABLE_NAME: variableName,
-        MODULE_NAME:   node.source,
-        KEY:           specifier.id
-      }));
+      // import { foo } from "foo";
+      nodes.push(t.variableDeclaration("var", [
+        t.variableDeclarator(
+          variableName,
+          t.memberExpression(ref, t.getSpecifierId(specifier))
+        )
+      ]));
     }
   }
 };
@@ -63,45 +59,35 @@ CommonJSFormatter.prototype.importDeclaration = function (node, nodes) {
 };
 
 CommonJSFormatter.prototype.exportDeclaration = function (node, nodes) {
-  if (node.default && !this.noInteropRequire && !this.noInteropExport) {
+  if (this.doDefaultExportInterop(node)) {
     var declar = node.declaration;
-    var assign;
+    var assign = util.template("exports-default-assign", {
+      VALUE: this._pushStatement(declar, nodes)
+    }, true);
 
-    // module.exports = VALUE;
-    var templateName = "exports-default-module";
-
-    // exports = module.exports = VALUE;
-    if (this.hasNonDefaultExports) templateName = "exports-default-module-override";
-
-    if (t.isFunctionDeclaration(declar) || !this.hasNonDefaultExports) {
-      assign = util.template(templateName, {
-        VALUE: this._pushStatement(declar, nodes)
-      }, true);
-
-      // hoist to the top if this default is a function
-      nodes.push(this._hoistExport(declar, assign, 3));
-      return;
-    } else {
-      // this export isn't a function so we can't hoist it to the top so we need to set it
-      // at the very end of the file with something like:
-      //
-      //   module.exports = _extends(exports["default"], exports)
-      //
-
-      assign = util.template("common-export-default-assign", {
-        EXTENDS_HELPER: this.file.addHelper("extends")
-      }, true);
-      assign._blockHoist = 0;
-
-      nodes.push(assign);
+    if (t.isFunctionDeclaration(declar)) {
+      // we can hoist this assignment to the top of the file
+      assign._blockHoist = 3;
     }
+
+    nodes.push(assign);
+    return;
   }
 
   DefaultFormatter.prototype.exportDeclaration.apply(this, arguments);
 };
 
-CommonJSFormatter.prototype.exportSpecifier = function (specifier, node, nodes) {
-  this._exportSpecifier(function () {
-    return t.callExpression(t.identifier("require"), [node.source]);
-  }, specifier, node, nodes);
+CommonJSFormatter.prototype._getExternalReference = function (node, nodes) {
+  var source = node.source.value;
+  var call = t.callExpression(t.identifier("require"), [node.source]);
+
+  if (this.localImportOccurences[source] > 1) {
+    var uid = this.file.generateUidIdentifier(source);
+    nodes.push(t.variableDeclaration("var", [
+      t.variableDeclarator(uid, call)
+    ]));
+    return uid;
+  } else {
+    return call;
+  }
 };

lib/6to5/transformation/modules/index.js

@@ -0,0 +1,10 @@
+module.exports = {
+  commonStrict: require("./common-strict"),
+  amdStrict:    require("./amd-strict"),
+  umdStrict:    require("./umd-strict"),
+  common:       require("./common"),
+  system:       require("./system"),
+  ignore:       require("./ignore"),
+  amd:          require("./amd"),
+  umd:          require("./umd")
+};

lib/6to5/transformation/modules/system.js

@@ -2,18 +2,19 @@
 
 module.exports = SystemFormatter;
 
-var AMDFormatter = require("./amd");
-var useStrict    = require("../helpers/use-strict");
-var traverse     = require("../../traverse");
-var util         = require("../../util");
-var t            = require("../../types");
-var _            = require("lodash");
+var DefaultFormatter = require("./_default");
+var AMDFormatter     = require("./amd");
+var useStrict        = require("../helpers/use-strict");
+var traverse         = require("../../traverse");
+var util             = require("../../util");
+var t                = require("../../types");
+var _                = require("lodash");
 
 function SystemFormatter(file) {
-  this.exportIdentifier  = file.generateUidIdentifier("export");
+  this.exportIdentifier = file.generateUidIdentifier("export");
   this.noInteropRequire = true;
 
-  AMDFormatter.apply(this, arguments);
+  DefaultFormatter.apply(this, arguments);
 }
 
 util.inherits(SystemFormatter, AMDFormatter);
@@ -23,7 +24,7 @@ SystemFormatter.prototype._addImportSource = function (node, exportNode) {
   return node;
 };
 
-SystemFormatter.prototype._exportsWildcard = function (objectIdentifier, node) {
+SystemFormatter.prototype.buildExportsWildcard = function (objectIdentifier, node) {
   var leftIdentifier = this.file.generateUidIdentifier("key");
   var valIdentifier  = t.memberExpression(objectIdentifier, leftIdentifier, true);
 
@@ -40,7 +41,7 @@ SystemFormatter.prototype._exportsWildcard = function (objectIdentifier, node) {
   return this._addImportSource(t.forInStatement(left, right, block), node);
 };
 
-SystemFormatter.prototype._exportsAssign = function (id, init, node) {
+SystemFormatter.prototype.buildExportsAssignment = function (id, init, node) {
   var call = this.buildExportCall(t.literal(id.name), init, true);
   return this._addImportSource(call, node);
 };
@@ -63,36 +64,97 @@ SystemFormatter.prototype.importSpecifier = function (specifier, node, nodes) {
   this._addImportSource(_.last(nodes), node);
 };
 
+var runnerSettersVisitor = {
+  enter: function (node, parent, scope, context, state) {
+    if (node._importSource === state.source) {
+      if (t.isVariableDeclaration(node)) {
+        _.each(node.declarations, function (declar) {
+          state.hoistDeclarators.push(t.variableDeclarator(declar.id));
+          state.nodes.push(t.expressionStatement(
+            t.assignmentExpression("=", declar.id, declar.init)
+          ));
+        });
+      } else {
+        state.nodes.push(node);
+      }
+
+      context.remove();
+    }
+  }
+};
+
 SystemFormatter.prototype.buildRunnerSetters = function (block, hoistDeclarators) {
+  var scope = this.file.scope;
+
   return t.arrayExpression(_.map(this.ids, function (uid, source) {
     var state = {
-      nodes: [],
+      source:           source,
+      nodes:            [],
       hoistDeclarators: hoistDeclarators
     };
 
-    traverse(block, {
-      enter: function (node, parent, scope, context, state) {
-        if (node._importSource === source) {
-          if (t.isVariableDeclaration(node)) {
-            _.each(node.declarations, function (declar) {
-              state.hoistDeclarators.push(t.variableDeclarator(declar.id));
-              state.nodes.push(t.expressionStatement(
-                t.assignmentExpression("=", declar.id, declar.init)
-              ));
-            });
-          } else {
-            state.nodes.push(node);
-          }
-
-          context.remove();
-        }
-      }
-    }, null, state);
+    traverse(block, runnerSettersVisitor, scope, state);
 
     return t.functionExpression(null, [uid], t.blockStatement(state.nodes));
   }));
 };
 
+var hoistVariablesVisitor = {
+  enter: function (node, parent, scope, context, hoistDeclarators) {
+    if (t.isFunction(node)) {
+      // nothing inside is accessible
+      return context.skip();
+    }
+
+    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 (node._blockHoist) return;
+
+      var nodes = [];
+
+      for (var i = 0; i < node.declarations.length; i++) {
+        var declar = node.declarations[i];
+        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)) {
+        if (parent.left === node) {
+          return node.declarations[0].id;
+        }
+
+        if (parent.init === node) {
+          return t.toSequenceExpression(nodes, scope);
+        }
+      }
+
+      return nodes;
+    }
+  }
+};
+
+var hoistFunctionsVisitor = {
+  enter: function (node, parent, scope, context, handlerBody) {
+    if (t.isFunction(node)) context.skip();
+
+    if (t.isFunctionDeclaration(node) || node._blockHoist) {
+      handlerBody.push(node);
+      context.remove();
+    }
+  }
+};
+
 SystemFormatter.prototype.transform = function (ast) {
   var program = ast.program;
 
@@ -116,46 +178,7 @@ SystemFormatter.prototype.transform = function (ast) {
   var returnStatement = handlerBody.pop();
 
   // hoist up all variable declarations
-  traverse(block, {
-    enter: function (node, parent, scope, context, hoistDeclarators) {
-      if (t.isFunction(node)) {
-        // nothing inside is accessible
-        return context.skip();
-      }
-
-      if (t.isVariableDeclaration(node)) {
-        if (node.kind !== "var" && !t.isProgram(parent)) { // let, const
-          // can't be accessed
-          return;
-        }
-
-        var nodes = [];
-
-        _.each(node.declarations, function (declar) {
-          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)) {
-          if (parent.left === node) {
-            return node.declarations[0].id;
-          }
-
-          if (parent.init === node) {
-            return t.toSequenceExpression(nodes, scope);
-          }
-        }
-
-        return nodes;
-      }
-    }
-  }, null, hoistDeclarators);
+  traverse(block, hoistVariablesVisitor, this.file.scope, hoistDeclarators);
 
   if (hoistDeclarators.length) {
     var hoistDeclar = t.variableDeclaration("var", hoistDeclarators);
@@ -164,16 +187,7 @@ SystemFormatter.prototype.transform = function (ast) {
   }
 
   // hoist up function declarations for circular references
-  traverse(block, {
-    enter: function (node, parent, scope, context, handlerBody) {
-      if (t.isFunction(node)) context.skip();
-
-      if (t.isFunctionDeclaration(node) || node._blockHoist) {
-        handlerBody.push(node);
-        context.remove();
-      }
-    }
-  }, null, handlerBody);
+  traverse(block, hoistFunctionsVisitor, this.file.scope, handlerBody);
 
   handlerBody.push(returnStatement);
 

lib/6to5/transformation/templates/async-to-generator.js

@@ -3,35 +3,26 @@
     var gen = fn.apply(this, arguments);
 
     return new Promise(function (resolve, reject) {
-      function step(getNext) {
-        var next;
+      var callNext = step.bind(gen.next);
+      var callThrow = step.bind(gen.throw);
 
+      function step(arg) {
         try {
-          next = getNext();
-        } catch(e) {
-          reject(e);
+          var info = this(arg);
+          var value = info.value;
+        } catch (error) {
+          reject(error);
           return;
         }
 
-        if (next.done) {
-          resolve(next.value);
-          return;
+        if (info.done) {
+          resolve(value);
+        } else {
+          Promise.resolve(value).then(callNext, callThrow);
         }
-
-        Promise.resolve(next.value).then(function (v) {
-          step(function () {
-            return gen.next(v);
-          });
-        }, function (e) {
-          step(function () {
-            return gen["throw"](e);
-          });
-        });
       }
 
-      step(function () {
-        return gen.next();
-      });
+      callNext();
     });
-  }
+  };
 })

lib/6to5/transformation/templates/common-export-default-assign.js

@@ -1 +0,0 @@
-module.exports = EXTENDS_HELPER(exports["default"], exports);

lib/6to5/transformation/templates/exports-default-module-override.js

@@ -1 +0,0 @@
-exports = module.exports = VALUE;

lib/6to5/transformation/templates/exports-module-declaration.js

@@ -0,0 +1 @@
+exports.__esModule = true;

lib/6to5/transformation/templates/extends.js

@@ -2,7 +2,9 @@
   for (var i = 1; i < arguments.length; i++) {
     var source = arguments[i];
     for (var key in source) {
-      target[key] = source[key];
+      if (Object.prototype.hasOwnProperty.call(source, key)) {
+        target[key] = source[key];
+      }
     }
   }
   return target;

lib/6to5/transformation/templates/interop-require-wildcard.js

@@ -1,3 +1,3 @@
 (function (obj) {
-  return obj && obj.constructor === Object ? obj : { default: obj };
+  return obj && obj.__esModule ? obj : { default: obj };
 })

lib/6to5/transformation/templates/interop-require.js

@@ -1,3 +1,3 @@
 (function (obj) {
-  return obj && (obj["default"] || obj);
+  return obj && obj.__esModule ? obj.default : obj;
 })

lib/6to5/transformation/templates/tagged-template-literal.js

@@ -3,4 +3,3 @@
       raw: { value: Object.freeze(raw) }
   }));
 });
-

lib/6to5/transformation/transform.js

@@ -3,6 +3,7 @@
 module.exports = transform;
 
 var Transformer = require("./transformer");
+var object      = require("../helpers/object");
 var File        = require("../file");
 var util        = require("../util");
 var _           = require("lodash");
@@ -21,88 +22,52 @@ transform.fromAst = function (ast, code, opts) {
   return file.generate();
 };
 
-transform._ensureTransformerNames = function (type, keys) {
-  for (var i = 0; i < keys.length; i++) {
-    var key = keys[i];
-    if (!_.has(transform.transformers, key)) {
-      throw new ReferenceError("unknown transformer " + key + " specified in " + type);
+transform._ensureTransformerNames = function (type, rawKeys) {
+  var keys = [];
+
+  for (var i = 0; i < rawKeys.length; i++) {
+    var key = rawKeys[i];
+
+    var deprecatedKey = transform.deprecatedTransformerMap[key];
+    if (deprecatedKey) {
+      // deprecated key, remap it to the new one
+      console.error(
+        "The transformer " + key + " has been renamed to " + deprecatedKey +
+        " in v3.0.0 - backwards compatibilty will be removed 4.0.0"
+      );
+      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 + " - " +
+        "transformer key names have been changed in 3.0.0 see " +
+        "the changelog for more info " +
+        "https://github.com/6to5/6to5/blob/master/CHANGELOG.md#300"
+      );
     }
   }
+
+  return keys;
 };
 
-transform.transformers = {};
+transform.transformers = object();
+transform.namespaces   = object();
 
-transform.moduleFormatters = {
-  commonStrict: require("./modules/common-strict"),
-  umdStrict:    require("./modules/umd-strict"),
-  amdStrict:    require("./modules/amd-strict"),
-  common:       require("./modules/common"),
-  system:       require("./modules/system"),
-  ignore:       require("./modules/ignore"),
-  amd:          require("./modules/amd"),
-  umd:          require("./modules/umd")
-};
+transform.deprecatedTransformerMap = require("./transformers/deprecated");
+transform.moduleFormatters = require("./modules");
 
-_.each({
-  specNoForInOfAssignment:   require("./transformers/spec-no-for-in-of-assignment"),
-  specSetters:               require("./transformers/spec-setters"),
-  specBlockScopedFunctions:  require("./transformers/spec-block-scoped-functions"),
+var rawTransformers = require("./transformers");
 
-  // playground
-  malletOperator:            require("./transformers/playground-mallet-operator"),
-  methodBinding:             require("./transformers/playground-method-binding"),
-  memoizationOperator:       require("./transformers/playground-memoization-operator"),
-  objectGetterMemoization:   require("./transformers/playground-object-getter-memoization"),
+_.each(rawTransformers, function (transformer, key) {
+  var namespace = key.split(".")[0];
+  transform.namespaces[namespace] = transform.namespaces[namespace] || [];
+  transform.namespaces[namespace].push(key);
 
-  asyncToGenerator:          require("./transformers/optional-async-to-generator"),
-  bluebirdCoroutines:        require("./transformers/optional-bluebird-coroutines"),
-
-  react:                     require("./transformers/react"),
-  modules:                   require("./transformers/es6-modules"),
-  propertyNameShorthand:     require("./transformers/es6-property-name-shorthand"),
-  arrayComprehension:        require("./transformers/es7-array-comprehension"),
-  generatorComprehension:    require("./transformers/es7-generator-comprehension"),
-  arrowFunctions:            require("./transformers/es6-arrow-functions"),
-  classes:                   require("./transformers/es6-classes"),
-
-  objectSpread:              require("./transformers/es7-object-spread"),
-  exponentiationOperator:    require("./transformers/es7-exponentiation-operator"),
-  spread:                    require("./transformers/es6-spread"),
-  templateLiterals:          require("./transformers/es6-template-literals"),
-  propertyMethodAssignment:  require("./transformers/es6-property-method-assignment"),
-  computedPropertyNames:     require("./transformers/es6-computed-property-names"),
-  defaultParameters:         require("./transformers/es6-default-parameters"),
-  restParameters:            require("./transformers/es6-rest-parameters"),
-  destructuring:             require("./transformers/es6-destructuring"),
-  forOf:                     require("./transformers/es6-for-of"),
-  unicodeRegex:              require("./transformers/es6-unicode-regex"),
-  abstractReferences:        require("./transformers/es7-abstract-references"),
-
-  constants:                 require("./transformers/es6-constants"),
-  letScoping:                require("./transformers/es6-let-scoping"),
-  blockScopingTDZ:           require("./transformers/optional-block-scoping-tdz"),
-
-  _blockHoist:               require("./transformers/_block-hoist"),
-
-  generators:                require("./transformers/es6-generators"),
-
-  protoToAssign:             require("./transformers/optional-proto-to-assign"),
-
-  _declarations:             require("./transformers/_declarations"),
-
-  // wrap up
-  useStrict:                 require("./transformers/use-strict"),
-  _aliasFunctions:           require("./transformers/_alias-functions"),
-  _moduleFormatter:          require("./transformers/_module-formatter"),
-
-  typeofSymbol:              require("./transformers/optional-typeof-symbol"),
-  coreAliasing:              require("./transformers/optional-core-aliasing"),
-  undefinedToVoid:           require("./transformers/optional-undefined-to-void"),
-  undeclaredVariableCheck:   require("./transformers/optional-undeclared-variable-check"),
-
-  // spec
-  specPropertyLiterals:         require("./transformers/spec-property-literals"),
-  specMemberExpressionLiterals: require("./transformers/spec-member-expression-literals")
-}, function (transformer, key) {
   transform.transformers[key] = new Transformer(key, transformer);
 });

lib/6to5/transformation/transformer-pass.js

@@ -0,0 +1,69 @@
+module.exports = TransformerPass;
+
+var traverse = require("../traverse");
+var _        = require("lodash");
+
+/**
+ * This class is responsible for traversing over the provided `File`s
+ * AST and running it's parent transformers handlers over it.
+ */
+
+function TransformerPass(file, transformer) {
+  this.transformer = transformer;
+  this.handlers    = transformer.handlers;
+  this.file        = file;
+}
+
+TransformerPass.prototype.astRun = function (key) {
+  var handlers = this.handlers;
+  var file = this.file;
+
+  if (handlers.ast && handlers.ast[key]) {
+    handlers.ast[key](file.ast, file);
+  }
+};
+
+TransformerPass.prototype.canRun = function () {
+  var transformer = this.transformer;
+
+  var opts = this.file.opts;
+  var key  = transformer.key;
+  if (key[0] === "_") return true;
+
+  var blacklist = opts.blacklist;
+  if (blacklist.length && _.contains(blacklist, key)) return false;
+
+  var whitelist = opts.whitelist;
+  if (whitelist.length && !_.contains(whitelist, key)) return false;
+
+  if (transformer.optional && !_.contains(opts.optional, key)) return false;
+
+  if (transformer.experimental && !opts.experimental) return false;
+
+  return true;
+};
+
+var transformVisitor = {
+  enter: function (node, parent, scope, context, state) {
+    var fns = state.handlers[node.type];
+    if (!fns) return;
+    return fns.enter(node, parent, scope, context, state.file, state.pass);
+  },
+
+  exit: function (node, parent, scope, context, state) {
+    var fns = state.handlers[node.type];
+    if (!fns) return;
+    return fns.exit(node, parent, scope, context, state.file, state.pass);
+  }
+};
+
+TransformerPass.prototype.transform = function () {
+  var file = this.file;
+
+  this.astRun("before");
+
+  var state = { file: file, handlers: this.handlers, pass: this };
+  traverse(file.ast, transformVisitor, file.scope, state);
+
+  this.astRun("after");
+};

lib/6to5/transformation/transformer.js

@@ -2,35 +2,22 @@
 
 module.exports = Transformer;
 
-var traverse = require("../traverse");
-var t        = require("../types");
-var _        = require("lodash");
+var TransformerPass = require("./transformer-pass");
+var t               = require("../types");
+var _               = require("lodash");
 
-function noop() { }
-
-function enter(node, parent, scope, context, args) {
-  var fns = args[1][node.type];
-  if (!fns) return;
-  return fns.enter(node, parent, scope, context, args[0]);
-}
-
-function exit(node, parent, scope, context, args) {
-  var fns = args[1][node.type];
-  if (!fns) return;
-  return fns.exit(node, parent, scope, context, args[0]);
-}
-
-var traverseOpts = {
-  enter: enter,
-  exit: exit
-};
+/**
+ * This is the class responsible for normalising a transformers handlers
+ * as well as constructing a `TransformerPass` that is repsonsible for
+ * actually running the transformer over the provided `File`.
+ */
 
 function Transformer(key, transformer, opts) {
   this.manipulateOptions = transformer.manipulateOptions;
   this.experimental      = !!transformer.experimental;
   this.secondPass        = !!transformer.secondPass;
-  this.transformer       = this.normalise(transformer);
   this.optional          = !!transformer.optional;
+  this.handlers          = this.normalise(transformer);
   this.opts              = opts || {};
   this.key               = key;
 }
@@ -53,8 +40,8 @@ Transformer.prototype.normalise = function (transformer) {
 
     if (!_.isObject(fns)) return;
 
-    if (!fns.enter) fns.enter = noop;
-    if (!fns.exit) fns.exit = noop;
+    if (!fns.enter) fns.enter = _.noop;
+    if (!fns.exit) fns.exit = _.noop;
 
     transformer[type] = fns;
 
@@ -69,34 +56,6 @@ Transformer.prototype.normalise = function (transformer) {
   return transformer;
 };
 
-Transformer.prototype.astRun = function (file, key) {
-  var transformer = this.transformer;
-
-  if (transformer.ast && transformer.ast[key]) {
-    transformer.ast[key](file.ast, file);
-  }
-};
-
-Transformer.prototype.transform = function (file) {
-  this.astRun(file, "before");
-  traverse(file.ast, traverseOpts, null, [file, this.transformer]);
-  this.astRun(file, "after");
-};
-
-Transformer.prototype.canRun = function (file) {
-  var opts = file.opts;
-  var key  = this.key;
-  if (key[0] === "_") return true;
-
-  var blacklist = opts.blacklist;
-  if (blacklist.length && _.contains(blacklist, key)) return false;
-
-  var whitelist = opts.whitelist;
-  if (whitelist.length && !_.contains(whitelist, key)) return false;
-
-  if (this.optional && !_.contains(opts.optional, key)) return false;
-
-  if (this.experimental && !opts.experimental) return false;
-
-  return true;
+Transformer.prototype.buildPass = function (file) {
+  return new TransformerPass(file, this);
 };

lib/6to5/transformation/transformers/_module-formatter.js

@@ -1,13 +0,0 @@
-"use strict";
-
-var transform = require("../transform");
-
-exports.ast = {
-  exit: function (ast, file) {
-    if (!transform.transformers.modules.canRun(file)) return;
-
-    if (file.moduleFormatter.transform) {
-      file.moduleFormatter.transform(ast);
-    }
-  }
-};

lib/6to5/transformation/transformers/deprecated.json

@@ -0,0 +1,38 @@
+{
+  "specNoForInOfAssignment": "validation.noForInOfAssignment",
+  "specSetters": "validation.setters",
+  "specBlockScopedFunctions": "spec.blockScopedFunctions",
+  "malletOperator": "playground.malletOperator",
+  "methodBinding": "playground.methodBinding",
+  "memoizationOperator": "playground.memoizationOperator",
+  "objectGetterMemoization": "playground.objectGetterMemoization",
+  "modules": "es6.modules",
+  "propertyNameShorthand": "es6.properties.shorthand",
+  "arrayComprehension": "es7.comprehensions",
+  "generatorComprehension": "es7.comprehensions",
+  "arrowFunctions": "es6.arrowFunctions",
+  "classes": "es6.classes",
+  "objectSpread": "es7.objectSpread",
+  "exponentiationOperator": "es7.exponentiationOperator",
+  "spread": "es6.spread",
+  "templateLiterals": "es6.templateLiterals",
+  "propertyMethodAssignment": "es6.properties.shorthand",
+  "computedPropertyNames": "es6.properties.computed",
+  "defaultParameters": "es6.parameters.default",
+  "restParameters": "es6.parameters.rest",
+  "destructuring": "es6.destructuring",
+  "forOf": "es6.forOf",
+  "unicodeRegex": "es6.unicodeRegex",
+  "abstractReferences": "es7.abstractReferences",
+  "constants": "es6.constants",
+  "letScoping": "es6.letScoping",
+  "blockScopingTDZ": "es6.blockScopingTDZ",
+  "generators": "regenerator",
+  "protoToAssign": "spec.protoToAssign",
+  "typeofSymbol": "spec.typeofSymbol",
+  "coreAliasing": "selfContained",
+  "undefinedToVoid": "spec.undefinedToVoid",
+  "undeclaredVariableCheck": "validation.undeclaredVariableCheck",
+  "specPropertyLiterals": "minification.propertyLiterals",
+  "specMemberExpressionLiterals": "minification.memberExpressionLiterals"
+}

lib/6to5/transformation/transformers/es5/properties.mutators.js

@@ -1,16 +1,7 @@
 "use strict";
 
-var nameMethod = require("../helpers/name-method");
-var util       = require("../../util");
-var t          = require("../../types");
-
-exports.Property = function (node, parent, scope, context, file) {
-  if (!node.method) return;
-
-  node.method = false;
-
-  nameMethod.property(node, file, scope);
-};
+var util = require("../../../util");
+var t    = require("../../../types");
 
 exports.ObjectExpression = function (node) {
   var mutatorMap = {};

lib/6to5/transformation/transformers/es6-constants.js

@@ -1,89 +0,0 @@
-"use strict";
-
-var traverse = require("../../traverse");
-var t        = require("../../types");
-var _        = require("lodash");
-
-exports.Program =
-exports.BlockStatement =
-exports.ForInStatement =
-exports.ForOfStatement =
-exports.ForStatement = function (node, parent, scope, context, file) {
-  var hasConstants = false;
-  var constants = {};
-
-  /**
-   * Check the results of `util.getIds` as `names` generated from a
-   * node against it's parent.
-   */
-
-  var check = function (parent, names, scope) {
-    for (var name in names) {
-      var nameNode = names[name];
-      if (!_.has(constants, name)) continue;
-      if (parent && t.isBlockStatement(parent) && parent !== constants[name]) continue;
-
-      if (scope) {
-        var defined = scope.get(name);
-        if (defined && defined === nameNode) continue;
-      }
-
-      throw file.errorWithNode(nameNode, name + " is read-only");
-    }
-  };
-
-  var getIds = function (node) {
-    return t.getIds(node, true, ["MemberExpression"]);
-  };
-
-  /**
-   * Collect all constants in this scope.
-   */
-
-  _.each(node.body, function (child, parent) {
-    if (t.isExportDeclaration(child)) {
-      child = child.declaration;
-    }
-
-    if (t.isVariableDeclaration(child, { kind: "const" })) {
-      for (var i = 0; i < child.declarations.length; i++) {
-        var declar = child.declarations[i];
-
-        var ids = getIds(declar);
-        for (var name in ids) {
-          var nameNode = ids[name];
-
-          var names = {};
-          names[name] = nameNode;
-          check(parent, names);
-
-          constants[name] = parent;
-          hasConstants = true;
-        }
-
-        declar._ignoreConstant = true;
-      }
-
-      child._ignoreConstant = true;
-      child.kind = "let";
-    }
-  });
-
-  if (!hasConstants) return;
-
-  var state = {
-    check: check,
-    getIds: getIds
-  };
-
-  traverse(node, {
-    enter: function (child, parent, scope, context, state) {
-      if (child._ignoreConstant) return;
-      if (t.isVariableDeclaration(child)) return;
-
-      if (t.isVariableDeclarator(child) || t.isDeclaration(child) || t.isAssignmentExpression(child)) {
-        state.check(parent, state.getIds(child), scope);
-      }
-    }
-  }, null, state);
-};

lib/6to5/transformation/transformers/es6-default-parameters.js

@@ -1,97 +0,0 @@
-"use strict";
-
-var traverse = require("../../traverse");
-var util     = require("../../util");
-var t        = require("../../types");
-
-exports.Function = function (node, parent, scope, context, file) {
-  if (!node.defaults || !node.defaults.length) return;
-  t.ensureBlock(node);
-
-  var ids = node.params.map(function (param) {
-    return t.getIds(param);
-  });
-
-  var iife = false;
-  var def;
-
-  var checkTDZ = function (param, def, ids) {
-    var check = function (node, parent) {
-      if (!t.isReferencedIdentifier(node, parent)) return;
-
-      if (ids.indexOf(node.name) >= 0) {
-        throw file.errorWithNode(node, "Temporal dead zone - accessing a variable before it's initialized");
-      }
-
-      if (scope.has(node.name, true)) {
-        iife = true;
-      }
-    };
-
-    check(def, node);
-
-    if (!t.isPattern(param)) {
-      traverse(def, { enter: check });
-    }
-  };
-
-  for (var i = 0; i < node.defaults.length; i++) {
-    def = node.defaults[i];
-    if (!def) continue;
-
-    var param = node.params[i];
-
-    // temporal dead zone check - here we prevent accessing of params that
-    // are to the right - ie. uninitialized parameters
-    var rightIds = ids.slice(i);
-    for (var i2 = 0; i2 < rightIds.length; i2++) {
-      checkTDZ(param, def, rightIds[i2]);
-    }
-
-    // we're accessing a variable that's already defined within this function
-    var has = scope.get(param.name, true);
-    if (has && node.params.indexOf(has) < 0) {
-      iife = true;
-    }
-  }
-
-  var body = [];
-
-  var argsIdentifier = t.identifier("arguments");
-  argsIdentifier._ignoreAliasFunctions = true;
-
-  var lastNonDefaultParam = 0;
-
-  for (i = 0; i < node.defaults.length; i++) {
-    def = node.defaults[i];
-    if (!def) {
-      lastNonDefaultParam = +i + 1;
-      continue;
-    }
-
-    var defNode = util.template("default-parameter", {
-      VARIABLE_NAME: node.params[i],
-      DEFAULT_VALUE: def,
-      ARGUMENT_KEY:  t.literal(+i),
-      ARGUMENTS:     argsIdentifier
-    }, true);
-    defNode._blockHoist = node.defaults.length - i;
-    body.push(defNode);
-  }
-
-  // we need to cut off all trailing default parameters
-  node.params = node.params.slice(0, lastNonDefaultParam);
-
-  if (iife) {
-    var container = t.functionExpression(null, [], node.body, node.generator);
-    container._aliasFunction = true;
-
-    body.push(t.returnStatement(t.callExpression(container, [])));
-
-    node.body = t.blockStatement(body);
-  } else {
-    node.body.body = body.concat(node.body.body);
-  }
-
-  node.defaults = [];
-};

lib/6to5/transformation/transformers/es6-property-name-shorthand.js

@@ -1,10 +0,0 @@
-"use strict";
-
-var t = require("../../types");
-var _ = require("lodash");
-
-exports.Property = function (node) {
-  if (!node.shorthand) return;
-  node.shorthand = false;
-  node.key = t.removeComments(_.clone(node.key));
-};

lib/6to5/transformation/transformers/es6/arrow-functions.js

@@ -1,6 +1,6 @@
 "use strict";
 
-var t = require("../../types");
+var t = require("../../../types");
 
 exports.ArrowFunctionExpression = function (node) {
   t.ensureBlock(node);

lib/6to5/transformation/transformers/es6/block-scoping-tdz.js

@@ -0,0 +1,50 @@
+"use strict";
+
+var traverse = require("../../../traverse");
+var t        = require("../../../types");
+
+var visitor = {
+  enter: function (node, parent, scope, context, state) {
+    if (!t.isReferencedIdentifier(node, parent)) return;
+
+    var declared = state.letRefs[node.name];
+    if (!declared) return;
+
+    // declared node is different in this scope
+    if (scope.get(node.name, true) !== declared) return;
+
+    var declaredLoc  = declared.loc;
+    var referenceLoc = node.loc;
+
+    if (!declaredLoc || !referenceLoc) return;
+
+    // does this reference appear on a line before the declaration?
+    var before = referenceLoc.start.line < declaredLoc.start.line;
+
+    if (referenceLoc.start.line === declaredLoc.start.line) {
+      // this reference appears on the same line
+      // check it appears before the declaration
+      before = referenceLoc.start.col < declaredLoc.start.col;
+    }
+
+    if (before) {
+      throw state.file.errorWithNode(node, "Temporal dead zone - accessing a variable before it's initialized");
+    }
+  }
+};
+
+exports.optional = true;
+
+exports.Loop =
+exports.Program =
+exports.BlockStatement = function (node, parent, scope, context, file) {
+  var letRefs = node._letReferences;
+  if (!letRefs) return;
+
+  var state = {
+    letRefs: letRefs,
+    file:    file
+  };
+
+  traverse(node, visitor, scope, state);
+};

lib/6to5/transformation/transformers/es6/block-scoping.js

@@ -1,8 +1,9 @@
 "use strict";
 
-var traverse = require("../../traverse");
-var util     = require("../../util");
-var t        = require("../../types");
+var traverse = require("../../../traverse");
+var object   = require("../../../helpers/object");
+var util     = require("../../../util");
+var t        = require("../../../types");
 var _        = require("lodash");
 
 var isLet = function (node, parent) {
@@ -12,9 +13,10 @@ var isLet = function (node, parent) {
 
   // https://github.com/6to5/6to5/issues/255
   if (!t.isFor(parent) || t.isFor(parent) && parent.left !== node) {
-    _.each(node.declarations, function (declar) {
+    for (var i = 0; i < node.declarations.length; i++) {
+      var declar = node.declarations[i];
       declar.init = declar.init || t.identifier("undefined");
-    });
+    }
   }
 
   node._let = true;
@@ -40,7 +42,7 @@ exports.Loop = function (node, parent, scope, context, file) {
   var init = node.left || node.init;
   if (isLet(init, node)) {
     t.ensureBlock(node);
-    node.body._letDeclars = [init];
+    node.body._letDeclarators = [init];
   }
 
   if (t.isLabeledStatement(parent)) {
@@ -82,9 +84,9 @@ function LetScoping(loopParent, block, parent, scope, file) {
   this.block      = block;
   this.file       = file;
 
-  this.outsideLetReferences = {};
+  this.outsideLetReferences = object();
   this.hasLetReferences     = false;
-  this.letReferences        = block._letReferences = {};
+  this.letReferences        = block._letReferences = object();
   this.body                 = [];
 }
 
@@ -112,6 +114,31 @@ LetScoping.prototype.run = function () {
   }
 };
 
+function replace(node, parent, scope, context, remaps) {
+  if (!t.isReferencedIdentifier(node, parent)) return;
+
+  var remap = remaps[node.name];
+  if (!remap) return;
+
+  var own = scope.get(node.name, true);
+  if (own === remap.node) {
+    node.name = remap.uid;
+  } else {
+    // scope already has it's own declaration that doesn't
+    // match the one we have a stored replacement for
+    if (context) context.skip();
+  }
+}
+
+var replaceVisitor = {
+  enter: replace
+};
+
+function traverseReplace(node, parent, scope, remaps) {
+  replace(node, parent, scope, null, remaps);
+  traverse(node, replaceVisitor, scope, remaps);
+}
+
 /**
  * Description
  */
@@ -120,13 +147,12 @@ LetScoping.prototype.remap = function () {
   var hasRemaps = false;
   var letRefs   = this.letReferences;
   var scope     = this.scope;
-  var file      = this.file;
 
   // alright, so since we aren't wrapping this block in a closure
   // we have to check if any of our let variables collide with
   // those in upper scopes and then if they do, generate a uid
   // for them and replace all references with it
-  var remaps = {};
+  var remaps = object();
 
   for (var key in letRefs) {
     // just an Identifier node we collected in `getLetReferences`
@@ -134,7 +160,7 @@ LetScoping.prototype.remap = function () {
     var ref = letRefs[key];
 
     if (scope.parentHas(key)) {
-      var uid = file.generateUidIdentifier(ref.name, scope).name;
+      var uid = scope.generateUidIdentifier(ref.name).name;
       ref.name = uid;
 
       hasRemaps = true;
@@ -149,35 +175,14 @@ LetScoping.prototype.remap = function () {
 
   //
 
-  var replace = function (node, parent, scope, context, remaps) {
-    if (!t.isReferencedIdentifier(node, parent)) return;
-
-    var remap = remaps[node.name];
-    if (!remap) return;
-
-    var own = scope.get(node.name, true);
-    if (own === remap.node) {
-      node.name = remap.uid;
-    } else {
-      // scope already has it's own declaration that doesn't
-      // match the one we have a stored replacement for
-      if (context) context.skip();
-    }
-  };
-
-  var traverseReplace = function (node, parent) {
-    replace(node, parent, scope, null, remaps);
-    traverse(node, { enter: replace }, scope, remaps);
-  };
-
   var loopParent = this.loopParent;
   if (loopParent) {
-    traverseReplace(loopParent.right, loopParent);
-    traverseReplace(loopParent.test, loopParent);
-    traverseReplace(loopParent.update, loopParent);
+    traverseReplace(loopParent.right, loopParent, scope, remaps);
+    traverseReplace(loopParent.test, loopParent, scope, remaps);
+    traverseReplace(loopParent.update, loopParent, scope, remaps);
   }
 
-  traverse(this.block, { enter: replace }, scope, remaps);
+  traverse(this.block, replaceVisitor, scope, remaps);
 };
 
 /**
@@ -206,17 +211,50 @@ LetScoping.prototype.needsClosure = function () {
 
   // build a call and a unique id that we can assign the return value to
   var call = t.callExpression(fn, params);
-  var ret  = this.file.generateUidIdentifier("ret", this.scope);
+  var ret  = this.scope.generateUidIdentifier("ret");
 
-  var hasYield = traverse.hasType(fn.body, "YieldExpression", t.FUNCTION_TYPES);
+  // handle generators
+  var hasYield = traverse.hasType(fn.body, this.scope, "YieldExpression", t.FUNCTION_TYPES);
   if (hasYield) {
     fn.generator = true;
     call = t.yieldExpression(call, true);
   }
 
+  // handlers async functions
+  var hasAsync = traverse.hasType(fn.body, this.scope, "AwaitExpression", t.FUNCTION_TYPES);
+  if (hasAsync) {
+    fn.async = true;
+    call = t.awaitExpression(call, true);
+  }
+
   this.build(ret, call);
 };
 
+var letReferenceFunctionVisitor = {
+  enter: function (node, parent, scope, context, state) {
+    // not a direct reference
+    if (!t.isReferencedIdentifier(node, parent)) return;
+
+    // this scope has a variable with the same name so it couldn't belong
+    // to our let scope
+    if (scope.hasOwn(node.name, true)) return;
+
+    // not a part of our scope
+    if (!state.letReferences[node.name]) return;
+
+    state.closurify = true;
+  }
+};
+
+var letReferenceBlockVisitor = {
+  enter: function (node, parent, scope, context, state) {
+    if (t.isFunction(node)) {
+      traverse(node, letReferenceFunctionVisitor, scope, state);
+      return context.skip();
+    }
+  }
+};
+
 /**
  * Description
  */
@@ -224,7 +262,7 @@ LetScoping.prototype.needsClosure = function () {
 LetScoping.prototype.getLetReferences = function () {
   var block = this.block;
 
-  var declarators = block._letDeclars || [];
+  var declarators = block._letDeclarators || [];
   var declar;
 
   //
@@ -264,33 +302,42 @@ LetScoping.prototype.getLetReferences = function () {
 
   // traverse through this block, stopping on functions and checking if they
   // contain any local let references
-  traverse(this.block, {
-    enter: function (node, parent, scope, context, state) {
-      if (t.isFunction(node)) {
-        traverse(node, {
-          enter: function (node, parent) {
-            // not a direct reference
-            if (!t.isReferencedIdentifier(node, parent)) return;
-
-            // this scope has a variable with the same name so it couldn't belong
-            // to our let scope
-            if (scope.hasOwn(node.name, true)) return;
-
-            // not a part of our scope
-            if (!state.letReferences[node.name]) return;
-
-            state.closurify = true;
-          }
-        }, scope, state);
-
-        return context.skip();
-      }
-    }
-  }, this.scope, state);
+  traverse(this.block, letReferenceBlockVisitor, this.scope, state);
 
   return state.closurify;
 };
 
+var loopVisitor = {
+  enter: function (node, parent, scope, context, state) {
+    var replace;
+
+    if (t.isFunction(node) || t.isLoop(node)) {
+      return context.skip();
+    }
+
+    if (node && !node.label && state.isLoop) {
+      if (t.isBreakStatement(node)) {
+        if (t.isSwitchCase(parent)) return;
+
+        state.hasBreak = true;
+        replace = t.returnStatement(t.literal("break"));
+      } else if (t.isContinueStatement(node)) {
+        state.hasContinue = true;
+        replace = t.returnStatement(t.literal("continue"));
+      }
+    }
+
+    if (t.isReturnStatement(node)) {
+      state.hasReturn = true;
+      replace = t.returnStatement(t.objectExpression([
+        t.property("init", t.identifier("v"), node.argument || t.identifier("undefined"))
+      ]));
+    }
+
+    if (replace) return t.inherits(replace, node);
+  }
+};
+
 /**
  * If we're inside of a loop then traverse it and check if it has one of
  * the following node types `ReturnStatement`, `BreakStatement`,
@@ -301,44 +348,33 @@ LetScoping.prototype.getLetReferences = function () {
  */
 
 LetScoping.prototype.checkLoop = function () {
-  var has = {
+  var state = {
     hasContinue: false,
     hasReturn:   false,
     hasBreak:    false,
+    isLoop:      !!this.loopParent
   };
 
-  traverse(this.block, {
-    enter: function (node, parent, scope, context) {
-      var replace;
+  traverse(this.block, loopVisitor, this.scope, state);
+  return state;
+};
 
-      if (t.isFunction(node) || t.isLoop(node)) {
-        return context.skip();
+var hoistVarDeclarationsVisitor = {
+  enter: function (node, parent, scope, context, self) {
+    if (t.isForStatement(node)) {
+      if (isVar(node.init, node)) {
+        node.init = t.sequenceExpression(self.pushDeclar(node.init));
       }
-
-      if (node && !node.label) {
-        if (t.isBreakStatement(node)) {
-          if (t.isSwitchCase(parent)) return;
-
-          has.hasBreak = true;
-          replace = t.returnStatement(t.literal("break"));
-        } else if (t.isContinueStatement(node)) {
-          has.hasContinue = true;
-          replace = t.returnStatement(t.literal("continue"));
-        }
+    } else if (t.isFor(node)) {
+      if (isVar(node.left, node)) {
+        node.left = node.left.declarations[0].id;
       }
-
-      if (t.isReturnStatement(node)) {
-        has.hasReturn = true;
-        replace = t.returnStatement(t.objectExpression([
-          t.property("init", t.identifier("v"), node.argument || t.identifier("undefined"))
-        ]));
-      }
-
-      if (replace) return t.inherits(replace, node);
+    } else if (isVar(node, parent)) {
+      return self.pushDeclar(node).map(t.expressionStatement);
+    } else if (t.isFunction(node)) {
+      return context.skip();
     }
-  }, this.scope, has);
-
-  return has;
+  }
 };
 
 /**
@@ -347,23 +383,7 @@ LetScoping.prototype.checkLoop = function () {
  */
 
 LetScoping.prototype.hoistVarDeclarations = function () {
-  traverse(this.block, {
-    enter: function (node, parent, scope, context, self) {
-      if (t.isForStatement(node)) {
-        if (isVar(node.init, node)) {
-          node.init = t.sequenceExpression(self.pushDeclar(node.init));
-        }
-      } else if (t.isFor(node)) {
-        if (isVar(node.left, node)) {
-          node.left = node.left.declarations[0].id;
-        }
-      } else if (isVar(node, parent)) {
-        return self.pushDeclar(node).map(t.expressionStatement);
-      } else if (t.isFunction(node)) {
-        return context.skip();
-      }
-    }
-  }, this.scope, this);
+  traverse(this.block, hoistVarDeclarationsVisitor, this.scope, this);
 };
 
 /**
@@ -435,9 +455,14 @@ LetScoping.prototype.buildHas = function (ret, call) {
   }
 
   if (has.hasBreak || has.hasContinue) {
+    if (!loopParent) {
+      throw new Error("Has no loop parent but we're trying to reassign breaks " +
+                      "and continues, something is going wrong here.");
+    }
+
     // ensure that the parent has a label as we're building a switch and we
     // need to be able to access it
-    var label = loopParent.label = loopParent.label || this.file.generateUidIdentifier("loop", this.scope);
+    var label = loopParent.label = loopParent.label || this.scope.generateUidIdentifier("loop");
 
     if (has.hasBreak) {
       cases.push(t.switchCase(t.literal("break"), [t.breakStatement(label)]));

lib/6to5/transformation/transformers/es6/classes.js

@@ -1,9 +1,9 @@
 "use strict";
 
-var ReplaceSupers = require("../helpers/replace-supers");
-var nameMethod    = require("../helpers/name-method");
-var util          = require("../../util");
-var t             = require("../../types");
+var ReplaceSupers = require("../../helpers/replace-supers");
+var nameMethod    = require("../../helpers/name-method");
+var util          = require("../../../util");
+var t             = require("../../../types");
 
 exports.ClassDeclaration = function (node, parent, scope, context, file) {
   return new Class(node, file, scope, true).run();
@@ -46,9 +46,9 @@ function Class(node, file, scope, isStatement) {
   this.instanceMutatorMap = {};
   this.staticMutatorMap   = {};
   this.hasConstructor     = false;
-  this.className          = node.id || file.generateUidIdentifier("class", scope);
+  this.className          = node.id || scope.generateUidIdentifier("class");
   this.superName          = node.superClass;
-  this.isLoose            = file.isLoose("classes");
+  this.isLoose            = file.isLoose("es6.classes");
 }
 
 /**
@@ -137,7 +137,14 @@ Class.prototype.buildBody = function () {
   for (var i = 0; i < classBody.length; i++) {
     var node = classBody[i];
     if (t.isMethodDefinition(node)) {
-      var replaceSupers = new ReplaceSupers(node, this.className, this.superName, this.isLoose, this.file);
+      var replaceSupers = new ReplaceSupers({
+        methodNode: node,
+        className:  this.className,
+        superName:  this.superName,
+        isLoose:    this.isLoose,
+        scope:      this.scope,
+        file:       this.file
+      });
       replaceSupers.replace();
 
       if (node.key.name === "constructor") {
@@ -246,8 +253,6 @@ Class.prototype.pushConstructor = function (method) {
   t.inheritsComments(construct, method);
 
   construct._ignoreUserWhitespace = true;
-  construct.defaults              = fn.defaults;
   construct.params                = fn.params;
   construct.body                  = fn.body;
-  construct.rest                  = fn.rest;
 };

lib/6to5/transformation/transformers/es6/constants.js

@@ -0,0 +1,41 @@
+"use strict";
+
+var traverse = require("../../../traverse");
+var t        = require("../../../types");
+
+var visitor = {
+  enter: function (node, parent, scope, context, state) {
+    if (t.isDeclaration(node) || t.isAssignmentExpression(node)) {
+      var ids = t.getIds(node, true);
+
+      for (var key in ids) {
+        var id = ids[key];
+
+        var constant = state.constants[key];
+
+        // no constant exists
+        if (!constant) 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 === constant) continue;
+
+        throw state.file.errorWithNode(id, key + " is read-only");
+      }
+    } else if (t.isScope(node)) {
+      context.skip();
+    }
+  }
+};
+
+exports.Scope = function (node, parent, scope, context, file) {
+  traverse(node, visitor, scope, {
+    constants: scope.getAllOfKind("const"),
+    file:      file
+  });
+};
+
+exports.VariableDeclaration = function (node) {
+  if (node.kind === "const") node.kind = "let";
+};

lib/6to5/transformation/transformers/es6/destructuring.js

@@ -2,7 +2,7 @@
 
 // TODO: Clean up
 
-var t = require("../../types");
+var t = require("../../../types");
 
 var buildVariableAssign = function (opts, id, init) {
   var op = opts.operator;
@@ -65,24 +65,24 @@ var pushObjectPattern = function (opts, nodes, pattern, parentId) {
   for (var i = 0; i < pattern.properties.length; i++) {
     var prop = pattern.properties[i];
     if (t.isSpreadProperty(prop)) {
-        // get all the keys that appear in this object before the current spread
-        var keys = [];
-        for (var i2 = 0; i2 < pattern.properties.length; i2++) {
-          var prop2 = pattern.properties[i2];
+      // get all the keys that appear in this object before the current spread
+      var keys = [];
+      for (var i2 = 0; i2 < pattern.properties.length; i2++) {
+        var prop2 = pattern.properties[i2];
 
-          if (i2 >= i) break;
-          if (t.isSpreadProperty(prop2)) continue;
+        if (i2 >= i) break;
+        if (t.isSpreadProperty(prop2)) continue;
 
-          var key = prop2.key;
-          if (t.isIdentifier(key)) {
-            key = t.literal(prop2.key.name);
-          }
-          keys.push(key);
+        var key = prop2.key;
+        if (t.isIdentifier(key)) {
+          key = t.literal(prop2.key.name);
         }
-        keys = t.arrayExpression(keys);
+        keys.push(key);
+      }
+      keys = t.arrayExpression(keys);
 
-        var value = t.callExpression(opts.file.addHelper("object-without-properties"), [parentId, keys]);
-        nodes.push(buildVariableAssign(opts, prop.argument, value));
+      var value = t.callExpression(opts.file.addHelper("object-without-properties"), [parentId, keys]);
+      nodes.push(buildVariableAssign(opts, prop.argument, value));
     } else {
       if (t.isLiteral(prop.key)) prop.computed = true;
 
@@ -103,15 +103,15 @@ var pushArrayPattern = function (opts, nodes, pattern, parentId) {
 
   var i;
 
-  var hasSpreadElement = false;
+  var hasRest = false;
   for (i = 0; i < pattern.elements.length; i++) {
-    if (t.isSpreadElement(pattern.elements[i])) {
-      hasSpreadElement = true;
+    if (t.isRestElement(pattern.elements[i])) {
+      hasRest = true;
       break;
     }
   }
 
-  var toArray = opts.file.toArray(parentId, !hasSpreadElement && pattern.elements.length);
+  var toArray = opts.file.toArray(parentId, !hasRest && pattern.elements.length);
 
   var _parentId = opts.scope.generateUidBasedOnNode(parentId, opts.file);
   nodes.push(buildVariableDeclar(opts, _parentId, toArray));
@@ -125,7 +125,7 @@ var pushArrayPattern = function (opts, nodes, pattern, parentId) {
 
     var newPatternId;
 
-    if (t.isSpreadElement(elem)) {
+    if (t.isRestElement(elem)) {
       newPatternId = opts.file.toArray(parentId);
 
       if (i > 0) {
@@ -145,11 +145,10 @@ var pushPattern = function (opts) {
   var nodes = opts.nodes;
   var pattern = opts.pattern;
   var parentId = opts.id;
-  var file = opts.file;
   var scope = opts.scope;
 
   if (!t.isArrayExpression(parentId) && !t.isMemberExpression(parentId) && !t.isIdentifier(parentId)) {
-    var key = scope.generateUidBasedOnNode(parentId, file);
+    var key = scope.generateUidBasedOnNode(parentId);
     nodes.push(buildVariableDeclar(opts, key, parentId));
     parentId = key;
   }
@@ -165,7 +164,7 @@ exports.ForOfStatement = function (node, parent, scope, context, file) {
   var pattern = declar.declarations[0].id;
   if (!t.isPattern(pattern)) return;
 
-  var key = file.generateUidIdentifier("ref", scope);
+  var key = scope.generateUidIdentifier("ref");
   node.left = t.variableDeclaration(declar.kind, [
     t.variableDeclarator(key, null)
   ]);
@@ -193,7 +192,7 @@ exports.Function = function (node, parent, scope, context, file) {
     if (!t.isPattern(pattern)) return pattern;
 
     hasDestructuring = true;
-    var parentId = file.generateUidIdentifier("ref", scope);
+    var parentId = scope.generateUidIdentifier("ref");
 
     pushPattern({
       blockHoist: node.params.length - i,
@@ -220,7 +219,7 @@ exports.CatchClause = function (node, parent, scope, context, file) {
   var pattern = node.param;
   if (!t.isPattern(pattern)) return;
 
-  var ref = file.generateUidIdentifier("ref", scope);
+  var ref = scope.generateUidIdentifier("ref");
   node.param = ref;
 
   var nodes = [];
@@ -237,12 +236,12 @@ exports.CatchClause = function (node, parent, scope, context, file) {
 exports.ExpressionStatement = function (node, parent, scope, context, file) {
   var expr = node.expression;
   if (expr.type !== "AssignmentExpression") return;
-
   if (!t.isPattern(expr.left)) return;
+  if (file.isConsequenceExpressionStatement(node)) return;
 
   var nodes = [];
 
-  var ref = file.generateUidIdentifier("ref", scope);
+  var ref = scope.generateUidIdentifier("ref");
   nodes.push(t.variableDeclaration("var", [
     t.variableDeclarator(ref, expr.right)
   ]));
@@ -257,10 +256,9 @@ exports.ExpressionStatement = function (node, parent, scope, context, file) {
 };
 
 exports.AssignmentExpression = function (node, parent, scope, context, file) {
-  if (parent.type === "ExpressionStatement") return;
   if (!t.isPattern(node.left)) return;
 
-  var ref = file.generateUidIdentifier("temp", scope);
+  var ref = scope.generateUidIdentifier("temp");
   scope.push({
     key: ref.name,
     id: ref

lib/6to5/transformation/transformers/es6/for-of.js

@@ -1,11 +1,11 @@
 "use strict";
 
-var util = require("../../util");
-var t    = require("../../types");
+var util = require("../../../util");
+var t    = require("../../../types");
 
 exports.ForOfStatement = function (node, parent, scope, context, file) {
   var callback = spec;
-  if (file.isLoose("forOf")) callback = loose;
+  if (file.isLoose("es6.forOf")) callback = loose;
 
   var build  = callback(node, parent, scope, context, file);
   var declar = build.declar;
@@ -19,7 +19,7 @@ exports.ForOfStatement = function (node, parent, scope, context, file) {
   t.ensureBlock(node);
 
   // add the value declaration to the new loop body
-  if (declar){
+  if (declar) {
     if (build.shouldUnshift) {
       block.body.unshift(declar);
     } else {
@@ -54,10 +54,10 @@ var loose = function (node, parent, scope, context, file) {
   }
 
   var loop = util.template("for-of-loose", {
-    LOOP_OBJECT:  file.generateUidIdentifier("iterator", scope),
-    IS_ARRAY:     file.generateUidIdentifier("isArray", scope),
+    LOOP_OBJECT:  scope.generateUidIdentifier("iterator"),
+    IS_ARRAY:     scope.generateUidIdentifier("isArray"),
     OBJECT:       node.right,
-    INDEX:        file.generateUidIdentifier("i", scope),
+    INDEX:        scope.generateUidIdentifier("i"),
     ID:           id
   });
 
@@ -72,7 +72,7 @@ var spec = function (node, parent, scope, context, file) {
   var left = node.left;
   var declar;
 
-  var stepKey   = file.generateUidIdentifier("step", scope);
+  var stepKey   = scope.generateUidIdentifier("step");
   var stepValue = t.memberExpression(stepKey, t.identifier("value"));
 
   if (t.isIdentifier(left) || t.isPattern(left)) {
@@ -88,7 +88,7 @@ var spec = function (node, parent, scope, context, file) {
   }
 
   var loop = util.template("for-of", {
-    ITERATOR_KEY: file.generateUidIdentifier("iterator", scope),
+    ITERATOR_KEY: scope.generateUidIdentifier("iterator"),
     STEP_KEY:     stepKey,
     OBJECT:       node.right
   });

lib/6to5/transformation/transformers/es6/modules.js

@@ -1,12 +1,6 @@
 "use strict";
 
-var t = require("../../types");
-
-exports.ast = {
-  before: function (ast, file) {
-    ast.program.body = file.dynamicImports.concat(ast.program.body);
-  }
-};
+var t = require("../../../types");
 
 exports.ImportDeclaration = function (node, parent, scope, context, file) {
   var nodes = [];
@@ -20,8 +14,7 @@ exports.ImportDeclaration = function (node, parent, scope, context, file) {
   }
 
   if (nodes.length === 1) {
-    // inherit `_blockHoist`
-    // this for `_blockHoist` in File.prototype.addImport
+    // inherit `_blockHoist` - this is for `_blockHoist` in File.prototype.addImport
     nodes[0]._blockHoist = node._blockHoist;
   }
 
@@ -30,6 +23,7 @@ exports.ImportDeclaration = function (node, parent, scope, context, file) {
 
 exports.ExportDeclaration = function (node, parent, scope, context, file) {
   var nodes = [];
+  var i;
 
   if (node.declaration) {
     // make sure variable exports have an initialiser
@@ -40,11 +34,17 @@ exports.ExportDeclaration = function (node, parent, scope, context, file) {
     }
 
     file.moduleFormatter.exportDeclaration(node, nodes, parent);
-  } else {
-    for (var i = 0; i < node.specifiers.length; i++) {
+  } else if (node.specifiers) {
+    for (i = 0; i < node.specifiers.length; i++) {
       file.moduleFormatter.exportSpecifier(node.specifiers[i], node, nodes, parent);
     }
   }
 
+  if (node._blockHoist) {
+    for (i = 0; i < nodes.length; i++) {
+      nodes[i]._blockHoist = node._blockHoist;
+    }
+  }
+
   return nodes;
 };

lib/6to5/transformation/transformers/es6/parameters.default.js

@@ -0,0 +1,81 @@
+"use strict";
+
+var traverse = require("../../../traverse");
+var util     = require("../../../util");
+var t        = require("../../../types");
+
+var hasDefaults = function (node) {
+  for (var i = 0; i < node.params.length; i++) {
+    if (t.isAssignmentPattern(node.params[i])) return true;
+  }
+  return false;
+};
+
+var iifeVisitor = {
+  enter: function (node, parent, scope, context, state) {
+    if (t.isReferencedIdentifier(node, parent) && scope.hasOwn(node.name)) {
+      state.iife = true;
+      context.stop();
+    }
+  }
+};
+
+exports.Function = function (node, parent, scope) {
+  if (!hasDefaults(node)) return;
+
+  t.ensureBlock(node);
+
+  var body = [];
+
+  var argsIdentifier = t.identifier("arguments");
+  argsIdentifier._ignoreAliasFunctions = true;
+
+  var lastNonDefaultParam = 0;
+
+  var state = { iife: false, scope: scope };
+
+  for (var i = 0; i < node.params.length; i++) {
+    var param = node.params[i];
+
+    if (!t.isAssignmentPattern(param)) {
+      lastNonDefaultParam = +i + 1;
+      continue;
+    }
+
+    var left  = param.left;
+    var right = param.right;
+
+    node.params[i] = scope.generateUidIdentifier("x");
+
+    if (!state.iife) {
+      if (t.isIdentifier(right) && scope.hasOwn(right.name)) {
+        state.iife = true;
+      } else {
+        traverse(right, iifeVisitor, scope, state);
+      }
+    }
+
+    var defNode = util.template("default-parameter", {
+      VARIABLE_NAME: left,
+      DEFAULT_VALUE: right,
+      ARGUMENT_KEY:  t.literal(+i),
+      ARGUMENTS:     argsIdentifier
+    }, true);
+    defNode._blockHoist = node.params.length - i;
+    body.push(defNode);
+  }
+
+  // we need to cut off all trailing default parameters
+  node.params = node.params.slice(0, lastNonDefaultParam);
+
+  if (state.iife) {
+    var container = t.functionExpression(null, [], node.body, node.generator);
+    container._aliasFunction = true;
+
+    body.push(t.returnStatement(t.callExpression(container, [])));
+
+    node.body = t.blockStatement(body);
+  } else {
+    node.body.body = body.concat(node.body.body);
+  }
+};

lib/6to5/transformation/transformers/es6/parameters.rest.js

@@ -1,13 +1,16 @@
 "use strict";
 
-var util = require("../../util");
-var t    = require("../../types");
+var util = require("../../../util");
+var t    = require("../../../types");
 
-exports.Function = function (node, parent, scope, context, file) {
-  if (!node.rest) return;
+var hasRest = function (node) {
+  return t.isRestElement(node.params[node.params.length - 1]);
+};
 
-  var rest = node.rest;
-  node.rest = null;
+exports.Function = function (node, parent, scope) {
+  if (!hasRest(node)) return;
+
+  var rest = node.params.pop().argument;
 
   t.ensureBlock(node);
 
@@ -17,8 +20,8 @@ exports.Function = function (node, parent, scope, context, file) {
   argsId._ignoreAliasFunctions = true;
 
   var start = t.literal(node.params.length);
-  var key = file.generateUidIdentifier("key");
-  var len = file.generateUidIdentifier("len");
+  var key = scope.generateUidIdentifier("key");
+  var len = scope.generateUidIdentifier("len");
 
   var arrKey = key;
   var arrLen = len;
@@ -44,7 +47,7 @@ exports.Function = function (node, parent, scope, context, file) {
   // support patterns
   if (t.isPattern(rest)) {
     var pattern = rest;
-    rest = file.generateUidIdentifier("ref", scope);
+    rest = scope.generateUidIdentifier("ref");
 
     // let the destructuring transformer handle this
     var restDeclar = t.variableDeclaration("var", [

lib/6to5/transformation/transformers/es6/properties.computed.js

@@ -1,6 +1,6 @@
 "use strict";
 
-var t = require("../../types");
+var t = require("../../../types");
 
 exports.ObjectExpression = function (node, parent, scope, context, file) {
   var hasComputed = false;
@@ -13,7 +13,7 @@ exports.ObjectExpression = function (node, parent, scope, context, file) {
   if (!hasComputed) return;
 
   var initProps = [];
-  var objId = scope.generateUidBasedOnNode(parent, file);
+  var objId = scope.generateUidBasedOnNode(parent);
 
   //
 
@@ -24,7 +24,7 @@ exports.ObjectExpression = function (node, parent, scope, context, file) {
   //
 
   var callback = spec;
-  if (file.isLoose("computedPropertyNames")) callback = loose;
+  if (file.isLoose("es6.properties.computed")) callback = loose;
 
   var result = callback(node, body, objId, initProps, file);
   if (result) return result;

lib/6to5/transformation/transformers/es6/properties.shorthand.js

@@ -0,0 +1,17 @@
+"use strict";
+
+var nameMethod = require("../../helpers/name-method");
+var t          = require("../../../types");
+var _          = require("lodash");
+
+exports.Property = function (node, parent, scope, context, file) {
+  if (node.method) {
+    node.method = false;
+    nameMethod.property(node, file, scope);
+  }
+
+  if (node.shorthand) {
+    node.shorthand = false;
+    node.key = t.removeComments(_.clone(node.key));
+  }
+};

lib/6to5/transformation/transformers/es6/spread.js

@@ -1,6 +1,6 @@
 "use strict";
 
-var t = require("../../types");
+var t = require("../../../types");
 var _ = require("lodash");
 
 var getSpreadLiteral = function (spread, file) {
@@ -66,7 +66,7 @@ exports.CallExpression = function (node, parent, scope, context, file) {
   node.arguments = [];
 
   var nodes;
-  if (args.length === 1 && args[0].argument.name === 'arguments') {
+  if (args.length === 1 && args[0].argument.name === "arguments") {
     nodes = [args[0].argument];
   } else {
     nodes = build(args, file);
@@ -82,7 +82,7 @@ exports.CallExpression = function (node, parent, scope, context, file) {
   var callee = node.callee;
 
   if (t.isMemberExpression(callee)) {
-    var temp = scope.generateTempBasedOnNode(callee.object, file);
+    var temp = scope.generateTempBasedOnNode(callee.object);
     if (temp) {
       callee.object = t.assignmentExpression("=", temp, callee.object);
       contextLiteral = temp;

lib/6to5/transformation/transformers/es6/template-literals.js

@@ -1,6 +1,6 @@
 "use strict";
 
-var t = require("../../types");
+var t = require("../../../types");
 
 var buildBinaryExpression = function (left, right) {
   return t.binaryExpression("+", left, right);
@@ -23,7 +23,7 @@ exports.TaggedTemplateExpression = function (node, parent, scope, context, file)
   raw = t.arrayExpression(raw);
 
   var templateName = "tagged-template-literal";
-  if (file.isLoose("templateLiterals")) templateName += "-loose";
+  if (file.isLoose("es6.templateLiterals")) templateName += "-loose";
   args.push(t.callExpression(file.addHelper(templateName), [strings, raw]));
 
   args = args.concat(quasi.expressions);

lib/6to5/transformation/transformers/es7-array-comprehension.js

@@ -1,43 +0,0 @@
-"use strict";
-
-var buildComprehension = require("../helpers/build-comprehension");
-var traverse           = require("../../traverse");
-var util               = require("../../util");
-var t                  = require("../../types");
-
-exports.experimental = true;
-
-var build = function (node, parent, scope, context, file) {
-  var uid = scope.generateUidBasedOnNode(parent, file);
-
-  var container = util.template("array-comprehension-container", {
-    KEY: uid
-  });
-  container.callee._aliasFunction = true;
-
-  var block = container.callee.body;
-  var body  = block.body;
-
-  if (traverse.hasType(node, "YieldExpression", t.FUNCTION_TYPES)) {
-    container.callee.generator = true;
-    container = t.yieldExpression(container, true);
-  }
-
-  var returnStatement = body.pop();
-
-  body.push(buildComprehension(node, function () {
-    return util.template("array-push", {
-      STATEMENT: node.body,
-      KEY:       uid
-    }, true);
-  }));
-  body.push(returnStatement);
-
-  return container;
-};
-
-exports.ComprehensionExpression = function (node, parent, scope, context, file) {
-  if (node.generator) return;
-
-  return build(node, parent, scope, context, file);
-};

lib/6to5/transformation/transformers/es7-generator-comprehension.js

@@ -1,20 +0,0 @@
-"use strict";
-
-var buildComprehension = require("../helpers/build-comprehension");
-var t                  = require("../../types");
-
-exports.experimental = true;
-
-exports.ComprehensionExpression = function (node) {
-  if (!node.generator) return;
-
-  var body = [];
-  var container = t.functionExpression(null, [], t.blockStatement(body), true);
-  container._aliasFunction = true;
-
-  body.push(buildComprehension(node, function () {
-    return t.expressionStatement(t.yieldExpression(node.body));
-  }));
-
-  return t.callExpression(container, []);
-};

lib/6to5/transformation/transformers/es7/abstract-references.js

@@ -2,13 +2,13 @@
 
 // https://github.com/zenparsing/es-abstract-refs
 
-var util = require("../../util");
-var t    = require("../../types");
+var util = require("../../../util");
+var t    = require("../../../types");
 
 exports.experimental = true;
 
-var container = function (parent, call, ret) {
-  if (t.isExpressionStatement(parent)) {
+var container = function (parent, call, ret, file) {
+  if (t.isExpressionStatement(parent) && !file.isConsequenceExpressionStatement(parent)) {
     // we don't need to worry about return values
     return call;
   } else {
@@ -32,7 +32,7 @@ exports.AssignmentExpression = function (node, parent, scope, context, file) {
 
   // we need to return `node.right`
   if (!t.isExpressionStatement(parent)) {
-    temp = scope.generateTempBasedOnNode(node.right, file);
+    temp = scope.generateTempBasedOnNode(node.right);
     if (temp) value = temp;
   }
 
@@ -60,10 +60,10 @@ exports.AssignmentExpression = function (node, parent, scope, context, file) {
     ]);
   }
 
-  return container(parent, call, value);
+  return container(parent, call, value, file);
 };
 
-exports.UnaryExpression = function (node, parent) {
+exports.UnaryExpression = function (node, parent, scope, context, file) {
   var arg = node.argument;
   if (!t.isVirtualPropertyExpression(arg)) return;
   if (node.operator !== "delete") return;
@@ -73,14 +73,14 @@ exports.UnaryExpression = function (node, parent) {
     OBJECT:   arg.object
   });
 
-  return container(parent, call, t.literal(true));
+  return container(parent, call, t.literal(true), file);
 };
 
-exports.CallExpression = function (node, parent, scope, context, file) {
+exports.CallExpression = function (node, parent, scope) {
   var callee = node.callee;
   if (!t.isVirtualPropertyExpression(callee)) return;
 
-  var temp = scope.generateTempBasedOnNode(callee.object, file);
+  var temp = scope.generateTempBasedOnNode(callee.object);
 
   var call = util.template("abstract-expression-call", {
     PROPERTY: callee.property,

lib/6to5/transformation/transformers/es7/comprehensions.js

@@ -0,0 +1,55 @@
+"use strict";
+
+var buildComprehension = require("../../helpers/build-comprehension");
+var traverse           = require("../../../traverse");
+var util               = require("../../../util");
+var t                  = require("../../../types");
+
+exports.experimental = true;
+
+exports.ComprehensionExpression = function (node, parent, scope, context, file) {
+  var callback = array;
+  if (node.generator) callback = generator;
+  return callback(node, parent, scope, file);
+};
+
+var generator = function (node) {
+  var body = [];
+  var container = t.functionExpression(null, [], t.blockStatement(body), true);
+  container._aliasFunction = true;
+
+  body.push(buildComprehension(node, function () {
+    return t.expressionStatement(t.yieldExpression(node.body));
+  }));
+
+  return t.callExpression(container, []);
+};
+
+var array = function (node, parent, scope, file) {
+  var uid = scope.generateUidBasedOnNode(parent, file);
+
+  var container = util.template("array-comprehension-container", {
+    KEY: uid
+  });
+  container.callee._aliasFunction = true;
+
+  var block = container.callee.body;
+  var body  = block.body;
+
+  if (traverse.hasType(node, scope, "YieldExpression", t.FUNCTION_TYPES)) {
+    container.callee.generator = true;
+    container = t.yieldExpression(container, true);
+  }
+
+  var returnStatement = body.pop();
+
+  body.push(buildComprehension(node, function () {
+    return util.template("array-push", {
+      STATEMENT: node.body,
+      KEY:       uid
+    }, true);
+  }));
+  body.push(returnStatement);
+
+  return container;
+};

lib/6to5/transformation/transformers/es7/exponentiation-operator.js

@@ -4,8 +4,8 @@
 
 exports.experimental = true;
 
-var build = require("../helpers/build-binary-assignment-operator-transformer");
-var t     = require("../../types");
+var build = require("../../helpers/build-binary-assignment-operator-transformer");
+var t     = require("../../../types");
 
 var MATH_POW = t.memberExpression(t.identifier("Math"), t.identifier("pow"));
 

lib/6to5/transformation/transformers/es7/object-spread.js

@@ -2,7 +2,7 @@
 
 // https://github.com/sebmarkbage/ecmascript-rest-spread
 
-var t = require("../../types");
+var t = require("../../../types");
 
 exports.experimental = true;
 

lib/6to5/transformation/transformers/index.js

@@ -0,0 +1,85 @@
+module.exports = {
+  useStrict:                               require("./other/use-strict"),
+
+  "validation.undeclaredVariableCheck":    require("./validation/undeclared-variable-check"),
+  "validation.noForInOfAssignment":        require("./validation/no-for-in-of-assignment"),
+  "validation.setters":                    require("./validation/setters"),
+  "spec.blockScopedFunctions":             require("./spec/block-scoped-functions"),
+
+  "playground.malletOperator":             require("./playground/mallet-operator"),
+  "playground.methodBinding":              require("./playground/method-binding"),
+  "playground.memoizationOperator":        require("./playground/memoization-operator"),
+  "playground.objectGetterMemoization":    require("./playground/object-getter-memoization"),
+
+  react:                                   require("./other/react"),
+
+  _modulesSplit:                           require("./internal/modules-split"),
+
+  // needs to be before `regenerator` due to generator comprehensions
+  // needs to be before `_aliasFunction`
+  "es7.comprehensions":                    require("./es7/comprehensions"),
+
+  // needs to be before `_aliasFunction`
+  "es6.arrowFunctions":                    require("./es6/arrow-functions"),
+
+  "es6.classes":                           require("./es6/classes"),
+
+  asyncToGenerator:                        require("./other/async-to-generator"),
+  bluebirdCoroutines:                      require("./other/bluebird-coroutines"),
+
+  "es7.objectSpread":                      require("./es7/object-spread"),
+  "es7.exponentiationOperator":            require("./es7/exponentiation-operator"),
+  "es6.spread":                            require("./es6/spread"),
+  "es6.templateLiterals":                  require("./es6/template-literals"),
+
+  "es5.properties.mutators":               require("./es5/properties.mutators"),
+  "es6.properties.shorthand":              require("./es6/properties.shorthand"),
+
+  // needs to be before `_aliasFunction` due to define property closure
+  "es6.properties.computed":               require("./es6/properties.computed"),
+
+  "es6.forOf":                             require("./es6/for-of"),
+
+  "es6.unicodeRegex":                      require("./es6/unicode-regex"),
+  "es7.abstractReferences":                require("./es7/abstract-references"),
+
+  "es6.constants":                         require("./es6/constants"),
+
+  // needs to be before `_aliasFunction` 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.blockScopingTDZ":                   require("./es6/block-scoping-tdz"),
+
+  // needs to be after block scoping since regenerator doesn't support it
+  regenerator:                             require("./other/regenerator"),
+
+  "es6.parameters.default":                require("./es6/parameters.default"),
+  "es6.parameters.rest":                   require("./es6/parameters.rest"),
+
+  "es6.destructuring":                     require("./es6/destructuring"),
+
+  // needs to be after `regenerator` due to needing `regeneratorRuntime` references
+  // needs to be after `es6.forOf` due to needing `Symbol.iterator` references
+  // needs to be before `es6.modules` due to dynamic imports
+  selfContained:                           require("./other/self-contained"),
+
+  // needs to be before `_blockHoist` due to function hoisting etc
+  "es6.modules":                           require("./es6/modules"),
+
+  _blockHoist:                             require("./internal/block-hoist"),
+
+  "spec.protoToAssign":                    require("./spec/proto-to-assign"),
+
+  _declarations:                           require("./internal/declarations"),
+
+  _aliasFunctions:                         require("./internal/alias-functions"),
+  _moduleFormatter:                        require("./internal/module-formatter"),
+
+  "spec.typeofSymbol":                     require("./spec/typeof-symbol"),
+  "spec.undefinedToVoid":                  require("./spec/undefined-to-void"),
+
+  "minification.propertyLiterals":         require("./minification/property-literals"),
+  "minification.memberExpressionLiterals": require("./minification/member-expression-literals")
+};

lib/6to5/transformation/transformers/internal/alias-functions.js

@@ -1,9 +1,9 @@
 "use strict";
 
-var traverse = require("../../traverse");
-var t        = require("../../types");
+var traverse = require("../../../traverse");
+var t        = require("../../../types");
 
-var functionChildrenTraverser = {
+var functionChildrenVisitor = {
   enter: function (node, parent, scope, context, state) {
     if (t.isFunction(node) && !node._aliasFunction) {
       return context.skip();
@@ -25,7 +25,7 @@ var functionChildrenTraverser = {
   }
 };
 
-var functionTraverser = {
+var functionVisitor = {
   enter: function (node, parent, scope, context, state) {
     if (!node._aliasFunction) {
       if (t.isFunction(node)) {
@@ -37,28 +37,28 @@ var functionTraverser = {
     }
 
     // traverse all child nodes of this function and find `arguments` and `this`
-    traverse(node, functionChildrenTraverser, null, state);
+    traverse(node, functionChildrenVisitor, scope, state);
 
     return context.skip();
   }
 };
 
-var go = function (getBody, node, file, scope) {
+var go = function (getBody, node, scope) {
   var argumentsId;
   var thisId;
 
   var state = {
     getArgumentsId: function () {
-      return argumentsId = argumentsId || file.generateUidIdentifier("arguments", scope);
+      return argumentsId = argumentsId || scope.generateUidIdentifier("arguments");
     },
     getThisId: function () {
-      return thisId = thisId || file.generateUidIdentifier("this", scope);
+      return thisId = thisId || scope.generateUidIdentifier("this");
     }
   };
 
   // traverse the function and find all alias functions so we can alias
   // `arguments` and `this` if necessary
-  traverse(node, functionTraverser, null, state);
+  traverse(node, functionVisitor, scope, state);
 
   var body;
 
@@ -78,16 +78,16 @@ var go = function (getBody, node, file, scope) {
   }
 };
 
-exports.Program = function (node, parent, scope, context, file) {
+exports.Program = function (node, parent, scope) {
   go(function () {
     return node.body;
-  }, node, file, scope);
+  }, node, scope);
 };
 
 exports.FunctionDeclaration =
-exports.FunctionExpression = function (node, parent, scope, context, file) {
+exports.FunctionExpression = function (node, parent, scope) {
   go(function () {
     t.ensureBlock(node);
     return node.body.body;
-  }, node, file, scope);
+  }, node, scope);
 };

lib/6to5/transformation/transformers/internal/block-hoist.js

@@ -1,6 +1,6 @@
 "use strict";
 
-var useStrict = require("../helpers/use-strict");
+var useStrict = require("../../helpers/use-strict");
 var _         = require("lodash");
 
 // Priority:

lib/6to5/transformation/transformers/internal/declarations.js

@@ -1,7 +1,7 @@
 "use strict";
 
-var useStrict = require("../helpers/use-strict");
-var t         = require("../../types");
+var useStrict = require("../../helpers/use-strict");
+var t         = require("../../../types");
 
 exports.secondPass = true;
 

lib/6to5/transformation/transformers/internal/module-formatter.js

@@ -0,0 +1,17 @@
+"use strict";
+
+var useStrict = require("../../helpers/use-strict");
+
+exports.ast = {
+  exit: function (ast, file) {
+    if (!file.transformers["es6.modules"].canRun()) return;
+
+    useStrict.wrap(ast.program, function () {
+      ast.program.body = file.dynamicImports.concat(ast.program.body);
+    });
+
+    if (file.moduleFormatter.transform) {
+      file.moduleFormatter.transform(ast);
+    }
+  }
+};

lib/6to5/transformation/transformers/internal/modules-split.js

@@ -0,0 +1,32 @@
+"use strict";
+
+var t = require("../../../types");
+
+exports.ExportDeclaration = function (node, parent, scope) {
+  var declar = node.declaration;
+
+  if (node.default) {
+    if (t.isClassDeclaration(declar)) {
+      node.declaration = declar.id;
+      return [declar, node];
+    } else if (t.isClassExpression(declar)) {
+      var temp = scope.generateUidIdentifier("default");
+      declar = t.variableDeclaration("var", [
+        t.variableDeclarator(temp, declar)
+      ]);
+      node.declaration = temp;
+      return [declar, node];
+    } else if (t.isFunctionDeclaration(declar)) {
+      node._blockHoist = 2;
+      node.declaration = declar.id;
+      return [declar, node];
+    }
+  } else {
+    if (t.isFunctionDeclaration(declar)) {
+      node.specifiers  = [t.importSpecifier(declar.id, declar.id)];
+      node.declaration = null;
+      node._blockHoist = 2;
+      return [declar, node];
+    }
+  }
+};

lib/6to5/transformation/transformers/minification/member-expression-literals.js

@@ -1,14 +1,15 @@
 "use strict";
 
-var t = require("../../types");
+var t = require("../../../types");
 
 exports.MemberExpression = function (node) {
   var prop = node.property;
   if (node.computed && t.isLiteral(prop) && t.isValidIdentifier(prop.value)) {
-    // computed literal that is a valid identifier
+    // 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;
   }

lib/6to5/transformation/transformers/minification/property-literals.js

@@ -1,15 +1,15 @@
 "use strict";
 
-var t = require("../../types");
+var t = require("../../../types");
 
 exports.Property = function (node) {
   var key = node.key;
   if (t.isLiteral(key) && t.isValidIdentifier(key.value)) {
-    // property key is a literal but a valid identifier
+    // "foo": "bar" -> foo: "bar"
     node.key = t.identifier(key.value);
     node.computed = false;
   } else if (!node.computed && t.isIdentifier(key) && !t.isValidIdentifier(key.name)) {
-    // property key is a keyword
+    // default: "bar" -> "default": "bar"
     node.key = t.literal(key.name);
   }
 };

lib/6to5/transformation/transformers/optional-block-scoping-tdz.js

@@ -1,46 +0,0 @@
-var traverse = require("../../traverse");
-var t        = require("../../types");
-
-exports.optional = true;
-
-exports.Loop =
-exports.Program =
-exports.BlockStatement = function (node, parent, scope, context, file) {
-  var letRefs = node._letReferences;
-  if (!letRefs) return;
-
-  var state = {
-    letRefs: letRefs,
-    file: file
-  };
-
-  traverse(node, {
-    enter: function (node, parent, scope, context, state) {
-      if (!t.isReferencedIdentifier(node, parent)) return;
-
-      var declared = state.letRefs[node.name];
-      if (!declared) return;
-
-      // declared node is different in this scope
-      if (scope.get(node.name, true) !== declared) return;
-
-      var declaredLoc  = declared.loc;
-      var referenceLoc = node.loc;
-
-      if (!declaredLoc || !referenceLoc) return;
-
-      // does this reference appear on a line before the declaration?
-      var before = referenceLoc.start.line < declaredLoc.start.line;
-
-      if (referenceLoc.start.line === declaredLoc.start.line) {
-        // this reference appears on the same line
-        // check it appears before the declaration
-        before = referenceLoc.start.col < declaredLoc.start.col;
-      }
-
-      if (before) {
-        throw state.file.errorWithNode(node, "Temporal dead zone - accessing a variable before it's initialized");
-      }
-    }
-  }, scope, state);
-};

lib/6to5/transformation/transformers/optional-core-aliasing.js

@@ -1,69 +0,0 @@
-"use strict";
-
-var traverse = require("../../traverse");
-var util     = require("../../util");
-var core     = require("core-js/library");
-var t        = require("../../types");
-var _        = require("lodash");
-
-var coreHas = function (node) {
-  return node.name !== "_" && _.has(core, node.name);
-};
-
-var ALIASABLE_CONSTRUCTORS = [
-  "Symbol",
-  "Promise",
-  "Map",
-  "WeakMap",
-  "Set",
-  "WeakSet"
-];
-
-exports.optional = true;
-
-exports.ast = {
-  enter: function (ast, file) {
-    file._coreId = file.addImport("core-js/library", "core");
-  },
-
-  exit: function (ast, file) {
-    traverse(ast, {
-      enter: function (node, parent, scope, context) {
-        var prop;
-
-        if (t.isMemberExpression(node) && t.isReferenced(node, parent)) {
-          // Array.from -> _core.Array.from
-          var obj = node.object;
-          prop = node.property;
-
-          if (!t.isReferenced(obj, node)) return;
-
-          if (!node.computed && coreHas(obj) && _.has(core[obj.name], prop.name)) {
-            context.skip();
-            return t.prependToMemberExpression(node, file._coreId);
-          }
-        } else if (t.isReferencedIdentifier(node, parent) && !t.isMemberExpression(parent) && _.contains(ALIASABLE_CONSTRUCTORS, node.name)) {
-          // Symbol() -> _core.Symbol(); new Promise -> new _core.Promise
-          return t.memberExpression(file._coreId, node);
-        } else if (t.isCallExpression(node)) {
-          // arr[Symbol.iterator]() -> _core.$for.getIterator(arr)
-
-          if (node.arguments.length) return;
-
-          var callee = node.callee;
-          if (!t.isMemberExpression(callee)) return;
-          if (!callee.computed) return;
-
-          prop = callee.property;
-          if (!t.isIdentifier(prop.object, { name: "Symbol" })) return;
-          if (!t.isIdentifier(prop.property, { name: "iterator" })) return;
-
-          return util.template("corejs-iterator", {
-            CORE_ID: file._coreId,
-            VALUE:   callee.object
-          });
-        }
-      }
-    });
-  }
-};

lib/6to5/transformation/transformers/other/async-to-generator.js

@@ -1,7 +1,7 @@
 "use strict";
 
-var remapAsyncToGenerator = require("../helpers/remap-async-to-generator");
-var bluebirdCoroutines    = require("./optional-bluebird-coroutines");
+var remapAsyncToGenerator = require("../../helpers/remap-async-to-generator");
+var bluebirdCoroutines    = require("./bluebird-coroutines");
 
 exports.optional = true;
 
@@ -10,5 +10,5 @@ exports.manipulateOptions = bluebirdCoroutines.manipulateOptions;
 exports.Function = function (node, parent, scope, context, file) {
   if (!node.async || node.generator) return;
 
-  return remapAsyncToGenerator(node, file.addHelper("async-to-generator"));
+  return remapAsyncToGenerator(node, file.addHelper("async-to-generator"), scope);
 };

lib/6to5/transformation/transformers/other/bluebird-coroutines.js

@@ -1,21 +1,21 @@
 "use strict";
 
-var remapAsyncToGenerator = require("../helpers/remap-async-to-generator");
-var t                     = require("../../types");
+var remapAsyncToGenerator = require("../../helpers/remap-async-to-generator");
+var t                     = require("../../../types");
 
 exports.manipulateOptions = function (opts) {
   opts.experimental = true;
-  opts.blacklist.push("generators");
+  opts.blacklist.push("regenerator");
 };
 
 exports.optional = true;
 
-
 exports.Function = function (node, parent, scope, context, file) {
   if (!node.async || node.generator) return;
 
   return remapAsyncToGenerator(
     node,
-    t.memberExpression(file.addImport("bluebird"), t.identifier("coroutine"))
+    t.memberExpression(file.addImport("bluebird"), t.identifier("coroutine")),
+    scope
   );
 };

lib/6to5/transformation/transformers/other/react.js

@@ -6,10 +6,9 @@
 // jsx
 
 var esutils = require("esutils");
-var t       = require("../../types");
-var _       = require("lodash");
+var t       = require("../../../types");
 
-exports.XJSIdentifier = function (node) {
+exports.JSXIdentifier = function (node) {
   if (esutils.keyword.isIdentifierName(node.name)) {
     node.type = "Identifier";
   } else {
@@ -17,33 +16,33 @@ exports.XJSIdentifier = function (node) {
   }
 };
 
-exports.XJSNamespacedName = function (node, parent, scope, context, file) {
+exports.JSXNamespacedName = function (node, parent, scope, context, file) {
   throw file.errorWithNode(node, "Namespace tags are not supported. ReactJSX is not XML.");
 };
 
-exports.XJSMemberExpression = {
+exports.JSXMemberExpression = {
   exit: function (node) {
     node.computed = t.isLiteral(node.property);
     node.type = "MemberExpression";
   }
 };
 
-exports.XJSExpressionContainer = function (node) {
+exports.JSXExpressionContainer = function (node) {
   return node.expression;
 };
 
-exports.XJSAttribute = {
+exports.JSXAttribute = {
   exit: function (node) {
     var value = node.value || t.literal(true);
     return t.inherits(t.property("init", node.name, value), node);
   }
 };
 
-var isCompatTag = function(tagName) {
+var isCompatTag = function (tagName) {
   return /^[a-z]|\-/.test(tagName);
 };
 
-exports.XJSOpeningElement = {
+exports.JSXOpeningElement = {
   exit: function (node, parent, scope, context, file) {
     var reactCompat = file.opts.reactCompat;
     var tagExpr = node.name;
@@ -66,7 +65,7 @@ exports.XJSOpeningElement = {
 
     var attribs = node.attributes;
     if (attribs.length) {
-      attribs = buildXJSOpeningElementAttributes(attribs);
+      attribs = buildJSXOpeningElementAttributes(attribs, file);
     } else {
       attribs = t.literal(null);
     }
@@ -99,7 +98,7 @@ exports.XJSOpeningElement = {
  * all prior attributes to an array for later processing.
  */
 
-var buildXJSOpeningElementAttributes = function (attribs) {
+var buildJSXOpeningElementAttributes = function (attribs, file) {
   var _props = [];
   var objs = [];
 
@@ -112,7 +111,7 @@ var buildXJSOpeningElementAttributes = function (attribs) {
 
   while (attribs.length) {
     var prop = attribs.shift();
-    if (t.isXJSSpreadAttribute(prop)) {
+    if (t.isJSXSpreadAttribute(prop)) {
       pushProps();
       objs.push(prop.argument);
     } else {
@@ -133,7 +132,7 @@ var buildXJSOpeningElementAttributes = function (attribs) {
 
     // spread it
     attribs = t.callExpression(
-      t.memberExpression(t.identifier("React"), t.identifier("__spread")),
+      file.addHelper("extends"),
       objs
     );
   }
@@ -141,17 +140,17 @@ var buildXJSOpeningElementAttributes = function (attribs) {
   return attribs;
 };
 
-exports.XJSElement = {
+exports.JSXElement = {
   exit: function (node) {
     var callExpr = node.openingElement;
 
     for (var i = 0; i < node.children.length; i++) {
       var child = node.children[i];
 
-      if (t.isLiteral(child) && _.isString(child.value)) {
-        cleanXJSElementLiteralChild(child, callExpr.arguments);
+      if (t.isLiteral(child) && typeof child.value === "string") {
+        cleanJSXElementLiteralChild(child, callExpr.arguments);
         continue;
-      } else if (t.isXJSEmptyExpression(child)) {
+      } else if (t.isJSXEmptyExpression(child)) {
         continue;
       }
 
@@ -166,7 +165,7 @@ exports.XJSElement = {
   }
 };
 
-var cleanXJSElementLiteralChild = function (child, args) {
+var cleanJSXElementLiteralChild = function (child, args) {
   var lines = child.value.split(/\r\n|\n|\r/);
 
   for (var i = 0; i < lines.length; i++) {