v2.5.0

Conflicts:
	package.json

CHANGELOG.md

@@ -2,6 +2,84 @@
 
 Gaps between patch versions are faulty/broken releases.
 
+## 2.5.0
+
+ * Remove `noDuplicateProperties` transformer.
+ * Better generated UIDs based on nodes.
+ * Default parameters now use `arguments[i]`, conditionals and variable declarations instead of using long-form if statements.
+
+## 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.

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/index.js

@@ -17,6 +17,7 @@ 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);
@@ -28,8 +29,16 @@ commander.on("--help", function(){
     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);
     });
 
@@ -96,6 +105,7 @@ exports.opts = {
   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

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,13 +10,16 @@ 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",
@@ -25,7 +28,13 @@ File.declarations = [
   "sliced-to-array",
   "object-without-properties",
   "has-own",
-  "slice"
+  "slice",
+  "define-property",
+  "async-to-generator"
+];
+
+File.excludeHelpersFromRuntime = [
+  "async-to-generator"
 ];
 
 File.normaliseOptions = function (opts) {
@@ -39,6 +48,7 @@ File.normaliseOptions = function (opts) {
     blacklist:    [],
     whitelist:    [],
     sourceMap:    false,
+    optional:     [],
     comments:     true,
     filename:     "unknown",
     modules:      "common",
@@ -80,15 +90,38 @@ File.normaliseOptions = function (opts) {
 
   transform._ensureTransformerNames("blacklist", opts.blacklist);
   transform._ensureTransformerNames("whitelist", opts.whitelist);
+  transform._ensureTransformerNames("optional", opts.optional);
 
   return opts;
 };
 
+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 {
     var declarationName = "to-array";
     var args = [node];
@@ -96,7 +129,7 @@ File.prototype.toArray = function (node, i) {
       args.push(t.literal(i));
       declarationName = "sliced-to-array";
     }
-    return t.callExpression(this.addDeclaration(declarationName), args);
+    return t.callExpression(this.addHelper(declarationName), args);
   }
 };
 
@@ -127,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);
   }
 
