v2.4.10

add code of conduct

.jshintignore

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

.npmignore

@@ -1,7 +1,7 @@
 node_modules
 *.log
 *.cache
-lib/6to5/templates
+lib/6to5/transformation/templates
 test
 benchmark
 Makefile

CHANGELOG.md

@@ -2,6 +2,109 @@
 
 Gaps between patch versions are faulty/broken releases.
 
+## 2.4.10
+
+ * Upgrade `acorn-6to5`.
+
+## 2.4.9
+
+ * Upgrade `acorn-6to5`.
+ * Add optional `protoToAssign` transformer.
+ * Fix missing properties from computed property keys.
+ * Make ES7 comprehensions `let` variables.
+
+## 2.4.8
+
+ * Make `require("6to5/register")` work with browserify - [#370](https://github.com/6to5/6to5/pull/370). Thanks [@hughsk](https://github.com/hughsk)!
+
+## 2.4.7
+
+ * Upgrade `acorn-6to5`.
+
+## 2.4.6
+
+ * Move `coreAliasing` and `undefinedToVoid` transformers down to catch `moduleFormatter` transforms.
+
+## 2.4.5
+
+ * Avoid printing comments if they've already been output.
+
+## 2.4.4
+
+ * Add `module` type to browser build `<script>` handler.
+ * Fix some `MemberExpression` modifying incorrectly setting `property` to a `MemberExpression`.
+
+## 2.4.3
+
+ * Upgrade `acorn-6to5`.
+ * Add support for `FunctionDeclaration`s in `bluebirdCoroutines` and `asyncToGenerators` transformers.
+
+## 2.4.2
+
+ * Upgrade `acorn-6to5`.
+ * Better uids generated for various transformers based on parent node.
+ * Alias flat references in `coreAliasing` transformer.
+
+## 2.4.1
+
+ * Better whitespace handling of parenthesized expressions due to trailing comments.
+ * Fix `yield` inside of comprehensions.
+
+## 2.4.0
+
+ * Use a closure always for classes with a super.
+ * Always use native loops for array comprehensions.
+ * Allow `yield` inside of comprehensions.
+ * Add optional `bluebirdCoroutine` transformer.
+ * Add optional `asyncToGenerator` transformer.
+ * Move `useStrict` transformer to before `_moduleFormatter` causing `"use strict";` to always be placed the very top.
+
+## 2.3.2
+
+ * Add parens on expressions with trailing comments.
+
+## 2.3.1
+
+ * Add `undefinedToVoid` optional transformer.
+ * Use `Object.defineProperty` for computed properties.
+
+## 2.3.0
+
+ * Upgrade `acorn-6to5`.
+ * Support circular references and hoist variable declarations in `system` module formatter.
+ * Add optional transformers, including a new `coreAliasing` transformer that aliases native ES6 static properties to their `core-js` equivalent.
+
+## 2.2.0
+
+ * Make `system` module formatter modules anonymous by default.
+ * Fix duplicate comments being output, breaking code.
+
+## 2.1.0
+
+ * Add `cache` option to register hook.
+ * Update `core-js`.
+ * Fix starting newline not being added on case statements.
+ * Fix destructuring `VariableDeclaration`s not inside `BlockStatement`s and `Program`.
+
+## 2.0.4
+
+ * Avoid being greedy when destructuring array iterables.
+
+## 2.0.3
+
+ * Hoist function declarations in system module formatter for circular references.
+ * Hoist default function declarations in umd and amd module formatters for circular references.
+
+## 2.0.2
+
+ * Inherit comments in `for-of` transformer.
+ * Remove `interopRequire` from `system` module formatter.
+
+## 2.0.1
+
+ * Remap `UpdateExpression` module export binding.
+ * Fix automatic closure on `PrivateDeclaration` in classes.
+
 ## 2.0.0
 
  * Make string literal generation only escapes unicode that it has to.

CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

CONTRIBUTING.md

@@ -1,5 +1,7 @@
 # Contributing
 
+Before contributing, please read the [code of conduct](https://github.com/6to5/6to5/blob/master/CODE_OF_CONDUCT.md).
+
  * **General**
    * No ES6 syntax features or methods, exclusively ES5.
    * Max of five arguments for functions

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2014 Sebastian McKenzie
+Copyright (c) 2014-2015 Sebastian McKenzie
 
 MIT License
 

Makefile

@@ -21,8 +21,7 @@ lint:
 test-clean:
 	rm -rf test/tmp
 
-test:
-	make lint
+test: lint
 	$(MOCHA_CMD)
 	make test-clean
 
@@ -33,8 +32,7 @@ test-cov:
 test-spec:
 	node $(ISTANBUL_CMD) $(MOCHA_CMD) -- --reporter spec
 
-test-travis:
-	make test-spec
+test-travis: test-spec
 	if test -n "$$CODECLIMATE_REPO_TOKEN"; then codeclimate < coverage/lcov.info; fi
 
 test-browser:

README.md

@@ -11,10 +11,6 @@
     <img alt="Travis Status" src="http://img.shields.io/travis/6to5/6to5/master.svg?style=flat&amp;label=travis">
   </a>
 
-  <a href="https://ci.appveyor.com/project/sebmck/6to5">
-    <img alt="Appveyor Status" src="http://img.shields.io/appveyor/ci/sebmck/6to5.svg?style=flat&amp;label=appveyor">
-  </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>

bin/6to5-runtime

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

bin/6to5/index.js

@@ -17,18 +17,28 @@ commander.option("-p, --playground", "Enable playground support");
 commander.option("-m, --modules [modules]", "Module formatter type to use [common]", "common");
 commander.option("-w, --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("-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("-a, --amd-module-ids", "Insert module id in AMD modules", false);
+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.on("--help", function(){
   var outKeys = function (title, obj) {
     console.log("  " + title + ":");
     console.log();
 
+    var hasOptional = true;
+
     _.each(_.keys(obj).sort(), function (key) {
       if (key[0] === "_") return;
+
+      if (obj[key].optional) {
+        hasOptional = true;
+        key = "[" + key + "]";
+      }
+
       console.log("    - " + key);
     });
 
@@ -89,12 +99,13 @@ if (errors.length) {
 
 exports.opts = {
   sourceMapName: commander.outFile,
-  amdModuleIds:  commander.amdModuleIds,
   experimental:  commander.experimental,
   playground:    commander.playground,
+  moduleIds:     commander.amdModuleIds || 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

doc/caveats.md

@@ -9,12 +9,15 @@ You may alternatively selectively include what you need:
 | Feature                     | Requirements                                                                                                           |
 | --------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
 | Abstract References         | [experimental](experimental.md), `Symbol`                                                                              |
-| Array destructuring         | `Array.isArray`, `Array.from`                                                                                          |
+| Array destructuring         | `Array.from`                                                                                                           |
 | Async functions, Generators | [experimental](experimental.md), [regenerator runtime](https://github.com/facebook/regenerator/blob/master/runtime.js) |
-| Comprehensions              | [experimental](experimental.md), `Array.isArray`, `Array.from`                                                         |
+| Comprehensions              | [experimental](experimental.md), `Array.from`                                                                          |
 | For Of                      | `Symbol`, `prototype[Symbol.iterator]`                                                                                 |
+| Modules                     | `Object.assign`*                                                                                                       |
 | Object spread/rest          | [experimental](experimental.md), `Object.assign`                                                                       |
-| Spread                      | `Array.isArray`, `Array.from`                                                                                          |
+| Spread                      | `Array.from`                                                                                                           |
+
+*Only required for exporting a non-function `default` with additional `export`s.
 
 ## ES5
 
@@ -26,13 +29,13 @@ ES5 such as lower versions of IE then using the
 
 ## Internet Explorer
 
-### Classes (9 and below)
+### Classes (10 and below)
 
 If you're inheriting from a class then static properties are inherited from it
 via [\_\_proto\_\_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/proto),
 this is widely supported but you may run into problems with much older browsers.
 
-**NOTE:** `__proto__` is not supported on IE <= 9 so static properties
+**NOTE:** `__proto__` is not supported in IE <= 10 so static properties
 **will not** be inherited. A possible workaround is to use `super();`:
 
 ```javascript
@@ -56,4 +59,4 @@ unfortunate as it's required to set getters and setters. Due to this if
 you plan on supporting IE8 or below then the user of getters and setters
 isn't recommended.
 
-Reference: [MDN](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty#Internet_Explorer_8_specific_notes).
+**Reference**: [MDN](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty#Internet_Explorer_8_specific_notes).

doc/differences.md

@@ -49,13 +49,12 @@ var seattlers = (function() {
 }());
 ```
 
-As you can tell, it's not very pretty, unreadable even. Instead of mapping
-directly to a runtime, like other transpilers, 6to5 maps directly to the
-equivalent ES5.
+As you can tell, it's not very pretty. Instead of mapping directly to a
+runtime, like other transpilers, 6to5 maps directly to the equivalent ES5.
 
 Sometimes there are little inline functions that 6to5 needs. These are
 placed at the top of your file much like coffee-script does. If these
-are bother you then you can use the [optional runtime](optional-runtime.md).
+bother you then you can use the [optional runtime](optional-runtime.md).
 We promise that these inline functions will never be significant and will
 always be used as little as possible.
 

doc/index.md

@@ -52,7 +52,7 @@ And it doesn't end here! To see all the ways you can use 6to5, check out the
  - [Let scoping](features.md#let-scoping)
  - [Modules](features.md#modules)
  - [Numeric literals](features.md#numeric-literals)
- - [Object Rest/Spread](features.md#object-rest-spread) ([experimental](experimental.md))
+ - [Object rest/spread](features.md#object-rest-spread) ([experimental](experimental.md))
  - [Property method assignment](features.md#property-method-assignment)
  - [Property name shorthand](features.md#property-name-shorthand)
  - [React/JSX](react.md)

doc/playground.md

@@ -18,11 +18,19 @@ to5.transform("code", { playground: true });
 
  * [Memoization operator](#memoization-operator)
  * [Method binding](#method-binding)
+ * [Method binding function shorthand](#method-binding-function-shorthand)
  * [Object getter memoization](#object-getter-memoization)
  * [This shorthand](#this-shorthand)
 
 ### Memoization assignment operator
 
+The memoization assignment operator allows you to lazily set an object property.
+It checks whether there's a property defined on the object and if there isn't then
+the right hand value is set.
+
+This means that `obj.x` in the following `var x = { x: undefined }; obj.x ?= 2;`
+will still be `undefined` because it's already been defined on the object.
+
 ```javascript
 var obj = {};
 obj.x ?= 2;
@@ -42,7 +50,7 @@ var obj = {};
 obj.x ?= 2;
 ```
 
-equivalent to:
+equivalent to
 
 ```javascript
 var obj = {};
@@ -54,17 +62,25 @@ if (!Object.prototype.hasOwnProperty.call(obj, "x")) obj.x = 2;
 ```javascript
 var fn = obj#method;
 var fn = obj#method("foob");
-
-["foo", "bar"].map(#toUpperCase); // ["FOO", "BAR"]
-[1.1234, 23.53245, 3].map(#toFixed(2)); // ["1.12", "23.53", "3.00"]
 ```
 
-equivalent to:
+equivalent to
 
 ```javascript
 var fn = obj.method.bind(obj);
 var fn = obj.method.bind(obj, "foob");
+```
 
+### Method binding function shorthand
+
+```javascript
+["foo", "bar"].map(#toUpperCase); // ["FOO", "BAR"]
+[1.1234, 23.53245, 3].map(#toFixed(2)); // ["1.12", "23.53", "3.00"]
+```
+
+equivalent to
+
+```javascript
 ["foo", "bar"].map(function (val) { return val.toUpperCase(); });
 [1.1234, 23.53245, 3].map(function (val) { return val.toFixed(2); });
 ```
@@ -90,23 +106,27 @@ equivalent to
 ```javascript
 var foo = {
   get bar() {
-    if (this._barRan) return this._bar;
-    this._barRan = true;
-    return this._bar = complex();
+    return Object.defineProperty(this, "bar", {
+      value: complex(),
+      enumerable: true,
+      configurable: true,
+      writable: true
+    }).bar;
   }
 };
 
 class Foo {
   get bar() {
-    if (this._barRan) return this._bar;
-    this._barRan = true;
-    return this._bar = complex();
+    return Object.defineProperty(this, "bar", {
+      value: complex(),
+      enumerable: true,
+      configurable: true,
+      writable: true
+    }).bar;
   }
 }
 ```
 
-**NOTE:** Memoised functions will return the result of the **first** execution, regardless of arguments.
-
 ### This shorthand
 
 ```javascript

doc/usage.md

@@ -152,10 +152,10 @@ result.ast;
   // Default: `sourceRoot` option.
   moduleRoot: "my-app",
 
-  // If truthy, insert an explicit id for each defined AMD module.
-  // By default, AMD modules are anonymous.
+  // If truthy, insert an explicit id for each defined AMD/System module.
+  // By default, AMD/System modules are anonymous.
   // Default: false
-  amdModuleIds: true,
+  moduleIds: true,
 
   // Optionally replace all 6to5 helper declarations with a referenece to this
   // variable. If set to `true` then the default namespace is used "to5Runtime".
@@ -250,6 +250,10 @@ require("6to5/register")({
 
   // This will remove the currently hooked extensions of .es6 and .js so you'll
   // have to add them back if you want them to be used again.
-  extensions: [".js", ".es6"]
+  extensions: [".js", ".es6"],
+
+  // Enables `roadrunner` cache that will save to a `.roadrunner.json` file in your cwd
+  // Do not check this into git as it's user-specific
+  cache: true
 });
 ```

lib/6to5/browser.js

@@ -34,7 +34,7 @@ transform.load = function (url, callback, opts, hold) {
 
 var runScripts = function () {
   var scripts = [];
-  var types   = ["text/ecmascript-6", "text/6to5"];
+  var types   = ["text/ecmascript-6", "text/6to5", "module"];
   var index   = 0;
 
   var exec = function () {
@@ -60,8 +60,9 @@ var runScripts = function () {
     }
   };
 
-  var _scripts = global.document.getElementsByTagName("script");
-  for (var i in _scripts) {
+  var _scripts = global.document .getElementsByTagName("script");
+
+  for (var i = 0; i < _scripts.length; ++i) {
     var _script = _scripts[i];
     if (types.indexOf(_script.type) >= 0) scripts.push(_script);
   }

lib/6to5/file.js

@@ -10,21 +10,31 @@ var t         = require("./types");
 var _         = require("lodash");
 
 function File(opts) {
-  this.opts = File.normaliseOptions(opts);
-  this.uids = {};
-  this.ast  = {};
+  this.dynamicImports = [];
+  this.opts           = File.normaliseOptions(opts);
+  this.transformers   = this.getTransformers();
+  this.uids           = {};
+  this.ast            = {};
 }
 
-File.declarations = [
+File.helpers = [
   "inherits",
+  "defaults",
   "prototype-properties",
   "apply-constructor",
   "tagged-template-literal",
   "interop-require",
   "to-array",
+  "sliced-to-array",
   "object-without-properties",
   "has-own",
-  "slice"
+  "slice",
+  "define-property",
+  "async-to-generator"
+];
+
+File.excludeHelpersFromRuntime = [
+  "async-to-generator"
 ];
 
 File.normaliseOptions = function (opts) {
@@ -34,9 +44,11 @@ File.normaliseOptions = function (opts) {
     experimental: false,
     playground:   false,
     whitespace:   true,
+    moduleIds:    opts.amdModuleIds || false,
     blacklist:    [],
     whitelist:    [],
     sourceMap:    false,
+    optional:     [],
     comments:     true,
     filename:     "unknown",
     modules:      "common",
@@ -78,17 +90,46 @@ File.normaliseOptions = function (opts) {
 
   transform._ensureTransformerNames("blacklist", opts.blacklist);
   transform._ensureTransformerNames("whitelist", opts.whitelist);
+  transform._ensureTransformerNames("optional", opts.optional);
 
   return opts;
 };
 
-File.prototype.toArray = function (node) {
+File.prototype.getTransformers = function () {
+  var file = this;
+  var transformers = [];
+  var secondPassTransformers = [];
+
+  _.each(transform.transformers, function (transformer) {
+    if (transformer.canRun(file)) {
+      transformers.push(transformer);
+
+      if (transformer.secondPass) {
+        secondPassTransformers.push(transformer);
+      }
+
+      if (transformer.manipulateOptions) {
+        transformer.manipulateOptions(file.opts, file);
+      }
+    }
+  });
+
+  return transformers.concat(secondPassTransformers);
+};
+
+File.prototype.toArray = function (node, i) {
   if (t.isArrayExpression(node)) {
     return node;
   } else if (t.isIdentifier(node) && node.name === "arguments") {
-    return t.callExpression(t.memberExpression(this.addDeclaration("slice"), t.identifier("call")), [node]);
+    return t.callExpression(t.memberExpression(this.addHelper("slice"), t.identifier("call")), [node]);
   } else {
-    return t.callExpression(this.addDeclaration("to-array"), [node]);
+    var declarationName = "to-array";
+    var args = [node];
+    if (i) {
+      args.push(t.literal(i));
+      declarationName = "sliced-to-array";
+    }
+    return t.callExpression(this.addHelper(declarationName), args);
   }
 };
 
@@ -119,8 +160,15 @@ File.prototype.parseShebang = function (code) {
   return code;
 };
 
-File.prototype.addDeclaration = function (name) {
-  if (!_.contains(File.declarations, name)) {
+File.prototype.addImport = function (id, source) {
+  var specifiers = [t.importSpecifier(t.identifier("default"), id)];
+  var declar = t.importDeclaration(specifiers, t.literal(source));
+  declar._blockHoist = 3;
+  this.dynamicImports.push(declar);
+};
+
+File.prototype.addHelper = function (name) {
+  if (!_.contains(File.helpers, name)) {
     throw new ReferenceError("unknown declaration " + name);
   }
 
@@ -131,7 +179,7 @@ File.prototype.addDeclaration = function (name) {
 
   var ref;
   var runtimeNamespace = this.opts.runtime;
-  if (runtimeNamespace) {
+  if (runtimeNamespace && !_.contains(File.excludeHelpersFromRuntime, name)) {
     name = t.identifier(t.toIdentifier(name));
     return t.memberExpression(t.identifier(runtimeNamespace), name);
   } else {
@@ -174,15 +222,25 @@ File.prototype.parse = function (code) {
 };
 
 File.prototype.transform = function (ast) {
+  var self = this;
+
   this.ast = ast;
   this.scope = new Scope(ast.program);
   this.moduleFormatter = this.getModuleFormatter(this.opts.modules);
 
-  var self = this;
+  var astRun = function (key) {
+    _.each(self.transformers, function (transformer) {
+      transformer.astRun(self, key);
+    });
+  };
 
-  _.each(transform.transformers, function (transformer) {
+  astRun("enter");
+
+  _.each(this.transformers, function (transformer) {
     transformer.transform(self);
   });
+
+  astRun("exit");
 };
 
 File.prototype.generate = function () {

lib/6to5/generation/generator.js

@@ -115,6 +115,7 @@ CodeGenerator.prototype.print = function (node, parent, opts) {
   if (!node) return "";
 
   var self = this;
+
   opts = opts || {};
 
   var newline = function (leading) {
@@ -147,6 +148,12 @@ CodeGenerator.prototype.print = function (node, parent, opts) {
   };
 
   if (this[node.type]) {
+    var needsCommentParens = t.isExpression(node) && node.leadingComments && node.leadingComments.length;
+    var needsParens        = needsCommentParens || n.needsParens(node, parent);
+
+    if (needsParens) this.push("(");
+    if (needsCommentParens) this.indent();
+
     this.printLeadingComments(node, parent);
 
     newline(true);
@@ -154,13 +161,12 @@ CodeGenerator.prototype.print = function (node, parent, opts) {
     if (opts.before) opts.before();
     this.map.mark(node, "start");
 
-    // only compute if this node needs parens if our parent has been changed
-    // since acorn would've wrapped us in a ParanthesizedExpression
-    var needsParens = n.needsParens(node, parent);
-    if (needsParens) this.push("(");
-
     this[node.type](node, this.buildPrint(node), parent);
 
+    if (needsCommentParens) {
+      this.newline();
+      this.dedent();
+    }
     if (needsParens) this.push(")");
 
     this.map.mark(node, "end");
@@ -170,7 +176,7 @@ CodeGenerator.prototype.print = function (node, parent, opts) {
 
     this.printTrailingComments(node, parent);
   } else {
-    throw new ReferenceError("unknown node " + node.type);
+    throw new ReferenceError("unknown node of type " + JSON.stringify(node.type) + " with constructor " + JSON.stringify(node && node.constructor.name));
   }
 };
 
@@ -268,14 +274,21 @@ CodeGenerator.prototype._printComments = function (comments) {
   var self = this;
 
   _.each(comments, function (comment) {
+    var skip = false;
+
     // find the original comment in the ast and set it as displayed
     _.each(self.ast.comments, function (origComment) {
       if (origComment.start === comment.start) {
+        // comment has already been output
+        if (origComment._displayed) skip = true;
+
         origComment._displayed = true;
         return false;
       }
     });
 
+    if (skip) return;
+
     // whitespace before
     self.newline(self.whitespace.getNewlinesBefore(comment));
 

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

@@ -98,6 +98,10 @@ exports.MemberExpression = function (node, print) {
   var obj = node.object;
   print(obj);
 
+  if (!node.computed && t.isMemberExpression(node.property)) {
+    throw new TypeError("Got a MemberExpression for MemberExpression property");
+  }
+
   if (node.computed) {
     this.push("[");
     print(node.property);

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

@@ -146,7 +146,7 @@ exports.SwitchCase = function (node, print) {
     this.push("default:");
   }
 
-  this.space();
+  this.newline();
   print.sequence(node.consequent, { indent: true });
 };
 

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

@@ -55,6 +55,8 @@ _.each({
   Function: 1,
   Class: 1,
   For: 1,
+  ArrayExpression: { after: 1 },
+  ObjectExpression: { after: 1 },
   SwitchStatement: 1,
   IfStatement: { before: 1 },
   CallExpression: { after: 1 },

lib/6to5/index.js

@@ -3,11 +3,9 @@ var util      = require("./util");
 var fs        = require("fs");
 var _         = require("lodash");
 
-exports.Transformer = require("./transformation/transformer");
-
 exports.types = require("./types");
 
-exports.runtime = require("./runtime");
+exports.runtime = require("./runtime-generator");
 
 exports.register = function (opts) {
   var register = require("./register");

lib/6to5/register-browser.js

@@ -0,0 +1,4 @@
+// Required to safely use 6to5/register within a browserify codebase.
+module.exports = function () {};
+
+require("./polyfill");

lib/6to5/register.js

@@ -1,6 +1,7 @@
 require("./polyfill");
 
 var sourceMapSupport = require("source-map-support");
+var roadrunner       = require("roadrunner");
 var util             = require("./util");
 var to5              = require("./index");
 var fs               = require("fs");
@@ -38,15 +39,22 @@ var blacklistTest = function (transformer, code) {
 };
 
 blacklistTest("arrayComprehension", "var foo = [for (foo of bar) foo * foo];");
-//blacklistTest("generatorComprehension", "");
+blacklistTest("generatorComprehension", "var foo = (for (foo of bar) foo * foo)");
 blacklistTest("arrowFunctions", "var foo = x => x * x;");
 blacklistTest("classes", "class Foo {}");
 blacklistTest("computedPropertyNames", "var foo = { [foo]: bar };");
-//blacklistTest("constants", "const foo = 0;");
+blacklistTest("constants", function () {
+  try {
+    new Function("const foo = 'foo';\nfoo = 'wow';");
+  } catch (err) {
+    return; // constants are supported
+  }
+  throw new SyntaxError;
+});
 blacklistTest("defaultParamaters", "var foo = function (bar = 0) {};");
 blacklistTest("destructuring", "var { x, y } = { x: 0, y: 0 };");
 blacklistTest("forOf", "for (var foo of bar) {}");
-blacklistTest("generators", "function* foo() {}");
+blacklistTest("generators", "function* foo() {}\nasync function bar() {}"); // generators/async functions delegated to same transformer
 blacklistTest("letScoping", "let foo = 0;");
 blacklistTest("modules", 'import foo from "from";');
 blacklistTest("propertyMethodAssignment", "{ get foo() {} }");
@@ -130,6 +138,11 @@ module.exports = function (opts) {
 
   if (opts.cache) cache = opts.cache;
   if (opts.cache === false) cache = null;
+  if (opts.cache === true) {
+    roadrunner.load();
+    roadrunner.setup();
+    cache = roadrunner.get("6to5");
+  }
 
   _.extend(transformOpts, opts);
 };

lib/6to5/runtime-generator.js

@@ -18,7 +18,11 @@ module.exports = function (namespace) {
     )
   ]));
 
-  _.each(File.declarations, function (name) {
+  _.each(File.helpers, function (name) {
+    if (_.contains(File.excludeHelpersFromRuntime, name)) {
+      return false;
+    }
+
     var key = t.identifier(t.toIdentifier(name));
     body.push(t.expressionStatement(
       t.assignmentExpression("=", t.memberExpression(namespace, key), util.template(name))

lib/6to5/templates/array-expression-comprehension-filter.js

@@ -1,5 +0,0 @@
-ARRAY.filter(function (KEY) {
-  return FILTER;
-}).map(function (KEY) {
-  return STATEMENT;
-});

lib/6to5/templates/array-expression-comprehension-map.js

@@ -1,3 +0,0 @@
-ARRAY.map(function (KEY) {
-  return STATEMENT;
-});

lib/6to5/templates/function-return-obj.js

@@ -1,3 +0,0 @@
-(function (KEY) {
-  return KEY;
-})(OBJECT)

lib/6to5/templates/object-define-properties-closure.js

@@ -1,4 +0,0 @@
-(function (KEY) {
-  CONTENT;
-  return KEY;
-})(OBJECT);

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

@@ -44,16 +44,42 @@ DefaultFormatter.prototype.remapAssignments = function () {
   var self = this;
 
   var isLocalReference = function (node, scope) {
-    var left = node.left;
-    var name = left.name;
-    return t.isIdentifier(left) && localExports[name] && localExports[name] === scope.get(name, true);
+    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) {
-      if (t.isExportDeclaration(node)) return false;
+      if (t.isUpdateExpression(node) && isLocalReference(node.argument, scope)) {
+        this.skip();
 
-      if (t.isAssignmentExpression(node) && isLocalReference(node, scope)) {
+        // 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)) {
+        this.skip();
         return self.remapExportAssignment(node);
       }
     }
@@ -98,9 +124,9 @@ DefaultFormatter.prototype._pushStatement = function (ref, nodes) {
   return ref;
 };
 
-DefaultFormatter.prototype._hoistExport = function (declar, assign) {
+DefaultFormatter.prototype._hoistExport = function (declar, assign, priority) {
   if (t.isFunctionDeclaration(declar)) {
-    assign._blockHoist = true;
+    assign._blockHoist = priority || 2;
   }
 
   return assign;
@@ -113,17 +139,18 @@ DefaultFormatter.prototype._exportSpecifier = function (getRef, specifier, node,
   if (node.source) {
     if (t.isExportBatchSpecifier(specifier)) {
       // export * from "foo";
-      nodes.push(this._exportsWildcard(getRef()));
+      nodes.push(this._exportsWildcard(getRef(), node));
     } else {
       // export { foo } from "test";
       nodes.push(this._exportsAssign(
         t.getSpecifierName(specifier),
-        t.memberExpression(getRef(), specifier.id)
+        t.memberExpression(getRef(), specifier.id),
+        node
       ));
     }
   } else {
     // export { foo };
-    nodes.push(this._exportsAssign(t.getSpecifierName(specifier), specifier.id));
+    nodes.push(this._exportsAssign(t.getSpecifierName(specifier), specifier.id, node));
   }
 };
 
@@ -143,30 +170,36 @@ DefaultFormatter.prototype._exportsAssign = function (id, init) {
 DefaultFormatter.prototype.exportDeclaration = function (node, nodes) {
   var declar = node.declaration;
 
+  var id = declar.id;
+
   if (node.default) {
-    nodes.push(
-      this._exportsAssign(t.identifier("default"), this._pushStatement(declar, nodes))
-    );
-  } else {
-    var assign;
+    id = t.identifier("default");
+  }
 
-    if (t.isVariableDeclaration(declar)) {
-      for (var i in declar.declarations) {
-        var decl = declar.declarations[i];
+  var assign;
 
-        decl.init = this._exportsAssign(decl.id, decl.init).expression;
+  if (t.isVariableDeclaration(declar)) {
+    for (var i in declar.declarations) {
+      var decl = declar.declarations[i];
 
-        var newDeclar = t.variableDeclaration(declar.kind, [decl]);
-        if (i === "0") t.inherits(newDeclar, declar);
-        nodes.push(newDeclar);
-      }
-    } else {
-      assign = this._exportsAssign(declar.id, declar.id);
+      decl.init = this._exportsAssign(decl.id, decl.init, node).expression;
 
-      nodes.push(t.toStatement(declar));
-      nodes.push(assign);
-
-      this._hoistExport(declar, assign);
+      var newDeclar = t.variableDeclaration(declar.kind, [decl]);
+      if (i === "0") t.inherits(newDeclar, declar);
+      nodes.push(newDeclar);
     }
+  } else {
+    var ref = declar;
+
+    if (t.isFunctionDeclaration(declar) || t.isClassDeclaration(declar)) {
+      ref = declar.id;
+      nodes.push(declar);
+    }
+
+    assign = this._exportsAssign(id, ref, node);
+
+    nodes.push(assign);
+
+    this._hoistExport(declar, assign);
   }
 };

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

@@ -5,8 +5,8 @@ var util             = require("../../util");
 var t                = require("../../types");
 var _                = require("lodash");
 
-function AMDFormatter(file) {
-  this.file = file;
+function AMDFormatter() {
+  DefaultFormatter.apply(this, arguments);
   this.ids  = {};
 }
 
@@ -55,7 +55,7 @@ AMDFormatter.prototype.transform = function (ast) {
  */
 
 AMDFormatter.prototype.getModuleName = function () {
-  if (this.file.opts.amdModuleIds) {
+  if (this.file.opts.moduleIds) {
     return DefaultFormatter.prototype.getModuleName.apply(this, arguments);
   } else {
     return null;
@@ -83,9 +83,9 @@ AMDFormatter.prototype.importSpecifier = function (specifier, node, nodes) {
 
   if (t.isImportBatchSpecifier(specifier)) {
     // import * as bar from "foo";
-  } else if (t.isSpecifierDefault(specifier)) {
+  } else if (t.isSpecifierDefault(specifier) && !this.noInteropRequire) {
     // import foo from "foo";
-    ref = t.callExpression(this.file.addDeclaration("interop-require"), [ref]);
+    ref = t.callExpression(this.file.addHelper("interop-require"), [ref]);
   } else {
     // import {foo} from "foo";
     ref = t.memberExpression(ref, specifier.id, false);

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

@@ -26,7 +26,7 @@ CommonJSFormatter.prototype.importSpecifier = function (specifier, node, nodes)
   if (t.isSpecifierDefault(specifier)) {
     nodes.push(t.variableDeclaration("var", [
       t.variableDeclarator(variableName,
-        t.callExpression(this.file.addDeclaration("interop-require"), [util.template("require", {
+        t.callExpression(this.file.addHelper("interop-require"), [util.template("require", {
           MODULE_NAME: node.source
         })])
       )
@@ -57,6 +57,7 @@ CommonJSFormatter.prototype.importDeclaration = function (node, nodes) {
 CommonJSFormatter.prototype.exportDeclaration = function (node, nodes) {
   if (node.default) {
     var declar = node.declaration;
+    var assign;
 
     // module.exports = VALUE;
     var templateName = "exports-default-module";
@@ -64,15 +65,29 @@ CommonJSFormatter.prototype.exportDeclaration = function (node, nodes) {
     // exports = module.exports = VALUE;
     if (this.hasNonDefaultExports) templateName = "exports-default-module-override";
 
-    var assign = util.template(templateName, {
-      VALUE: this._pushStatement(declar, nodes)
-    }, true);
+    if (t.isFunction(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));
-  } else {
-    DefaultFormatter.prototype.exportDeclaration.apply(this, arguments);
+      // 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 = Object.assign(exports["default"], exports)
+      //
+
+      assign = util.template("common-export-default-assign", true);
+      assign._blockHoist = 0;
+
+      nodes.push(assign);
+    }
   }
+
+  DefaultFormatter.prototype.exportDeclaration.apply(this, arguments);
 };
 
 CommonJSFormatter.prototype.exportSpecifier = function (specifier, node, nodes) {

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

@@ -1,24 +1,27 @@
 module.exports = SystemFormatter;
 
-var DefaultFormatter = require("./_default");
-var AMDFormatter     = require("./amd");
-var util             = require("../../util");
-var t                = require("../../types");
-var _                = require("lodash");
+var AMDFormatter = require("./amd");
+var traverse     = require("../../traverse");
+var util         = require("../../util");
+var t            = require("../../types");
+var _            = require("lodash");
 
 function SystemFormatter(file) {
-  AMDFormatter.apply(this, arguments);
-
-  this.moduleNameLiteral = t.literal(this.getModuleName());
   this.exportIdentifier  = file.generateUidIdentifier("export");
+  this.noInteropRequire = true;
+
+  AMDFormatter.apply(this, arguments);
 }
 
 util.inherits(SystemFormatter, AMDFormatter);
 
-SystemFormatter.prototype.getModuleName = DefaultFormatter.prototype.getModuleName;
+SystemFormatter.prototype._addImportSource = function (node, exportNode) {
+  node._importSource = exportNode.source && exportNode.source.value;
+  return node;
+};
 
-SystemFormatter.prototype._exportsWildcard = function (objectIdentifier) {
-  var leftIdentifier = t.identifier("i");
+SystemFormatter.prototype._exportsWildcard = function (objectIdentifier, node) {
+  var leftIdentifier = this.file.generateUidIdentifier("key");
   var valIdentifier  = t.memberExpression(objectIdentifier, leftIdentifier, true);
 
   var left = t.variableDeclaration("var", [
@@ -31,11 +34,12 @@ SystemFormatter.prototype._exportsWildcard = function (objectIdentifier) {
     this.buildExportCall(leftIdentifier, valIdentifier)
   ]);
 
-  return t.forInStatement(left, right, block);
+  return this._addImportSource(t.forInStatement(left, right, block), node);
 };
 
-SystemFormatter.prototype._exportsAssign = function (id, init) {
-  return this.buildExportCall(t.literal(id.name), init, true);
+SystemFormatter.prototype._exportsAssign = function (id, init, node) {
+  var call = this.buildExportCall(t.literal(id.name), init, true);
+  return this._addImportSource(call, node);
 };
 
 SystemFormatter.prototype.remapExportAssignment = function (node) {
@@ -51,33 +55,120 @@ SystemFormatter.prototype.buildExportCall = function (id, init, isStatement) {
   }
 };
 
-SystemFormatter.prototype.buildRunnerSetters = function () {
-  return t.arrayExpression(_.map(this.ids, function (uid) {
-    var moduleIdentifier = t.identifier("m");
+SystemFormatter.prototype.importSpecifier = function (specifier, node, nodes) {
+  AMDFormatter.prototype.importSpecifier.apply(this, arguments);
+  this._addImportSource(_.last(nodes), node);
+};
 
-    return t.functionExpression(null, [moduleIdentifier], t.blockStatement([
-      t.assignmentExpression("=", uid, moduleIdentifier)
-    ]));
+SystemFormatter.prototype.buildRunnerSetters = function (block, hoistDeclarators) {
+  return t.arrayExpression(_.map(this.ids, function (uid, source) {
+    var nodes = [];
+
+    traverse(block, {
+      enter: function (node) {
+        if (node._importSource === source) {
+          if (t.isVariableDeclaration(node)) {
+            _.each(node.declarations, function (declar) {
+              hoistDeclarators.push(t.variableDeclarator(declar.id));
+              nodes.push(t.expressionStatement(
+                t.assignmentExpression("=", declar.id, declar.init)
+              ));
+            });
+          } else {
+            nodes.push(node);
+          }
+
+          this.remove();
+        }
+      }
+    });
+
+    return t.functionExpression(null, [uid], t.blockStatement(nodes));
   }));
 };
 
 SystemFormatter.prototype.transform = function (ast) {
   var program = ast.program;
 
+  var hoistDeclarators = [];
+  var moduleName = this.getModuleName();
+  var moduleNameLiteral = t.literal(moduleName);
+
+  var block = t.blockStatement(program.body);
+
   var runner = util.template("system", {
-    MODULE_NAME: this.moduleNameLiteral,
+    MODULE_NAME: moduleNameLiteral,
     MODULE_DEPENDENCIES: t.arrayExpression(this.buildDependencyLiterals()),
     EXPORT_IDENTIFIER: this.exportIdentifier,
-    SETTERS: this.buildRunnerSetters(),
-    EXECUTE: t.functionExpression(null, [], t.blockStatement(program.body))
+    SETTERS: this.buildRunnerSetters(block, hoistDeclarators),
+    EXECUTE: t.functionExpression(null, [], block)
   }, true);
 
-  if (!_.isEmpty(this.ids)) {
-    var handlerBody = runner.expression.arguments[2].body.body;
-    handlerBody.unshift(t.variableDeclaration("var", _.map(this.ids, function (uid) {
-      return t.variableDeclarator(uid);
-    })));
+  var handlerBody = runner.expression.arguments[2].body.body;
+  if (!moduleName) runner.expression.arguments.shift();
+
+  var returnStatement = handlerBody.pop();
+
+  // hoist up all variable declarations
+  traverse(block, {
+    enter: function (node, parent, scope) {
+      if (t.isFunction(node)) {
+        // nothing inside is accessible
+        return this.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;
+      }
+    }
+  });
+  if (hoistDeclarators.length) {
+    var hoistDeclar = t.variableDeclaration("var", hoistDeclarators);
+    hoistDeclar._blockHoist = true;
+    handlerBody.unshift(hoistDeclar);
   }
 
+  // hoist up function declarations for circular references
+  traverse(block, {
+    enter: function (node) {
+      if (t.isFunction(node)) this.skip();
+
+      if (t.isFunctionDeclaration(node) || node._blockHoist) {
+        handlerBody.push(node);
+        this.remove();
+      }
+    }
+  });
+
+  handlerBody.push(returnStatement);
+
   program.body = [runner];
 };

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

@@ -0,0 +1,37 @@
+(function (fn) {
+  return function () {
+    var gen = fn.apply(this, arguments);
+
+    return new Promise(function (resolve, reject) {
+      function step(getNext) {
+        var next;
+
+        try {
+          next = getNext();
+        } catch(e) {
+          reject(e);
+          return;
+        }
+
+        if (next.done) {
+          resolve(next.value);
+          return;
+        }
+
+        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();
+      });
+    });
+  }
+})

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

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

lib/6to5/transformation/templates/corejs-iterator.js

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

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

@@ -0,0 +1,8 @@
+(function (obj, defaults) {
+  for (var key in defaults) {
+    if (obj[key] === undefined) {
+      obj[key] = defaults[key];
+    }
+  }
+  return obj;
+})

lib/6to5/transformation/templates/define-property.js

@@ -0,0 +1,8 @@
+(function (obj, key, value) {
+  return Object.defineProperty(obj, key, {
+    value: value,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  });
+});

lib/6to5/transformation/templates/property-method-assignment-wrapper.js

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

lib/6to5/transformation/templates/sliced-to-array.js

@@ -0,0 +1,12 @@
+(function (arr, i) {
+  if (Array.isArray(arr)) {
+    return arr;
+  } else {
+    var _arr = [];
+    for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) {
+      _arr.push(_step.value);
+      if (i && _arr.length === i) break;
+    }
+    return _arr;
+  }
+});

lib/6to5/transformation/transform.js

@@ -49,6 +49,9 @@ _.each({
   memoizationOperator:       require("./transformers/playground-memoization-operator"),
   objectGetterMemoization:   require("./transformers/playground-object-getter-memoization"),
 
+  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"),
@@ -63,7 +66,7 @@ _.each({
   exponentiationOperator:    require("./transformers/es7-exponentiation-operator"),
   spread:                    require("./transformers/es6-spread"),
   templateLiterals:          require("./transformers/es6-template-literals"),
-  propertyMethodAssignment:  require("./transformers/es5-property-method-assignment"),
+  propertyMethodAssignment:  require("./transformers/es6-property-method-assignment"),
   destructuring:             require("./transformers/es6-destructuring"),
   defaultParameters:         require("./transformers/es6-default-parameters"),
   forOf:                     require("./transformers/es6-for-of"),
@@ -78,12 +81,17 @@ _.each({
   generators:                require("./transformers/es6-generators"),
   restParameters:            require("./transformers/es6-rest-parameters"),
 
+  protoToAssign:             require("./transformers/optional-proto-to-assign"),
+
   _declarations:             require("./transformers/_declarations"),
 
   // wrap up
   _aliasFunctions:           require("./transformers/_alias-functions"),
-  useStrict:                 require("./transformers/use-strict"),
   _moduleFormatter:          require("./transformers/_module-formatter"),
+  useStrict:                 require("./transformers/use-strict"),
+
+  coreAliasing:              require("./transformers/optional-core-aliasing"),
+  undefinedToVoid:           require("./transformers/optional-undefined-to-void"),
 
   // spec
   specPropertyLiterals:         require("./transformers/spec-property-literals"),

lib/6to5/transformation/transformer.js

@@ -5,9 +5,13 @@ var t        = require("../types");
 var _        = require("lodash");
 
 function Transformer(key, transformer, opts) {
-  this.transformer = Transformer.normalise(transformer);
-  this.opts        = opts || {};
-  this.key         = key;
+  this.manipulateOptions = transformer.manipulateOptions;
+  this.experimental      = !!transformer.experimental;
+  this.secondPass        = !!transformer.secondPass;
+  this.transformer       = Transformer.normalise(transformer);
+  this.optional          = !!transformer.optional;
+  this.opts              = opts || {};
+  this.key               = key;
 }
 
 Transformer.normalise = function (transformer) {
@@ -16,8 +20,13 @@ Transformer.normalise = function (transformer) {
   }
 
   _.each(transformer, function (fns, type) {
+    // hidden property
     if (type[0] === "_") return;
+
     if (_.isFunction(fns)) fns = { enter: fns };
+
+    if (!_.isObject(fns)) return;
+
     transformer[type] = fns;
 
     var aliases = t.FLIPPED_ALIAS_KEYS[type];
@@ -33,20 +42,14 @@ Transformer.normalise = function (transformer) {
 
 Transformer.prototype.astRun = function (file, key) {
   var transformer = this.transformer;
-  var ast         = file.ast;
 
   if (transformer.ast && transformer.ast[key]) {
-    transformer.ast[key](ast, file);
+    transformer.ast[key](file.ast, file);
   }
 };
 
 Transformer.prototype.transform = function (file) {
-  if (!this.canRun(file)) return;
-
   var transformer = this.transformer;
-  var ast         = file.ast;
-
-  this.astRun(file, "enter");
 
   var build = function (exit) {
     return function (node, parent, scope) {
@@ -61,25 +64,30 @@ Transformer.prototype.transform = function (file) {
     };
   };
 
-  traverse(ast, {
+  this.astRun(file, "before");
+
+  traverse(file.ast, {
     enter: build(),
     exit:  build(true)
   });
 
-  this.astRun(file, "exit");
+  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;
 
-  if (key[0] !== "_") {
-    var whitelist = opts.whitelist;
-    if (whitelist.length && !_.contains(whitelist, 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;
 };

lib/6to5/transformation/transformers/_alias-functions.js

@@ -20,7 +20,7 @@ var go = function (getBody, node, file, scope) {
       if (!node._aliasFunction) {
         if (t.isFunction(node)) {
           // stop traversal of this node as it'll be hit again by this transformer
-          return false;
+          return this.skip();
         } else {
           return;
         }
@@ -30,10 +30,10 @@ var go = function (getBody, node, file, scope) {
       traverse(node, {
         enter: function (node, parent) {
           if (t.isFunction(node) && !node._aliasFunction) {
-            return false;
+            return this.skip();
           }
 
-          if (node._ignoreAliasFunctions) return false;
+          if (node._ignoreAliasFunctions) return this.skip();
 
           var getId;
 
@@ -49,7 +49,7 @@ var go = function (getBody, node, file, scope) {
         }
       });
 
-      return false;
+      return this.skip();
     }
   });
 

lib/6to5/transformation/transformers/_block-hoist.js

@@ -1,17 +1,29 @@
+var _ = require("lodash");
+
+// Priority:
+//
+//  - 0 We want this to be at the **very** bottom
+//  - 1 Default node position
+//  - 2 Priority over normal nodes
+//  - 3 We want this to be at the **very** top
+
 exports.BlockStatement =
 exports.Program = {
   exit: function (node) {
-    var unshift = [];
+    var hasChange = false;
+    for (var i in node.body) {
+      var bodyNode = node.body[i];
+      if (bodyNode && bodyNode._blockHoist != null) hasChange = true;
+    }
+    if (!hasChange) return;
 
-    node.body = node.body.filter(function (bodyNode) {
-      if (bodyNode._blockHoist) {
-        unshift.push(bodyNode);
-        return false;
-      } else {
-        return true;
-      }
+    var nodePriorities = _.groupBy(node.body, function (bodyNode) {
+      var priority = bodyNode._blockHoist;
+      if (priority == null) priority = 1;
+      if (priority === true) priority = 2;
+      return priority;
     });
 
-    node.body = unshift.concat(node.body);
+    node.body = _.flatten(_.values(nodePriorities).reverse());
   }
 };

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

@@ -1,5 +1,7 @@
 var t = require("../../types");
 
+exports.secondPass = true;
+
 exports.BlockStatement =
 exports.Program = function (node) {
   var kinds = {};
@@ -22,4 +24,6 @@ exports.Program = function (node) {
   for (kind in kinds) {
     node.body.unshift(t.variableDeclaration(kind, kinds[kind]));
   }
+
+  node._declarations = null;
 };

lib/6to5/transformation/transformers/es5-property-method-assignment.js

@@ -1,33 +0,0 @@
-var util = require("../../util");
-
-exports.Property = function (node) {
-  if (node.method) node.method = false;
-};
-
-exports.ObjectExpression = function (node, parent, file) {
-  var mutatorMap = {};
-  var hasAny = false;
-
-  node.properties = node.properties.filter(function (prop) {
-    if (prop.kind === "get" || prop.kind === "set") {
-      hasAny = true;
-      util.pushMutatorMap(mutatorMap, prop.key, prop.kind, prop.value);
-      return false;
-    } else {
-      return true;
-    }
-  });
-
-  if (!hasAny) return;
-
-  var objId = util.getUid(parent, file);
-
-  return util.template("object-define-properties-closure", {
-    KEY: objId,
-    OBJECT: node,
-    CONTENT: util.template("object-define-properties", {
-      OBJECT: objId,
-      PROPS:  util.buildDefineProperties(mutatorMap)
-    })
-  });
-};

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

@@ -8,16 +8,24 @@ exports.ClassDeclaration = function (node, parent, file, scope) {
     closure = false;
   }
 
-  var newNode = new Class(node, file, scope, closure).run();
-  if (closure) {
-    // declaration in an expression context...
-    // export default class Foo {}
-    scope.push({
-      kind: "var",
-      key: node.id.key,
-      id: node.id
-    });
-    return t.assignmentExpression("=", node.id, newNode);
+  var factory = new Class(node, file, scope, closure);
+  var newNode = factory.run();
+  if (factory.closure) {
+    if (closure) {
+      // declaration in an expression context...
+      // export default class Foo {}
+      scope.push({
+        kind: "var",
+        key: node.id.key,
+        id: node.id
+      });
+      return t.assignmentExpression("=", node.id, newNode);
+    } else {
+      // has a super class or PrivateDeclaration etc
+      return t.variableDeclaration("let", [
+        t.variableDeclarator(node.id, newNode)
+      ]);
+    }
   } else {
     return newNode;
   }
@@ -77,24 +85,18 @@ Class.prototype.run = function () {
 
   //
 
-  if (superName && t.isDynamic(superName)) {
-    // so we're only evaluating it once
-    var superRefName = "super";
-    if (className) superRefName = className.name + "Super";
+  if (superName) {
+    this.closure = true;
 
-    var superRef = file.generateUidIdentifier(superRefName, this.scope);
+    // so we're only evaluating it once
+    var superRef = this.scope.generateUidBasedOnNode(superName, this.file);
     body.unshift(t.variableDeclaration("var", [
       t.variableDeclarator(superRef, superName)
     ]));
     superName = superRef;
-  }
 
-  this.superName = superName;
-
-  //
-
-  if (superName) {
-    body.push(t.expressionStatement(t.callExpression(file.addDeclaration("inherits"), [className, superName])));
+    this.superName = superName;
+    body.push(t.expressionStatement(t.callExpression(file.addHelper("inherits"), [className, superName])));
   }
 
   this.buildBody();
@@ -145,7 +147,7 @@ Class.prototype.buildBody = function () {
     }
   }
 
-  if (!this.hasConstructor && superName) {
+  if (!this.hasConstructor && superName && !t.isFalsyExpression(superName)) {
     constructor.body.body.push(util.template("class-super-constructor-call", {
       SUPER_NAME: superName
     }, true));
@@ -173,7 +175,7 @@ Class.prototype.buildBody = function () {
     if (instanceProps) args.push(instanceProps);
 
     body.push(t.expressionStatement(
-      t.callExpression(this.file.addDeclaration("prototype-properties"), args)
+      t.callExpression(this.file.addHelper("prototype-properties"), args)
     ));
   }
 };
@@ -274,7 +276,7 @@ Class.prototype.replaceInstanceSuperReferences = function (methodNode) {
         if (callee.object.name !== "super") return;
 
         // super.test(); -> ClassName.prototype.MethodName.call(this);
-        callee.property = t.memberExpression(callee.property, t.identifier("call"));
+        t.appendToMemberExpression(callee, t.identifier("call"));
         node.arguments.unshift(t.thisExpression());
       }
     }

lib/6to5/transformation/transformers/es6-computed-property-names.js

@@ -1,47 +1,97 @@
-var util = require("../../util");
-var t    = require("../../types");
+var t = require("../../types");
 
-exports.ObjectExpression = function (node, parent, file) {
+exports.ObjectExpression = function (node, parent, file, scope) {
   var hasComputed = false;
+  var prop;
+  var key;
+  var i;
 
-  var computed = [];
-
-  node.properties = node.properties.filter(function (prop) {
-    if (prop.computed) {
-      hasComputed = true;
-      computed.unshift(prop);
-      return false;
-    } else {
-      return true;
-    }
-  });
+  for (i in node.properties) {
+    hasComputed = t.isProperty(node.properties[i], { computed: true });
+    if (hasComputed) break;
+  }
 
   if (!hasComputed) return;
 
-  var objId = util.getUid(parent, file);
+  var objId = scope.generateUidBasedOnNode(parent, file);
 
-  var container = util.template("function-return-obj", {
-    KEY: objId,
-    OBJECT: node
-  });
+  var body = [];
+  var container = t.functionExpression(null, [], t.blockStatement(body));
+  container._aliasFunction = true;
 
-  var containerCallee = container.callee;
-  var containerBody = containerCallee.body.body;
+  var props = node.properties;
 
-  containerCallee._aliasFunction = true;
+  // normalise key
 
-  for (var i in computed) {
-    var prop = computed[i];
-    containerBody.unshift(
-      t.expressionStatement(
-        t.assignmentExpression(
-          "=",
-          t.memberExpression(objId, prop.key, true),
-          prop.value
-        )
-      )
-    );
+  for (i in props) {
+    prop = props[i];
+    key = prop.key;
+
+    if (!prop.computed && t.isIdentifier(key)) {
+      prop.key = t.literal(key.name);
+    }
   }
 
-  return container;
+  // add all non-computed properties and `__proto__` properties to the initializer
+
+  var initProps = [];
+  var broken = false;
+
+  for (i in props) {
+    prop = props[i];
+
+    if (prop.computed) {
+      broken = true;
+    }
+
+    if (!broken || t.isLiteral(t.toComputedKey(prop, prop.key), { value: "__proto__" })) {
+      initProps.push(prop);
+      props[i] = null;
+    }
+  }
+
+  // add a simple assignment for all Symbol member expressions due to symbol polyfill limitations
+  // otherwise use Object.defineProperty
+
+  for (i in props) {
+    prop = props[i];
+    if (!prop) continue;
+
+    key = prop.key;
+    var bodyNode;
+
+    if (prop.computed && t.isMemberExpression(key) && t.isIdentifier(key.object, { name: "Symbol" })) {
+      // { [Symbol.iterator]: "foo" }
+      bodyNode = t.assignmentExpression(
+        "=",
+        t.memberExpression(objId, key, true),
+        prop.value
+      );
+    } else {
+      bodyNode = t.callExpression(file.addHelper("define-property"), [objId, key, prop.value]);
+    }
+
+    body.push(t.expressionStatement(bodyNode));
+  }
+
+  // only one node and it's a Object.defineProperty that returns the object
+
+  if (body.length === 1) {
+    var first = body[0].expression;
+
+    if (t.isCallExpression(first)) {
+      first.arguments[0] = t.objectExpression(initProps);
+      return first;
+    }
+  }
+
+  //
+
+  body.unshift(t.variableDeclaration("var", [
+    t.variableDeclarator(objId, t.objectExpression(initProps))
+  ]));
+
+  body.push(t.returnStatement(objId));
+
+  return t.callExpression(container, []);
 };

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

@@ -45,7 +45,7 @@ var pushObjectPattern = function (opts, nodes, pattern, parentId) {
         }
         keys = t.arrayExpression(keys);
 
-        var value = t.callExpression(opts.file.addDeclaration("object-without-properties"), [parentId, keys]);
+        var value = t.callExpression(opts.file.addHelper("object-without-properties"), [parentId, keys]);
         nodes.push(buildVariableAssign(opts, prop.argument, value));
     } else {
       var pattern2   = prop.value;
@@ -61,13 +61,27 @@ var pushObjectPattern = function (opts, nodes, pattern, parentId) {
 };
 
 var pushArrayPattern = function (opts, nodes, pattern, parentId) {
-  var _parentId = opts.file.generateUidIdentifier("ref", opts.scope);
+  if (!pattern.elements) return;
+
+  var i;
+
+  var hasSpreadElement = false;
+  for (i in pattern.elements) {
+    if (t.isSpreadElement(pattern.elements[i])) {
+      hasSpreadElement = true;
+      break;
+    }
+  }
+
+  var toArray = opts.file.toArray(parentId, !hasSpreadElement && pattern.elements.length);
+
+  var _parentId = opts.scope.generateUidBasedOnNode(parentId, opts.file);
   nodes.push(t.variableDeclaration("var", [
-    t.variableDeclarator(_parentId, opts.file.toArray(parentId))
+    t.variableDeclarator(_parentId, toArray)
   ]));
   parentId = _parentId;
 
-  for (var i in pattern.elements) {
+  for (i in pattern.elements) {
     var elem = pattern.elements[i];
     if (!elem) continue;
 
@@ -99,7 +113,7 @@ var pushPattern = function (opts) {
   var scope = opts.scope;
 
   if (!t.isMemberExpression(parentId) && !t.isIdentifier(parentId)) {
-    var key = file.generateUidIdentifier("ref", scope);
+    var key = scope.generateUidBasedOnNode(parentId, file);
 
     nodes.push(t.variableDeclaration("var", [
       t.variableDeclarator(key, parentId)
@@ -254,6 +268,7 @@ exports.VariableDeclaration = function (node, parent, file, scope) {
   }
 
   if (!t.isProgram(parent) && !t.isBlockStatement(parent)) {
+    declar = null;
 
     for (i in nodes) {
       node = nodes[i];

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

@@ -24,6 +24,7 @@ exports.ForOfStatement = function (node, parent, file, scope) {
     OBJECT:       node.right
   });
 
+  t.inheritsComments(node2, node);
   t.ensureBlock(node);
 
   var block = node2.body;

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

@@ -1 +1,3 @@
-module.exports = require("regenerator").transform;
+exports.ast = {
+  before: require("regenerator").transform
+};

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

@@ -280,7 +280,7 @@ LetScoping.prototype.checkLoop = function () {
       var replace;
 
       if (t.isFunction(node) || t.isLoop(node)) {
-        return false;
+        return this.skip();
       }
 
       if (node && !node.label) {
@@ -329,7 +329,7 @@ LetScoping.prototype.hoistVarDeclarations = function () {
       } else if (isVar(node, parent)) {
         return self.pushDeclar(node).map(t.expressionStatement);
       } else if (t.isFunction(node)) {
-        return false;
+        return this.skip();
       }
     }
   });
@@ -388,9 +388,9 @@ LetScoping.prototype.getLetReferences = function () {
           }
         });
 
-        return false;
+        return this.skip();
       } else if (t.isLoop(node)) {
-        return false;
+        return this.skip();
       }
     }
   });

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

@@ -1,8 +1,8 @@
 var t = require("../../types");
 
-var inheritsComments = function (node, nodes) {
-  if (nodes.length) {
-    t.inheritsComments(nodes[0], node);
+exports.ast = {
+  before: function (ast, file) {
+    ast.program.body = file.dynamicImports.concat(ast.program.body);
   }
 };
 
@@ -10,16 +10,18 @@ exports.ImportDeclaration = function (node, parent, file) {
   var nodes = [];
 
   if (node.specifiers.length) {
-    if (!file.moduleFormatter.importSpecifier) return;
     for (var i in node.specifiers) {
       file.moduleFormatter.importSpecifier(node.specifiers[i], node, nodes, parent);
     }
   } else {
-    if (!file.moduleFormatter.importDeclaration) return;
     file.moduleFormatter.importDeclaration(node, nodes, parent);
   }
 
-  inheritsComments(node, nodes);
+  if (nodes.length === 1) {
+    // inherit `_blockHoist`
+    // this for `_blockHoist` in File.prototype.addImport
+    nodes[0]._blockHoist = node._blockHoist;
+  }
 
   return nodes;
 };
@@ -35,16 +37,12 @@ exports.ExportDeclaration = function (node, parent, file) {
       declar.init = declar.init || t.identifier("undefined");
     }
 
-    if (!file.moduleFormatter.exportDeclaration) return;
     file.moduleFormatter.exportDeclaration(node, nodes, parent);
   } else {
-    if (!file.moduleFormatter.exportSpecifier) return;
     for (var i in node.specifiers) {
       file.moduleFormatter.exportSpecifier(node.specifiers[i], node, nodes, parent);
     }
   }
 
-  inheritsComments(node, nodes);
-
   return nodes;
 };

lib/6to5/transformation/transformers/es6-property-method-assignment.js

@@ -0,0 +1,82 @@
+var traverse = require("../../traverse");
+var util     = require("../../util");
+var t        = require("../../types");
+
+exports.Property = function (node, parent, file, scope) {
+  if (!node.method) return;
+
+  node.method = false;
+
+  var key = t.toComputedKey(node, node.key);
+  if (!t.isLiteral(key)) return; // we can't set a function id with this
+
+  var id = t.toIdentifier(key.value);
+  key = t.identifier(id);
+
+  var selfReference = false;
+  var outerDeclar = scope.get(id, true);
+
+  traverse(node, {
+    enter: function (node, parent, scope) {
+      // check if this node is an identifier that matches the same as our function id
+      if (!t.isIdentifier(node, { name: id })) return;
+
+      // check if this node is the one referenced
+      if (!t.isReferenced(node, parent)) return;
+
+      // check that we don't have a local variable declared as that removes the need
+      // for the wrapper
+      var localDeclar = scope.get(id, true);
+      if (localDeclar !== outerDeclar) return;
+
+      selfReference = true;
+      this.stop();
+    }
+  }, scope);
+
+  if (selfReference) {
+    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)
+    });
+  } else {
+    node.value.id = key;
+  }
+};
+
+exports.ObjectExpression = function (node, parent, file, scope) {
+  var mutatorMap = {};
+  var hasAny = false;
+
+  node.properties = node.properties.filter(function (prop) {
+    if (prop.kind === "get" || prop.kind === "set") {
+      hasAny = true;
+      util.pushMutatorMap(mutatorMap, prop.key, prop.kind, prop.value);
+      return false;
+    } else {
+      return true;
+    }
+  });
+
+  if (!hasAny) return;
+
+  if (node.properties.length) {
+    var objId = scope.generateUidBasedOnNode(parent, file);
+
+    return util.template("object-define-properties-closure", {
+      KEY: objId,
+      OBJECT: node,
+      CONTENT: util.template("object-define-properties", {
+        OBJECT: objId,
+        PROPS:  util.buildDefineProperties(mutatorMap)
+      })
+    });
+  } else {
+    return util.template("object-define-properties", {
+      OBJECT: node,
+      PROPS:  util.buildDefineProperties(mutatorMap)
+    });
+  }
+};

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

@@ -77,23 +77,14 @@ exports.CallExpression = function (node, parent, file, scope) {
   }
 
   var callee = node.callee;
-  var temp;
 
   if (t.isMemberExpression(callee)) {
-    contextLiteral = callee.object;
-
-    if (t.isDynamic(contextLiteral)) {
-      temp = contextLiteral = scope.generateTemp(file);
+    var temp = scope.generateTempBasedOnNode(callee.object, file);
+    if (temp) {
       callee.object = t.assignmentExpression("=", temp, callee.object);
+      contextLiteral = temp;
     }
-
-    if (callee.computed) {
-      callee.object = t.memberExpression(callee.object, callee.property, true);
-      callee.property = t.identifier("apply");
-      callee.computed = false;
-    } else {
-      callee.property = t.memberExpression(callee.property, t.identifier("apply"));
-    }
+    t.appendToMemberExpression(callee, t.identifier("apply"));
   } else {
     node.callee = t.memberExpression(node.callee, t.identifier("apply"));
   }
@@ -114,5 +105,5 @@ exports.NewExpression = function (node, parent, file) {
     args = first;
   }
 
-  return t.callExpression(file.addDeclaration("apply-constructor"), [node.callee, args]);
+  return t.callExpression(file.addHelper("apply-constructor"), [node.callee, args]);
 };

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

@@ -17,7 +17,7 @@ exports.TaggedTemplateExpression = function (node, parent, file) {
     raw.push(t.literal(elem.value.raw));
   }
 
-  args.push(t.callExpression(file.addDeclaration("tagged-template-literal"), [
+  args.push(t.callExpression(file.addHelper("tagged-template-literal"), [
     t.arrayExpression(strings),
     t.arrayExpression(raw)
   ]));

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

@@ -3,6 +3,8 @@
 var util = require("../../util");
 var t    = require("../../types");
 
+exports.experimental = true;
+
 var container = function (parent, call, ret) {
   if (t.isExpressionStatement(parent)) {
     // we don't need to worry about return values
@@ -28,10 +30,8 @@ exports.AssignmentExpression = function (node, parent, file, scope) {
 
   // we need to return `node.right`
   if (!t.isExpressionStatement(parent)) {
-    // `node.right` isn't a simple identifier so we need to reference it
-    if (t.isDynamic(value)) {
-      temp = value = scope.generateTemp(file);
-    }
+    temp = scope.generateTempBasedOnNode(node.right, file);
+    if (temp) value = temp;
   }
 
   if (node.operator !== "=") {
@@ -78,11 +78,7 @@ exports.CallExpression = function (node, parent, file, scope) {
   var callee = node.callee;
   if (!t.isVirtualPropertyExpression(callee)) return;
 
-  var temp;
-  if (t.isDynamic(callee.object)) {
-    // we need to save `callee.object` so we can call it again
-    temp = scope.generateTemp(file);
-  }
+  var temp = scope.generateTempBasedOnNode(callee.object, file);
 
   var call = util.template("abstract-expression-call", {
     PROPERTY: callee.property,

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

@@ -1,41 +1,25 @@
-var util = require("../../util");
-var t    = require("../../types");
+var traverse = require("../../traverse");
+var util     = require("../../util");
+var t        = require("../../types");
 
-var single = function (node, file) {
-  var block = node.blocks[0];
+exports.experimental = true;
 
-  var templateName = "array-expression-comprehension-map";
-  if (node.filter) templateName = "array-expression-comprehension-filter";
-
-  var result = util.template(templateName, {
-    STATEMENT: node.body,
-    FILTER:    node.filter,
-    ARRAY:     file.toArray(block.right),
-    KEY:       block.left
-  });
-
-  var aliasPossibles = [result.callee.object, result];
-  for (var i in aliasPossibles) {
-    var call = aliasPossibles[i];
-    if (t.isCallExpression(call)) {
-      call.arguments[0]._aliasFunction = true;
-    }
-  }
-
-  return result;
-};
-
-var multiple = function (node, file) {
-  var uid = file.generateUidIdentifier("arr");
+var build = function (node, parent, file, scope) {
+  var uid = scope.generateUidBasedOnNode(parent, file);
 
   var container = util.template("array-comprehension-container", {
     KEY: uid
   });
-  container.callee.expression._aliasFunction = true;
+  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(exports._build(node, function () {
@@ -65,18 +49,14 @@ exports._build = function (node, buildBody) {
   }
 
   return t.forOfStatement(
-    t.variableDeclaration("var", [t.variableDeclarator(self.left)]),
+    t.variableDeclaration("let", [t.variableDeclarator(self.left)]),
     self.right,
     t.blockStatement([child])
   );
 };
 
-exports.ComprehensionExpression = function (node, parent, file) {
+exports.ComprehensionExpression = function (node, parent, file, scope) {
   if (node.generator) return;
 
-  if (node.blocks.length === 1) {
-    return single(node, file);
-  } else {
-    return multiple(node, file);
-  }
+  return build(node, parent, file, scope);
 };

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

@@ -1,5 +1,7 @@
 // https://github.com/rwaldron/exponentiation-operator
 
+exports.experimental = true;
+
 var t = require("../../types");
 var pow = t.memberExpression(t.identifier("Math"), t.identifier("pow"));
 

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

@@ -1,6 +1,8 @@
 var arrayComprehension = require("./es7-array-comprehension");
 var t                  = require("../../types");
 
+exports.experimental = true;
+
 exports.ComprehensionExpression = function (node) {
   if (!node.generator) return;
 

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

@@ -2,6 +2,8 @@
 
 var t = require("../../types");
 
+exports.experimental = true;
+
 exports.ObjectExpression = function (node) {
   var hasSpread = false;
   var i;

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

@@ -0,0 +1,11 @@
+var bluebirdCoroutines = require("./optional-bluebird-coroutines");
+
+exports.optional = true;
+
+exports.manipulateOptions = bluebirdCoroutines.manipulateOptions;
+
+exports.Function = function (node, parent, file) {
+  if (!node.async || node.generator) return;
+
+  return bluebirdCoroutines._Function(node, file.addHelper("async-to-generator"));
+};

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

@@ -0,0 +1,45 @@
+var traverse = require("../../traverse");
+var t        = require("../../types");
+
+exports.manipulateOptions = function (opts) {
+  opts.experimental = true;
+  opts.blacklist.push("generators");
+};
+
+exports.optional = true;
+
+exports._Function = function (node, callId) {
+  node.async = false;
+  node.generator = true;
+
+  traverse(node, {
+    enter: function (node) {
+      if (t.isFunction(node)) this.skip();
+
+      if (t.isAwaitExpression(node)) {
+        node.type = "YieldExpression";
+      }
+    }
+  });
+
+  var call = t.callExpression(callId, [node]);
+
+  if (t.isFunctionDeclaration(node)) {
+    var declar = t.variableDeclaration("var", [
+      t.variableDeclarator(node.id, call)
+    ]);
+    declar._blockHoist = true;
+    return declar;
+  } else {
+    return call;
+  }
+};
+
+exports.Function = function (node, parent, file) {
+  if (!node.async || node.generator) return;
+
+  var id = t.identifier("Bluebird");
+  file.addImport(id, "bluebird");
+
+  return exports._Function(node, t.memberExpression(id, t.identifier("coroutine")));
+};

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

@@ -0,0 +1,59 @@
+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);
+};
+
+exports.optional = true;
+
+exports.ast = {
+  enter: function (ast, file) {
+    file._coreId = file.generateUidIdentifier("core");
+    file.addImport(file._coreId, "core-js/library");
+  },
+
+  exit: function (ast, file) {
+    traverse(ast, {
+      enter: function (node, parent) {
+        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)) {
+            this.skip();
+            return t.prependToMemberExpression(node, file._coreId);
+          }
+        } else if (t.isIdentifier(node) && !t.isMemberExpression(parent) && t.isReferenced(node, parent) && coreHas(node)) {
+          // 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/optional-proto-to-assign.js

@@ -0,0 +1,63 @@
+var t = require("../../types");
+var _ = require("lodash");
+
+var OBJECT_ASSIGN_MEMBER = t.memberExpression(t.identifier("Object"), t.identifier("assign"));
+
+var isProtoKey = function (node) {
+  return t.isLiteral(t.toComputedKey(node, node.key), { value: "__proto__" });
+};
+
+var isProtoAssignmentExpression = function (node) {
+  var left = node.left;
+  return t.isMemberExpression(left) && t.isLiteral(t.toComputedKey(left, left.property), { value: "__proto__" });
+};
+
+var buildDefaultsCallExpression = function (expr, ref, file) {
+  return t.expressionStatement(t.callExpression(file.addHelper("defaults"), [ref, expr.right]));
+};
+
+exports.optional = true;
+exports.secondPass = true;
+
+exports.AssignmentExpression = function (node, parent, file, scope) {
+  if (t.isExpressionStatement(parent)) return;
+  if (!isProtoAssignmentExpression(node)) return;
+
+  var nodes = [];
+  var left  = node.left.object;
+  var temp  = scope.generateTempBasedOnNode(node.left.object, file);
+
+  nodes.push(t.expressionStatement(t.assignmentExpression("=", temp, left)));
+  nodes.push(buildDefaultsCallExpression(node, temp, file));
+  if (temp) nodes.push(temp);
+
+  return t.toSequenceExpression(nodes);
+};
+
+exports.ExpressionStatement = function (node, parent, file) {
+  var expr = node.expression;
+  if (!t.isAssignmentExpression(expr, { operator: "=" })) return;
+
+  if (isProtoAssignmentExpression(expr)) {
+    return buildDefaultsCallExpression(expr, expr.left.object, file);
+  }
+};
+
+exports.ObjectExpression = function (node) {
+  var proto;
+
+  for (var i in node.properties) {
+    var prop = node.properties[i];
+
+    if (isProtoKey(prop)) {
+      proto = prop.value;
+      _.pull(node.properties, prop);
+    }
+  }
+
+  if (proto) {
+    var args = [t.objectExpression([]), proto];
+    if (node.properties.length) args.push(node);
+    return t.callExpression(OBJECT_ASSIGN_MEMBER, args);
+  }
+};

lib/6to5/transformation/transformers/optional-undefined-to-void.js

@@ -0,0 +1,9 @@
+var t = require("../../types");
+
+exports.optional = true;
+
+exports.Identifier = function (node, parent) {
+  if (node.name === "undefined" && t.isReferenced(node, parent)) {
+    return t.unaryExpression("void", t.literal(0), true);
+  }
+};