v2.9.1

Ensure more than one level of superclass works.

.gitignore

@@ -10,3 +10,4 @@ test/tmp
 /runtime.js
 coverage
 dist
+.package.json

.gitmodules

@@ -0,0 +1,9 @@
+[submodule "vendor/traceur"]
+	path = vendor/traceur
+	url = https://github.com/google/traceur-compiler
+[submodule "vendor/regenerator"]
+	path = vendor/regenerator
+	url = https://github.com/facebook/regenerator
+[submodule "vendor/test262"]
+	path = vendor/test262
+	url = https://github.com/tc39/test262

.npmignore

@@ -9,3 +9,4 @@ Makefile
 dist
 tests.json
 CHANGELOG.md
+.package.json

CHANGELOG.md

@@ -1,6 +1,126 @@
 # Changelog
 
-Gaps between patch versions are faulty/broken releases.
+> **Tags:**
+> - [New Feature]
+> - [Bug Fix]
+> - [Spec Compliancy]
+> - [Breaking Change]
+> - [Documentation]
+> - [Internal]
+> - [Polish]
+
+_Note: Gaps between patch versions are faulty/broken releases._
+
+## 2.9.1
+
+ * **Internal**
+  * Fix runtime generator breaking the helper inclusion loop.
+
+## 2.9.0
+
+ * **Internal**
+  * Upgrade `acorn-6to5`.
+    * Now supports destructuring shorthand properties.
+
+## 2.8.1
+
+ * **Bug Fix**
+  * Fix computed accessors on object literals.
+
+## 2.8.0
+
+ * **New Feature**
+  * Add `commonStrict`, `amdStrict` and `umdStrict` module formatters that remove `module.exports` interop assignment.
+  * Add `--indent` option to the 6to5 CLI.
+
+## 2.7.4
+
+ * **Polish**
+  * Inherit assignments from their declaration in destructuring.
+  * Properly align multi-declarator variable declarations.
+
+## 2.7.3
+
+ * **Polish**
+  * Indent and add newlines to `React.createElement` calls in `react` transformer.
+  * Remove `Object.assign` calls and replace it with an `extends` helper.
+
+## 2.7.1
+
+ * **New Feature**
+  * Expose `version` on browser and node API.
+ * **Internal**
+  * Upgrade `core-js` to 0.4.1
+
+## 2.7.0
+
+ * **Spec Compliancy**
+  * Disallow reassignments of imports.
+ * **New Feature**
+  * `reactCompat` option to enable pre-v0.12 react components.
+
+## 2.6.3
+
+ * **Bug Fix**
+  * Fix 2.6.0 regression caused by faulty export default from a source handling.
+
+## 2.6.2
+
+ * **Bug Fix**
+  * Fix rest parameter keys when on functions with params.
+
+## 2.6.1
+
+ * **Bug Fix**
+  * Fix rest parameter arguments key.
+
+## 2.6.0
+
+ * **Bug Fix**
+  * Better handling of number literal property keys.
+  * Handle `NewExpression` paren insertion edegcases better.
+ * **Internal**
+  * Fix incorrect AST node `identifier("this")`.
+  * Better `toIdentifier` method that handles reserved words.
+  * Upgrade `acorn-6to5`.
+    * Fix exponentiation operator precedence.
+    * Fix line terminators after async contextual keywords.
+    * Add semicolons as class elements inside of a class body.
+  * Upgrade to `core-js` 4.0.0.
+  * Upgrade to `regenerator` 0.8.3.
+    * Fix non-loop labeled statements.
+ * **New Feature**
+  * Basic destructuring defaults
+  * Add `.es` to list of supported extensions.
+  * Add optional `typeofSymbol` transformer.
+  * Use a `for` loop for rest parameters instead of `Array.prototype.slice`.
+ * **Polish**
+  * Move `"use strict";` to inside module bodies instead of at the top of the file.
+  * Better handling of dynamic imports.
+ * **Spec Compliancy**
+  * Class inheritance now has a `function` or `null` type check.
+  * Add `interopRequireWildcard` around wildcard imports and exports to handle non-object exports.
+
+## 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
 

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

Makefile

@@ -6,44 +6,7 @@ MOCHA_CMD = node_modules/mocha/bin/_mocha
 
 export NODE_ENV = test
 
-.PHONY: clean test test-cov test-clean lint test-travis test-spec test-browser publish bench build
-
-clean:
-	rm -rf coverage templates.json test/tmp dist
-
-bench:
-	npm install es6-transpiler traceur esnext es6now jstransform
-	node node_modules/matcha/bin/_matcha
-
-lint:
-	$(JSHINT_CMD) --reporter node_modules/jshint-stylish/stylish.js lib bin benchmark/index.js
-
-test-clean:
-	rm -rf test/tmp
-
-test: lint
-	$(MOCHA_CMD)
-	make test-clean
-
-test-cov:
-	rm -rf coverage
-	node $(ISTANBUL_CMD) $(MOCHA_CMD) --
-
-test-spec:
-	node $(ISTANBUL_CMD) $(MOCHA_CMD) -- --reporter spec
-
-test-travis: test-spec
-	if test -n "$$CODECLIMATE_REPO_TOKEN"; then codeclimate < coverage/lcov.info; fi
-
-test-browser:
-	mkdir -p dist
-
-	node bin/cache-templates
-	node bin/cache-tests
-	node $(BROWSERIFY_CMD) -e test/_browser.js >dist/6to5-test.js
-	rm -rf templates.json tests.json
-
-	test -n "`which open`" && open test/browser.html
+.PHONY: clean test test-cov test-clean lint test-travis test-simple test-all test-browser publish build bootstrap publish-core
 
 build:
 	mkdir -p dist
@@ -61,6 +24,48 @@ build:
 
 	rm -rf templates.json
 
+clean:
+	rm -rf coverage templates.json test/tmp dist
+
+lint:
+	$(JSHINT_CMD) --reporter node_modules/jshint-stylish/stylish.js lib bin
+
+test-clean:
+	rm -rf test/tmp
+
+test: lint
+	$(MOCHA_CMD)
+	make test-clean
+
+test-simple:
+	# excludes test262
+	export SIMPLE_6TO5_TESTS=1
+	make test
+
+test-all:
+	# includes traceur, esnext, regenerator
+	export ALL_6TO5_TESTS=1
+	make test
+
+test-cov:
+	export SIMPLE_6TO5_TESTS=1
+	rm -rf coverage
+	node $(ISTANBUL_CMD) $(MOCHA_CMD) --
+
+test-travis: bootstrap
+	node $(ISTANBUL_CMD) $(MOCHA_CMD) --
+	if test -n "$$CODECLIMATE_REPO_TOKEN"; then codeclimate < coverage/lcov.info; fi
+
+test-browser:
+	mkdir -p dist
+
+	node bin/cache-templates
+	node bin/cache-tests
+	node $(BROWSERIFY_CMD) -e test/_browser.js >dist/6to5-test.js
+	rm -rf templates.json tests.json
+
+	test -n "`which open`" && open test/browser.html
+
 publish:
 	git pull --rebase
 
@@ -80,4 +85,20 @@ publish:
 
 	git push --follow-tags
 
+	# generate
+	bin/generate-core-package-json >package2.json
+	mv package.json .package.json
+	mv package2.json package.json
+
+	npm publish
+
+	# restore
+	rm -rf package.json
+	mv .package.json package.json
+
 	rm -rf templates.json browser.js runtime.js browser-polyfill.js
+
+bootstrap:
+	npm install
+	git submodule update --init
+	cd vendor/regenerator; npm install

NOTES.md