@@ -139,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 {
@@ -182,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 needsNoLineTermParens = n.needsParensNoLineTerminator(node, parent);
+    var needsParens           = needsNoLineTermParens || n.needsParens(node, parent);
+
+    if (needsParens) this.push("(");
+    if (needsNoLineTermParens) 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 (needsNoLineTermParens) {
+      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/node/index.js

@@ -69,6 +69,29 @@ Node.prototype.needsParens = function () {
   return find(parens, node, parent);
 };
 
+Node.prototype.needsParensNoLineTerminator = function () {
+  var parent = this.parent;
+  var node   = this.node;
+
+  if (!parent) return false;
+
+  // no comments
+  if (!node.leadingComments || !node.leadingComments.length) {
+    return false;
+  }
+
+  if (t.isYieldExpression(parent) || t.isAwaitExpression(parent)) {
+    return true;
+  }
+
+  if (t.isContinueStatement(parent) || t.isBreakStatement(parent) ||
+      t.isReturnStatement(parent) || t.isThrowStatement(parent)) {
+    return true;
+  }
+
+  return false;
+};
+
 _.each(Node.prototype, function (fn, key) {
   Node[key] = function (node, parent) {
     var n = new Node(node, parent);

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

@@ -20,6 +20,20 @@ _.each([
   });
 });
 
+exports.ObjectExpression = function (node, parent) {
+  if (t.isExpressionStatement(parent)) {
+    // ({ foo: "bar" });
+    return true;
+  }
+
+  if (t.isMemberExpression(parent) && parent.object === node) {
+    // ({ foo: "bar" }).foo
+    return true;
+  }
+
+  return false;
+};
+
 exports.Binary = function (node, parent) {
   if (t.isCallExpression(parent) && parent.callee === node) {
     return 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,8 +3,6 @@ var util      = require("./util");
 var fs        = require("fs");
 var _         = require("lodash");
 
-exports.Transformer = require("./transformation/transformer");
-
 exports.types = require("./types");
 
 exports.runtime = require("./runtime-generator");

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/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/transformation/modules/_default.js

@@ -51,7 +51,7 @@ DefaultFormatter.prototype.remapAssignments = function () {
   traverse(this.file.ast, {
     enter: function (node, parent, scope) {
       if (t.isUpdateExpression(node) && isLocalReference(node.argument, scope)) {
-        this.stop();
+        this.skip();
 
         // expand to long file assignment expression
         var assign = t.assignmentExpression(node.operator[0] + "=", node.argument, t.literal(1));
@@ -79,7 +79,7 @@ DefaultFormatter.prototype.remapAssignments = function () {
       }
 
       if (t.isAssignmentExpression(node) && isLocalReference(node.left, scope)) {
-        this.stop();
+        this.skip();
         return self.remapExportAssignment(node);
       }
     }
@@ -124,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;
@@ -139,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));
   }
 };
 
@@ -181,7 +182,7 @@ DefaultFormatter.prototype.exportDeclaration = function (node, nodes) {
     for (var i in declar.declarations) {
       var decl = declar.declarations[i];
 
-      decl.init = this._exportsAssign(decl.id, decl.init).expression;
+      decl.init = this._exportsAssign(decl.id, decl.init, node).expression;
 
       var newDeclar = t.variableDeclaration(declar.kind, [decl]);
       if (i === "0") t.inherits(newDeclar, declar);
@@ -195,7 +196,7 @@ DefaultFormatter.prototype.exportDeclaration = function (node, nodes) {
       nodes.push(declar);
     }
 
-    assign = this._exportsAssign(id, ref);
+    assign = this._exportsAssign(id, ref, node);
 
     nodes.push(assign);
 

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

@@ -85,7 +85,7 @@ AMDFormatter.prototype.importSpecifier = function (specifier, node, nodes) {
     // import * as bar from "foo";
   } 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

@@ -15,8 +15,13 @@ function SystemFormatter(file) {
 
 util.inherits(SystemFormatter, AMDFormatter);
 
-SystemFormatter.prototype._exportsWildcard = function (objectIdentifier) {
-  var leftIdentifier = t.identifier("i");
+SystemFormatter.prototype._addImportSource = function (node, exportNode) {
+  node._importSource = exportNode.source && exportNode.source.value;
+  return node;
+};
+
+SystemFormatter.prototype._exportsWildcard = function (objectIdentifier, node) {
+  var leftIdentifier = this.file.generateUidIdentifier("key");
   var valIdentifier  = t.memberExpression(objectIdentifier, leftIdentifier, true);
 
   var left = t.variableDeclaration("var", [
@@ -29,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) {
@@ -49,28 +55,53 @@ 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: 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);
 
   var handlerBody = runner.expression.arguments[2].body.body;
@@ -78,10 +109,57 @@ SystemFormatter.prototype.transform = function (ast) {
 
   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(program, {
+  traverse(block, {
     enter: function (node) {
-      if (t.isFunction(node)) this.stop();
+      if (t.isFunction(node)) this.skip();
 
       if (t.isFunctionDeclaration(node) || node._blockHoist) {
         handlerBody.push(node);
@@ -90,12 +168,6 @@ SystemFormatter.prototype.transform = function (ast) {
     }
   });
 
-  if (!_.isEmpty(this.ids)) {
-    handlerBody.push(t.variableDeclaration("var", _.map(this.ids, function (uid) {
-      return t.variableDeclarator(uid);
-    })));
-  }
-
   handlerBody.push(returnStatement);
 
   program.body = [runner];

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

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

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

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

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/default-parameter.js

@@ -0,0 +1 @@
+var VARIABLE_NAME = ARGUMENTS[ARGUMENT_KEY] === undefined ? DEFAULT_VALUE : ARGUMENTS[ARGUMENT_KEY];

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/function-return-obj.js

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

lib/6to5/transformation/templates/if-undefined-set-to.js

@@ -1 +0,0 @@
-if (VARIABLE === undefined) VARIABLE = DEFAULT;

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

@@ -1,3 +1,4 @@
+
 (function (KEY) {
   CONTENT;
   return KEY;

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/transform.js

@@ -42,13 +42,15 @@ _.each({
   // spec
   specBlockHoistFunctions:   require("./transformers/spec-block-hoist-functions"),
   specNoForInOfAssignment:   require("./transformers/spec-no-for-in-of-assignment"),
-  specNoDuplicateProperties: require("./transformers/spec-no-duplicate-properties"),
 
   // playground
   methodBinding:             require("./transformers/playground-method-binding"),
   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 +65,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 +80,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,12 +64,14 @@ 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) {
@@ -80,5 +85,9 @@ Transformer.prototype.canRun = function (file) {
   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

@@ -21,7 +21,7 @@ exports.ClassDeclaration = function (node, parent, file, scope) {
       });
       return t.assignmentExpression("=", node.id, newNode);
     } else {
-      // likely has a PrivateDeclaration etc
+      // has a super class or PrivateDeclaration etc
       return t.variableDeclaration("let", [
         t.variableDeclarator(node.id, newNode)
       ]);
@@ -85,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();
@@ -153,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));
@@ -181,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)
     ));
   }
 };
@@ -282,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-default-parameters.js

@@ -49,16 +49,29 @@ exports.Function = function (node, parent, file, scope) {
 
   var body = [];
 
+  var argsIdentifier = t.identifier("arguments");
+  argsIdentifier._ignoreAliasFunctions = true;
+
+  var lastNonDefaultParam = 0;
+
   for (i in node.defaults) {
     def = node.defaults[i];
-    if (!def) continue;
+    if (!def) {
+      lastNonDefaultParam = +i + 1;
+      continue;
+    }
 
-    body.push(util.template("if-undefined-set-to", {
-      VARIABLE: node.params[i],
-      DEFAULT:  def
+    body.push(util.template("default-parameter", {
+      VARIABLE_NAME: node.params[i],
+      DEFAULT_VALUE: def,
+      ARGUMENT_KEY:  t.literal(+i),
+      ARGUMENTS:     argsIdentifier
     }, true));
   }
 
+  // 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;

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;
@@ -75,7 +75,7 @@ var pushArrayPattern = function (opts, nodes, pattern, parentId) {
 
   var toArray = opts.file.toArray(parentId, !hasSpreadElement && pattern.elements.length);
 
-  var _parentId = opts.file.generateUidIdentifier("ref", opts.scope);
+  var _parentId = opts.scope.generateUidBasedOnNode(parentId, opts.file);
   nodes.push(t.variableDeclaration("var", [
     t.variableDeclarator(_parentId, toArray)
   ]));
@@ -113,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)

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,5 +1,11 @@
 var t = require("../../types");
 
+exports.ast = {
+  before: function (ast, file) {
+    ast.program.body = file.dynamicImports.concat(ast.program.body);
+  }
+};
+
 exports.ImportDeclaration = function (node, parent, file) {
   var nodes = [];
 
@@ -11,6 +17,12 @@ exports.ImportDeclaration = function (node, parent, file) {
     file.moduleFormatter.importDeclaration(node, nodes, parent);
   }
 
+  if (nodes.length === 1) {
+    // inherit `_blockHoist`
+    // this for `_blockHoist` in File.prototype.addImport
+    nodes[0]._blockHoist = node._blockHoist;
+  }
+
   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,16 @@ 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);
-    }
-
-    if (callee.computed) {
-      callee.object = t.memberExpression(callee.object, callee.property, true);
-      callee.property = t.identifier("apply");
-      callee.computed = false;
+      contextLiteral = temp;
     } else {
-      callee.property = t.memberExpression(callee.property, t.identifier("apply"));
+      contextLiteral = callee.object;
     }
+    t.appendToMemberExpression(callee, t.identifier("apply"));
   } else {
     node.callee = t.memberExpression(node.callee, t.identifier("apply"));
   }
@@ -114,5 +107,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);
+  }
+};

lib/6to5/transformation/transformers/playground-memoization-operator.js

@@ -10,7 +10,7 @@ var getPropRef = function (nodes, prop, file, scope) {
   if (t.isIdentifier(prop)) {
     return t.literal(prop.name);
   } else {
-    var temp = file.generateUidIdentifier("propKey", scope);
+    var temp = scope.generateUidBasedOnNode(prop, file);
     nodes.push(t.variableDeclaration("var", [
       t.variableDeclarator(temp, prop)
     ]));
@@ -19,22 +19,18 @@ var getPropRef = function (nodes, prop, file, scope) {
 };
 
 var getObjRef = function (nodes, obj, file, scope) {
-  if (t.isDynamic(obj)) {
-    var temp = file.generateUidIdentifier("obj", scope);
-    nodes.push(t.variableDeclaration("var", [
-      t.variableDeclarator(temp, obj)
-    ]));
-    return temp;
-  } else {
-    return obj;
-  }
+  var temp = scope.generateUidBasedOnNode(obj, file);
+  nodes.push(t.variableDeclaration("var", [
+    t.variableDeclarator(temp, obj)
+  ]));
+  return temp;
 };
 
 var buildHasOwn = function (obj, prop, file) {
   return t.unaryExpression(
     "!",
     t.callExpression(
-      t.memberExpression(file.addDeclaration("has-own"), t.identifier("call")),
+      t.memberExpression(file.addHelper("has-own"), t.identifier("call")),
       [obj, prop]
     ),
     true

lib/6to5/transformation/transformers/playground-method-binding.js

@@ -1,14 +1,11 @@
 var t = require("../../types");
-var _ = require("lodash");
 
 exports.BindMemberExpression = function (node, parent, file, scope) {
   var object = node.object;
   var prop   = node.property;
 
-  var temp;
-  if (t.isDynamic(object)) {
-    temp = object = scope.generateTemp(file);
-  }
+  var temp = scope.generateTempBasedOnNode(node.object, file);
+  if (temp) object = temp;
 
   var call = t.callExpression(
     t.memberExpression(t.memberExpression(object, prop), t.identifier("bind")),
@@ -33,16 +30,12 @@ exports.BindFunctionExpression = function (node, parent, file, scope) {
     ]));
   };
 
-  if (_.find(node.arguments, t.isDynamic)) {
-    var temp = scope.generateTemp(file, "args");
+  var temp = scope.generateTemp(file, "args");
 
-    return t.sequenceExpression([
-      t.assignmentExpression("=", temp, t.arrayExpression(node.arguments)),
-      buildCall(node.arguments.map(function (node, i) {
-        return t.memberExpression(temp, t.literal(i), true);
-      }))
-    ]);
-  } else {
-    return buildCall(node.arguments);
-  }
+  return t.sequenceExpression([
+    t.assignmentExpression("=", temp, t.arrayExpression(node.arguments)),
+    buildCall(node.arguments.map(function (node, i) {
+      return t.memberExpression(temp, t.literal(i), true);
+    }))
+  ]);
 };

lib/6to5/transformation/transformers/playground-object-getter-memoization.js

@@ -2,38 +2,30 @@ var traverse = require("../../traverse");
 var t        = require("../../types");
 
 exports.Property =
-exports.MethodDefinition = function (node, parent, file, scope) {
+exports.MethodDefinition = function (node, parent, file) {
   if (node.kind !== "memo") return;
   node.kind = "get";
 
   var value = node.value;
   t.ensureBlock(value);
 
-  var body  = value.body.body;
-  var key   = node.key;
+  var key = node.key;
 
   if (t.isIdentifier(key) && !node.computed) {
-    key = "_" + key.name;
-  } else {
-    key = file.generateUid("memo", scope);
+    key = t.literal(key.name);
   }
 
-  var memoId = t.memberExpression(t.thisExpression(), t.identifier(key));
-  var doneId = t.memberExpression(t.thisExpression(), t.identifier(key + "Done"));
-
   traverse(value, {
     enter: function (node) {
       if (t.isFunction(node)) return;
 
       if (t.isReturnStatement(node) && node.argument) {
-        node.argument = t.assignmentExpression("=", memoId, node.argument);
+        node.argument = t.memberExpression(t.callExpression(file.addHelper("define-property"), [
+          t.thisExpression(),
+          key,
+          node.argument
+        ]), key, true);
       }
     }
   });
-
-  // this._barDone = true;
-  body.unshift(t.expressionStatement(t.assignmentExpression("=", doneId, t.literal(true))));
-
-  // if (this._barDone) return this._bar;
-  body.unshift(t.ifStatement(doneId, t.returnStatement(memoId)));
 };

lib/6to5/transformation/transformers/spec-no-duplicate-properties.js

@@ -1,25 +0,0 @@
-var t = require("../../types");
-
-exports.ObjectExpression = function (node, parent, file) {
-  var keys = [];
-
-  for (var i in node.properties) {
-    var prop = node.properties[i];
-    if (prop.computed || prop.kind !== "init") continue;
-
-    var key = prop.key;
-    if (t.isIdentifier(key)) {
-      key = key.name;
-    } else if (t.isLiteral(key)) {
-      key = key.value;
-    } else {
-      continue;
-    }
-
-    if (keys.indexOf(key) >= 0) {
-      throw file.errorWithNode(prop.key, "Duplicate property key");
-    } else {
-      keys.push(key);
-    }
-  }
-};

lib/6to5/transformation/transformers/use-strict.js

@@ -1,12 +1,14 @@
 var t = require("../../types");
 
-module.exports = function (ast) {
-  var body = ast.program.body;
-  var first = body[0];
+exports.ast = {
+  exit: function (ast) {
+    var body = ast.program.body;
+    var first = body[0];
 
-  var noStrict = !first || !t.isExpressionStatement(first) || !t.isLiteral(first.expression) || first.expression.value !== "use strict";
+    var noStrict = !first || !t.isExpressionStatement(first) || !t.isLiteral(first.expression) || first.expression.value !== "use strict";
 
-  if (noStrict) {
-    body.unshift(t.expressionStatement(t.literal("use strict")));
+    if (noStrict) {
+      body.unshift(t.expressionStatement(t.literal("use strict")));
+    }
   }
 };

lib/6to5/traverse/index.js

@@ -22,12 +22,14 @@ function traverse(parent, opts, scope) {
 
   opts = opts || {};
 
+  var stopped = false;
+
   for (var i in keys) {
     var key = keys[i];
     var nodes = parent[key];
     if (!nodes) continue;
 
-    var updated = false;
+    var flatten = false;
 
     var handle = function (obj, key) {
       var node = obj[key];
@@ -39,38 +41,42 @@ function traverse(parent, opts, scope) {
       // replace node
       var maybeReplace = function (result) {
         if (result === false) return;
+        if (result == null) return;
 
-        if (result != null) {
-          updated = true;
+        var isArray = _.isArray(result);
 
-          var isArray = _.isArray(result);
+        // inherit comments from original node to the first replacement node
+        var inheritTo = result;
+        if (isArray) inheritTo = result[0];
+        if (inheritTo) t.inheritsComments(inheritTo, node);
 
-          // inherit comments from original node to the first replacement node
-          var inheritTo = result;
-          if (isArray) inheritTo = result[0];
-          if (inheritTo) t.inheritsComments(inheritTo, node);
+        // replace the node
+        node = obj[key] = result;
 
-          // replace the node
-          node = obj[key] = result;
+        if (isArray) flatten = true;
 
-          // we're replacing a statement or block node with an array of statements so we better
-          // ensure that it's a block
-          if (isArray && _.contains(t.STATEMENT_OR_BLOCK_KEYS, key) && !t.isBlockStatement(obj)) {
-            t.ensureBlock(obj, key);
-          }
+        // we're replacing a statement or block node with an array of statements so we better
+        // ensure that it's a block
+        if (isArray && _.contains(t.STATEMENT_OR_BLOCK_KEYS, key) && !t.isBlockStatement(obj)) {
+          t.ensureBlock(obj, key);
         }
       };
 
-      var stopped = false;
+      var skipped = false;
       var removed = false;
 
       var context = {
         stop: function () {
-          stopped = true;
+          skipped = stopped = true;
+        },
+
+        skip: function () {
+          skipped = true;
         },
 
         remove: function () {
-          stopped = removed = true;
+          this.skip();
+          removed = true;
         }
       };
 
@@ -84,12 +90,12 @@ function traverse(parent, opts, scope) {
         maybeReplace(result);
 
         if (removed) {
-          delete obj[key];
-          updated = true;
+          obj[key] = null;
+          flatten = true;
         }
 
         // stop iteration
-        if (stopped || result === false) return;
+        if (skipped) return;
       }
 
       // traverse node
@@ -104,11 +110,20 @@ function traverse(parent, opts, scope) {
     if (_.isArray(nodes)) {
       for (i in nodes) {
         handle(nodes, i);
+        if (stopped) return;
       }
 
-      if (updated) parent[key] = _.flatten(parent[key]);
+      if (flatten) {
+        parent[key] = _.flatten(parent[key]);
+
+        if (key === "body") {
+          // we can safely compact this
+          parent[key] = _.compact(parent[key]);
+        }
+      }
     } else {
       handle(parent, key);
+      if (stopped) return;
     }
   }
 }
@@ -155,7 +170,7 @@ traverse.hasType = function (tree, type, blacklistTypes) {
     enter: function (node) {
       if (node.type === type) {
         has = true;
-        return false;
+        this.skip();
       }
     }
   });

lib/6to5/traverse/scope.js

@@ -31,6 +31,13 @@ Scope.add = function (node, references) {
   _.defaults(references, t.getIds(node, true));
 };
 
+/**
+ * Description
+ *
+ * @param {File} file
+ * @param {String} [name="temp"]
+ */
+
 Scope.prototype.generateTemp = function (file, name) {
   var id = file.generateUidIdentifier(name || "temp", this);
   this.push({
@@ -40,6 +47,70 @@ Scope.prototype.generateTemp = function (file, name) {
   return id;
 };
 
+/*
+ * Description
+ *
+ * @param {Object} parent
+ * @param {File} file
+ * @param {Scope} scope
+ * @returns {Object}
+ */
+
+Scope.prototype.generateUidBasedOnNode = function (parent, file) {
+  var node = parent;
+
+  if (t.isAssignmentExpression(parent)) {
+    node = parent.left;
+  } else if (t.isVariableDeclarator(parent)) {
+    node = parent.id;
+  } else if (t.isProperty(node)) {
+    node = node.key;
+  }
+
+  var parts = [];
+
+  var add = function (node) {
+    if (t.isMemberExpression(node)) {
+      add(node.object);
+      add(node.property);
+    } else if (t.isIdentifier(node)) {
+      parts.push(node.name);
+    } else if (t.isLiteral(node)) {
+      parts.push(node.value);
+    } else if (t.isCallExpression(node)) {
+      add(node.callee);
+    }
+  };
+
+  add(node);
+
+  var id = parts.join("$");
+  id = id.replace(/^_/, "") || "ref";
+
+  return file.generateUidIdentifier(id, this);
+};
+
+/**
+ * Description
+ *
+ * @param {Object} node
+ * @param {File} file
+ * @returns {Object}
+ */
+
+Scope.prototype.generateTempBasedOnNode = function (node, file) {
+  if (t.isIdentifier(node) && this.has(node.name, true)) {
+    return null;
+  }
+
+  var id = this.generateUidBasedOnNode(node, file);
+  this.push({
+    key: id.name,
+    id: id
+  });
+  return id;
+};
+
 Scope.prototype.getInfo = function () {
   var block = this.block;
   if (block._scopeInfo) return block._scopeInfo;
@@ -93,7 +164,7 @@ Scope.prototype.getInfo = function () {
 
         // this block is a function so we'll stop since none of the variables
         // declared within are accessible
-        if (t.isFunction(node)) return false;
+        if (t.isFunction(node)) return this.skip();
 
         // function identifier doesn't belong to this scope
         if (block.id && node === block.id) return;
@@ -123,6 +194,12 @@ Scope.prototype.getInfo = function () {
   return info;
 };
 
+/**
+ * Description
+ *
+ * @param {Object} opts
+ */
+
 Scope.prototype.push = function (opts) {
   var block = this.block;
 
@@ -143,33 +220,84 @@ Scope.prototype.push = function (opts) {
   }
 };
 
+/**
+ * Description
+ *
+ * @param {Object} node
+ */
+
 Scope.prototype.add = function (node) {
   Scope.add(node, this.references);
 };
 
+/**
+ * Description
+ *
+ * @param {String} [id]
+ * @param {Boolean} [decl]
+ */
+
 Scope.prototype.get = function (id, decl) {
   return id && (this.getOwn(id, decl) || this.parentGet(id, decl));
 };
 
+/**
+ * Description
+ *
+ * @param {String} [id]
+ * @param {Boolean} [decl]
+ */
+
 Scope.prototype.getOwn = function (id, decl) {
   var refs = this.references;
   if (decl) refs = this.declarations;
   return _.has(refs, id) && refs[id];
 };
 
+/**
+ * Description
+ *
+ * @param {String} [id]
+ * @param {Boolean} [decl]
+ */
+
 Scope.prototype.parentGet = function (id, decl) {
   return this.parent && this.parent.get(id, decl);
 };
 
+/**
+ * Description
+ *
+ * @param {String} [id]
+ * @param {Boolean} [decl]
+ * @returns {Boolean}
+ */
+
 Scope.prototype.has = function (id, decl) {
   return (id && (this.hasOwn(id, decl) || this.parentHas(id, decl))) ||
          _.contains(Scope.defaultDeclarations, id);
 };
 
+/**
+ * Description
+ *
+ * @param {String} [id]
+ * @param {Boolean} [decl]
+ * @returns {Boolean}
+ */
+
 Scope.prototype.hasOwn = function (id, decl) {
   return !!this.getOwn(id, decl);
 };
 
+/**
+ * Description
+ *
+ * @param {String} [id]
+ * @param {Boolean} [decl]
+ * @returns {Boolean}
+ */
+
 Scope.prototype.parentHas = function (id, decl) {
   return this.parent && this.parent.has(id, decl);
 };

lib/6to5/types/alias-keys.json

@@ -17,23 +17,23 @@
   "ExportDeclaration":   ["Statement", "Declaration"],
   "ImportDeclaration":   ["Statement", "Declaration"],
 
-  "ArrowFunctionExpression": ["Scope", "Function"],
+  "ArrowFunctionExpression": ["Scope", "Function", "Expression"],
   "FunctionDeclaration":     ["Statement", "Declaration", "Scope", "Function"],
-  "FunctionExpression":      ["Scope", "Function"],
+  "FunctionExpression":      ["Scope", "Function", "Expression"],
 
   "BlockStatement": ["Statement", "Scope"],
   "Program":        ["Scope"],
   "CatchClause":    ["Scope"],
 
-  "LogicalExpression": ["Binary"],
-  "BinaryExpression":  ["Binary"],
+  "LogicalExpression": ["Binary", "Expression"],
+  "BinaryExpression":  ["Binary", "Expression"],
 
-  "UnaryExpression": ["UnaryLike"],
+  "UnaryExpression": ["UnaryLike", "Expression"],
   "SpreadProperty":  ["UnaryLike"],
   "SpreadElement":   ["UnaryLike"],
 
   "ClassDeclaration": ["Statement", "Declaration", "Class"],
-  "ClassExpression":  ["Class"],
+  "ClassExpression":  ["Class", "Expression"],
 
   "ForOfStatement": ["Statement", "For", "Scope", "Loop"],
   "ForInStatement": ["Statement", "For", "Scope", "Loop"],
@@ -43,5 +43,27 @@
   "ArrayPattern":  ["Pattern"],
 
   "Property": ["UserWhitespacable"],
-  "XJSElement": ["UserWhitespacable"]
+  "XJSElement": ["UserWhitespacable", "Expression"],
+
+  "ArrayExpression": ["Expression"],
+  "AssignmentExpression": ["Expression"],
+  "AwaitExpression": ["Expression"],
+  "BindFunctionExpression": ["Expression"],
+  "BindMemberExpression": ["Expression"],
+  "CallExpression": ["Expression"],
+  "ComprehensionExpression": ["Expression"],
+  "ConditionalExpression": ["Expression"],
+  "Identifier": ["Expression"],
+  "Literal": ["Expression"],
+  "MemberExpression": ["Expression"],
+  "NewExpression": ["Expression"],
+  "ObjectExpression": ["Expression"],
+  "SequenceExpression": ["Expression"],
+  "TaggedTemplateExpression": ["Expression"],
+  "ThisExpression": ["Expression"],
+  "UpdateExpression": ["Expression"],
+  "VirtualPropertyExpression": ["Expression"],
+  "XJSEmptyExpression": ["Expression"],
+  "XJSMemberExpression": ["Expression"],
+  "YieldExpression": ["Expression"]
 }

lib/6to5/types/builder-keys.json

@@ -11,6 +11,8 @@
   "FunctionExpression":      ["id", "params", "body", "generator"],
   "Identifier":              ["name"],
   "IfStatement":             ["test", "consequent", "alternate"],
+  "ImportDeclaration":       ["specifiers", "source"],
+  "ImportSpecifier":         ["id", "name"],
   "Literal":                 ["value"],
   "LogicalExpression":       ["operator", "left", "right"],
   "MemberExpression":        ["object", "property", "computed"],

lib/6to5/types/index.js

@@ -64,15 +64,46 @@ _.each(t.FLIPPED_ALIAS_KEYS, function (types, type) {
   addAssert(type, is);
 });
 
-//
+/**
+ * Description
+ *
+ * @param {Object} node
+ * @returns {Object}
+ */
 
-t.isExpression = function (node) {
-  return !t.isStatement(node);
+t.toComputedKey = function (node, key) {
+  if (!node.computed) {
+    if (t.isIdentifier(key)) key = t.literal(key.name);
+  }
+  return key;
 };
 
-addAssert("Expression", t.isExpression);
+/*
+ * Shallowly checks to see if the passed `node` will evaluate to a
+ * falsy. This is if `node` is a `Literal` and `value` is falsy or
+ * `node` is an `Identifier` with a name of `undefiend`.
+ *
+ * @param {Object} node
+ * @returns {Boolean}
+ */
 
-//
+t.isFalsyExpression = function (node) {
+  if (t.isLiteral(node)) {
+    return !node.value;
+  } else if (t.isIdentifier(node)) {
+    return node.name === "undefined";
+  }
+  return false;
+};
+
+/**
+ * Turn an array of statement `nodes` into a `SequenceExpression`.
+ *
+ * Variable declarations are turned into simple assignments and their
+ * declarations hoisted to the top of the current scope.
+ *
+ * Expression statements are just resolved to their standard expression.
+ */
 
 t.toSequenceExpression = function (nodes, scope) {
   var exprs = [];
@@ -94,7 +125,11 @@ t.toSequenceExpression = function (nodes, scope) {
     }
   });
 
-  return t.sequenceExpression(exprs);
+  if (exprs.length === 1) {
+    return exprs[0];
+  } else {
+    return t.sequenceExpression(exprs);
+  }
 };
 
 //
@@ -113,21 +148,43 @@ t.shallowEqual = function (actual, expected) {
   return same;
 };
 
-//
+/**
+ * Description
+ *
+ * @param {Object} member
+ * @param {Object} append
+ * @param {Boolean} [computed]
+ * @returns {Object} member
+ */
 
-t.isDynamic = function (node) {
-  if (t.isExpressionStatement(node)) {
-    return t.isDynamic(node.expression);
-  } else if (t.isIdentifier(node) || t.isLiteral(node) || t.isThisExpression(node)) {
-    return false;
-  } else if (t.isMemberExpression(node)) {
-    return t.isDynamic(node.object) || t.isDynamic(node.property);
-  } else {
-    return true;
-  }
+t.appendToMemberExpression = function (member, append, computed) {
+  member.object   = t.memberExpression(member.object, member.property, member.computed);
+  member.property = append;
+  member.computed = !!computed;
+  return member;
 };
 
-// todo: https://github.com/eventualbuddha/ast-util/blob/9bf91c5ce8/lib/index.js#L454-L507
+/**
+ * Description
+ *
+ * @param {Object} member
+ * @param {Object} append
+ * @returns {Object} member
+ */
+
+t.prependToMemberExpression = function (member, append) {
+  member.object = t.memberExpression(append, member.object);
+  return member;
+};
+
+/**
+ * Description
+ *
+ * @param {Object} node
+ * @param {Object} parent
+ * @returns {Boolean}
+ */
+
 t.isReferenced = function (node, parent) {
   // we're a property key and we aren't computed so we aren't referenced
   if (t.isProperty(parent) && parent.key === node && !parent.computed) return false;
@@ -149,11 +206,29 @@ t.isReferenced = function (node, parent) {
   return false;
 };
 
+/**
+ * Description
+ *
+ * @param {String} name
+ * @returns {Boolean}
+ */
+
+t.isValidIdentifier = function (name) {
+  return _.isString(name) && esutils.keyword.isIdentifierName(name) && !esutils.keyword.isKeywordES6(name, true);
+};
+
+/*
+ * Description
+ *
+ * @param {String} name
+ * @returns {String}
+ */
+
 t.toIdentifier = function (name) {
   if (t.isIdentifier(name)) return name.name;
 
   // replace all non-valid identifiers with dashes
-  name = name.replace(/[^a-zA-Z0-9]/g, "-");
+  name = name.replace(/[^a-zA-Z0-9$_]/g, "-");
 
   // remove all dashes and numbers from start of name
   name = name.replace(/^[-0-9]+/, "");
@@ -163,18 +238,32 @@ t.toIdentifier = function (name) {
     return c ? c.toUpperCase() : "";
   });
 
+  // remove underscores from start of name
+  name = name.replace(/^\_/, "");
+
   return name || '_';
 };
 
-t.isValidIdentifier = function (name) {
-  return _.isString(name) && esutils.keyword.isIdentifierName(name) && !esutils.keyword.isKeywordES6(name, true);
-};
+/**
+ * Description
+ *
+ * @param {Object} node
+ * @param {String} key
+ */
 
 t.ensureBlock = function (node, key) {
   key = key || "body";
   node[key] = t.toBlock(node[key], node);
 };
 
+/**
+ * Description
+ *
+ * @param {Object} node
+ * @param {Boolean} [ignore]
+ * @returns {Object|Boolean}
+ */
+
 t.toStatement = function (node, ignore) {
   if (t.isStatement(node)) {
     return node;
@@ -208,6 +297,14 @@ t.toStatement = function (node, ignore) {
   return node;
 };
 
+/**
+ * Description
+ *
+ * @param {Object} node
+ * @param {Object} parent
+ * @returns {Object}
+ */
+
 t.toBlock = function (node, parent) {
   if (t.isBlockStatement(node)) {
     return node;
@@ -228,6 +325,15 @@ t.toBlock = function (node, parent) {
   return t.blockStatement(node);
 };
 
+/**
+ * Description
+ *
+ * @param {Object} node
+ * @param {Boolean} [map]
+ * @param {Array} [ignoreTypes]
+ * @returns {Array|Object}
+ */
+
 t.getIds = function (node, map, ignoreTypes) {
   ignoreTypes = ignoreTypes || [];
 
@@ -278,27 +384,69 @@ t.getIds.arrays = {
   ObjectPattern: ["properties"]
 };
 
+/**
+ * Description
+ *
+ * @param {Object} node
+ * @returns {Boolean}
+ */
+
 t.isLet = function (node) {
   return t.isVariableDeclaration(node) && (node.kind !== "var" || node._let);
 };
 
+/**
+ * Description
+ *
+ * @param {Object} node
+ * @returns {Boolean}
+ */
+
 t.isVar = function (node) {
   return t.isVariableDeclaration(node, { kind: "var" }) && !node._let;
 };
 
+//
+
+t.COMMENT_KEYS = ["leadingComments", "trailingComments"];
+
+/**
+ * Description
+ *
+ * @param {Object} child
+ * @returns {Object} child
+ */
+
 t.removeComments = function (child) {
-  delete child.leadingComments;
-  delete child.trailingComments;
+  _.each(t.COMMENT_KEYS, function (key) {
+    delete child[key];
+  });
   return child;
 };
 
+/**
+ * Description
+ *
+ * @param {Object} child
+ * @param {Object} parent
+ * @returns {Object} child
+ */
+
 t.inheritsComments = function (child, parent) {
-  _.each(["leadingComments", "trailingComments"], function (key) {
+  _.each(t.COMMENT_KEYS, function (key) {
     child[key]  = _.uniq(_.compact([].concat(child[key], parent[key])));
   });
   return child;
 };
 
+/**
+ * Description
+ *
+ * @param {Object} child
+ * @param {Object} parent
+ * @returns {Object} child
+ */
+
 t.inherits = function (child, parent) {
   child.loc   = parent.loc;
   child.end   = parent.end;
@@ -308,10 +456,24 @@ t.inherits = function (child, parent) {
   return child;
 };
 
+/**
+ * Description
+ *
+ * @param {Object} specifier
+ * @returns {String}
+ */
+
 t.getSpecifierName = function (specifier) {
   return specifier.name || specifier.id;
 };
 
+/**
+ * Description
+ *
+ * @param {Object} specifier
+ * @returns {Boolean}
+ */
+
 t.isSpecifierDefault = function (specifier) {
   return t.isIdentifier(specifier.id) && specifier.id.name === "default";
 };

lib/6to5/util.js

@@ -52,22 +52,6 @@ exports.arrayify = function (val) {
   throw new TypeError("illegal type for arrayify");
 };
 
-exports.getUid = function (parent, file) {
-  var node;
-
-  if (t.isAssignmentExpression(parent)) {
-    node = parent.left;
-  } else if (t.isVariableDeclarator(parent)) {
-    node = parent.id;
-  }
-
-  var id = "ref";
-
-  if (t.isIdentifier(node)) id = node.name;
-
-  return file.generateUidIdentifier(id);
-};
-
 exports.isAbsolute = function (loc) {
   if (!loc) return false;
   if (loc[0] === "/") return true; // unix

package.json

@@ -1,7 +1,7 @@
 {
   "name": "6to5",
   "description": "Turn ES6 code into readable vanilla ES5 with source maps",
-  "version": "2.2.0",
+  "version": "2.5.0",
   "author": "Sebastian McKenzie <sebmck@gmail.com>",
   "homepage": "https://github.com/6to5/6to5",
   "repository": {
@@ -18,6 +18,10 @@
     "6to5-node": "./bin/6to5-node",
     "6to5-runtime": "./bin/6to5-runtime"
   },
+  "browser": {
+    "./lib/6to5/index.js": "./lib/6to5/browser.js",
+    "./lib/6to5/register.js": "./lib/6to5/register-browser.js"
+  },
   "keywords": [
     "harmony",
     "classes",
@@ -35,7 +39,7 @@
     "test": "make test"
   },
   "dependencies": {
-    "acorn-6to5": "0.9.1-16",
+    "acorn-6to5": "0.11.1-10",
     "ast-types": "~0.6.1",
     "chokidar": "0.11.1",
     "commander": "2.5.0",

test/_helper.js

@@ -1,5 +1,6 @@
-var fs = require("fs");
-var _  = require("lodash");
+var path = require("path");
+var fs   = require("fs");
+var _    = require("lodash");
 
 var humanise = function (val) {
   return val.replace(/-/g, " ");
@@ -37,7 +38,6 @@ exports.get = function (entryName) {
 
     _.each(fs.readdirSync(suite.filename), function (taskName) {
       var taskDir = suite.filename + "/" + taskName;
-      if (fs.statSync(taskDir).isFile()) return;
 
       var actualLocAlias = suiteName + "/" + taskName + "/actual.js";
       var expectLocAlias = suiteName + "/" + taskName + "/expected.js";
@@ -47,6 +47,13 @@ exports.get = function (entryName) {
       var expectLoc = taskDir + "/expected.js";
       var execLoc   = taskDir + "/exec.js";
 
+      if (fs.statSync(taskDir).isFile()) {
+        var ext = path.extname(taskDir);
+        if (ext !== ".js") return;
+
+        execLoc = taskDir;
+      }
+
       var taskOpts = _.merge({
         filenameRelative: expectLocAlias,
         sourceFileName:   actualLocAlias,

test/api.js

@@ -13,10 +13,10 @@ suite("api", function () {
     assert.ok(!result.ast);
   });
 
-  test("addDeclaration unknown", function () {
+  test("addHelper unknown", function () {
     var file = new File;
     assert.throws(function () {
-      file.addDeclaration("foob");
+      file.addHelper("foob");
     }, /unknown declaration foob/);
   });
 });

test/browserify.js

@@ -0,0 +1,19 @@
+var browserify = require("browserify");
+var assert = require("assert");
+var path = require("path");
+var vm = require("vm");
+
+suite("browserify", function() {
+  test("6to5/register may be used without breaking browserify", function(done) {
+    var bundler = browserify(path.join(__dirname, "fixtures/browserify/register.js"));
+
+    bundler.bundle(function(err, bundle) {
+      if (err) return done(err);
+      assert.ok(bundle.length, "bundle output code");
+
+      // ensure that the code runs without throwing an exception
+      vm.runInNewContext(bundle, {});
+      done();
+    })
+  })
+});

test/fixtures/browserify/register.js

@@ -0,0 +1,3 @@
+require("../../../register")({
+  ignore: false
+});

test/fixtures/generation/harmony-edgecase/class-declaration/actual.js

@@ -2,8 +2,6 @@ class Test {
 }
 class Derived extends Super {
 }
-class Derived2 extends Super() {
-}
 class StaticMethods {
   static n1() {
   }

test/fixtures/generation/harmony-edgecase/class-declaration/expected.js

@@ -1,6 +1,5 @@
 class Test {}
 class Derived extends Super {}
-class Derived2 extends Super() {}
 class StaticMethods {
   static n1() {}
 

test/fixtures/generation/harmony-edgecase/class-expression/actual.js

@@ -1,6 +1,5 @@
 (class Test { });
 (class Derived extends Super { });
-(class Derived2 extends Super() { });
 (class StaticMethods {
   static n1() {
   }
@@ -54,4 +53,3 @@
   }
 });
 (class { });
-(class extends Super() { });

test/fixtures/generation/harmony-edgecase/class-expression/expected.js

@@ -1,6 +1,5 @@
 (class Test {});
 (class Derived extends Super {});
-(class Derived2 extends Super() {});
 (class StaticMethods {
   static n1() {}
 
@@ -38,4 +37,3 @@
   *[gen1]() {}
 });
 (class {});
-(class extends Super() {});

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

@@ -1,21 +0,0 @@
-System.register([], function (_export) {
-  _export("foo7", foo7);
-
-  function foo7() {}
-  return {
-    setters: [],
-    execute: function () {
-      "use strict";
-
-      var foo = _export("foo", 1);
-      var foo2 = _export("foo2", function () {});
-      var foo3 = _export("foo3", undefined);
-      var foo4 = _export("foo4", 2);
-      var foo5 = _export("foo5", undefined);
-      var foo6 = _export("foo6", 3);
-      var foo8 = function foo8() {};
-
-      _export("foo8", foo8);
-    }
-  };
-});

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

@@ -1,14 +0,0 @@
-System.register([], function (_export) {
-  var _foo;
-  return {
-    setters: [function (m) {
-      _foo = m
-    }],
-    execute: function () {
-      "use strict";
-
-      var foo = _foo["default"];
-      var foo = _foo["default"];
-    }
-  };
-});

test/fixtures/transformation/.es6-modules-system/imports-glob/expected.js

@@ -1,13 +0,0 @@
-System.register(["foo"], function (_export) {
-  var _foo;
-  return {
-    setters: [function (m) {
-      _foo = m
-    }],
-    execute: function () {
-      "use strict";
-
-      var foo = _foo;
-    }
-  };
-});

test/fixtures/transformation/.es6-modules-system/imports-mixing/expected.js

@@ -1,14 +0,0 @@
-System.register(["foo"], function (_export) {
-  var _foo;
-  return {
-    setters: [function (m) {
-      _foo = m
-    }],
-    execute: function () {
-      "use strict";
-
-      var foo = _foo["default"];
-      var xyz = _foo.baz;
-    }
-  };
-});

test/fixtures/transformation/.es6-modules-system/imports-named/expected.js

@@ -1,18 +0,0 @@
-System.register(["foo"], function (_export) {
-  var _foo;
-  return {
-    setters: [function (m) {
-      _foo = m
-    }],
-    execute: function () {
-      "use strict";
-
-      var bar = _foo.bar;
-      var bar = _foo.bar;
-      var baz = _foo.baz;
-      var baz = _foo.bar;
-      var baz = _foo.bar;
-      var xyz = _foo.xyz;
-    }
-  };
-});

test/fixtures/transformation/.es6-modules-system/imports/expected.js

@@ -1,15 +0,0 @@
-System.register(["foo", "foo-bar", "./directory/foo-bar"], function (_export) {
-  var _foo, _fooBar, _directoryFooBar;
-  return {
-    setters: [function (m) {
-      _foo = m
-    }, function (m) {
-      _fooBar = m
-    }, function (m) {
-      _directoryFooBar = m
-    }],
-    execute: function () {
-      "use strict";
-    }
-  };
-});

test/fixtures/transformation/.es6-modules-system/overview/expected.js

@@ -1,25 +0,0 @@
-System.register(["foo", "foo-bar", "./directory/foo-bar"], function (_export) {
-  var _foo, _fooBar, _directoryFooBar;
-  return {
-    setters: [function (m) {
-      _foo = m
-    }, function (m) {
-      _fooBar = m
-    }, function (m) {
-      _directoryFooBar = m
-    }],
-    execute: function () {
-      "use strict";
-
-      var foo = _foo["default"];
-      var foo = _foo;
-      var bar = _foo.bar;
-      var bar = _foo.foo;
-      _export("test", test);
-
-      var test = _export("test", 5);
-
-      _export("default", test);
-    }
-  };
-});

test/fixtures/transformation/es5-property-methods-assignment/getter-and-setter/expected.js

@@ -1,17 +0,0 @@
-"use strict";
-
-var obj = (function (_obj) {
-  Object.defineProperties(_obj, {
-    foo: {
-      get: function () {
-        return 5 + 5;
-      },
-      set: function (value) {
-        this._foo = value;
-      },
-      enumerable: true
-    }
-  });
-
-  return _obj;
-})({});

test/fixtures/transformation/es5-property-methods-assignment/getter/expected.js

@@ -1,14 +0,0 @@
-"use strict";
-
-var obj = (function (_obj) {
-  Object.defineProperties(_obj, {
-    foo: {
-      get: function () {
-        return 5 + 5;
-      },
-      enumerable: true
-    }
-  });
-
-  return _obj;
-})({});

test/fixtures/transformation/es5-property-methods-assignment/setter/expected.js

@@ -1,14 +0,0 @@
-"use strict";
-
-var obj = (function (_obj) {
-  Object.defineProperties(_obj, {
-    foo: {
-      set: function (value) {
-        this._foo = value;
-      },
-      enumerable: true
-    }
-  });
-
-  return _obj;
-})({});

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

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

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

@@ -1,13 +1,13 @@
 module.exports = {
-  init() {
-  return new Promise((resolve, reject) => {
-    MongoClient.connect(config.mongodb, (err, db) => {
-    if (err) {
-      return reject(err);
-    }
-    this.db = db;
-    resolve(this);
+  init: function () {
+    return new Promise((resolve, reject) => {
+      MongoClient.connect(config.mongodb, (err, db) => {
+        if (err) {
+          return reject(err);
+        }
+        this.db = db;
+        resolve(this);
+      });
     });
-  });
   }
 };

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

@@ -13,29 +13,37 @@ var _inherits = function (child, parent) {
   if (parent) child.__proto__ = parent;
 };
 
-var Test = function Test() {
-  woops["super"].test();
-  Foo.call(this);
-  Foo.prototype.test.call(this);
-  foob(Foo);
+var Test = (function () {
+  var _Foo = Foo;
+  var Test = function Test() {
+    var _Foo$prototype$test, _Foo$prototype$test2;
+    woops["super"].test();
+    _Foo.call(this);
+    _Foo.prototype.test.call(this);
+    foob(_Foo);
 
-  Foo.call.apply(Foo, [this].concat(_slice.call(arguments)));
-  Foo.call.apply(Foo, [this, "test"].concat(_slice.call(arguments)));
+    _Foo.call.apply(_Foo, [this].concat(_slice.call(arguments)));
+    _Foo.call.apply(_Foo, [this, "test"].concat(_slice.call(arguments)));
 
-  Foo.prototype.test.call.apply(Foo.prototype, [this].concat(_slice.call(arguments)));
-  Foo.prototype.test.call.apply(Foo.prototype, [this, "test"].concat(_slice.call(arguments)));
-};
+    (_Foo$prototype$test = _Foo.prototype.test).call.apply(_Foo$prototype$test, [this].concat(_slice.call(arguments)));
+    (_Foo$prototype$test2 = _Foo.prototype.test).call.apply(_Foo$prototype$test2, [this, "test"].concat(_slice.call(arguments)));
+  };
 
-_inherits(Test, Foo);
+  _inherits(Test, _Foo);
 
-Test.prototype.test = function () {
-  Foo.prototype.test.call(this);
-  Foo.prototype.test.call.apply(Foo.prototype.test, [this].concat(_slice.call(arguments)));
-  Foo.prototype.test.call.apply(Foo.prototype.test, [this, "test"].concat(_slice.call(arguments)));
-};
+  Test.prototype.test = function () {
+    var _Foo$prototype$test3, _Foo$prototype$test4;
+    _Foo.prototype.test.call(this);
+    (_Foo$prototype$test3 = _Foo.prototype.test).call.apply(_Foo$prototype$test3, [this].concat(_slice.call(arguments)));
+    (_Foo$prototype$test4 = _Foo.prototype.test).call.apply(_Foo$prototype$test4, [this, "test"].concat(_slice.call(arguments)));
+  };
 
-Test.foo = function () {
-  Foo.foo.call(this);
-  Foo.foo.call.apply(Foo.foo, [this].concat(_slice.call(arguments)));
-  Foo.foo.call.apply(Foo.foo, [this, "test"].concat(_slice.call(arguments)));
-};
+  Test.foo = function () {
+    var _Foo$foo, _Foo$foo2;
+    _Foo.foo.call(this);
+    (_Foo$foo = _Foo.foo).call.apply(_Foo$foo, [this].concat(_slice.call(arguments)));
+    (_Foo$foo2 = _Foo.foo).call.apply(_Foo$foo2, [this, "test"].concat(_slice.call(arguments)));
+  };
+
+  return Test;
+})();

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

@@ -12,9 +12,14 @@ var _inherits = function (child, parent) {
   if (parent) child.__proto__ = parent;
 };
 
-var Test = function Test() {
-  Foo.prototype.test;
-  Foo.prototype.test.whatever;
-};
+var Test = (function () {
+  var _Foo = Foo;
+  var Test = function Test() {
+    _Foo.prototype.test;
+    _Foo.prototype.test.whatever;
+  };
 
-_inherits(Test, Foo);
+  _inherits(Test, _Foo);
+
+  return Test;
+})();

test/fixtures/transformation/es6-classes/calling-super-properties/expected.js

@@ -12,13 +12,18 @@ var _inherits = function (child, parent) {
   if (parent) child.__proto__ = parent;
 };
 
-var Test = function Test() {
-  Foo.prototype.test.whatever();
-  Foo.prototype.test.call(this);
-};
+var Test = (function () {
+  var _Foo = Foo;
+  var Test = function Test() {
+    _Foo.prototype.test.whatever();
+    _Foo.prototype.test.call(this);
+  };
 
-_inherits(Test, Foo);
+  _inherits(Test, _Foo);
 
-Test.test = function () {
-  return Foo.wow.call(this);
-};
+  Test.test = function () {
+    return _Foo.wow.call(this);
+  };
+
+  return Test;
+})();

test/fixtures/transformation/es6-classes/constructor/expected.js

@@ -16,8 +16,13 @@ var Test = function Test() {
   this.state = "test";
 };
 
-var Foo = function Foo() {
-  this.state = "test";
-};
+var Foo = (function () {
+  var _Bar = Bar;
+  var Foo = function Foo() {
+    this.state = "test";
+  };
 
-_inherits(Foo, Bar);
+  _inherits(Foo, _Bar);
+
+  return Foo;
+})();

test/fixtures/transformation/es6-classes/super-class-id-member-expression/expected.js

@@ -12,18 +12,28 @@ var _inherits = function (child, parent) {
   if (parent) child.__proto__ = parent;
 };
 
-var BaseController = function BaseController() {
-  if (Chaplin.Controller) {
-    Chaplin.Controller.apply(this, arguments);
-  }
-};
+var BaseController = (function () {
+  var _Chaplin$Controller = Chaplin.Controller;
+  var BaseController = function BaseController() {
+    if (_Chaplin$Controller) {
+      _Chaplin$Controller.apply(this, arguments);
+    }
+  };
 
-_inherits(BaseController, Chaplin.Controller);
+  _inherits(BaseController, _Chaplin$Controller);
 
-var BaseController2 = function BaseController2() {
-  if (Chaplin.Controller.Another) {
-    Chaplin.Controller.Another.apply(this, arguments);
-  }
-};
+  return BaseController;
+})();
 
-_inherits(BaseController2, Chaplin.Controller.Another);
+var BaseController2 = (function () {
+  var _Chaplin$Controller$Another = Chaplin.Controller.Another;
+  var BaseController2 = function BaseController2() {
+    if (_Chaplin$Controller$Another) {
+      _Chaplin$Controller$Another.apply(this, arguments);
+    }
+  };
+
+  _inherits(BaseController2, _Chaplin$Controller$Another);
+
+  return BaseController2;
+})();