@@ -0,0 +1,9 @@
+# Notes
+
+ * Wildcard exports/imports wont normalise if `export default` is a non-object. See [#224](https://github.com/6to5/6to5/issues/224).
+
+## 3.0.0 breaking changes
+
+ * Remove `allowImportExportEverywhere` option from acorn.
+ * Remove this shorthand from playground.
+ * Remove `super()` inside non-constructors - add descriptive error message.

benchmark/fixtures/all.js

@@ -1,99 +0,0 @@
-var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-var obj = {};
-var foo = "foo";
-var bar = "bar";
-
-// constants
-const MULTIPLIER = 5;
-
-// classes
-class Foo {
-  constructor() {
-    this.foo = "bar";
-  }
-}
-
-class Bar extends Foo {
-  constructor() {
-    super();
-  }
-
-  // default parameters
-  go(foo = "bar", bar = "foo") {
-
-  }
-
-  // not supported by jstransform
-  //get foo() {
-  //  return this._foo;
-  //}
-  //set foo(val) {
-  //  this._foo = val + " foo!";
-  //}
-}
-
-// arrow functions
-arr.map(x => x * x);
-
-// block binding
-for (let key in arr) {
-  let val = arr[key];
-  console.log(key, val);
-}
-
-// computed property names
-obj = {
-  ["foo" + bar]: "foobar"
-};
-
-// destructuring
-var [a, [b], c, d] = ["hello", [", ", "junk"], ["world"]];
-console.log(a + b + c);
-
-// array comprehension
-// [for (i of [1, 2, 3]) i * i]; // not supported by es6now
-
-// for-of
-for (var i of [1, 2, 3]) {
-  console.log(i * i);
-}
-
-// property method assignment
-obj = {
-  foo() {
-    return "foobar";
-  },
-
-  get bar() {
-    return this._bar;
-  },
-
-  set bar(val) {
-    this._bar = val;
-  }
-};
-
-// property name shorthand
-function f(x, y) {
-  return { x, y };
-}
-
-// rest parameters
-function printList(name, ...items) {
-  console.log("list %s has the following items", name);
-  items.forEach(function (item) {
-    console.log(item);
-  });
-}
-
-// spread
-function add(x, y) {
-  return x + y;
-}
-var numbers = [5, 10];
-add(...numbers);
-
-// template literals
-var x = 5;
-var y = 10;
-console.log(`${x} + ${y} = ${x + y}`);

benchmark/index.js

@@ -1,168 +0,0 @@
-Error.stackTraceLimit = Infinity;
-
-var jsTrans = require("jstransform");
-var traceur = require("traceur");
-//var es6tr   = require("es6-transpiler");
-var es6now  = require("es6now");
-//var esnext  = require("esnext");
-var to5     = require("../lib/6to5");
-
-//var uglify  = require("uglify-js");
-var matcha  = require("matcha");
-var path    = require("path");
-var fs      = require("fs");
-var _       = require("lodash");
-
-var readResolve = function (filename) {
-  try {
-    filename = require.resolve(filename);
-  } catch (err) {
-    return null;
-  }
-  return fs.readFileSync(filename, "utf8");
-};
-
-var getVersion = function (name) {
-  return require(name + "/package.json").version;
-};
-
-var jsTransVisitors = [];
-
-_.each([
-  "arrow-function-visitors", "class-visitors", "destructuring-visitors",
-  "object-concise-method-visitors", "object-short-notation-visitors",
-  "rest-param-visitors", "template-visitors"
-], function (name) {
-  var mod = require("jstransform/visitors/es6-" + name);
-  jsTransVisitors = jsTransVisitors.concat(mod.visitorList);
-});
-
-
-var compilers = {
-  "6to5": {
-    version: getVersion(".."),
-    compile: function (code, filename) {
-      return to5.transform(code, { filename: filename }).code;
-    }
-  },
-
-  traceur: {
-    runtime: readResolve("traceur/bin/traceur-runtime.js"),
-    compile: function (code) {
-      return traceur.compile(code, {
-        modules: "commonjs",
-        experimental: true
-      });
-    }
-  },
-
-  /*esnext: {
-    runtime: readResolve("esnext/node_modules/regenerator/runtime.js") || readResolve("regenerator/runtime.js"),
-    compile: function (code) {
-      return esnext.compile(code).code;
-    }
-  },*/
-
-  es6now: {
-    runtime: readResolve("es6now/runtime/ES6.js"),
-    compile: function (code) {
-      return es6now.translate(code);
-    }
-  },
-
-  /*"es6-transpiler": {
-    compile: function (code) {
-      var result = es6tr.run({ src: code });
-      if (result.errors.length) throw new Error(result.join("; "));
-      return result.src;
-    }
-  },*/
-
-  jstransform: {
-    compile: function (code) {
-      return jsTrans.transform(jsTransVisitors, code).code;
-    }
-  }
-};
-
-// versions
-
-//var uglifyTitle = "uglify v" + getVersion("uglify-js");
-
-_.each(compilers, function (compiler, name) {
-  compiler.title = name + " v" + (compiler.version || getVersion(name));
-});
-
-//
-
-var sizeBenchmark = function (code, loc, name, compiler) {
-  var log = function (output, title) {
-    title = [compiler.title].concat(title || []).join(" + ");
-
-    var text;
-    var color;
-    if (output.stack) {
-      text = "error";
-      color = "red";
-    } else {
-      var kilo  = (output.length / 1024).toFixed(2);
-      text = kilo + "KB";
-      color = "cyan";
-    }
-
-    text = matcha.utils.color(matcha.utils.padBefore(text, 22), color);
-
-    console.log(text, matcha.utils.color("» " + title, "gray"));
-
-    if (output.stack) {
-      console.error(output.stack);
-    }
-  };
-
-  var go = function (getOutput, title) {
-    var code;
-    try {
-      code = getOutput();
-    } catch (err) {
-      log(err, title);
-      return;
-    }
-
-    log(code, title);
-  };
-
-  var output;
-  go(function () {
-    return output = compiler.compile(code, loc);
-  });
-  if (!output) return;
-
-  //go(function () {
-  //  return uglify.minify(output, { fromString: true }).code;
-  //}, uglifyTitle);
-};
-
-//
-
-_.each(fs.readdirSync(__dirname + "/fixtures"), function (name) {
-  var alias = path.basename(name, path.extname(name));
-
-  suite(alias, function () {
-    set("delay", 0);
-
-    var loc  = __dirname + "/fixtures/" + name;
-    var code = fs.readFileSync(loc, "utf8");
-
-    before(function () {
-      _.each(compilers, function (compiler, name) {
-        sizeBenchmark(code, loc, name, compiler);
-      });
-    });
-
-    _.each(compilers, function (compiler) {
-      bench(compiler.title, function () {
-        compiler.compile(code, loc);
-      });
-    });
-  });
-});

bin/6to5/index.js

@@ -21,6 +21,7 @@ commander.option("-i, --optional [list]", "List of optional transformers to enab
 commander.option("-o, --out-file [out]", "Compile all input files into a single file");
 commander.option("-d, --out-dir [out]", "Compile an input directory of modules into an output directory");
 commander.option("-c, --remove-comments", "Remove comments from the compiled code", false);
+commander.option("-I, --indent [width]", "Indent width [2]", 2);
 commander.option("-a, --amd-module-ids", "Insert module id in AMD modules", false); // todo: remove in 3.0.0
 commander.option("-m, --module-ids", "Insert module id in modules", false);
 
@@ -108,7 +109,12 @@ exports.opts = {
   optional:      commander.optional,
   comments:      !commander.removeComments,
   runtime:       commander.runtime,
-  modules:       commander.modules
+  modules:       commander.modules,
+  format: {
+    indent: {
+      style:     util.repeat(parseInt(commander.indent))
+    }
+  }
 };
 
 var fn;

bin/generate-core-package-json

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+
+var pkg = require("../package.json");
+pkg.name += "-core";
+delete pkg.dependencies.chokidar;
+delete pkg.optionalDependencies;
+delete pkg.devDependencies;
+delete pkg.preferGlobal;
+delete pkg.scripts;
+delete pkg.bin;
+console.log(JSON.stringify(pkg, null, "  "));

doc/browser.md

@@ -1,65 +0,0 @@
-# Browser
-
-A browser version of 6to5 is available from `browser.js` inside the 6to5
-directory in an npm release.
-
-## Scripts
-
-While it's not recommended for serious use, when the browser version is included
-all scripts with the type `text/ecmascript-6` and `text/6to5` are automatically
-compiled and ran.
-
-For example:
-
-```html
-<script src="node_modules/6to5/browser.js"></script>
-<script type="text/6to5">
-class Test {
-  test() {
-    return "test";
-  }
-}
-
-var test = new Test;
-test.test();
-</script>
-```
-
-## Build
-
-You can build a browser version of the compiler by running the following in the
-6to5 directory:
-
-```sh
-$ make build
-```
-
-This will output the files `dist/6to5.js` and `dist/6to5.min.js`.
-
-## Test
-
-To test 6to5 in your browser run:
-
-```sh
-$ make test-browser
-```
-
-And open `test/browser.html` in your browser if it doesn't open automatically.
-
-## API
-
-### to5.transform(code, [opts])
-
-See [options](usage.md#options) for additional documentation.
-
-```javascript
-to5.transform("class Test {}").code;
-```
-
-### to5.run(code, [opts])
-
-See [options](usage.md#options) for additional documentation.
-
-```javascript
-to5.run("class Test {}");
-```

doc/caveats.md

@@ -1,62 +0,0 @@
-# Caveats
-
-In order for certain features to work they require certain polyfills. You can
-satisfy **all** 6to5 feature requirements by using the included
-[polyfill](polyfill.md).
-
-You may alternatively selectively include what you need:
-
-| Feature                     | Requirements                                                                                                           |
-| --------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
-| Abstract References         | [experimental](experimental.md), `Symbol`                                                                              |
-| 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.from`                                                                          |
-| For Of                      | `Symbol`, `prototype[Symbol.iterator]`                                                                                 |
-| Modules                     | `Object.assign`*                                                                                                       |
-| Object spread/rest          | [experimental](experimental.md), `Object.assign`                                                                       |
-| Spread                      | `Array.from`                                                                                                           |
-
-*Only required for exporting a non-function `default` with additional `export`s.
-
-## ES5
-
-Since 6to5 assumes that your code will be ran in an ES5 environment it uses ES5
-functions. So if you're using an environment that has limited or no support for
-ES5 such as lower versions of IE then using the
-[es5-shim](https://github.com/es-shims/es5-shim) along with the
-[6to5 polyfill](polyfill.md) will add support for these methods.
-
-## Internet Explorer
-
-### 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 in IE <= 10 so static properties
-**will not** be inherited. A possible workaround is to use `super();`:
-
-```javascript
-class Foo {
-  static foo() {
-
-  }
-}
-
-class Bar extends Foo {
-  static foo() {
-    super();
-  }
-}
-```
-
-## Getters/setters (8 and below)
-
-In IE8 `Object.defineProperty` can only be used on DOM objects. This is
-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).

doc/differences.md

@@ -1,138 +0,0 @@
-# Differences
-
-There are three main points that separate 6to5 from all other transpilers.
-
-### Readable code
-
-The fundamental concept behind 6to5 is that the generated code must be close as
-possible to the original, retaining all the same formatting and readability.
-
-Many other transpilers are just concerned with making the code work while 6to5
-is concerned with making sure it works **and** is readable at the same time.
-
-For example, given the following array comprehension:
-
-```javascript
-var seattlers = [for (c of customers) if (c.city == "Seattle") { name: c.name, age: c.age }];
-```
-
-is generated to the following with 6to5:
-
-```javascript
-var seattlers = Array.from(customers).filter(function (c) {
-  return c.city == "Seattle";
-}).map(function (c) {
-  return {
-    name: c.name,
-    age: c.age
-  };
-});
-```
-
-The following is what Traceur generates:
-
-```javascript
-var seattlers = (function() {
-  var c;
-  var $__20 = 0,
-      $__21 = [];
-  for (var $__22 = customers[$traceurRuntime.toProperty(Symbol.iterator)](),
-      $__23; !($__23 = $__22.next()).done; ) {
-    c = $__23.value;
-    if (c.city == "Seattle")
-      $traceurRuntime.setProperty($__21, $__20++, {
-        name: c.name,
-        age: c.age
-      });
-  }
-  return $__21;
-}());
-```
-
-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.
-
-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).
-We promise that these inline functions will never be significant and will
-always be used as little as possible.
-
-### Static analysis
-
-6to5 uses a lot of static analysis to simplify code as much as possible.
-Not many other transpilers do this, and those that do don't do it nearly
-as much as 6to5. This process is pretty intensive but it leads to higher
-quality code.
-
-### Spec compliancy
-
-6to5 prides itself on
-[spec compliancy](https://kangax.github.io/compat-table/es6/). We have
-excellent support for edgecases, something that many other transpilers
-suffer from, including Traceur. When you use 6to5 you can be confident
-that when you turn it off and use your code in a full ES6 environment
-**it'll just work**.
-
-## Comparison to other transpilers
-
-### Features
-
-|                              | 6to5 | Traceur | es6-transpiler | esnext | es6now | jstransform |
-| ---------------------------- | ---- | ------- | -------------- | ------ | ------ | ----------- |
-| Source maps                  | ✓    | ✓       | ✓              | ✓      |        | ✓           |
-| No compiler global pollution | ✓    |         | ✓              | ✓      |        | ✓           |
-| Optional runtime             | ✓    |         | ✓              |        |        | ✓           |
-| Browser compiler             | ✓    | ✓       |                | ✓      |        |             |
-
-### Language Support
-
-|                              | 6to5 | Traceur | es6-transpiler | esnext | es6now | jstransform |
-| ---------------------------- | ---- | ------- | -------------- | ------ | ------ | ----------- |
-| Abstract references          | ✓    |         |                |        |        |             |
-| Array comprehension          | ✓    | ✓       | ✓              |        |        |             |
-| Arrow functions              | ✓    | ✓       | ✓              | ✓      | ✓      | ✓           |
-| Async functions              | ✓    | ✓       |                | ✓      |        |             |
-| Async generator functions    | ✓    | ✓       |                |        |        |             |
-| Classes                      | ✓    | ✓       | ✓              | ✓      | ✓      | ✓           |
-| Computed property names      | ✓    | ✓       | ✓              | ✓      | ✓      |             |
-| Constants                    | ✓    | ✓       | ✓              |        |        |             |
-| Default parameters           | ✓    | ✓       | ✓              | ✓      | ✓      |             |
-| Destructuring                | ✓    | ✓       | ✓              | ✓      | ✓      | ✓           |
-| Exponentiation operator      | ✓    | ✓       |                |        |        |             |
-| Flow types                   | ✓    |         |                |        |        | ✓           |
-| For-of                       | ✓    | ✓       | ✓              | ✓      | ✓      |             |
-| Generators                   | ✓    | ✓       |                | ✓      |        |             |
-| Generator comprehension      | ✓    | ✓       |                |        |        |             |
-| JSX                          | ✓    |         |                |        |        |             |
-| Let scoping                  | ✓    | ✓       | ✓              |        |        |             |
-| Modules                      | ✓    | ✓       |                |        | ✓      |             |
-| Object rest/spread           | ✓    |         |                |        |        | ✓           |
-| Property method assignment   | ✓    | ✓       | ✓              | ✓      | ✓      | ✓           |
-| Property name shorthand      | ✓    | ✓       | ✓              | ✓      | ✓      | ✓           |
-| Rest parameters              | ✓    | ✓       | ✓              | ✓      | ✓      | ✓           |
-| React                        | ✓    |         |                |        |        |             |
-| Spread                       | ✓    | ✓       | ✓              | ✓      | ✓      |             |
-| Template literals            | ✓    | ✓       | ✓              | ✓      | ✓      | ✓           |
-| Unicode regex                | ✓    | ✓       | ✓              |        |        |             |
-
-### [Traceur](https://github.com/google/traceur-compiler)
-
-Traceur requires quite a bulky runtime (~75KB) and produces quite verbose code.
-While this can be trimmed down by selectively building the runtime, it's an
-unnecessary step when a large runtime can be eliminated entirely.
-
-### [es6now](https://github.com/zenparsing/es6now)
-
-es6now doesn't output sourcemaps. This is cited as a positive as line-to-line
-mapping is the goal. This however obviously doesn't retain column mapping
-resulting in the output code not being very pleasant.
-
-### [es6-transpiler](https://github.com/termi/es6-transpiler)
-
-The es6-transpiler compiler requires shims to operate which pollutes the global
-scope resulting in possible collisions.
-
-es6-transpiler maps line-by-line, just like es6now, this results in the same
-issues such as lack of column information and unpleasant code output.

doc/experimental.md

@@ -1,8 +0,0 @@
-## Experimental
-
-6to5 also has experimental support for ES7 proposals. You can enable this with
-the `experimental: true` option when using the [Node API](#node) or
-`--experimental` when using the [CLI](#cli).
-
-**WARNING:** These proposals are subject to change so use with
-**extreme caution**.

doc/features.md

@@ -1,283 +0,0 @@
-# Features
-
-## Abstract references ([experimental](experimental.md)) ([spec](https://github.com/zenparsing/es-abstract-refs))
-
-```javascript
-foo::bar;
-foo::bar = baz;
-delete foo::bar;
-```
-
-## Array comprehensions ([experimental](experimental.md))
-
-```javascript
-var results = [for (c of customers) if (c.city == "Seattle") { name: c.name, age: c.age }]
-```
-
-## Arrow functions
-
-```javascript
-// Expression bodies
-var odds = evens.map(v => v + 1);
-var nums = evens.map((v, i) => v + i);
-
-// Statement bodies
-nums.forEach(v => {
-  if (v % 5 === 0)
-    fives.push(v);
-});
-
-// Lexical this
-var bob = {
-  _name: "Bob",
-  _friends: [],
-  printFriends() {
-    this._friends.forEach(f => {
-      console.log(this._name + " knows " + f);
-    });
-  }
-};
-```
-
-## Async functions ([experimental](experimental.md)) ([spec](https://github.com/lukehoban/ecmascript-asyncawait))
-
-```javascript
-async function chainAnimationsAsync(elem, animations) {
-  for (var anim of animations) {
-    await anim(elem);
-  }
-}
-```
-
-## Async generator functions ([experimental](experimental.md)) ([spec](https://github.com/jhusain/asyncgenerator))
-
-```javascript
-
-```
-
-## Classes
-
-```javascript
-class SkinnedMesh extends THREE.Mesh {
-  constructor(geometry, materials) {
-    super(geometry, materials);
-
-    this.idMatrix = SkinnedMesh.defaultMatrix();
-    this.bones = [];
-    this.boneMatrices = [];
-    //...
-  }
-
-  update(camera) {
-    //...
-    super.update();
-  }
-
-  static defaultMatrix() {
-    return new THREE.Matrix4();
-  }
-}
-```
-
-## Computed property names
-
-```javascript
-var foo = "foo";
-var bar = "bar";
-var obj = {
-  ["foo" + bar]: "heh",
-  ["bar" + foo]: "noo",
-  foo: "foo",
-  bar: "bar"
-};
-```
-
-## Constants
-
-```javascript
-const MULTIPLIER = 5;
-console.log(2 * MULTIPLIER);
-
-MULTIPLIER = 6; // error
-var MULTIPLIER; // error
-```
-
-## Default parameters
-
-```javascript
-function f(x, y = 12) {
-  // y is 12 if not passed (or passed as undefined)
-  return x + y;
-}
-f(3) == 15
-```
-
-## Destructuring
-
-```javascript
-// list matching
-var [a, , b] = [1,2,3];
-
-// object matching
-var { op: a, lhs: { op: b }, rhs: c } = getASTNode();
-
-// object matching shorthand
-// binds `op`, `lhs` and `rhs` in scope
-var { op, lhs, rhs } = getASTNode();
-
-// Can be used in parameter position
-function g({ name: x }) {
-  console.log(x);
-}
-g({ name: 5 });
-
-// Fail-soft destructuring
-var [a] = [];
-a === undefined;
-```
-
-## Exponentiation operator ([experimental](experimental.md)) ([spec](https://github.com/rwaldron/exponentiation-operator))
-
-```javascript
-var a = 2;
-a **= 2;
-
-var squared = 2 ** 2;
-```
-
-## For-of
-
-```javascript
-for (var i of [1, 2, 3]) {
-  console.log(i * i);
-}
-```
-
-## Generators
-
-```javascript
-function* fibonacci() {
-  var pre = 0, cur = 1;
-  for (;;) {
-    var temp = pre;
-    pre = cur;
-    cur += temp;
-    yield cur;
-  }
-}
-
-for (var n of fibonacci()) {
-  // truncate the sequence at 1000
-  if (n > 1000) break;
-  console.log(n);
-}
-```
-
-## Generator comprehensions ([experimental](experimental.md))
-
-```javascript
-var nums = [1, 2, 3, 4, 5, 6];
-var multiples = (for (i of nums) if (i % 2) i * i);
-assert.equal(multiples.next().value, 1);
-assert.equal(multiples.next().value, 9);
-assert.equal(multiples.next().value, 25);
-```
-
-## Let scoping
-
-```javascript
-for (let i in arr) {
-  let v = arr[i];
-}
-```
-
-## Modules
-
-```javascript
-import "foo";
-import foo from "foo";
-import * as foo from "foo";
-import {bar} from "foo";
-import {foo as bar} from "foo";
-
-export { test };
-export var test = 5;
-export function test() {}
-
-export default test;
-```
-
-## Numeric literals
-
-```javascript
-0b111110111 === 503; // true
-0o767 === 503; // true
-```
-
-## Object spread/rest ([experimental](experimental.md)) ([spec](https://github.com/sebmarkbage/ecmascript-rest-spread))
-
-```javascript
-var n = { x, y, ...z };
-var { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };
-```
-
-## Property method assignment
-
-```javascript
-var obj = {
-  foo() {
-    return "foobar";
-  },
-
-  get bar() {
-    return this._bar;
-  },
-
-  set bar(val) {
-    this._bar = val;
-  }
-};
-```
-
-## Property name shorthand
-
-```javascript
-function f(x, y) {
-  return { x, y };
-}
-```
-
-## Rest parameters
-
-```javascript
-function f(x, ...y) {
-  // y is an Array
-  return x * y.length;
-}
-f(3, "hello", true) == 6
-```
-
-## Spread
-
-```javascript
-function f(x, y, z) {
-  return x + y + z;
-}
-// Pass each elem of array as argument
-f(...[1,2,3]) == 6
-```
-
-## Template literals
-
-```javascript
-var x = 5;
-var y = 10;
-console.log(`${x} + ${y} = ${x + y}`); // "5 + 10 = 15"
-```
-## Unicode regex
-
-```javascript
-var string = 'foo💩bar';
-var match = string.match(/foo(.)bar/u);
-console.log(match[1]);
-```

doc/index.md

@@ -1,62 +1 @@
-**6to5** turns ES6+ code into vanilla ES5, so you can use next generation features **today.**
-
- - **Readable** - formatting is retained if possible so your generated code is as similar as possible.
- - **Extensible** - with a large range of [plugins](plugins.md) and **browser support**.
- - **Lossless** - **source map support** so you can debug your compiled code with ease.
- - **Compact** - maps directly to the equivalent ES5 with **no runtime**[\*](caveats.md).
-
-## Installation
-
-It's as easy as:
-
-    $ npm install -g 6to5
-
-## Usage
-
-Once you've installed 6to5, there are multiple paths you can take depending on
-how you want to use it.
-
-6to5 will simply compile your ES6+ script to ES5 if you pass it as an argument
-to the command-line tool `6to5`:
-
-```sh
-$ 6to5 script.js
-```
-
-If you have a file written using ES6+ and you just want to run it, `6to5-node`
-has you covered:
-
-```sh
-$ 6to5-node script.js
-```
-
-And it doesn't end here! To see all the ways you can use 6to5, check out the
-[Usage](http://6to5.github.io/usage.html) page.
-
-## [Features](features.md)
-
- - [Abstract references](features.md#abstract-references) ([experimental](experimental.md))
- - [Array comprehension](features.md#array-comprehension) ([experimental](experimental.md))
- - [Async functions](features.md#async-functions) ([experimental](experimental.md))
- - [Async generator functions](features.md#async-generator-functions) ([experimental](experimental.md))
- - [Arrow functions](features.md#arrow-functions)
- - [Classes](features.md#classes)
- - [Computed property names](features.md#computed-property-names)
- - [Constants](features.md#constants)
- - [Default parameters](features.md#default-parameters)
- - [Destructuring](features.md#destructuring)
- - [Exponentiation operator](features.md#exponentiation-operator) ([experimental](experimental.md))
- - [For-of](features.md#for-of)
- - [Generators](features.md#generators)
- - [Generator comprehension](features.md#generator-comprehension) ([experimental](experimental.md))
- - [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))
- - [Property method assignment](features.md#property-method-assignment)
- - [Property name shorthand](features.md#property-name-shorthand)
- - [React/JSX](react.md)
- - [Rest parameters](features.md#rest-parameters)
- - [Spread](features.md#spread)
- - [Template literals](features.md#template-literals)
- - [Unicode regex](features.md#unicode-regex)
+See [6to5.github.io/docs](https://github.com/6to5/6to5.github.io/tree/master/docs).

doc/modules.md

@@ -1,257 +0,0 @@
-# Modules
-
-## Usage
-
-### CLI
-
-```sh
-$ 6to5 --modules common script.js
-```
-
-### Node
-
-```javascript
-var to5 = require("6to5");
-to5.transform('import "foo";', { modules: "common" });
-```
-
-## Formats
-
- * [AMD](#amd)
- * [Common (Default)](#common-default)
- * [Ignore](#ignore)
- * [System](#system)
- * [UMD](#umd)
-
-### Common
-
-```sh
-$ 6to5 --modules common
-```
-
-**In**
-
-```javascript
-export default test;
-
-export {test};
-export var test = 5;
-
-import "foo";
-
-import foo from "foo";
-import * as foo from "foo";
-
-import {bar} from "foo";
-import {foo as bar} from "foo";
-```
-
-**Out**
-
-```javascript
-"use strict";
-
-var _interopRequire = function (obj) {
-  return obj && (obj["default"] || obj);
-};
-
-exports = module.exports = test;
-
-exports.test = test;
-var test = exports.test = 5;
-
-require("foo");
-
-var foo = _interopRequire(require("foo"));
-
-var foo = require("foo");
-
-var bar = require("foo").bar;
-var bar = require("foo").foo;
-```
-
-### AMD
-
-```sh
-$ 6to5 --modules amd
-```
-
-**In**
-
-```javascript
-import foo from "foo";
-
-export function bar() {
-  return foo("foobar");
-}
-```
-
-**Out**
-
-```javascript
-define(["exports", "foo"], function (exports, _foo) {
-  "use strict";
-
-  var _interopRequire = function (obj) {
-    return obj && (obj["default"] || obj);
-  };
-
-  exports.bar = bar;
-  var foo = _interopRequire(_foo);
-
-  function bar() {
-    return foo("foobar");
-  }
-});
-```
-
-You can optionally specify to include the module id (using the `--amd-module-id` argument):
-
-```javascript
-define("filename", ["exports", "foo"], function (exports, _foo) {})
-```
-
-### UMD
-
-```sh
-$ 6to5 --modules umd
-```
-
-**In**
-
-```javascript
-import foo from "foo";
-
-export function bar() {
-  return foo("foobar");
-}
-```
-
-**Out**
-
-```javascript
-(function (factory) {
-  if (typeof define === "function" && define.amd) {
-    define(["exports", "foo"], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require("foo"));
-  }
-})(function (exports, _foo) {
-  "use strict";
-
-  var _interopRequire = function (obj) {
-    return obj && (obj["default"] || obj);
-  };
-
-  exports.bar = bar;
-  var foo = _interopRequire(_foo);
-
-  function bar() {
-    return foo("foobar");
-  }
-});
-```
-
-### Ignore
-
-```sh
-$ 6to5 --modules ignore
-```
-
-**In**
-
-```javascript
-import foo from "foo";
-
-export function bar() {
-  return foo("foobar");
-}
-```
-
-**Out**
-
-```javascript
-function bar() {
-  return foo("foobar");
-}
-```
-
-### System
-
-```sh
-$ 6to5 --modules system
-```
-
-**In**
-
-```javascript
-import foo from "foo";
-
-export function bar() {
-  return foo("foobar");
-}
-```
-
-**Out**
-
-```javascript
-System.register("bar", ["foo"], function (_export) {
-  "use strict";
-
-  var __moduleName = "bar";
-
-  var foo;
-  function bar() {
-    return foo("foobar");
-  }
-  return {
-    setters: [function (m) {
-      foo = m.default;
-    }],
-    execute: function () {
-      _export("bar", bar);
-    }
-  };
-});
-```
-
-## Custom
-
-You can alternatively specify module names instead of one of the built-in types.
-
-```sh
-$ 6to5 --modules custom-module-formatter
-```
-
-**node_modules/custom-module-formatter/index.js**
-
-```javascript
-module.exports = ModuleFormatter;
-
-function ModuleFormatter() {
-
-}
-
-ModuleFormatter.prototype.transform = function (ast) {
-  // this is ran after all transformers have had their turn at modifying the ast
-  // feel free to modify this however
-};
-
-ModuleFormatter.prototype.importDeclaration = function (node, nodes) {
-  // node is an ImportDeclaration
-};
-
-ModuleFormatter.prototype.importSpecifier = function (specifier, node, nodes) {
-  // specifier is an ImportSpecifier
-  // node is an ImportDeclaration
-};
-
-ModuleFormatter.prototype.exportDeclaration = function (node, nodes) {
-  // node is an ExportDeclaration
-};
-
-ModuleFormatter.prototype.exportSpecifier = function (specifier, node, nodes) {
-  // specifier is an ExportSpecifier
-  // node is an ExportDeclaration
-};
-```

doc/optional-runtime.md

@@ -1,57 +0,0 @@
-# Optional runtime
-
-6to5 has a few helper functions that'll be placed at the top of the generated
-code if needed so it's not inlined multiple times throughout that file. This may
-become an issue if you have multiple files, especially when you're sending them
-to the browser. gzip alleviates most of this concern but it's still not ideal.
-
-You can tell 6to5 to not place any declarations at the top of your files and
-instead just point them to a reference contained within the runtime.
-
-Simply use the following option if you're using the [Node API](usage.md#node):
-
-```javascript
-{
-  runtime: true
-}
-```
-
-or the following flag if you're using the [CLI](usage.md#cli):
-
-```ssh
-$ 6to5 --runtime
-```
-
-Then just include the runtime before your generated code.
-
-## Getting the runtime
-
-You can get the runtime via either:
-
-```sh
-$ 6to5-runtime
-```
-
-or
-
-```javascript
-require("6to5").runtime();
-```
-
-or from an npm release in `runtime.js` from the 6to5 directory.
-
-## Customising namespace
-
-You can also customise the runtime namespace by passing an optional namespace
-argument:
-
-```javascript
-require("6to5").runtime("myCustomNamespace");
-```
-
-```sh
-$ 6to5-runtime myCustomNamespace
-```
-
-See [Options - runtime](usage.md#options) for documentation on changing the
-reference in generated code.

doc/playground.md

@@ -1,140 +0,0 @@
-# Playground
-
-Playground is a proving ground for **possible** ES7 proposals.
-
-**NOTE: These features are in no way endorsed by Ecma International and are not a part of ES6. They might become a part of ECMAScript in the future.**
-
-## Usage
-
-    $ 6to5 --playground
-
-```javascript
-to5.transform("code", { playground: true });
-```
-
-**NOTE:** Enabling `playground` also enables [experimental support](experimental.md).
-
-## Features
-
- * [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;
-obj.x; // 2
-
-obj = { x: 1 };
-obj.x ?= 2;
-obj.x; // 1
-
-obj = { x: undefined }
-obj.x ?= 2;
-obj.x; // undefined
-```
-
-```javascript
-var obj = {};
-obj.x ?= 2;
-```
-
-equivalent to
-
-```javascript
-var obj = {};
-if (!Object.prototype.hasOwnProperty.call(obj, "x")) obj.x = 2;
-```
-
-### Method binding
-
-```javascript
-var fn = obj#method;
-var fn = obj#method("foob");
-```
-
-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); });
-```
-
-### Object getter memoization
-
-```javascript
-var foo = {
-  memo bar() {
-    return complex();
-  }
-};
-
-class Foo {
-  memo bar() {
-    return complex();
-  }
-}
-```
-
-equivalent to
-
-```javascript
-var foo = {
-  get bar() {
-    return Object.defineProperty(this, "bar", {
-      value: complex(),
-      enumerable: true,
-      configurable: true,
-      writable: true
-    }).bar;
-  }
-};
-
-class Foo {
-  get bar() {
-    return Object.defineProperty(this, "bar", {
-      value: complex(),
-      enumerable: true,
-      configurable: true,
-      writable: true
-    }).bar;
-  }
-}
-```
-
-### This shorthand
-
-```javascript
-@foo
-```
-
-equivalent to
-
-```javascirpt
-this.foo
-```

doc/plugins.md

@@ -1,33 +0,0 @@
-# Plugins
-
-## Build systems
-
- - [Broccoli](https://github.com/6to5/broccoli-6to5-transpiler)
- - [Browserify](https://github.com/6to5/6to5ify)
- - [Brunch](https://github.com/6to5/6to5-brunch)
- - [Duo](https://github.com/6to5/duo6to5)
- - [Gobble](https://github.com/6to5/gobble-6to5)
- - [Gulp](https://github.com/6to5/gulp-6to5)
- - [Grunt](https://github.com/6to5/grunt-6to5)
- - [Sprockets](https://github.com/josh/sprockets-es6) or via [Browserify](https://github.com/6to5/6to5-rails)
- - [webpack](https://github.com/6to5/6to5-loader)
-
-## Integrations
-
- - [Isparta](https://github.com/douglasduteil/isparta) - Code coverage with `karma` and `instanbul` using 6to5
- - [JSXHint](https://github.com/STRML/JSXHint) - A wrapper around JSHint to allow linting of JSX files
-
-## Bridges
-
- - [Ruby](https://github.com/6to5/6to5-ruby)
-
-## Testing
-
- - [Jest](https://github.com/6to5/6to5-jest)
- - [Karma](https://github.com/6to5/karma-6to5-preprocessor)
- - [Mocha](https://github.com/6to5/6to5-mocha)
-
-## Misc
-
- - [Connect](https://github.com/6to5/6to5-connect)
- - [Jade](https://github.com/6to5/jade-6to5)

doc/polyfill.md

@@ -1,34 +0,0 @@
-# Polyfill
-
-6to5 includes a polyfill that includes a custom
-[regenerator runtime](https://github.com/facebook/regenerator/blob/master/runtime.js) and
-[core.js](https://github.com/zloirock/core-js).
-
-This will emulate a full ES6 environment. This polyfill is automatically loaded
-when using [6to5-node](usage.md#node) and [6to5/register](usage.md#register-hook).
-
-## Usage
-
-### Node/Browserify
-
-You need to include the polyfill require at the top the **entry point** to your
-application.
-
-```javascript
-require("6to5/polyfill");
-```
-
-Fortunately, this is automatically loaded when using:
-
-```javascript
-require("6to5/register");
-```
-
-### Browser
-
-Available from the `browser-polyfill.js` file within the 6to5 directory of an
-npm release. This needs to be included **before** all your compiled 6to5 code.
-You can either prepend it to your compiled code or include it in a `<script>`
-before it.
-
-**NOTE:** Do not `require` this via browserify etc, use `6to5/polyfill`.

doc/react.md

@@ -1,17 +0,0 @@
-# React/JSX
-
-6to5 has built-in support for React v0.12. Tags are automatically transformed to
-their equivalent `React.createElement(...)` and `displayName` is automatically
-inferred and added to all `React.createClass` calls.
-
-## Blacklist
-
-To disable this behaviour add `react` to your blacklist:
-
-```javascript
-to5.transform("code", { blacklist: ["react"] });
-```
-
-```sh
-$ 6to5 --blacklist react
-```

doc/usage.md

@@ -1,259 +0,0 @@
-# Usage
-
-## CLI
-
-Compile the file `script.js` and output it to stdout.
-
-```sh
-$ 6to5 script.js
-```
-
-Compile the file `script.js` and output it to `script-compiled.js`.
-
-```sh
-$ 6to5 script.js --out-file script-compiled.js
-```
-
-Compile the file `script.js` and output it to `script-compiled.js` and save a
-source map to `script-compiled.js.map`.
-
-```sh
-$ 6to5 script.js --source-maps --out-file script-compiled.js
-```
-
-Compile the file `script.js` and output it to `script-compiled.js` with a source
-map embedded in a comment at the bottom.
-
-```sh
-$ 6to5 script.js --source-maps-inline --out-file script-compiled.js
-```
-
-Compile the entire `src` directory and output it to the `lib` directory.
-
-```sh
-$ 6to5 src --out-dir lib
-```
-
-Compile the entire `src` directory and output it to the one concatenated file.
-
-```sh
-$ 6to5 src --out-file script-compiled.js
-```
-
-Pipe a file in via stdin and output it to `script-compiled.js`
-
-```sh
-$ 6to5 --out-file script-compiled.js < script.js
-```
-
-### Node
-
-Launch a repl.
-
-```sh
-$ 6to5-node
-```
-
-Evaluate code.
-
-```sh
-$ 6to5-node -e "class Test { }"
-```
-
-Compile and run `test.js`.
-
-```sh
-$ 6to5-node test
-```
-
-## Node
-
-```javascript
-var to5 = require("6to5");
-```
-
-### to5.transform(code, [opts]);
-
-```javascript
-var result = to5.transform("code();", options);
-result.code;
-result.map;
-result.ast;
-```
-
-### to5.transformFileSync(filename, [opts])
-
-```javascript
-to5.transformFileSync("filename.js", options).code;
-```
-
-### to5.transformFile(filename, [opts], callback)
-
-```javascript
-to5.transformFile("filename.js", options, function (err, result) {
-  result.code;
-});
-```
-
-### to5.transform.fromAst(ast, [code], [opts])
-
-```javascript
-var result = to5.transform.fromAst(ast, "var a = 2;", opts);
-result.code;
-result.map;
-result.ast;
-```
-
-#### Options
-
-```javascript
-{
-  // Filename for use in errors etc.
-  // Default: "unknown"
-  filename: "filename",
-
-  // Filename relative to `sourceRoot`
-  // Default: `filename` option.
-  filenameRelative: "",
-
-  // List of transformers to EXCLUDE.
-  // Run `6to5 --help` to see a full list of transformers.
-  blacklist: [],
-
-  // List of transformers to ONLY use.
-  // Run `6to5 --help` to see a full list of transformers.
-  whitelist: [],
-
-  // Module formatter to use
-  // Run `6to5 --help` to see a full list of module formatters.
-  // Default: "common"
-  modules: "common",
-
-  // If truthy, adds a `map` property to returned output.
-  // If set to "inline", a comment with a sourceMappingURL directive is added to
-  // the bottom of the returned code.
-  // Default: false
-  sourceMap: true,
-
-  // Set `file` on returned source map.
-  // Default: `filenameRelative` option.
-  sourceMapName: "filename",
-
-  // Set `sources[0]` on returned source map.
-  // Default: `filenameRelative` option.
-  sourceFileName: "filename",
-
-  // The root from which all sources are relative
-  // Default: `moduleRoot` option.
-  sourceRoot: "assets/scripts",
-
-  // Optional prefix for the AMD module formatter that will be prepend to the
-  // filename on module definitions
-  // Default: `sourceRoot` option.
-  moduleRoot: "my-app",
-
-  // If truthy, insert an explicit id for each defined AMD/System module.
-  // By default, AMD/System modules are anonymous.
-  // Default: false
-  moduleIds: true,
-
-  // Optionally replace all 6to5 helper declarations with a referenece to this
-  // variable. If set to `true` then the default namespace is used "to5Runtime".
-  // Default: false
-  runtime: true,
-
-  // Enable support for experimental ES7 features
-  // Default: false
-  experimental: true,
-
-  // Set this to `false` if you don't want the transformed AST in the returned
-  // result
-  // Default: true
-  ast: true,
-
-  // Set this to `false` if you don't want the transformed code in the returned
-  // result
-  // Default: true
-  code: true,
-
-  format: {
-    // Output comments in generated output
-    // Default: true
-    comments: true,
-
-    // Do not include superfluous whitespace characters and line terminators
-    // Default: false
-    compact: false,
-
-    indent: {
-      // Preserve parentheses in new expressions that have no arguments
-      // Default: true
-      parentheses: true,
-
-      // Adjust the indentation of multiline comments to keep asterisks vertically aligned
-      // Default: true
-      adjustMultilineComment: true,
-
-      // Indent string
-      // Default: "  "
-      style: "  ",
-
-      // Base indent level
-      // Default: 0
-      base: 0
-    }
-  }
-}
-```
-
-### Require hook
-
-All subsequent files required by node with the extensions `.es6` and `.js` will
-be transformed by 6to5. The polyfill specified in [Polyfill](polyfill.md) is
-also required; but this is automatically loaded when using:
-
-Source maps are automatically configured so if any errors a thrown then line
-number info is mapped and you'll get the correct source location.
-
-```javascript
-require("6to5/register");
-```
-
-**NOTE:** By default all requires to `node_modules` will be ignored. You can
-override this by passing an ignore regex via:
-
-```javascript
-require("6to5/register")({
-  // This will override `node_modules` ignoring - you can alternatively pass
-  // a regex
-  ignore: false
-});
-```
-
-**NOTE:** Using 6to5-node or `require("6to5/register")`, 6to5 will check what features are available in the current environment and blacklists them if they're supported.
-
-#### Options
-
-```javascript
-require("6to5/register")({
-  // Optional ignore regex - if any filenames **do** match this regex then they
-  // aren't compiled
-  ignore: /regex/,
-
-  // Optional only regex - if any filenames **don't** match this regex then they
-  // aren't compiled
-  only: /my_es6_folder/,
-
-  // See options above for usage
-  whitelist: [],
-  blacklist: [],
-
-  // This will remove the currently hooked extensions of .es6 and .js so you'll
-  // have to add them back if you want them to be used again.
-  extensions: [".js", ".es6"],
-
-  // Enables `roadrunner` cache that will save to a `.roadrunner.json` file in your cwd
-  // Do not check this into git as it's user-specific
-  cache: true
-});
-```

lib/6to5/browser.js

@@ -1,5 +1,7 @@
 var transform = module.exports = require("./transformation/transform");
 
+transform.version = require("../../package").version;
+
 transform.transform = transform;
 
 transform.run = function (code, opts) {

lib/6to5/file.js

@@ -10,15 +10,17 @@ var t         = require("./types");
 var _         = require("lodash");
 
 function File(opts) {
-  this.dynamicImports = [];
-  this.opts           = File.normaliseOptions(opts);
-  this.transformers   = this.getTransformers();
-  this.uids           = {};
-  this.ast            = {};
+  this.dynamicImports   = [];
+  this.dynamicImportIds = {};
+  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",
@@ -28,12 +30,19 @@ File.declarations = [
   "object-without-properties",
   "has-own",
   "slice",
+  "bind",
   "define-property",
-  "async-to-generator"
+  "async-to-generator",
+  "interop-require-wildcard",
+  "typeof",
+  "exports-wildcard",
+  "extends",
+  "get"
 ];
 
-File.excludeDeclarationsFromRuntime = [
-  "async-to-generator"
+File.excludeHelpersFromRuntime = [
+  "async-to-generator",
+  "typeof"
 ];
 
 File.normaliseOptions = function (opts) {
@@ -41,6 +50,7 @@ File.normaliseOptions = function (opts) {
 
   _.defaults(opts, {
     experimental: false,
+    reactCompat:  false,
     playground:   false,
     whitespace:   true,
     moduleIds:    opts.amdModuleIds || false,
@@ -97,25 +107,30 @@ File.normaliseOptions = function (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;
+  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];
@@ -123,7 +138,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);
   }
 };
 
@@ -154,15 +169,24 @@ File.prototype.parseShebang = function (code) {
   return code;
 };
 
-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.addImport = function (source, name) {
+  name = name || source;
+  var id = this.dynamicImportIds[name];
+
+  if (!id) {
+    id = this.dynamicImportIds[name] = this.generateUidIdentifier(name);
+
+    var specifiers = [t.importSpecifier(t.identifier("default"), id)];
+    var declar = t.importDeclaration(specifiers, t.literal(source));
+    declar._blockHoist = 3;
+    this.dynamicImports.push(declar);
+  }
+
+  return id;
 };
 
-File.prototype.addDeclaration = function (name) {
-  if (!_.contains(File.declarations, name)) {
+File.prototype.addHelper = function (name) {
+  if (!_.contains(File.helpers, name)) {
     throw new ReferenceError("unknown declaration " + name);
   }
 
@@ -173,7 +197,7 @@ File.prototype.addDeclaration = function (name) {
 
   var ref;
   var runtimeNamespace = this.opts.runtime;
-  if (runtimeNamespace && !_.contains(File.excludeDeclarationsFromRuntime, name)) {
+  if (runtimeNamespace && !_.contains(File.excludeHelpersFromRuntime, name)) {
     name = t.identifier(t.toIdentifier(name));
     return t.memberExpression(t.identifier(runtimeNamespace), name);
   } else {
@@ -267,7 +291,7 @@ File.prototype.generate = function () {
 };
 
 File.prototype.generateUid = function (name, scope) {
-  name = t.toIdentifier(name);
+  name = t.toIdentifier(name).replace(/^_+/, "");
 
   scope = scope || this.scope;
 

lib/6to5/generation/generator.js

@@ -148,11 +148,11 @@ CodeGenerator.prototype.print = function (node, parent, opts) {
   };
 
   if (this[node.type]) {
-    var needsCommentParens = t.isExpression(node) && node.leadingComments && node.leadingComments.length;
-    var needsParens        = needsCommentParens || n.needsParens(node, parent);
+    var needsNoLineTermParens = n.needsParensNoLineTerminator(node, parent);
+    var needsParens           = needsNoLineTermParens || n.needsParens(node, parent);
 
     if (needsParens) this.push("(");
-    if (needsCommentParens) this.indent();
+    if (needsNoLineTermParens) this.indent();
 
     this.printLeadingComments(node, parent);
 
@@ -163,7 +163,7 @@ CodeGenerator.prototype.print = function (node, parent, opts) {
 
     this[node.type](node, this.buildPrint(node), parent);
 
-    if (needsCommentParens) {
+    if (needsNoLineTermParens) {
       this.newline();
       this.dedent();
     }

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

@@ -1,5 +1,6 @@
 var util = require("../../util");
 var t    = require("../../types");
+var _    = require("lodash");
 
 exports.UnaryExpression = function (node, print) {
   var hasSpace = /[a-z]$/.test(node.operator);
@@ -56,8 +57,28 @@ exports.ThisExpression = function () {
 
 exports.CallExpression = function (node, print) {
   print(node.callee);
+
   this.push("(");
-  print.join(node.arguments, { separator: ", " });
+
+  var separator = ",";
+
+  if (node._prettyCall) {
+    separator += "\n";
+    this.newline();
+    this.indent();
+  } else {
+    separator += " ";
+  }
+
+  print.join(node.arguments, {
+    separator: separator
+  });
+
+  if (node._prettyCall) {
+    this.newline();
+    this.dedent();
+  }
+
   this.push(")");
 };
 
@@ -86,6 +107,7 @@ exports.ExpressionStatement = function (node, print) {
 
 exports.BinaryExpression =
 exports.LogicalExpression =
+exports.AssignmentPattern =
 exports.AssignmentExpression = function (node, print) {
   print(node.left);
   this.push(" " + node.operator + " ");
@@ -102,7 +124,12 @@ exports.MemberExpression = function (node, print) {
     throw new TypeError("Got a MemberExpression for MemberExpression property");
   }
 
-  if (node.computed) {
+  var computed = node.computed;
+  if (t.isLiteral(node.property) && _.isNumber(node.property.value)) {
+    computed = true;
+  }
+
+  if (computed) {
     this.push("[");
     print(node.property);
     this.push("]");

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

@@ -1,4 +1,5 @@
-var t = require("../../types");
+var util = require("../../util");
+var t    = require("../../types");
 
 exports.WithStatement = function (node, print) {
   this.keyword("with");
@@ -157,7 +158,24 @@ exports.DebuggerStatement = function () {
 exports.VariableDeclaration = function (node, print, parent) {
   this.push(node.kind + " ");
 
-  print.join(node.declarations, { separator: ", " });
+  var inits = 0;
+  var noInits = 0;
+  for (var i in node.declarations) {
+    if (node.declarations[i].init) {
+      inits++;
+    } else {
+      noInits++;
+    }
+  }
+
+  var sep = ",";
+  if (inits > noInits) { // more inits than noinits
+    sep += "\n" + util.repeat(node.kind.length + 1);
+  } else {
+    sep += " ";
+  }
+
+  print.join(node.declarations, { separator: sep });
 
   if (!t.isFor(parent)) {
     this.semicolon();

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

@@ -61,14 +61,40 @@ Node.prototype.needsParens = function () {
   if (!parent) return false;
 
   if (t.isNewExpression(parent) && parent.callee === node) {
-    return t.isCallExpression(node) || _.some(node, function (val) {
+    if (t.isCallExpression(node)) return true;
+
+    var hasCall = _.some(node, function (val) {
       return t.isCallExpression(val);
     });
+    if (hasCall) return true;
   }
 
   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

@@ -13,15 +13,30 @@ _.each([
   ["<", ">", "<=", ">=", "in", "instanceof"],
   [">>", "<<", ">>>"],
   ["+", "-"],
-  ["*", "/", "%"]
+  ["*", "/", "%"],
+  ["**"]
 ], function (tier, i) {
   _.each(tier, function (op) {
     PRECEDENCE[op] = i;
   });
 });
 
+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) {
+  if ((t.isCallExpression(parent) || t.isNewExpression(parent)) && parent.callee === node) {
     return true;
   }
 

lib/6to5/index.js

@@ -3,6 +3,8 @@ var util      = require("./util");
 var fs        = require("fs");
 var _         = require("lodash");
 
+exports.version = require("../../package").version;
+
 exports.types = require("./types");
 
 exports.runtime = require("./runtime-generator");

lib/6to5/patch.js

@@ -12,6 +12,12 @@ var types = require("ast-types");
 var def   = types.Type.def;
 var or    = types.Type.or;
 
+def("AssignmentPattern")
+    .bases("Pattern")
+    .build("left", "right")
+    .field("left", def("Pattern"))
+    .field("right", def("Expression"));
+
 // Acorn - Same as ImportNamespaceSpecifier but `id` is `name`
 def("ImportBatchSpecifier")
   .bases("Specifier")

lib/6to5/register-browser.js

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

lib/6to5/register.js

@@ -123,7 +123,7 @@ var hookExtensions = function (_exts) {
   });
 };
 
-hookExtensions([".es6", ".js"]);
+hookExtensions([".es6", ".es", ".js"]);
 
 module.exports = function (opts) {
   // normalise options

lib/6to5/runtime-generator.js

@@ -18,9 +18,9 @@ module.exports = function (namespace) {
     )
   ]));
 
-  _.each(File.declarations, function (name) {
-    if (_.contains(File.excludeDeclarationsFromRuntime, name)) {
-      return false;
+  _.each(File.helpers, function (name) {
+    if (_.contains(File.excludeHelpersFromRuntime, name)) {
+      return;
     }
 
     var key = t.identifier(t.toIdentifier(name));

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

@@ -9,7 +9,11 @@ function DefaultFormatter(file) {
   this.file = file;
 
   this.localExports = this.getLocalExports();
+  this.localImports = this.getLocalImports();
+
   this.remapAssignments();
+
+  //this.checkCollisions();
 }
 
 DefaultFormatter.prototype.getLocalExports = function () {
@@ -27,6 +31,53 @@ DefaultFormatter.prototype.getLocalExports = function () {
   return localExports;
 };
 
+DefaultFormatter.prototype.getLocalImports = function () {
+  var localImports = {};
+
+  traverse(this.file.ast, {
+    enter: function (node) {
+      if (t.isImportDeclaration(node)) {
+        _.extend(localImports, t.getIds(node, true));
+      }
+    }
+  });
+
+  return localImports;
+};
+
+DefaultFormatter.prototype.checkCollisions = function () {
+  // todo: all check export collissions
+
+  var localImports = this.localImports;
+  var file = this.file;
+
+  var isLocalReference = function (node) {
+    return t.isIdentifier(node) && _.has(localImports, node.name) && localImports[node.name] !== node;
+  };
+
+  var check = function (node) {
+    if (isLocalReference(node)) {
+      throw file.errorWithNode(node, "Illegal assignment of module import");
+    }
+  };
+
+  traverse(file.ast, {
+    enter: function (node) {
+      if (t.isAssignmentExpression(node)) {
+
+        var left = node.left;
+        if (t.isMemberExpression(left)) {
+          while (left.object) left = left.object;
+        }
+
+        check(left);
+      } else if (t.isDeclaration(node)) {
+        _.each(t.getIds(node, true), check);
+      }
+    }
+  });
+};
+
 DefaultFormatter.prototype.remapExportAssignment = function (node) {
   return t.assignmentExpression(
     "=",
@@ -51,7 +102,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 +130,7 @@ DefaultFormatter.prototype.remapAssignments = function () {
       }
 
       if (t.isAssignmentExpression(node) && isLocalReference(node.left, scope)) {
-        this.stop();
+        this.skip();
         return self.remapExportAssignment(node);
       }
     }
@@ -110,6 +161,9 @@ DefaultFormatter.prototype.getModuleName = function () {
 
   moduleName += filenameRelative;
 
+  // normalise path separators
+  moduleName = moduleName.replace(/\\/g, "/");
+
   return moduleName;
 };
 
@@ -141,10 +195,18 @@ DefaultFormatter.prototype._exportSpecifier = function (getRef, specifier, node,
       // export * from "foo";
       nodes.push(this._exportsWildcard(getRef(), node));
     } else {
+      var ref;
+      if (t.isSpecifierDefault(specifier) && !this.noInteropRequire) {
+        // importing a default so we need to normalise it
+        ref = t.callExpression(this.file.addHelper("interop-require"), [getRef()]);
+      } else {
+        ref = t.memberExpression(getRef(), specifier.id);
+      }
+
       // export { foo } from "test";
       nodes.push(this._exportsAssign(
         t.getSpecifierName(specifier),
-        t.memberExpression(getRef(), specifier.id),
+        ref,
         node
       ));
     }
@@ -155,9 +217,9 @@ DefaultFormatter.prototype._exportSpecifier = function (getRef, specifier, node,
 };
 
 DefaultFormatter.prototype._exportsWildcard = function (objectIdentifier) {
-  return util.template("exports-wildcard", {
-    OBJECT: objectIdentifier
-  }, true);
+  return t.expressionStatement(t.callExpression(this.file.addHelper("exports-wildcard"), [
+    t.callExpression(this.file.addHelper("interop-require-wildcard"), [objectIdentifier])
+  ]));
 };
 
 DefaultFormatter.prototype._exportsAssign = function (id, init) {

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

@@ -0,0 +1,12 @@
+var util = require("../../util");
+
+module.exports = function (Parent) {
+  var Constructor = function () {
+    this.noInteropExport = true;
+    Parent.apply(this, arguments);
+  };
+
+  util.inherits(Constructor, Parent);
+
+  return Constructor;
+};

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

@@ -0,0 +1 @@
+module.exports = require("./_strict")(require("./amd"));

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

@@ -1,13 +1,14 @@
 module.exports = AMDFormatter;
 
 var DefaultFormatter = require("./_default");
+var CommonFormatter  = require("./common");
 var util             = require("../../util");
 var t                = require("../../types");
 var _                = require("lodash");
 
 function AMDFormatter() {
-  DefaultFormatter.apply(this, arguments);
-  this.ids  = {};
+  CommonFormatter.apply(this, arguments);
+  this.ids = {};
 }
 
 util.inherits(AMDFormatter, DefaultFormatter);
@@ -30,12 +31,15 @@ AMDFormatter.prototype.transform = function (ast) {
 
   // build an array of module names
 
-  var names = [t.literal("exports")].concat(this.buildDependencyLiterals());
+  var names = [t.literal("exports")];
+  if (this.passModuleArg) names.push(t.literal("module"));
+  names = names.concat(this.buildDependencyLiterals());
   names = t.arrayExpression(names);
 
   // build up define container
 
   var params = _.values(this.ids);
+  if (this.passModuleArg) params.unshift(t.identifier("module"));
   params.unshift(t.identifier("exports"));
 
   var container = t.functionExpression(null, params, t.blockStatement(body));
@@ -85,7 +89,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);
@@ -96,6 +100,14 @@ AMDFormatter.prototype.importSpecifier = function (specifier, node, nodes) {
   ]));
 };
 
+AMDFormatter.prototype.exportDeclaration = function (node) {
+  if (node.default && !this.noInteropExport) {
+    this.passModuleArg = true;
+  }
+
+  CommonFormatter.prototype.exportDeclaration.apply(this, arguments);
+};
+
 AMDFormatter.prototype.exportSpecifier = function (specifier, node, nodes) {
   var self = this;
   return this._exportSpecifier(function () {

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

@@ -0,0 +1 @@
+module.exports = require("./_strict")(require("./common"));

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

@@ -26,24 +26,30 @@ 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
         })])
       )
     ]));
   } else {
-    // import foo from "foo";
-
-    var templateName = "require-assign";
-
-    // import * as bar from "foo";
-    if (specifier.type !== "ImportBatchSpecifier") templateName += "-key";
-
-    nodes.push(util.template(templateName, {
-      VARIABLE_NAME: variableName,
-      MODULE_NAME:   node.source,
-      KEY:           specifier.id
-    }));
+    if (specifier.type === "ImportBatchSpecifier") {
+      // import * as bar from "foo";
+      nodes.push(t.variableDeclaration("var", [
+        t.variableDeclarator(
+          variableName,
+          t.callExpression(this.file.addHelper("interop-require-wildcard"), [
+            t.callExpression(t.identifier("require"), [node.source])
+          ])
+        )
+      ]));
+    } else {
+      // import foo from "foo";
+      nodes.push(util.template("require-assign-key", {
+        VARIABLE_NAME: variableName,
+        MODULE_NAME:   node.source,
+        KEY:           specifier.id
+      }));
+    }
   }
 };
 
@@ -55,7 +61,7 @@ CommonJSFormatter.prototype.importDeclaration = function (node, nodes) {
 };
 
 CommonJSFormatter.prototype.exportDeclaration = function (node, nodes) {
-  if (node.default) {
+  if (node.default && !this.noInteropRequire && !this.noInteropExport) {
     var declar = node.declaration;
     var assign;
 
@@ -65,7 +71,7 @@ CommonJSFormatter.prototype.exportDeclaration = function (node, nodes) {
     // exports = module.exports = VALUE;
     if (this.hasNonDefaultExports) templateName = "exports-default-module-override";
 
-    if (t.isFunction(declar) || !this.hasNonDefaultExports) {
+    if (t.isFunctionDeclaration(declar) || !this.hasNonDefaultExports) {
       assign = util.template(templateName, {
         VALUE: this._pushStatement(declar, nodes)
       }, true);
@@ -77,10 +83,12 @@ CommonJSFormatter.prototype.exportDeclaration = function (node, nodes) {
       // 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)
+      //   module.exports = _extends(exports["default"], exports)
       //
 
-      assign = util.template("common-export-default-assign", true);
+      assign = util.template("common-export-default-assign", {
+        EXTENDS_HELPER: this.file.addHelper("extends")
+      }, true);
       assign._blockHoist = 0;
 
       nodes.push(assign);

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

@@ -1,6 +1,7 @@
 module.exports = SystemFormatter;
 
 var AMDFormatter = require("./amd");
+var useStrict    = require("../transformers/use-strict");
 var traverse     = require("../../traverse");
 var util         = require("../../util");
 var t            = require("../../types");
@@ -31,7 +32,7 @@ SystemFormatter.prototype._exportsWildcard = function (objectIdentifier, node) {
   var right = objectIdentifier;
 
   var block = t.blockStatement([
-    this.buildExportCall(leftIdentifier, valIdentifier)
+    t.expressionStatement(this.buildExportCall(leftIdentifier, valIdentifier))
   ]);
 
   return this._addImportSource(t.forInStatement(left, right, block), node);
@@ -114,7 +115,7 @@ SystemFormatter.prototype.transform = function (ast) {
     enter: function (node, parent, scope) {
       if (t.isFunction(node)) {
         // nothing inside is accessible
-        return this.stop();
+        return this.skip();
       }
 
       if (t.isVariableDeclaration(node)) {
@@ -159,7 +160,7 @@ SystemFormatter.prototype.transform = function (ast) {
   // hoist up function declarations for circular references
   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);
@@ -170,5 +171,9 @@ SystemFormatter.prototype.transform = function (ast) {
 
   handlerBody.push(returnStatement);
 
+  if (useStrict._has(block)) {
+    handlerBody.unshift(block.body.shift());
+  }
+
   program.body = [runner];
 };

lib/6to5/transformation/modules/umd-strict.js

@@ -0,0 +1 @@
+module.exports = require("./_strict")(require("./umd"));

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

@@ -25,22 +25,36 @@ UMDFormatter.prototype.transform = function (ast) {
   // factory
 
   var ids  = _.values(this.ids);
-  var args = [t.identifier("exports")].concat(ids);
+  var args = [t.identifier("exports")];
+  if (this.passModuleArg) args.push(t.identifier("module"));
+  args = args.concat(ids);
 
   var factory = t.functionExpression(null, args, t.blockStatement(body));
 
   // runner
 
-  var defineArgs = [t.arrayExpression([t.literal("exports")].concat(names))];
+  var defineArgs = [t.literal("exports")];
+  if (this.passModuleArg) defineArgs.push(t.literal("module"));
+  defineArgs = defineArgs.concat(names);
+  defineArgs = [t.arrayExpression(defineArgs)];
+
+  var testExports = util.template("test-exports");
+  var testModule = util.template("test-module");
+  var commonTests = this.passModuleArg ? t.logicalExpression("&&", testExports, testModule) : testExports;
+
+  var commonArgs = [t.identifier("exports")];
+  if (this.passModuleArg) commonArgs.push(t.identifier("module"));
+  commonArgs = commonArgs.concat(names.map(function (name) {
+    return t.callExpression(t.identifier("require"), [name]);
+  }));
+
   var moduleName = this.getModuleName();
   if (moduleName) defineArgs.unshift(t.literal(moduleName));
 
   var runner = util.template("umd-runner-body", {
     AMD_ARGUMENTS: defineArgs,
-
-    COMMON_ARGUMENTS: names.map(function (name) {
-      return t.callExpression(t.identifier("require"), [name]);
-    })
+    COMMON_TEST: commonTests,
+    COMMON_ARGUMENTS: commonArgs
   });
 
   //

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

@@ -0,0 +1 @@
+Function.prototype.bind

lib/6to5/transformation/templates/class-super-constructor-call.js

@@ -1,3 +1,3 @@
-if (SUPER_NAME) {
-  SUPER_NAME.apply(this, arguments);
+if (Object.getPrototypeOf(CLASS_NAME) !== null) {
+  Object.getPrototypeOf(CLASS_NAME).apply(this, arguments);
 }

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

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

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/exports-wildcard.js

@@ -1,5 +1,7 @@
 (function (obj) {
   for (var i in obj) {
-    exports[i] = obj[i];
+    if (exports[i] !== undefined) {
+      exports[i] = obj[i];
+    }
   }
-})(OBJECT);
+})

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

@@ -0,0 +1,9 @@
+(function (target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i];
+    for (var key in source) {
+      target[key] = source[key];
+    }
+  }
+  return target;
+})

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

@@ -0,0 +1,23 @@
+(function get(object, property, receiver) {
+  var desc = Object.getOwnPropertyDescriptor(object, property);
+
+  if (desc === undefined) {
+    var parent = Object.getPrototypeOf(object);
+
+    if (parent === null) {
+      return undefined;
+    } else {
+      return get(parent, property, receiver);
+    }
+  } else if ("value" in desc && desc.writable) {
+    return desc.value;
+  } else {
+    var getter = desc.get;
+
+    if (getter === undefined) {
+      return undefined;
+    }
+
+    return getter.call(receiver);
+  }
+});

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

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

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

@@ -1,4 +1,7 @@
 (function (child, parent) {
+  if (typeof parent !== "function" && parent !== null) {
+    throw new TypeError("Super expression must either be null or a function, not " + typeof parent);
+  }
   child.prototype = Object.create(parent && parent.prototype, {
     constructor: {
       value: child,

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

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

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

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

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

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

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

@@ -1 +0,0 @@
-var VARIABLE_NAME = require(MODULE_NAME);

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

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

lib/6to5/transformation/templates/test-exports.js

@@ -0,0 +1 @@
+typeof exports !== "undefined"

lib/6to5/transformation/templates/test-module.js

@@ -0,0 +1 @@
+typeof module !== "undefined"

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

@@ -0,0 +1,3 @@
+(function (obj) {
+  return obj && obj.constructor === Symbol ? "symbol" : typeof obj;
+});

lib/6to5/transformation/templates/umd-runner-body.js

@@ -1,7 +1,7 @@
 (function (factory) {
   if (typeof define === "function" && define.amd) {
     define(AMD_ARGUMENTS, factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, COMMON_ARGUMENTS);
+  } else if (COMMON_TEST) {
+    factory(COMMON_ARGUMENTS);
   }
 });

lib/6to5/transformation/transform.js

@@ -31,18 +31,18 @@ transform._ensureTransformerNames = function (type, keys) {
 transform.transformers = {};
 
 transform.moduleFormatters = {
-  common: require("./modules/common"),
-  system: require("./modules/system"),
-  ignore: require("./modules/ignore"),
-  amd:    require("./modules/amd"),
-  umd:    require("./modules/umd")
+  commonStrict: require("./modules/common-strict"),
+  umdStrict:    require("./modules/umd-strict"),
+  amdStrict:    require("./modules/amd-strict"),
+  common:       require("./modules/common"),
+  system:       require("./modules/system"),
+  ignore:       require("./modules/ignore"),
+  amd:          require("./modules/amd"),
+  umd:          require("./modules/umd")
 };
 
 _.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"),
@@ -60,13 +60,12 @@ _.each({
   arrowFunctions:            require("./transformers/es6-arrow-functions"),
   classes:                   require("./transformers/es6-classes"),
 
-  computedPropertyNames:     require("./transformers/es6-computed-property-names"),
-
   objectSpread:              require("./transformers/es7-object-spread"),
   exponentiationOperator:    require("./transformers/es7-exponentiation-operator"),
   spread:                    require("./transformers/es6-spread"),
   templateLiterals:          require("./transformers/es6-template-literals"),
-  propertyMethodAssignment:  require("./transformers/es5-property-method-assignment"),
+  propertyMethodAssignment:  require("./transformers/es6-property-method-assignment"),
+  computedPropertyNames:     require("./transformers/es6-computed-property-names"),
   destructuring:             require("./transformers/es6-destructuring"),
   defaultParameters:         require("./transformers/es6-default-parameters"),
   forOf:                     require("./transformers/es6-for-of"),
@@ -81,13 +80,16 @@ _.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
+  useStrict:                 require("./transformers/use-strict"),
   _aliasFunctions:           require("./transformers/_alias-functions"),
   _moduleFormatter:          require("./transformers/_module-formatter"),
-  useStrict:                 require("./transformers/use-strict"),
 
+  typeofSymbol:              require("./transformers/optional-typeof-symbol"),
   coreAliasing:              require("./transformers/optional-core-aliasing"),
   undefinedToVoid:           require("./transformers/optional-undefined-to-void"),
 

lib/6to5/transformation/transformer.js

@@ -7,20 +7,26 @@ var _        = require("lodash");
 function Transformer(key, transformer, opts) {
   this.manipulateOptions = transformer.manipulateOptions;
   this.experimental      = !!transformer.experimental;
-  this.transformer       = Transformer.normalise(transformer);
+  this.secondPass        = !!transformer.secondPass;
+  this.transformer       = this.normalise(transformer);
   this.optional          = !!transformer.optional;
   this.opts              = opts || {};
   this.key               = key;
 }
 
-Transformer.normalise = function (transformer) {
+Transformer.prototype.normalise = function (transformer) {
+  var self = this;
+
   if (_.isFunction(transformer)) {
     transformer = { ast: transformer };
   }
 
   _.each(transformer, function (fns, type) {
     // hidden property
-    if (type[0] === "_") return;
+    if (type[0] === "_") {
+      self[type] = fns;
+      return;
+    }
 
     if (_.isFunction(fns)) fns = { enter: fns };
 
@@ -41,16 +47,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) {
   var transformer = this.transformer;
-  var ast         = file.ast;
 
   var build = function (exit) {
     return function (node, parent, scope) {
@@ -67,7 +71,7 @@ Transformer.prototype.transform = function (file) {
 
   this.astRun(file, "before");
 
-  traverse(ast, {
+  traverse(file.ast, {
     enter: build(),
     exit:  build(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 this.stop();
+          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 this.stop();
+            return this.skip();
           }
 
-          if (node._ignoreAliasFunctions) return this.stop();
+          if (node._ignoreAliasFunctions) return this.skip();
 
           var getId;
 
@@ -49,7 +49,7 @@ var go = function (getBody, node, file, scope) {
         }
       });
 
-      return this.stop();
+      return this.skip();
     }
   });
 
@@ -67,7 +67,7 @@ var go = function (getBody, node, file, scope) {
   }
 
   if (thisId) {
-    pushDeclaration(thisId, t.identifier("this"));
+    pushDeclaration(thisId, t.thisExpression());
   }
 };
 

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

@@ -1,4 +1,5 @@
-var _ = require("lodash");
+var useStrict = require("./use-strict");
+var _         = require("lodash");
 
 // Priority:
 //
@@ -17,13 +18,15 @@ exports.Program = {
     }
     if (!hasChange) return;
 
-    var nodePriorities = _.groupBy(node.body, function (bodyNode) {
-      var priority = bodyNode._blockHoist;
-      if (priority == null) priority = 1;
-      if (priority === true) priority = 2;
-      return priority;
-    });
+    useStrict._wrap(node, function () {
+      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 = _.flatten(_.values(nodePriorities).reverse());
+      node.body = _.flatten(_.values(nodePriorities).reverse());
+    });
   }
 };

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

@@ -1,25 +1,32 @@
-var t = require("../../types");
+var useStrict = require("./use-strict");
+var t         = require("../../types");
+
+exports.secondPass = true;
 
 exports.BlockStatement =
 exports.Program = function (node) {
   var kinds = {};
   var kind;
 
-  for (var i in node._declarations) {
-    var declar = node._declarations[i];
+  useStrict._wrap(node, function () {
+    for (var i in node._declarations) {
+      var declar = node._declarations[i];
 
-    kind = declar.kind || "var";
-    var declarNode = t.variableDeclarator(declar.id, declar.init);
+      kind = declar.kind || "var";
+      var declarNode = t.variableDeclarator(declar.id, declar.init);
 
-    if (!declar.init) {
-      kinds[kind] = kinds[kind] || [];
-      kinds[kind].push(declarNode);
-    } else {
-      node.body.unshift(t.variableDeclaration(kind, [declarNode]));
+      if (!declar.init) {
+        kinds[kind] = kinds[kind] || [];
+        kinds[kind].push(declarNode);
+      } else {
+        node.body.unshift(t.variableDeclaration(kind, [declarNode]));
+      }
     }
-  }
 
-  for (kind in kinds) {
-    node.body.unshift(t.variableDeclaration(kind, kinds[kind]));
-  }
+    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,41 +0,0 @@
-var util = require("../../util");
-var t    = require("../../types");
-
-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;
-
-  if (node.properties.length) {
-    var objId = t.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)
-      })
-    });
-  } else {
-    return util.template("object-define-properties", {
-      OBJECT: node,
-      PROPS:  util.buildDefineProperties(mutatorMap)
-    });
-  }
-};

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

@@ -89,14 +89,14 @@ Class.prototype.run = function () {
     this.closure = true;
 
     // so we're only evaluating it once
-    var superRef = t.getUid(superName, this.file);
+    var superRef = this.scope.generateUidBasedOnNode(superName, this.file);
     body.unshift(t.variableDeclaration("var", [
       t.variableDeclarator(superRef, superName)
     ]));
     superName = superRef;
 
     this.superName = superName;
-    body.push(t.expressionStatement(t.callExpression(file.addDeclaration("inherits"), [className, superName])));
+    body.push(t.expressionStatement(t.callExpression(file.addHelper("inherits"), [className, superName])));
   }
 
   this.buildBody();
@@ -149,7 +149,7 @@ Class.prototype.buildBody = function () {
 
   if (!this.hasConstructor && superName && !t.isFalsyExpression(superName)) {
     constructor.body.body.push(util.template("class-super-constructor-call", {
-      SUPER_NAME: superName
+      CLASS_NAME: className
     }, true));
   }
 
@@ -175,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)
     ));
   }
 };
@@ -210,50 +210,50 @@ Class.prototype.pushMethod = function (node) {
     } else {
       this.hasInstanceMutators = true;
     }
-    util.pushMutatorMap(mutatorMap, methodName, kind, node);
+    util.pushMutatorMap(mutatorMap, methodName, kind, node.computed, node);
   }
 };
 
 /**
- * Given a `methodNode`, produce a `MemberExpression` super class reference.
+ * Gets a node representing the super class value of the named property.
  *
- * @param {Node} methodNode MethodDefinition
- * @param {Node} node Identifier
- * @param {Node} parent
+ * @example
+ *
+ *   _get(Object.getPrototypeOf(CLASS.prototype), "METHOD", this)
+ *
+ * @param {Node} property
+ * @param {boolean} isStatic
+ * @param {boolean} isComputed
  *
  * @returns {Node}
  */
 
-Class.prototype.superIdentifier = function (methodNode, id, parent) {
-  var methodName = methodNode.key;
-  var superName  = this.superName || t.identifier("Function");
-
-  if (parent.property === id) {
-    return;
-  } else if (t.isCallExpression(parent, { callee: id })) {
-    // super(); -> ClassName.prototype.MethodName.call(this);
-    parent.arguments.unshift(t.thisExpression());
-
-    if (methodName.name === "constructor") {
-      // constructor() { super(); }
-      return t.memberExpression(superName, t.identifier("call"));
-    } else {
-      id = superName;
-
-      // foo() { super(); }
-      if (!methodNode.static) {
-        id = t.memberExpression(id, t.identifier("prototype"));
-      }
-
-      id = t.memberExpression(id, methodName, methodNode.computed);
-      return t.memberExpression(id, t.identifier("call"));
-    }
-  } else if (t.isMemberExpression(parent) && !methodNode.static) {
-    // super.test -> ClassName.prototype.test
-    return t.memberExpression(superName, t.identifier("prototype"));
-  } else {
-    return superName;
-  }
+Class.prototype.superProperty = function (property, isStatic, isComputed) {
+  return t.callExpression(
+    this.file.addHelper("get"),
+    [
+      t.callExpression(
+        t.memberExpression(
+          t.identifier("Object"),
+          t.identifier("getPrototypeOf"),
+          false
+        ),
+        [
+          isStatic ?
+            this.className :
+            t.memberExpression(
+              this.className,
+              t.identifier("prototype"),
+              false
+            )
+        ]
+      ),
+      isComputed ?
+        property :
+        t.literal(property.name),
+      t.thisExpression()
+    ]
+  );
 };
 
 /**
@@ -268,16 +268,48 @@ Class.prototype.replaceInstanceSuperReferences = function (methodNode) {
 
   traverse(method, {
     enter: function (node, parent) {
+      var property;
+      var computed;
+      var args;
+
       if (t.isIdentifier(node, { name: "super" })) {
-        return self.superIdentifier(methodNode, node, parent);
+        if (!(t.isMemberExpression(parent) && !parent.computed && parent.property === node)) {
+          throw self.file.errorWithNode(node, "illegal use of bare super");
+        }
       } else if (t.isCallExpression(node)) {
         var callee = node.callee;
-        if (!t.isMemberExpression(callee)) return;
-        if (callee.object.name !== "super") return;
+        if (t.isIdentifier(callee) && callee.name === "super") {
+          // super(); -> _get(Object.getPrototypeOf(ClassName), "MethodName", this).call(this);
+          property = methodNode.key;
+          computed = methodNode.computed;
+          args = node.arguments;
+        } else {
+          if (!t.isMemberExpression(callee)) return;
+          if (callee.object.name !== "super") return;
 
-        // super.test(); -> ClassName.prototype.MethodName.call(this);
-        t.appendToMemberExpression(callee, t.identifier("call"));
-        node.arguments.unshift(t.thisExpression());
+          // super.test(); -> _get(Object.getPrototypeOf(ClassName.prototype), "test", this).call(this);
+          property = callee.property;
+          computed = callee.computed;
+          args = node.arguments;
+        }
+      } else if (t.isMemberExpression(node)) {
+        if (!t.isIdentifier(node.object, { name: "super" })) return;
+
+        // super.name; -> _get(Object.getPrototypeOf(ClassName.prototype), "name", this);
+        property = node.property;
+        computed = node.computed;
+      }
+
+      if (property) {
+        var superProperty = self.superProperty(property, methodNode.static, computed);
+        if (args) {
+          return t.callExpression(
+            t.memberExpression(superProperty, t.identifier("call"), false),
+            [t.thisExpression()].concat(args)
+          );
+        } else {
+          return superProperty;
+        }
       }
     }
   });

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

@@ -1,19 +1,19 @@
 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;
 
   for (i in node.properties) {
-    hasComputed = t.isProperty(node.properties[i], { computed: true });
+    hasComputed = t.isProperty(node.properties[i], { computed: true, kind: "init" });
     if (hasComputed) break;
   }
 
   if (!hasComputed) return;
 
-  var objId = t.getUid(parent, file);
+  var objId = scope.generateUidBasedOnNode(parent, file);
 
   var body = [];
   var container = t.functionExpression(null, [], t.blockStatement(body));
@@ -25,6 +25,8 @@ exports.ObjectExpression = function (node, parent, file) {
 
   for (i in props) {
     prop = props[i];
+    if (prop.kind !== "init") continue;
+
     key = prop.key;
 
     if (!prop.computed && t.isIdentifier(key)) {
@@ -44,7 +46,7 @@ exports.ObjectExpression = function (node, parent, file) {
       broken = true;
     }
 
-    if (!broken || t.isLiteral(prop.key, { value: "__proto__" })) {
+    if (prop.kind !== "init" || !broken || t.isLiteral(t.toComputedKey(prop, prop.key), { value: "__proto__" })) {
       initProps.push(prop);
       props[i] = null;
     }
@@ -61,13 +63,14 @@ exports.ObjectExpression = function (node, parent, file) {
     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.addDeclaration("define-property"), [objId, key, prop.value]);
+      bodyNode = t.callExpression(file.addHelper("define-property"), [objId, key, prop.value]);
     }
 
     body.push(t.expressionStatement(bodyNode));
@@ -79,7 +82,7 @@ exports.ObjectExpression = function (node, parent, file) {
     var first = body[0].expression;
 
     if (t.isCallExpression(first)) {
-      first.arguments[0] = t.objectExpression([]);
+      first.arguments[0] = t.objectExpression(initProps);
       return first;
     }
   }

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

@@ -20,11 +20,31 @@ var push = function (opts, nodes, elem, parentId) {
     pushObjectPattern(opts, nodes, elem, parentId);
   } else if (t.isArrayPattern(elem)) {
     pushArrayPattern(opts, nodes, elem, parentId);
+  } else if (t.isAssignmentPattern(elem)) {
+    pushAssignmentPattern(opts, nodes, elem, parentId);
   } else {
     nodes.push(buildVariableAssign(opts, elem, parentId));
   }
 };
 
+var pushAssignmentPattern = function (opts, nodes, pattern, parentId) {
+  var tempParentId = opts.scope.generateUidBasedOnNode(parentId, opts.file);
+
+  nodes.push(t.variableDeclaration("var", [
+    t.variableDeclarator(tempParentId, parentId)
+  ]));
+
+  nodes.push(buildVariableAssign(
+    opts,
+    pattern.left,
+    t.conditionalExpression(
+      t.binaryExpression("===", tempParentId, t.identifier("undefined")),
+      pattern.right,
+      tempParentId
+    )
+  ));
+};
+
 var pushObjectPattern = function (opts, nodes, pattern, parentId) {
   for (var i in pattern.properties) {
     var prop = pattern.properties[i];
@@ -45,9 +65,11 @@ 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 {
+      if (t.isLiteral(prop.key)) prop.computed = true;
+
       var pattern2   = prop.value;
       var patternId2 = t.memberExpression(parentId, prop.key, prop.computed);
 
@@ -75,7 +97,7 @@ var pushArrayPattern = function (opts, nodes, pattern, parentId) {
 
   var toArray = opts.file.toArray(parentId, !hasSpreadElement && pattern.elements.length);
 
-  var _parentId = t.getUid(parentId, opts.file, opts.scope);
+  var _parentId = opts.scope.generateUidBasedOnNode(parentId, opts.file);
   nodes.push(t.variableDeclaration("var", [
     t.variableDeclarator(_parentId, toArray)
   ]));
@@ -113,7 +135,7 @@ var pushPattern = function (opts) {
   var scope = opts.scope;
 
   if (!t.isMemberExpression(parentId) && !t.isIdentifier(parentId)) {
-    var key = t.getUid(parentId, file, scope);
+    var key = scope.generateUidBasedOnNode(parentId, file);
 
     nodes.push(t.variableDeclaration("var", [
       t.variableDeclarator(key, parentId)
@@ -183,6 +205,24 @@ exports.Function = function (node, parent, file, scope) {
   block.body = nodes.concat(block.body);
 };
 
+exports.CatchClause = function (node, parent, file, scope) {
+  var pattern = node.param;
+  if (!t.isPattern(pattern)) return;
+
+  var ref = file.generateUidIdentifier("ref", scope);
+  node.param = ref;
+
+  var nodes = [];
+
+  push({
+    kind: "var",
+    file: file,
+    scope: scope
+  }, nodes, pattern, ref);
+
+  node.body.body = nodes.concat(node.body.body);
+};
+
 exports.ExpressionStatement = function (node, parent, file, scope) {
   var expr = node.expression;
   if (expr.type !== "AssignmentExpression") return;
@@ -260,10 +300,17 @@ exports.VariableDeclaration = function (node, parent, file, scope) {
       file:    file,
       scope:   scope
     };
+
     if (t.isPattern(pattern) && patternId) {
       pushPattern(opts);
+
+      if (+i !== node.declarations.length - 1) {
+        // we aren't the last declarator so let's just make the
+        // last transformed node inherit from us
+        t.inherits(nodes[nodes.length - 1], declar);
+      }
     } else {
-      nodes.push(buildVariableAssign(opts, declar.id, declar.init));
+      nodes.push(t.inherits(buildVariableAssign(opts, declar.id, declar.init), declar));
     }
   }
 

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 this.stop();
+        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 this.stop();
+        return this.skip();
       }
     }
   });
@@ -376,7 +376,7 @@ LetScoping.prototype.getLetReferences = function () {
 
             // this scope has a variable with the same name so it couldn't belong
             // to our let scope
-            if (scope.hasOwn(node.name)) return;
+            if (scope.hasOwn(node.name, true)) return;
 
             closurify = true;
 
@@ -388,9 +388,7 @@ LetScoping.prototype.getLetReferences = function () {
           }
         });
 
-        return this.stop();
-      } else if (t.isLoop(node)) {
-        return this.stop();
+        return this.skip();
       }
     }
   });

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.computed, 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-rest-parameters.js

@@ -1,4 +1,5 @@
-var t = require("../../types");
+var util = require("../../util");
+var t    = require("../../types");
 
 exports.Function = function (node, parent, file) {
   if (!node.rest) return;
@@ -8,15 +9,28 @@ exports.Function = function (node, parent, file) {
 
   t.ensureBlock(node);
 
-  var call = file.toArray(t.identifier("arguments"));
+  var argsId = t.identifier("arguments");
+  argsId._ignoreAliasFunctions = true;
 
+  var start = t.literal(node.params.length);
+  var key = file.generateUidIdentifier("key");
+
+  var arrKey = key;
   if (node.params.length) {
-    call.arguments.push(t.literal(node.params.length));
+    arrKey = t.binaryExpression("-", arrKey, start);
   }
 
-  call._ignoreAliasFunctions = true;
+  node.body.body.unshift(
+    t.variableDeclaration("var", [
+      t.variableDeclarator(rest, t.arrayExpression([]))
+    ]),
 
-  node.body.body.unshift(t.variableDeclaration("var", [
-    t.variableDeclarator(rest, call)
-  ]));
+    util.template("rest", {
+      ARGUMENTS: argsId,
+      ARRAY_KEY: arrKey,
+      START: start,
+      ARRAY: rest,
+      KEY: key
+    })
+  );
 };

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

@@ -1,4 +1,5 @@
 var t = require("../../types");
+var _ = require("lodash");
 
 var getSpreadLiteral = function (spread, file) {
   return file.toArray(spread.argument);
@@ -58,7 +59,7 @@ exports.CallExpression = function (node, parent, file, scope) {
   var args = node.arguments;
   if (!hasSpread(args)) return;
 
-  var contextLiteral = t.literal(null);
+  var contextLiteral = t.identifier("undefined");
 
   node.arguments = [];
 
@@ -77,16 +78,15 @@ exports.CallExpression = function (node, parent, file, scope) {
   }
 
   var callee = node.callee;
-  var temp;
 
   if (t.isMemberExpression(callee)) {
-    contextLiteral = callee.object;
-
-    if (t.isDynamic(contextLiteral)) {
-      temp = contextLiteral = scope.generateTemp(file);
+    var temp = scope.generateTempBasedOnNode(callee.object, file);
+    if (temp) {
       callee.object = t.assignmentExpression("=", temp, callee.object);
+      contextLiteral = temp;
+    } else {
+      contextLiteral = callee.object;
     }
-
     t.appendToMemberExpression(callee, t.identifier("apply"));
   } else {
     node.callee = t.memberExpression(node.callee, t.identifier("apply"));
@@ -99,7 +99,14 @@ exports.NewExpression = function (node, parent, file) {
   var args = node.arguments;
   if (!hasSpread(args)) return;
 
+  var nativeType = t.isIdentifier(node.callee) && _.contains(t.NATIVE_TYPE_NAMES, node.callee.name);
+
   var nodes = build(args, file);
+
+  if (nativeType) {
+    nodes.unshift(t.arrayExpression([t.literal(null)]));
+  }
+
   var first = nodes.shift();
 
   if (nodes.length) {
@@ -108,5 +115,15 @@ exports.NewExpression = function (node, parent, file) {
     args = first;
   }
 
-  return t.callExpression(file.addDeclaration("apply-constructor"), [node.callee, args]);
+  if (nativeType) {
+    return t.newExpression(
+      t.callExpression(
+        t.memberExpression(file.addHelper("bind"), t.identifier("apply")),
+        [node.callee, args]
+      ),
+      []
+    );
+  } else {
+    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

@@ -30,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 !== "=") {
@@ -80,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

@@ -5,7 +5,7 @@ var t        = require("../../types");
 exports.experimental = true;
 
 var build = function (node, parent, file, scope) {
-  var uid = t.getUid(parent, file, scope);
+  var uid = scope.generateUidBasedOnNode(parent, file);
 
   var container = util.template("array-comprehension-container", {
     KEY: uid
@@ -49,7 +49,7 @@ 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])
   );

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

@@ -4,7 +4,7 @@ var t = require("../../types");
 
 exports.experimental = true;
 
-exports.ObjectExpression = function (node) {
+exports.ObjectExpression = function (node, parent, file) {
   var hasSpread = false;
   var i;
   var prop;
@@ -42,5 +42,5 @@ exports.ObjectExpression = function (node) {
     args.unshift(t.objectExpression([]));
   }
 
-  return t.callExpression(t.memberExpression(t.identifier("Object"), t.identifier("assign")), args);
+  return t.callExpression(file.addHelper("extends"), args);
 };

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

@@ -7,5 +7,5 @@ exports.manipulateOptions = bluebirdCoroutines.manipulateOptions;
 exports.Function = function (node, parent, file) {
   if (!node.async || node.generator) return;
 
-  return bluebirdCoroutines._Function(node, file.addDeclaration("async-to-generator"));
+  return bluebirdCoroutines._Function(node, file.addHelper("async-to-generator"));
 };

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

@@ -14,7 +14,7 @@ exports._Function = function (node, callId) {
 
   traverse(node, {
     enter: function (node) {
-      if (t.isFunction(node)) this.stop();
+      if (t.isFunction(node)) this.skip();
 
       if (t.isAwaitExpression(node)) {
         node.type = "YieldExpression";
@@ -38,8 +38,6 @@ exports._Function = function (node, callId) {
 exports.Function = function (node, parent, file) {
   if (!node.async || node.generator) return;
 
-  var id = t.identifier("Bluebird");
-  file.addImport(id, "bluebird");
-
+  var id = file.addImport("bluebird");
   return exports._Function(node, t.memberExpression(id, t.identifier("coroutine")));
 };

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

@@ -12,8 +12,7 @@ exports.optional = true;
 
 exports.ast = {
   enter: function (ast, file) {
-    file._coreId = file.generateUidIdentifier("core");
-    file.addImport(file._coreId, "core-js/library");
+    file._coreId = file.addImport("core-js/library", "core");
   },
 
   exit: function (ast, file) {
@@ -29,7 +28,7 @@ exports.ast = {
           if (!t.isReferenced(obj, node)) return;
 
           if (!node.computed && coreHas(obj) && _.has(core[obj.name], prop.name)) {
-            this.stop();
+            this.skip();
             return t.prependToMemberExpression(node, file._coreId);
           }
         } else if (t.isIdentifier(node) && !t.isMemberExpression(parent) && t.isReferenced(node, parent) && coreHas(node)) {

lib/6to5/transformation/transformers/optional-proto-to-assign.js

@@ -0,0 +1,61 @@
+var t = require("../../types");
+var _ = require("lodash");
+
+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, parent, file) {
+  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(file.addHelper("extends"), args);
+  }
+};

lib/6to5/transformation/transformers/optional-typeof-symbol.js

@@ -0,0 +1,9 @@
+var t = require("../../types");
+
+exports.optional = true;
+
+exports.UnaryExpression = function (node, parent, file) {
+  if (node.operator === "typeof") {
+    return t.callExpression(file.addHelper("typeof"), [node.argument]);
+  }
+};

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 = t.getUid(prop, file, 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 = t.getUid(obj, file, 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

@@ -20,7 +20,7 @@ exports.MethodDefinition = function (node, parent, file) {
       if (t.isFunction(node)) return;
 
       if (t.isReturnStatement(node) && node.argument) {
-        node.argument = t.memberExpression(t.callExpression(file.addDeclaration("define-property"), [
+        node.argument = t.memberExpression(t.callExpression(file.addHelper("define-property"), [
           t.thisExpression(),
           key,
           node.argument

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

@@ -32,12 +32,17 @@ exports.XJSExpressionContainer = function (node) {
 exports.XJSAttribute = {
   exit: function (node) {
     var value = node.value || t.literal(true);
-    return t.property("init", node.name, value);
+    return t.inherits(t.property("init", node.name, value), node);
   }
 };
 
+var isTag = function(tagName) {
+  return (/^[a-z]|\-/).test(tagName);
+};
+
 exports.XJSOpeningElement = {
-  exit: function (node) {
+  exit: function (node, parent, file) {
+    var reactCompat = file.opts.reactCompat;
     var tagExpr = node.name;
     var args = [];
 
@@ -48,10 +53,12 @@ exports.XJSOpeningElement = {
       tagName = tagExpr.value;
     }
 
-    if (tagName && (/[a-z]/.exec(tagName[0]) || tagName.indexOf("-") >= 0)) {
-      args.push(t.literal(tagName));
-    } else {
-      args.push(tagExpr);
+    if (!reactCompat) {
+      if (tagName && isTag(tagName)) {
+        args.push(t.literal(tagName));
+      } else {
+        args.push(tagExpr);
+      }
     }
 
     var props = node.attributes;
@@ -96,7 +103,21 @@ exports.XJSOpeningElement = {
 
     args.push(props);
 
-    tagExpr = t.memberExpression(t.identifier("React"), t.identifier("createElement"));
+    if (reactCompat) {
+      if (tagName && isTag(tagName)) {
+        return t.callExpression(
+          t.memberExpression(
+            t.memberExpression(t.identifier("React"), t.identifier("DOM")),
+            tagExpr,
+            t.isLiteral(tagExpr)
+          ),
+          args
+        );
+      }
+    } else {
+      tagExpr = t.memberExpression(t.identifier("React"), t.identifier("createElement"));
+    }
+
     return t.callExpression(tagExpr, args);
   }
 };
@@ -119,16 +140,16 @@ exports.XJSElement = {
           var isLastLine = +i === lines.length - 1;
 
           // replace rendered whitespace tabs with spaces
-          var trimmedLine = line.replace(/\t/g, ' ');
+          var trimmedLine = line.replace(/\t/g, " ");
 
           // trim whitespace touching a newline
           if (!isFirstLine) {
-            trimmedLine = trimmedLine.replace(/^[ ]+/, '');
+            trimmedLine = trimmedLine.replace(/^[ ]+/, "");
           }
 
           // trim whitespace touching an endline
           if (!isLastLine) {
-            trimmedLine = trimmedLine.replace(/[ ]+$/, '');
+            trimmedLine = trimmedLine.replace(/[ ]+$/, "");
           }
 
           if (trimmedLine) {
@@ -144,6 +165,10 @@ exports.XJSElement = {
       callExpr.arguments.push(child);
     }
 
+    if (callExpr.arguments.length >= 3) {
+      callExpr._prettyCall = true;
+    }
+
     return t.inherits(callExpr, node);
   }
 };

lib/6to5/transformation/transformers/spec-block-hoist-functions.js

@@ -1,18 +0,0 @@
-var t = require("../../types");
-
-exports.BlockStatement = function (node, parent) {
-  if (t.isFunction(parent)) return;
-
-  node.body = node.body.map(function (node) {
-    if (t.isFunction(node)) {
-      node.type = "FunctionExpression";
-      var declar = t.variableDeclaration("let", [
-        t.variableDeclarator(node.id, node)
-      ]);
-      declar._blockHoist = true;
-      return declar;
-    } else {
-      return node;
-    }
-  });
-};

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

@@ -1,5 +1,4 @@
-var esutils = require("esutils");
-var t       = require("../../types");
+var t = require("../../types");
 
 exports.MemberExpression = function (node) {
   var prop = node.property;
@@ -7,7 +6,7 @@ exports.MemberExpression = function (node) {
     // computed literal that is a valid identifier
     node.property = t.identifier(prop.value);
     node.computed = false;
-  } else if (!node.computed && t.isIdentifier(prop) && esutils.keyword.isKeywordES6(prop.name, true)) {
+  } else if (!node.computed && t.isIdentifier(prop) && !t.isValidIdentifier(prop.name)) {
     node.property = t.literal(prop.name);
     node.computed = true;
   }

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/spec-property-literals.js

@@ -1,5 +1,4 @@
-var esutils = require("esutils");
-var t       = require("../../types");
+var t = require("../../types");
 
 exports.Property = function (node) {
   var key = node.key;
@@ -7,7 +6,7 @@ exports.Property = function (node) {
     // property key is a literal but a valid identifier
     node.key = t.identifier(key.value);
     node.computed = false;
-  } else if (!node.computed && t.isIdentifier(key) && esutils.keyword.isKeywordES6(key.name, true)) {
+  } else if (!node.computed && t.isIdentifier(key) && !t.isValidIdentifier(key.name)) {
     // property key is a keyword
     node.key = t.literal(key.name);
   }

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

@@ -1,14 +1,27 @@
 var t = require("../../types");
 
+exports._has = function (node) {
+  var first = node.body[0];
+  return t.isExpressionStatement(first) && t.isLiteral(first.expression, { value: "use strict" });
+};
+
+exports._wrap = function (node, callback) {
+  var useStrictNode;
+  if (exports._has(node)) {
+    useStrictNode = node.body.shift();
+  }
+
+  callback();
+
+  if (useStrictNode) {
+    node.body.unshift(useStrictNode);
+  }
+};
+
 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";
-
-    if (noStrict) {
-      body.unshift(t.expressionStatement(t.literal("use strict")));
+    if (!exports._has(ast.program)) {
+      ast.program.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];
@@ -50,7 +52,8 @@ function traverse(parent, opts, scope) {
 
         // replace the node
         node = obj[key] = result;
-        updated = true;
+
+        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
@@ -59,16 +62,20 @@ function traverse(parent, opts, scope) {
         }
       };
 
-      var stopped = false;
+      var skipped = false;
       var removed = false;
 
       var context = {
         stop: function () {
-          stopped = true;
+          skipped = stopped = true;
+        },
+
+        skip: function () {
+          skipped = true;
         },
 
         remove: function () {
-          this.stop();
+          this.skip();
           removed = true;
         }
       };
@@ -84,11 +91,11 @@ function traverse(parent, opts, scope) {
 
         if (removed) {
           obj[key] = null;
-          updated = true;
+          flatten = true;
         }
 
         // stop iteration
-        if (stopped) return;
+        if (skipped) return;
       }
 
       // traverse node
@@ -103,9 +110,10 @@ function traverse(parent, opts, scope) {
     if (_.isArray(nodes)) {
       for (i in nodes) {
         handle(nodes, i);
+        if (stopped) return;
       }
 
-      if (updated) {
+      if (flatten) {
         parent[key] = _.flatten(parent[key]);
 
         if (key === "body") {
@@ -115,6 +123,7 @@ function traverse(parent, opts, scope) {
       }
     } else {
       handle(parent, key);
+      if (stopped) return;
     }
   }
 }
@@ -161,7 +170,7 @@ traverse.hasType = function (tree, type, blacklistTypes) {
     enter: function (node) {
       if (node.type === type) {
         has = true;
-        this.stop();
+        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 this.stop();
+        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

@@ -39,8 +39,9 @@
   "ForInStatement": ["Statement", "For", "Scope", "Loop"],
   "ForStatement":   ["Statement", "For", "Scope", "Loop"],
 
-  "ObjectPattern": ["Pattern"],
-  "ArrayPattern":  ["Pattern"],
+  "ObjectPattern":     ["Pattern"],
+  "ArrayPattern":      ["Pattern"],
+  "AssignmentPattern": ["Pattern"],
 
   "Property": ["UserWhitespacable"],
   "XJSElement": ["UserWhitespacable", "Expression"],