v2.9.4

This reverts commit b619e843a9.

.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

.jshintignore

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

.npmignore

@@ -1,11 +1,12 @@
 node_modules
 *.log
 *.cache
-lib/6to5/templates
+lib/6to5/transformation/templates
 test
 benchmark
 Makefile
 .*
 dist
 tests.json
-!README.md
+CHANGELOG.md
+.package.json

CHANGELOG.md

@@ -1,34 +1,543 @@
-# 1.12.3
+# Changelog
+
+> **Tags:**
+> - [New Feature]
+> - [Bug Fix]
+> - [Spec Compliancy]
+> - [Breaking Change]
+> - [Documentation]
+> - [Internal]
+> - [Polish]
+
+_Note: Gaps between patch versions are faulty/broken releases._
+
+## 2.9.4
+
+ * **Bug Fix**
+  * Support `UpdateExpression`s as `MemberExpression` objects.
+
+## 2.9.3
+
+ * **Bug Fix**
+  * Remove `exportsWildcard` helper in favor of `defaults`.
+
+## 2.9.2
+
+ * **Bug Fix**
+  * Pass `exports` to `exportWildcard` helper to allow for use inside the optional runtime.
+
+## 2.9.1
+
+ * **Bug Fix**
+  * 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
+
+ * Upgrade `acorn-6to5`.
+
+## 2.4.6
+
+ * Move `coreAliasing` and `undefinedToVoid` transformers down to catch `moduleFormatter` transforms.
+
+## 2.4.5
+
+ * Avoid printing comments if they've already been output.
+
+## 2.4.4
+
+ * Add `module` type to browser build `<script>` handler.
+ * Fix some `MemberExpression` modifying incorrectly setting `property` to a `MemberExpression`.
+
+## 2.4.3
+
+ * Upgrade `acorn-6to5`.
+ * Add support for `FunctionDeclaration`s in `bluebirdCoroutines` and `asyncToGenerators` transformers.
+
+## 2.4.2
+
+ * Upgrade `acorn-6to5`.
+ * Better uids generated for various transformers based on parent node.
+ * Alias flat references in `coreAliasing` transformer.
+
+## 2.4.1
+
+ * Better whitespace handling of parenthesized expressions due to trailing comments.
+ * Fix `yield` inside of comprehensions.
+
+## 2.4.0
+
+ * Use a closure always for classes with a super.
+ * Always use native loops for array comprehensions.
+ * Allow `yield` inside of comprehensions.
+ * Add optional `bluebirdCoroutine` transformer.
+ * Add optional `asyncToGenerator` transformer.
+ * Move `useStrict` transformer to before `_moduleFormatter` causing `"use strict";` to always be placed the very top.
+
+## 2.3.2
+
+ * Add parens on expressions with trailing comments.
+
+## 2.3.1
+
+ * Add `undefinedToVoid` optional transformer.
+ * Use `Object.defineProperty` for computed properties.
+
+## 2.3.0
+
+ * Upgrade `acorn-6to5`.
+ * Support circular references and hoist variable declarations in `system` module formatter.
+ * Add optional transformers, including a new `coreAliasing` transformer that aliases native ES6 static properties to their `core-js` equivalent.
+
+## 2.2.0
+
+ * Make `system` module formatter modules anonymous by default.
+ * Fix duplicate comments being output, breaking code.
+
+## 2.1.0
+
+ * Add `cache` option to register hook.
+ * Update `core-js`.
+ * Fix starting newline not being added on case statements.
+ * Fix destructuring `VariableDeclaration`s not inside `BlockStatement`s and `Program`.
+
+## 2.0.4
+
+ * Avoid being greedy when destructuring array iterables.
+
+## 2.0.3
+
+ * Hoist function declarations in system module formatter for circular references.
+ * Hoist default function declarations in umd and amd module formatters for circular references.
+
+## 2.0.2
+
+ * Inherit comments in `for-of` transformer.
+ * Remove `interopRequire` from `system` module formatter.
+
+## 2.0.1
+
+ * Remap `UpdateExpression` module export binding.
+ * Fix automatic closure on `PrivateDeclaration` in classes.
+
+## 2.0.0
+
+ * Make string literal generation only escapes unicode that it has to.
+ * Internal code generation format options have been exposed.
+ * Change playground method binding operator from `:` to `#` removing ambiguous syntax with terns.
+ * Fix rest parameters in async and generator functions.
+ * Export/import declarations replace by the modules transformer now inherit comments.
+ * Added playground flag to `6to5-node`.
+ * `6to5-node` now behaves the same as `node`.
+ * `6to5-node` now uses `kexec` to become the forked process to correctly propagate signals on unix.
+ * Constants are now block scoped.
+ * Exposed ast transformer.
+ * Merged `commonInterop` and `common` module formatters.
+ * Fix generator comprehensions not inheriting `arguments`, `this` etc.
+ * Object and class mutator shorthand are now enumerable.
+ * Remove regenerator `Generator has already finished` error which isn't spec-compliant.
+ * Expose internal `spec` transformers that nicen up code output.
+ * Add export variable declaration default initializers.
+ * Propagate export declaration reassignments.
+ * Add initializer default to block scoped variable declarations within a loop.
+ * Flow type support.
+ * Make async/await contextual keywords.
+ * Allow `yield`ing of non-objects.
+ * Class declarations now lack an IIFE.
+ * Support falsy and `null` super classes.
+ * Add support for experimental abstract references `private` declarations.
+ * Leave out IIFE for class declarations.
+ * Switched to [core-js](https://github.com/zloirock/core-js) from [es6-symbol](https://github.com/medikoo/es6-symbol) and [es6-shim](https://github.com/paulmillr/es6-shim/) for built-in polyfill.
+ * `amd` and `umd` module formatters now behave the same as `common` with `interopRequire`.
+ * Micro-optimizations to boost performance by 200%.
+ * Rename module formatter methods `import` to `importDeclaration` and `export` to `exportDeclaration`.
+ * Support multiple declarators in export variable declarations.
+ * Freeze tagged template literal object.
+ * Remove inlined `regenerator` fork.
+ * Remove `ParenthesizedExpression`.
+ * Rename `object-spread` helper to `object-without-properties`.
+ * Rename `class-props` helper to `prototype-properties`.
+ * Rename `extends` helper to `inherits`.
+ * Completely rewritten `system` module formatter.
+
+## 1.15.0
+
+ * Don't alias `GeneratorFunction` and check the name which causes minifiers to remove the name and throw an error later on when we check if it's set.
+
+## 1.14.18
+
+ * Fix files only containg comments not being output.
+ * Fix duplicate comments on property key shorthands.
+
+## 1.14.17
+
+ * Add default initializer to let variables within loop bodies.
+ * Fix excessive `break` replacement inside of switches in let scoping.
+
+## 1.14.16
+
+ * Add object getter memos and this shorthand to playground.
+ * Fix while loops in let scoping.
+ * Upgrade `acorn-6to5`.
+
+## 1.14.14
+
+ * Fix template literals escaping.
+
+## 1.14.13
+
+ * Fix let scoping of `while` loops.
+ * Make class methods enumerable.
+
+## 1.14.12
+
+ * Fix duplicate dynamic expressions in call spread.
+
+## 1.14.10
+
+ * Fix let scoping unneccesary override.
+
+## 1.14.6
+
+ * Avoid ensuring a block on non-array node replacements.
+
+## 1.14.5
+
+ * Upgrade `acorn-6to5`.
+ * Fix JSON recursion error for unknown code generator node types.
+ * Ensure that a statement is a block on block/statement types when replacing them with multiple nodes.
+
+## 1.14.4
+
+ * Merge pretzel maps and method binding.
+
+## 1.14.3
+
+ * Add playground pretzel maps.
+
+## 1.14.2
+
+ * Fix `commonInterop` default export handling.
+ * Fix keyworded property key identifiers being turned into computed property key literals.
+
+## 1.14.1
+
+ * Inherit comments from `ClassDeclaration`.
+
+## 1.14.0
+
+ * Add [playground](https://6to5.github.io/playground.html).
+
+## 1.13.13
+
+ * Fix `--debug` in `bin/6to5-node`. Thanks [@timoxley](https://github.com/timoxley).
+
+## 1.13.12
+
+ * Ignore `XJSEmptyExpression`s in `react` transformer output.
+
+## 1.13.11
+
+ * Fix `util.regexify` on falsy values.
+ * Fix `_aliasFunction` with rest parameters.
+ * Export as `module.exports` instead of `exports.default` if there are no other `ExportDeclaration`s in `commonInterop` module formatter.
+ * Add `system` module formatter. Thanks [@douglasduteil](https://github.com/douglasduteil).
+
+## 1.13.10
+
+ * Add support for `AssignmentExpression` destructuring outside of `ExpressionStatement`.
+
+## 1.13.9
+
+ * Fix `VirtualPropertyExpression` visitor keys.
+
+## 1.13.8
+
+ * Only use a single reference in abstract references.
+
+## 1.13.7
+
+ * Upgrade `acorn-6to5`.
+ * Add experimental exponentiation operator support.
+
+## 1.13.6
+
+ * Fix experimental object spread/rest helper.
+
+## 1.13.5
+
+ * Upgrade `acorn-6to5`.
+ * Add experimental support for object spread/rest.
+ * Change `arguments` to array to an additional helper method.
+
+## 1.13.4
+
+ * Fix single spread element returning itself.
+
+## 1.13.3
+
+ * Upgrade `acorn-6to5`.
+ * Add experimental support for abstract references.
+
+## 1.13.2
+
+ * Optimise `Array.from` usage by adding a helper method.
+ * Upgrade `acorn-6to5`.
+
+## 1.13.1
+
+ * Fix constructor spread optimisation. Thanks [@zloirock](https://github.com/zloirock).
+
+## 1.13.0
+
+ * Put experimental ES7 features behind a flag `--experimental` and `experimental` option.
+ * Constructor spread performance increase. Thanks [@RReverser](https://github.com/RReverser).
+ * Use `self` instead of `window` in the optional 6to5 runtime. Thanks [@RReverser](https://github.com/RReverser).
+
+## 1.12.26
+
+ * Support computed property destructuring.
+
+## 1.12.25
+
+ * Update `acorn-6to5`, `ast-types`, `es6-shim`, `chokidar`, `estraverse` and `private`.
+
+## 1.12.24
+
+ * Collect references that haven't been declared in scope.
+
+## 1.12.23
+
+ * Fix generator function export hoisting.
+
+## 1.12.22
+
+ * Update `fs-readdir-recursive` and `chokidar`.
+ * Support array destructuring on iterables.
+ * Make amd module id optional. Thanks [@webpro](https://github.com/webpro).
+
+## 1.12.21
+
+ * Fix unneccesary let scoping replacement.
+ * Add `commonInterop` module formatter. Thanks [@Naddiseo](https://github.com/Naddiseo).
+ * Fix `return` outside of function body bug. Thanks [@brentburg](https://github.com/brentburg).
+ * Add more flexible option types.
+
+## 1.12.20
+
+ * Append `sourceMappingURL` when using `bin/6to5` and output sourcemaps.
+
+## 1.12.19
+
+ * Add `comments` option and `--remove-comments` flag. Thanks [@webpro](htps://github.com/webpro).
+ * Embed `regenerator`.
+
+## 1.12.18
+
+ * Use `global` reference instead of `window`.
+
+## 1.12.17
+
+ * Add `moduleName`, `sourceRoot` and `filenameRelative` options. Thanks [@darvelo](https://github.com/darvelo).
+ * Traversal optimisations.
+
+## 1.12.16
+
+ * Fix comments not being retained from `MethodDefinition` in classes.
+ * Add temporal dead zone in default parameters.
+
+## 1.12.15
+
+ * Update `acorn-6to5`.
+
+## 1.12.14
+
+ * Fix duplicate let scoping in functions.
+ * Make JSX whitespace more React-compliant.
+ * Add `_memberExpressionKeywords` transformer that turns keyword identifiers to computed literals.
+ * Upgrade `regenerator-6to5`.
+
+## 1.12.13
+
+ * Support duplicate constants within different block scopes.
+ * Fix for-head duplication testing and replacement.
+ * Support `raw` property on tagged template literals.
+
+## 1.12.12
+
+ * Make scope tracker more reliable to handle all edgecases.
+
+## 1.12.11
+
+ * Block scope classes.
+ * Fix generation of integer `Literal`s in `MemberExpression`.
+
+## 1.12.10
+
+ * Fix let scoping var hoisting.
+
+## 1.12.9
+
+ * Escape unicode characters when generating string `Literal`s.
+ * Fix semicolons being output for statements in `ExportDeclaration`.
+ * Fix `WithStatement` missing parenthesis.
+
+## 1.12.8
+
+ * Temporarily forbid `AssignmentExpression` destructuring outside of `ExpressionStatement`.
+
+## 1.12.7
+
+ * Update to latest `acorn-6to5`.
+
+## 1.12.6
+
+ * Update to latest `acorn-6to5`.
+
+## 1.12.5
+
+ * Fix excessive whitespace trimming resulting in innaccurate sourcemap line.
+
+## 1.12.4
+
+ * Add `doc` folder for documentation.
+
+## 1.12.3
 
  * Support generator comprehensions.
  * Use `Array.from` instead of `Array.prototype.slice` in spread transformer.
  * Support spread in `NewExpression`s.
 
-# 1.12.2
+## 1.12.2
 
  * Upgrade `matcha` to `0.6.0` and `browserify` to `6.3.2`.
  * Add own `trimRight` helper instead of relying on the string instance method.
  * Support JSX spreads that aren't the first.
 
-# 1.12.1
+## 1.12.1
 
  * Fix `this` and `arguments` mapping in the `_aliasFunctions` transformer.
 
-# 1.12.0
+## 1.12.0
 
  * Combine `jsx` and `react` transformers to `react`.
  * Update `react` syntax output to React v0.12.
 
-# 1.11.15
+## 1.11.15
 
  * Fix JSX literal whitespace generation.
 
-# 1.11.14
+## 1.11.14
 
  * Avoid using a switch for let-scoping continue and break statements and use an if statement instead.
  * Remove excess whitespace and newlines from JSX literals.
 
-# 1.11.13
+## 1.11.13
 
  * Update regenerator-6to5
  * Add support for most escodegen formatting options

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

@@ -0,0 +1,32 @@
+# 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
+   * Max depth of four nested blocks
+   * 2-spaced soft tabs
+ * **Naming**
+   * CamelCase all class names
+   * camelBack all variable names
+ * **Spacing**
+   * Spaces after all keywords
+   * Spaces before all left curly braces
+ * **Comments**
+   * Use JSDoc-style comments for methods
+   * Single-line comments for ambiguous code
+ * **Quotes**
+   * Always use double quotes
+   * Only use single quotes when the string contains a double quote
+ * **Declaration**
+   * No unused variables
+   * No pollution of global variables and prototypes
+
+## Testing
+
+    $ make test
+
+## Linting
+
+    $ make lint

FEATURES.md

@@ -1,177 +0,0 @@
-# Features
-
-## Array comprehension
-
-```javascript
-[for (i of [1, 2, 3]) i * i]; // [1, 4, 9]
-```
-
-## Async functions
-
-```javascript
-async function chainAnimationsAsync(elem, animations) {
-  for (var anim of animations) {
-    await anim(elem);
-  }
-}
-```
-
-## Arrow functions
-
-```javascript
-arr.map(x => x * x);
-```
-
-## Let scoping
-
-```javascript
-for (let i in arr) {
-  let v = arr[i];
-}
-```
-
-## Classes
-
-```javascript
-class Foo extends Bar {
-  constructor() { }
-
-  foo() { }
-
-  get bar() { }
-
-  set bar() { }
-}
-```
-
-## 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 foo(bar = "foo") {
-  return bar + "bar";
-}
-```
-
-## Destructuring
-
-```javascript
-var [a, [b], c, d] = ["hello", [", ", "junk"], ["world"]];
-console.log(a + b + c); // hello, world
-```
-
-## For-of
-
-```javascript
-for (var i of [1, 2, 3]) {
-  console.log(i * i);
-}
-```
-
-## Generators
-
-```javascript
-```
-
-## Generator comprehension
-
-```javascript
-```
-
-## Modules
-
-```javascript
-```
-
-## Numeric literals
-
-```javascript
-0b111110111 === 503; // true
-0o767 === 503; // true
-```
-
-## 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 printList(name, ...items) {
-  console.log("list %s has the following items", name);
-  items.forEach(function (item) {
-    console.log(item);
-  });
-}
-```
-
-## Spread
-
-```javascript
-function add(x, y) {
-  return x + y;
-}
-
-var numbers = [5, 10];
-add(...numbers); // 15
-```
-
-## 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]);
-```

LICENSE

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

MODULES.md

@@ -1,170 +0,0 @@
-# Modules
-
-## Usage
-
-### CLI
-
-    $ 6to5 --modules common script.js
-
-### Node
-
-```javascript
-var to5 = require("6to5");
-to5.transform('import "foo";', { modules: "common" });
-```
-
-## Formats
-
-### Common (Default)
-
-**In**
-
-```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 default test;
-```
-
-**Out**
-
-```javascript
-require("foo");
-
-var foo = require("foo").default;
-var foo = require("foo");
-
-var bar = require("foo").bar;
-var bar = require("foo").foo;
-
-exports.test = test;
-var test = 5; exports.test = test;
-
-exports.default = test;
-```
-
-### AMD
-
-**In**
-
-```javascript
-import foo from "foo";
-
-export function bar() {
-  return foo("foobar");
-}
-```
-
-**Out**
-
-```javascript
-define(["exports", "foo"], function (exports, _foo) {
-  exports.bar = bar;
-
-  var foo = _foo.default;
-
-  function bar() {
-    return foo("foobar");
-  }
-});
-```
-
-### 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) {
-  exports.bar = bar;
-
-  var foo = _foo.default;
-
-  function bar() {
-    return foo("foobar");
-  }
-});
-```
-
-### Ignore
-
-
-**In**
-
-```javascript
-import foo from "foo";
-
-export function bar() {
-  return foo("foobar");
-}
-```
-
-**Out**
-
-```javascript
-function bar() {
-  return foo("foobar");
-}
-```
-
-## Custom
-
-You can alternatively specify module names instead of one of the built-in types.
-
-    $ 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.import = function (node, nodes) {
-  // node is an ImportDeclaration
-};
-
-ModuleFormatter.prototype.importSpecifier = function (specifier, node, nodes) {
-  // specifier is an ImportSpecifier
-  // node is an ImportDeclaration
-};
-
-ModuleFormatter.prototype.export = function (node, nodes) {
-  // node is an ExportDeclaration
-};
-
-ModuleFormatter.prototype.exportSpecifier = function (specifier, node, nodes) {
-  // specifier is an ExportSpecifier
-  // node is an ExportDeclaration
-};
-```

Makefile

@@ -6,46 +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) lib bin benchmark/index.js
-
-test-clean:
-	rm -rf test/tmp
-
-test:
-	make 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:
-	make 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
@@ -63,11 +24,56 @@ 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
 
 	make test
 
+	read -p "Version: "  version; \
+	npm version $$version --message "v%s"
+
 	make build
 	cp dist/6to5.min.js browser.js
 	cp dist/polyfill.min.js browser-polyfill.js
@@ -76,10 +82,24 @@ publish:
 	node bin/cache-templates
 	test -f templates.json
 
-	read -p "Version: "  version; \
-  npm version $$version --message "v%s"
 	npm 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.

README.md

@@ -3,12 +3,12 @@
 </p>
 
 <p align="center">
-  <a href="https://travis-ci.org/6to5/6to5">
-    <img alt="Travis Status" src="http://img.shields.io/travis/6to5/6to5.svg?branch=master&amp;style=flat&amp;label=travis">
+  <a href="https://gratipay.com/sebmck">
+    <img alt="Gratipay" src="https://img.shields.io/gratipay/sebmck.svg?style=flat">
   </a>
 
-  <a href="https://ci.appveyor.com/project/sebmck/6to5">
-    <img alt="Appveyor Status" src="http://img.shields.io/appveyor/ci/sebmck/6to5.svg?style=flat&amp;label=appveyor">
+  <a href="https://travis-ci.org/6to5/6to5">
+    <img alt="Travis Status" src="http://img.shields.io/travis/6to5/6to5/master.svg?style=flat&amp;label=travis">
   </a>
 
   <a href="https://codeclimate.com/github/6to5/6to5">
@@ -24,499 +24,11 @@
   </a>
 </p>
 
-**6to5** turns ES6 code into vanilla ES5, so you can use ES6 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) 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**[\*](#generators).
-
-## Installation
-
-It's as easy as:
-
-    $ npm install -g 6to5
-
-## Table of Contents
-
-- [Features](#features)
-- [Usage](#usage)
-  - [Plugins](#plugins)
-  - [CLI](#cli)
-  - [Node](#node-1)
-  - [Browser](#browser)
-- [Modules](#modules)
-- [Caveats](#caveats)
-- [Polyfill](#polyfill)
-- [Optional runtime](#optional-runtime)
-- [React/JSX](#reactjsx)
-- [Differences](#differences)
-
-## [Features](FEATURES.md)
-
- - [Array comprehension](FEATURES.md#array-comprehension)
- - [Async functions](FEATURES.md#async-functions) via [regenerator](https://github.com/facebook/regenerator)
- - [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)
- - [For-of](FEATURES.md#for-of)
- - [Generators](FEATURES.md#generators) via [regenerator](https://github.com/facebook/regenerator)
- - [Generator comprehension](FEATURES.md#generator-comprehension)
- - [Let scoping](FEATURES.md#let-scoping)
- - [Modules](FEATURES.md#modules)
- - [Numeric literals](FEATURES.md#numeric-literals)
- - [Property method assignment](FEATURES.md#property-method-assignment)
- - [Property name shorthand](FEATURES.md#property-name-shorthand)
- - [React/JSX](#reactjsx)
- - [Rest parameters](FEATURES.md#rest-parameters)
- - [Spread](FEATURES.md#spread)
- - [Template literals](FEATURES.md#template-literals)
- - [Unicode regex](FEATURES.md#unicode-regex)
-
-## Usage
-
-### Plugins
-
- - [Broccoli](https://github.com/very-geek/broccoli-6to5-transpiler)
- - [Browserify](https://github.com/6to5/6to5-browserify)
- - [Brunch](https://github.com/es128/6to5-brunch)
- - [Duo](https://github.com/bdo-labs/duo6to5)
- - [Connect](https://github.com/6to5/6to5-connect)
- - [Gulp](https://github.com/sindresorhus/gulp-6to5)
- - [Grunt](https://github.com/sindresorhus/grunt-6to5)
- - [Jade](https://github.com/Apoxx/jade-6to5)
- - [Jest](https://github.com/6to5/6to5-jest)
- - [Karma](https://github.com/shuhei/karma-6to5-preprocessor)
- - [Mocha](https://github.com/6to5/6to5-mocha)
- - [Rails](https://github.com/6to5/6to5-rails)
- - [webpack](https://github.com/Couto/6to5-loader)
-
-### CLI
-
-Compile the file `script.js` and output it to stdout.
-
-    $ 6to5 script.js
-
-Compile the file `script.js` and output it to `script-compiled.js`.
-
-    $ 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`.
-
-    $ 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.
-
-    $ 6to5 script.js --source-maps-inline --out-file script-compiled.js
-
-Compile the entire `src` directory and output it to the `lib` directory.
-
-    $ 6to5 src --out-dir lib
-
-Compile the entire `src` directory and output it to the one concatenated file.
-
-    $ 6to5 src --out-file script-compiled.js
-
-Pipe a file in via stdin and output it to `script-compiled.js`
-
-    $ 6to5 --out-file script-compiled.js < script.js
-
-#### Node
-
-Launch a repl.
-
-    $ 6to5-node
-
-Evaluate code.
-
-    $ 6to5-node -e "class Test { }"
-
-Compile and run `test.js`.
-
-    $ 6to5-node test
-
-### Node
-
-```javascript
-var to5 = require("6to5");
-
-var result = to5.transform("code();", options);
-result.code;
-result.map;
-result.ast;
-
-to5.transformFileSync("filename.js", options).code;
-
-to5.transformFile("filename.js", options, function (err, result) {
-
-});
-```
-
-##### Options
-
-```javascript
-{
-  // Filename for use in errors etc.
-  // Default: "unknown"
-  filename: "filename",
-
-  // 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: `filename` option.
-  sourceMapName: "filename",
-
-  // Set `sources[0]` on returned source map.
-  // Default: `filename` option.
-  sourceFileName: "filename",
-
-  // 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
-}
-```
-
-#### 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) is also
-required.
-
-```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
-});
-```
-
-##### 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"]
-});
-```
-
-### 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:
-
-    $ make build
-
-This will output the files `dist/6to5.js` and `dist/6to5.min.js`.
-
-#### API
-
-```javascript
-to5.transform("class Test {}").code;
-```
-
-#### Test
-
-To test 6to5 in your browser run:
-
-    $ make test-browser
-
-And open `test/browser.html` in your browser if it doesn't open automatically.
-
-## [Modules](MODULES.md)
-
-See [Modules - Common](MODULES.md#common-default) for documentation on the
-default module formatting.
-
-Alternatively see [Modules](MODULES.md) for all other supported module formatting types.
-
-## Caveats
-
-### For-of
-
-A polyfill is required for for-of functionality that implements `Symbol` and
-adds `prototype[Symbol.iterator]` behaviour to built-ins. Using the polyfills
-specified in [polyfill](#polyfill) suffices.
-
-### Classes
-
-Built-in classes such as `Date`, `Array` and `DOM` cannot be subclassed due to
-limitations in ES5 implementations.
-
-If you're inheriting from a class then static properties are inherited from it
-via [\_\_proto\_\_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/proto),
-this is widely supported but you may run into problems with much older browsers.
-
-**NOTE:** `__proto__` is not supported on IE <= 9 so static properties
-**will not** be inherited. A possible workaround is to use `super();`:
-
-```javascript
-class Foo {
-  static foo() {
-
-  }
-}
-
-class Bar extends Foo {
-  static foo() {
-    super();
-  }
-}
-```
-
-### Spread
-
-An [ES6 polyfill](#polyfill) is required in order for spread to work. More
-specifically a polyfill for `Array.from`.
-
-### Generators
-
-The [regenerator runtime](https://github.com/facebook/regenerator/blob/master/runtime.js)
-and an [ES6 polyfill](#polyfill) are required in order for generators to work.
-
-## Polyfill
-
-6to5 includes a polyfill that includes the
-[regenerator runtime](https://github.com/facebook/regenerator/blob/master/runtime.js) and the
-[es6-shim](https://github.com/paulmillr/es6-shim) and
-[es6-symbol](https://github.com/medikoo/es6-symbol) polyfills.
-
-### Node
-
-```javascript
-require("6to5/polyfill");
-```
-
-### Browser
-
-Available from the `browser-polyfill.js` file within the 6to5 directory of an
-npm release.
-
-## 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](#node-1):
-
-```javascript
-{
-  runtime: true
-}
-```
-
-or the following flag if you're using the [CLI](#cli):
-
-    $ 6to5 --runtime
-
-Then just include the runtime before your generated code.
-
-### Getting the runtime
-
-You can get the runtime via either:
-
-    $ 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");
-```
-
-    $ 6to5-runtime myCustomNamespace
-
-See [Options - runtime](#options) for documentation on changing the reference in
-generated code.
-
-## 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.
-
-To disable this behaviour add `react` to your blacklist.
-
-## Differences
-
-### Philosophy
-
-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 = 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.
-
-I'm not saying 6to5 is for everyone or even suited for everything. Traceur is
-better suited if you'd like a full ES6 environment with polyfills and all.
-
-### Comparison to other transpilers
-
-|                              | 6to5 | Traceur | esnext | es6now | es6-transpiler | jstransform |
-| ---------------------------- | ---- | ------- | ------ | ------ | -------------- | ----------- |
-| No runtime                   | ✓    |         |        |        | ✓              | ✓           |
-| Source maps                  | ✓    | ✓       | ✓      |        | ✓              | ✓           |
-| No compiler global pollution | ✓    |         | ✓      |        | ✓              | ✓           |
-| Arrow functions              | ✓    | ✓       | ✓      | ✓      | ✓              | ✓           |
-| Classes                      | ✓    | ✓       | ✓      | ✓      | ✓              | ✓           |
-| Computed property names      | ✓    | ✓       | ✓      | ✓      | ✓              |             |
-| Constants                    | ✓    | ✓       |        |        | ✓              |             |
-| Default parameters           | ✓    | ✓       | ✓      | ✓      | ✓              |             |
-| Destructuring                | ✓    | ✓       | ✓      | ✓      | ✓              | ✓           |
-| For-of                       | ✓    | ✓       | ✓      | ✓      | ✓              |             |
-| Generators                   | ✓    | ✓       | ✓      |        |                |             |
-| Let scoping                  | ✓    | ✓       |        |        | ✓              |             |
-| Modules                      | ✓    | ✓       |        | ✓      |                |             |
-| Property method assignment   | ✓    | ✓       | ✓      | ✓      | ✓              | ✓           |
-| Property name shorthand      | ✓    | ✓       | ✓      | ✓      | ✓              | ✓           |
-| Rest parameters              | ✓    | ✓       | ✓      | ✓      | ✓              | ✓           |
-| 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
-unneccesary step when a 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.
+<p align="center">
+  <strong>6to5</strong> turns ES6+ code into vanilla ES5, so you can use next generation features <strong>today.</strong>
+</p>
+
+<p align="center">
+  For more information view the <a href="https://6to5.github.io">documentation</a>. For
+  support visit the <a href="https://gitter.im/6to5/6to5">gitter room</a>.
+</p>

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-node

@@ -5,7 +5,6 @@
  * when found, before invoking the "real" _6to5-node(1) executable.
  */
 
-var spawn = require("child_process").spawn;
 var args  = ["--harmony", __dirname + "/_6to5-node"];
 
 process.argv.slice(2).forEach(function(arg){
@@ -14,18 +13,19 @@ process.argv.slice(2).forEach(function(arg){
   switch (flag) {
     case "-d":
       args.unshift("--debug");
-      args.push("--no-timeouts");
       break;
+
     case "debug":
     case "--debug":
     case "--debug-brk":
       args.unshift(arg);
-      args.push("--no-timeouts");
       break;
+
     case "-gc":
     case "--expose-gc":
       args.unshift("--expose-gc");
       break;
+
     case "--gc-global":
     case "--harmony":
     case "--harmony-proxies":
@@ -37,20 +37,32 @@ process.argv.slice(2).forEach(function(arg){
     case "--trace-deprecation":
       args.unshift(arg);
       break;
+
     default:
-      if (0 == arg.indexOf("--trace")) args.unshift(arg);
-      else args.push(arg);
+      if (arg.indexOf("--trace") === 0) {
+        args.unshift(arg);
+      } else {
+        args.push(arg);
+      }
       break;
   }
 });
 
-var proc = spawn(process.argv[0], args, { stdio: "inherit" });
-proc.on("exit", function (code, signal) {
-  process.on("exit", function (){
-    if (signal) {
-      process.kill(process.pid, signal);
-    } else {
-      process.exit(code);
-    }
+try {
+  var kexec = require("kexec");
+  kexec(process.argv[0], args);
+} catch (err) {
+  if (err.code !== "MODULE_NOT_FOUND") throw err;
+
+  var child_process = require("child_process");
+  var proc = child_process.spawn(process.argv[0], args, { stdio: "inherit" });
+  proc.on("exit", function (code, signal) {
+    process.on("exit", function () {
+      if (signal) {
+        process.kill(process.pid, signal);
+      } else {
+        process.exit(code);
+      }
+    })
   });
-});
+}

bin/6to5-runtime

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

bin/6to5/dir.js

@@ -19,7 +19,9 @@ module.exports = function (commander, filenames, opts) {
     mkdirp.sync(up);
 
     if (commander.sourceMaps) {
-      fs.writeFileSync(dest + ".map", JSON.stringify(data.map));
+      var mapLoc = dest + ".map";
+      data.code = util.addSourceMappingUrl(data.code, mapLoc);
+      fs.writeFileSync(mapLoc, JSON.stringify(data.map));
     }
 
     fs.writeFileSync(dest, data.code);

bin/6to5/file.js

@@ -56,7 +56,9 @@ module.exports = function (commander, filenames) {
 
     if (commander.outFile) {
       if (commander.sourceMaps) {
-        fs.writeFileSync(commander.outFile + ".map", JSON.stringify(result.map));
+        var mapLoc = commander.outFile + ".map";
+        result.code = util.addSourceMappingUrl(result.code, mapLoc);
+        fs.writeFileSync(mapLoc, JSON.stringify(result.map));
       }
 
       fs.writeFileSync(commander.outFile, result.code);
@@ -111,16 +113,14 @@ module.exports = function (commander, filenames) {
     walk();
 
     if (commander.watch) {
-      var watcher = chokidar.watch(filenames, {
+      chokidar.watch(filenames, {
         persistent: true,
         ignoreInitial: true
-      });
-
-      _.each(["add", "change", "unlink"], function (type) {
-        watcher.on(type, function (filename) {
+      }).on("all", function (type, filename) {
+        if (type === "add" || type === "change" || type === "unlink" ) {
           console.log(type, filename);
           walk();
-        });
+        }
       });
     }
   };

bin/6to5/index.js

@@ -11,20 +11,35 @@ commander.option("-s, --source-maps", "Save source map alongside the compiled co
 commander.option("-f, --filename [filename]", "Filename to use when reading from stdin - this will be used in source-maps, errors etc [stdin]", "stdin");
 commander.option("-w, --watch", "Recompile files on changes");
 commander.option("-r, --runtime", "Replace 6to5 declarations with references to a runtime");
+commander.option("-e, --experimental", "Enable experimental support for proposed ES7 features");
+commander.option("-p, --playground", "Enable playground support");
 
 commander.option("-m, --modules [modules]", "Module formatter type to use [common]", "common");
 commander.option("-w, --whitelist [whitelist]", "Whitelist of transformers to ONLY use", util.list);
 commander.option("-b, --blacklist [blacklist]", "Blacklist of transformers to NOT use", util.list);
+commander.option("-i, --optional [list]", "List of optional transformers to enable", util.list);
 commander.option("-o, --out-file [out]", "Compile all input files into a single file");
 commander.option("-d, --out-dir [out]", "Compile an input directory of modules into an output directory");
+commander.option("-c, --remove-comments", "Remove comments from the compiled code", false);
+commander.option("-I, --indent [width]", "Indent width [2]", 2);
+commander.option("-a, --amd-module-ids", "Insert module id in AMD modules", false); // todo: remove in 3.0.0
+commander.option("-m, --module-ids", "Insert module id in modules", false);
 
 commander.on("--help", function(){
   var outKeys = function (title, obj) {
     console.log("  " + title + ":");
     console.log();
 
+    var hasOptional = true;
+
     _.each(_.keys(obj).sort(), function (key) {
       if (key[0] === "_") return;
+
+      if (obj[key].optional) {
+        hasOptional = true;
+        key = "[" + key + "]";
+      }
+
       console.log("    - " + key);
     });
 
@@ -85,11 +100,21 @@ if (errors.length) {
 
 exports.opts = {
   sourceMapName: commander.outFile,
+  experimental:  commander.experimental,
+  playground:    commander.playground,
+  moduleIds:     commander.amdModuleIds || commander.moduleIds,
   blacklist:     commander.blacklist,
   whitelist:     commander.whitelist,
   sourceMap:     commander.sourceMaps || commander.sourceMapsInline,
+  optional:      commander.optional,
+  comments:      !commander.removeComments,
   runtime:       commander.runtime,
-  modules:       commander.modules
+  modules:       commander.modules,
+  format: {
+    indent: {
+      style:     util.repeat(parseInt(commander.indent))
+    }
+  }
 };
 
 var fn;

bin/6to5/util.js

@@ -1,6 +1,7 @@
 var readdir = require("fs-readdir-recursive");
 var index   = require("./index");
 var util    = require("../../lib/6to5/util");
+var path    = require("path");
 var to5     = require("../../lib/6to5");
 var fs      = require("fs");
 var _       = require("lodash");
@@ -11,6 +12,10 @@ exports.readdirFilter = function (filename) {
   });
 };
 
+exports.addSourceMappingUrl = function (code, loc) {
+  return code + "\n//# sourceMappingURL=" + path.basename(loc);
+};
+
 exports.transform = function (filename, code, opts) {
   opts = _.extend(opts || {}, index.opts);
   opts.filename = filename;

bin/_6to5-node

@@ -1,41 +1,49 @@
 #!/usr/bin/env node
 
-var commander = require("commander");
-var path      = require("path");
-var repl      = require("repl");
-var to5       = require("../lib/6to5");
-var util      = require("../lib/6to5/util");
-var vm        = require("vm");
-var _         = require("lodash");
+var roadrunner = require("roadrunner");
+var commander  = require("commander");
+var Module     = require("module");
+var path       = require("path");
+var repl       = require("repl");
+var to5        = require("../lib/6to5");
+var util       = require("../lib/6to5/util");
+var vm         = require("vm");
+var _          = require("lodash");
 
-commander.option("-e, --eval [script]", "evaluate script");
-commander.option("-p, --print", "evaluate script and print result");
-commander.option("-i, --ignore [regex]", "ignore all files that match this regex when using the require hook");
-commander.option("-x, --extensions [extensions]", "list of extensions to hook into [.es6,.js]", util.list);
+commander.option("-e, --eval [script]", "Evaluate script");
+commander.option("-p, --print", "Evaluate script and print result");
+commander.option("-i, --ignore [regex]", "Ignore all files that match this regex when using the require hook");
+commander.option("-x, --extensions [extensions]", "List of extensions to hook into [.es6,.js]");
+commander.option("-r, --experimental", "Enable experimental support for proposed ES7 features");
+commander.option("-g, --playground", "Enable playground support");
+commander.option("-c, --cache", "Cache compiled files and require paths");
 
 var pkg = require("../package.json");
 commander.version(pkg.version);
 commander.usage("[options] [ -e script | script.js ] [arguments]");
 commander.parse(process.argv);
 
+if (commander.cache) roadrunner.load();
+
 //
 
-var registerOpts = {};
-
-if (commander.ignore) {
-  registerOpts.ignoreRegex = new RegExp(commander.ignore);
-}
-
-if (commander.extensions && commander.extensions.length) {
-  registerOpts.extensions = commander.extensions;
-}
-
-to5.register(registerOpts);
+to5.register({
+  experimental: commander.experimental,
+  extensions:   commander.extensions,
+  playground:   commander.playground,
+  ignore:       commander.ignore,
+  cache:        commander.cache && roadrunner.get("6to5")
+});
 
 //
 
 var _eval = function (code, filename) {
-  code = to5.transform(code, { filename: filename, blacklist: ["useStrict"] }).code;
+  code = to5.transform(code, {
+    filename: filename,
+    blacklist: ["useStrict"],
+    experimental: commander.experimental,
+    playground: commander.playground
+  }).code;
   return vm.runInThisContext(code, filename);
 };
 
@@ -43,21 +51,34 @@ if (commander.eval) {
   var result = _eval(commander.eval, "eval");
   if (commander.print) console.log(result);
 } else {
-  var filenames = commander.args;
+  if (commander.args.length) {
+    // slice all arguments up to the first filename since they're 6to5 args that we handle
+    var args = process.argv.slice(2);
 
-  if (filenames.length) {
-    _.each(filenames, function (filename) {
-      if (!util.isAbsolute(filename)) {
-        filename = path.join(process.cwd(), filename);
+    var i = 0;
+    _.each(args, function (arg, i2) {
+      if (arg[0] !== "-") {
+        i = i2;
+        return false;
       }
-
-      require(require.resolve(filename));
     });
+    args = args.slice(i);
+
+    // make the filename absolute
+    var filename = args[0]
+    if (!util.isAbsolute(filename)) args[0] = path.join(process.cwd(), filename);
+
+    // add back on node and concat the sliced args
+    process.argv = ["node"].concat(args);
+
+    Module.runMain();
   } else {
     replStart();
   }
 }
 
+if (commander.cache) roadrunner.save();
+
 function replStart() {
   repl.start({
     prompt: "> ",

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

@@ -0,0 +1 @@
+See [6to5.github.io/docs](https://github.com/6to5/6to5.github.io/tree/master/docs).

lib/6to5/browser.js

@@ -1,13 +1,8 @@
 var transform = module.exports = require("./transformation/transform");
 
-transform.transform = transform;
+transform.version = require("../../package").version;
 
-transform.eval = function (code, opts) {
-  opts = opts || {};
-  opts.filename = opts.filename || "eval";
-  opts.sourceMap = "inline";
-  return eval(transform(code, opts).code);
-};
+transform.transform = transform;
 
 transform.run = function (code, opts) {
   opts = opts || {};
@@ -19,7 +14,7 @@ transform.load = function (url, callback, opts, hold) {
   opts = opts || {};
   opts.filename = opts.filename || url;
 
-  var xhr = window.ActiveXObject ? new window.ActiveXObject("Microsoft.XMLHTTP") : new window.XMLHttpRequest();
+  var xhr = global.ActiveXObject ? new global.ActiveXObject("Microsoft.XMLHTTP") : new global.XMLHttpRequest();
   xhr.open("GET", url, true);
   if ("overrideMimeType" in xhr) xhr.overrideMimeType("text/plain");
 
@@ -41,7 +36,7 @@ transform.load = function (url, callback, opts, hold) {
 
 var runScripts = function () {
   var scripts = [];
-  var types   = ["text/ecmascript-6", "text/6to5"];
+  var types   = ["text/ecmascript-6", "text/6to5", "module"];
   var index   = 0;
 
   var exec = function () {
@@ -67,8 +62,9 @@ var runScripts = function () {
     }
   };
 
-  var _scripts = window.document.getElementsByTagName("script");
-  for (var i in _scripts) {
+  var _scripts = global.document .getElementsByTagName("script");
+
+  for (var i = 0; i < _scripts.length; ++i) {
     var _script = _scripts[i];
     if (types.indexOf(_script.type) >= 0) scripts.push(_script);
   }
@@ -80,8 +76,8 @@ var runScripts = function () {
   exec();
 };
 
-if (window.addEventListener) {
-  window.addEventListener("DOMContentLoaded", runScripts, false);
-} else {
-  window.attachEvent("onload", runScripts);
+if (global.addEventListener) {
+  global.addEventListener("DOMContentLoaded", runScripts, false);
+} else if (global.attachEvent) {
+  global.attachEvent("onload", runScripts);
 }

lib/6to5/file.js

@@ -10,50 +10,139 @@ var t         = require("./types");
 var _         = require("lodash");
 
 function File(opts) {
-  this.opts            = File.normaliseOptions(opts);
-  this.moduleFormatter = this.getModuleFormatter(this.opts.modules);
-
-  this.declarations = {};
-  this.uids         = {};
-  this.ast          = {};
+  this.dynamicImports   = [];
+  this.dynamicImportIds = {};
+  this.opts             = File.normaliseOptions(opts);
+  this.transformers     = this.getTransformers();
+  this.uids             = {};
+  this.ast              = {};
 }
 
-File.declarations = ["extends", "class-props", "slice", "apply-constructor"];
+File.helpers = [
+  "inherits",
+  "defaults",
+  "prototype-properties",
+  "apply-constructor",
+  "tagged-template-literal",
+  "interop-require",
+  "to-array",
+  "sliced-to-array",
+  "object-without-properties",
+  "has-own",
+  "slice",
+  "bind",
+  "define-property",
+  "async-to-generator",
+  "interop-require-wildcard",
+  "typeof",
+  "extends",
+  "get"
+];
+
+File.excludeHelpersFromRuntime = [
+  "async-to-generator",
+  "typeof"
+];
 
 File.normaliseOptions = function (opts) {
   opts = _.cloneDeep(opts || {});
 
   _.defaults(opts, {
-    whitespace: true,
-    blacklist:  [],
-    whitelist:  [],
-    sourceMap:  false,
-    filename:   "unknown",
-    modules:    "common",
-    runtime:    false,
-    code:       true
+    experimental: false,
+    reactCompat:  false,
+    playground:   false,
+    whitespace:   true,
+    moduleIds:    opts.amdModuleIds || false,
+    blacklist:    [],
+    whitelist:    [],
+    sourceMap:    false,
+    optional:     [],
+    comments:     true,
+    filename:     "unknown",
+    modules:      "common",
+    runtime:      false,
+    code:         true,
+    ast:          true
   });
 
   // normalise windows path separators to unix
   opts.filename = opts.filename.replace(/\\/g, "/");
 
+  opts.blacklist = util.arrayify(opts.blacklist);
+  opts.whitelist = util.arrayify(opts.whitelist);
+
   _.defaults(opts, {
-    sourceFileName: opts.filename,
-    sourceMapName:  opts.filename
+    moduleRoot: opts.sourceRoot
+  });
+
+  _.defaults(opts, {
+    sourceRoot: opts.moduleRoot
+  });
+
+  _.defaults(opts, {
+    filenameRelative: opts.filename
+  });
+
+  _.defaults(opts, {
+    sourceFileName: opts.filenameRelative,
+    sourceMapName:  opts.filenameRelative
   });
 
   if (opts.runtime === true) {
     opts.runtime = "to5Runtime";
   }
 
+  if (opts.playground) {
+    opts.experimental = true;
+  }
+
   transform._ensureTransformerNames("blacklist", opts.blacklist);
   transform._ensureTransformerNames("whitelist", opts.whitelist);
+  transform._ensureTransformerNames("optional", opts.optional);
 
   return opts;
 };
 
+File.prototype.getTransformers = function () {
+  var file = this;
+  var transformers = [];
+  var secondPassTransformers = [];
+
+  _.each(transform.transformers, function (transformer) {
+    if (transformer.canRun(file)) {
+      transformers.push(transformer);
+
+      if (transformer.secondPass) {
+        secondPassTransformers.push(transformer);
+      }
+
+      if (transformer.manipulateOptions) {
+        transformer.manipulateOptions(file.opts, file);
+      }
+    }
+  });
+
+  return transformers.concat(secondPassTransformers);
+};
+
+File.prototype.toArray = function (node, i) {
+  if (t.isArrayExpression(node)) {
+    return node;
+  } else if (t.isIdentifier(node) && node.name === "arguments") {
+    return t.callExpression(t.memberExpression(this.addHelper("slice"), t.identifier("call")), [node]);
+  } else {
+    var declarationName = "to-array";
+    var args = [node];
+    if (i) {
+      args.push(t.literal(i));
+      declarationName = "sliced-to-array";
+    }
+    return t.callExpression(this.addHelper(declarationName), args);
+  }
+};
+
 File.prototype.getModuleFormatter = function (type) {
-  var ModuleFormatter = transform.moduleFormatters[type];
+  var ModuleFormatter = _.isFunction(type) ? type : transform.moduleFormatters[type];
 
   if (!ModuleFormatter) {
     var loc = util.resolve(type);
@@ -61,7 +150,7 @@ File.prototype.getModuleFormatter = function (type) {
   }
 
   if (!ModuleFormatter) {
-    throw new ReferenceError("unknown module formatter type " + type);
+    throw new ReferenceError("Unknown module formatter type " + JSON.stringify(type));
   }
 
   return new ModuleFormatter(this);
@@ -79,28 +168,47 @@ File.prototype.parseShebang = function (code) {
   return code;
 };
 
-File.prototype.addDeclaration = function (name) {
-  if (!_.contains(File.declarations, name)) {
+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.addHelper = function (name) {
+  if (!_.contains(File.helpers, name)) {
     throw new ReferenceError("unknown declaration " + name);
   }
 
-  var declar = this.declarations[name];
-  if (declar) return declar.uid;
+  var program = this.ast.program;
+
+  var declar = program._declarations && program._declarations[name];
+  if (declar) return declar.id;
 
   var ref;
   var runtimeNamespace = this.opts.runtime;
-  if (runtimeNamespace) {
+  if (runtimeNamespace && !_.contains(File.excludeHelpersFromRuntime, name)) {
     name = t.identifier(t.toIdentifier(name));
     return t.memberExpression(t.identifier(runtimeNamespace), name);
   } else {
     ref = util.template(name);
   }
 
-  var uid = t.identifier(this.generateUid(name));
-  this.declarations[name] = {
-    uid: uid,
-    node: ref
-  };
+  var uid = this.generateUidIdentifier(name);
+  this.scope.push({
+    key: name,
+    id: uid,
+    init: ref
+  });
   return uid;
 };
 
@@ -113,14 +221,16 @@ File.prototype.errorWithNode = function (node, msg, Error) {
   return err;
 };
 
-File.prototype.parse = function (code) {
+File.prototype.addCode = function (code) {
   code = (code || "") + "";
+  this.code = code;
+  return this.parseShebang(code);
+};
 
+File.prototype.parse = function (code) {
   var self = this;
 
-  this.code = code;
-
-  code = this.parseShebang(code);
+  code = this.addCode(code);
 
   return util.parse(this.opts, code, function (tree) {
     self.transform(tree);
@@ -129,29 +239,43 @@ File.prototype.parse = function (code) {
 };
 
 File.prototype.transform = function (ast) {
-  this.ast = ast;
-  this.scope = new Scope(null, ast.program);
-
   var self = this;
 
-  _.each(transform.transformers, function (transformer) {
+  this.ast = ast;
+  this.scope = new Scope(ast.program);
+  this.moduleFormatter = this.getModuleFormatter(this.opts.modules);
+
+  var astRun = function (key) {
+    _.each(self.transformers, function (transformer) {
+      transformer.astRun(self, key);
+    });
+  };
+
+  astRun("enter");
+
+  _.each(this.transformers, function (transformer) {
     transformer.transform(self);
   });
+
+  astRun("exit");
 };
 
 File.prototype.generate = function () {
   var opts = this.opts;
   var ast  = this.ast;
 
-  if (!opts.code) {
-    return {
-      code: "",
-      map:  null,
-      ast:  ast
-    };
-  }
+  var result = {
+    code: "",
+    map: null,
+    ast: null
+  };
 
-  var result = generate(ast, opts, this.code);
+  if (opts.ast) result.ast = ast;
+  if (!opts.code) return result;
+
+  var _result = generate(ast, opts, this.code);
+  result.code = _result.code;
+  result.map  = _result.map;
 
   if (this.shebang) {
     // add back shebang
@@ -162,13 +286,11 @@ File.prototype.generate = function () {
     result.code += "\n" + util.sourceMapToComment(result.map);
   }
 
-  result.ast = result;
-
   return result;
 };
 
 File.prototype.generateUid = function (name, scope) {
-  name = t.toIdentifier(name);
+  name = t.toIdentifier(name).replace(/^_+/, "");
 
   scope = scope || this.scope;
 
@@ -179,6 +301,10 @@ File.prototype.generateUid = function (name, scope) {
   return uid;
 };
 
+File.prototype.generateUidIdentifier = function (name, scope) {
+  return t.identifier(this.generateUid(name, scope));
+};
+
 File.prototype._generateUid = function (name) {
   var uids = this.uids;
   var i = uids[name] || 1;

lib/6to5/generation/buffer.js

@@ -35,7 +35,7 @@ Buffer.prototype.dedent = function () {
 };
 
 Buffer.prototype.semicolon = function () {
-  if (this.format.semicolons) this.push(";");
+  this.push(";");
 };
 
 Buffer.prototype.ensureSemicolon = function () {
@@ -66,9 +66,7 @@ Buffer.prototype.removeLast = function (cha) {
 };
 
 Buffer.prototype.newline = function (i, removeLast) {
-  if (!this.buf) return;
   if (this.format.compact) return;
-  if (this.endsWith("{\n")) return;
 
   if (_.isBoolean(i)) {
     removeLast = i;
@@ -76,6 +74,9 @@ Buffer.prototype.newline = function (i, removeLast) {
   }
 
   if (_.isNumber(i)) {
+    if (this.endsWith("{\n")) i--;
+    if (this.endsWith(util.repeat(i, "\n"))) return;
+
     var self = this;
     _.times(i, function () {
       self.newline(null, removeLast);
@@ -86,7 +87,10 @@ Buffer.prototype.newline = function (i, removeLast) {
   if (removeLast && this.isLast("\n")) this.removeLast("\n");
 
   this.removeLast(" ");
-  this.buf = this.buf.replace(/\n(\s+)$/, "\n");
+
+  // remove whitespace if last character was a newline
+  this.buf = this.buf.replace(/\n +$/, "\n");
+
   this._push("\n");
 };
 

lib/6to5/generation/generator.js

@@ -35,21 +35,16 @@ _.each(Buffer.prototype, function (fn, key) {
 });
 
 CodeGenerator.normaliseOptions = function (opts) {
-  opts = opts.format || {};
-
-  opts = _.merge({
+  return _.merge({
     parentheses: true,
-    semicolons: true,
-    comments: true,
+    comments: opts.comments == null || opts.comments,
     compact: false,
     indent: {
       adjustMultilineComment: true,
       style: "  ",
       base: 0
     }
-  }, opts);
-
-  return opts;
+  }, opts.format || {});
 };
 
 CodeGenerator.generators = {
@@ -57,10 +52,12 @@ CodeGenerator.generators = {
   comprehensions:   require("./generators/comprehensions"),
   expressions:      require("./generators/expressions"),
   statements:       require("./generators/statements"),
+  playground:       require("./generators/playground"),
   classes:          require("./generators/classes"),
   methods:          require("./generators/methods"),
   modules:          require("./generators/modules"),
   types:            require("./generators/types"),
+  flow:             require("./generators/flow"),
   base:             require("./generators/base"),
   jsx:              require("./generators/jsx")
 };
@@ -74,6 +71,12 @@ CodeGenerator.prototype.generate = function () {
 
   this.print(ast);
 
+  var comments = [];
+  _.each(ast.comments, function (comment) {
+    if (!comment._displayed) comments.push(comment);
+  });
+  this._printComments(comments);
+
   return {
     map:  this.map.get(),
     code: this.buffer.get()
@@ -112,11 +115,10 @@ CodeGenerator.prototype.print = function (node, parent, opts) {
   if (!node) return "";
 
   var self = this;
+
   opts = opts || {};
 
   var newline = function (leading) {
-    var ignoreDuplicates = false;
-
     if (!opts.statement && !n.isUserWhitespacable(node, parent)) {
       return;
     }
@@ -137,12 +139,21 @@ CodeGenerator.prototype.print = function (node, parent, opts) {
       var needs = n.needsWhitespaceAfter;
       if (leading) needs = n.needsWhitespaceBefore;
       lines += needs(node, parent);
+
+      // generated nodes can't add starting file whitespace
+      if (!self.buffer.get()) lines = 0;
     }
 
-    self.newline(lines, ignoreDuplicates);
+    self.newline(lines);
   };
 
   if (this[node.type]) {
+    var needsNoLineTermParens = n.needsParensNoLineTerminator(node, parent);
+    var needsParens           = needsNoLineTermParens || n.needsParens(node, parent);
+
+    if (needsParens) this.push("(");
+    if (needsNoLineTermParens) this.indent();
+
     this.printLeadingComments(node, parent);
 
     newline(true);
@@ -150,13 +161,12 @@ CodeGenerator.prototype.print = function (node, parent, opts) {
     if (opts.before) opts.before();
     this.map.mark(node, "start");
 
-    // only compute if this node needs parens if our parent has been changed
-    // since acorn would've wrapped us in a ParanthesizedExpression
-    var needsParens = parent !== node._parent && n.needsParens(node, parent);
-    if (needsParens) this.push("(");
-
     this[node.type](node, this.buildPrint(node), parent);
 
+    if (needsNoLineTermParens) {
+      this.newline();
+      this.dedent();
+    }
     if (needsParens) this.push(")");
 
     this.map.mark(node, "end");
@@ -166,11 +176,13 @@ CodeGenerator.prototype.print = function (node, parent, opts) {
 
     this.printTrailingComments(node, parent);
   } else {
-    throw new ReferenceError("unknown node " + node.type + " " + JSON.stringify(node));
+    throw new ReferenceError("unknown node of type " + JSON.stringify(node.type) + " with constructor " + JSON.stringify(node && node.constructor.name));
   }
 };
 
 CodeGenerator.prototype.printJoin = function (print, nodes, opts) {
+  if (!nodes || !nodes.length) return;
+
   opts = opts || {};
 
   var self = this;
@@ -262,6 +274,21 @@ CodeGenerator.prototype._printComments = function (comments) {
   var self = this;
 
   _.each(comments, function (comment) {
+    var skip = false;
+
+    // find the original comment in the ast and set it as displayed
+    _.each(self.ast.comments, function (origComment) {
+      if (origComment.start === comment.start) {
+        // comment has already been output
+        if (origComment._displayed) skip = true;
+
+        origComment._displayed = true;
+        return false;
+      }
+    });
+
+    if (skip) return;
+
     // whitespace before
     self.newline(self.whitespace.getNewlinesBefore(comment));
 

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

@@ -30,3 +30,11 @@ exports.ClassBody = function (node, print) {
     this.rightBrace();
   }
 };
+
+exports.MethodDefinition = function (node, print) {
+  if (node.static) {
+    this.push("static ");
+  }
+
+  this._method(node, print);
+};

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

@@ -1,4 +1,6 @@
-var t = require("../../types");
+var util = require("../../util");
+var t    = require("../../types");
+var _    = require("lodash");
 
 exports.UnaryExpression = function (node, print) {
   var hasSpace = /[a-z]$/.test(node.operator);
@@ -17,12 +19,6 @@ exports.UnaryExpression = function (node, print) {
   print(node.argument);
 };
 
-exports.ParenthesizedExpression = function (node, print) {
-  this.push("(");
-  print(node.expression);
-  this.push(")");
-};
-
 exports.UpdateExpression = function (node, print) {
   if (node.prefix) {
     this.push(node.operator);
@@ -61,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(")");
 };
 
@@ -91,20 +107,38 @@ exports.ExpressionStatement = function (node, print) {
 
 exports.BinaryExpression =
 exports.LogicalExpression =
+exports.AssignmentPattern =
 exports.AssignmentExpression = function (node, print) {
   print(node.left);
   this.push(" " + node.operator + " ");
   print(node.right);
 };
 
-exports.MemberExpression = function (node, print) {
-  print(node.object);
+var SCIENTIFIC_NOTATION = /e/i;
 
-  if (node.computed) {
+exports.MemberExpression = function (node, print) {
+  var obj = node.object;
+  print(obj);
+
+  if (!node.computed && t.isMemberExpression(node.property)) {
+    throw new TypeError("Got a MemberExpression for MemberExpression property");
+  }
+
+  var computed = node.computed;
+  if (t.isLiteral(node.property) && _.isNumber(node.property.value)) {
+    computed = true;
+  }
+
+  if (computed) {
     this.push("[");
     print(node.property);
     this.push("]");
   } else {
+    // 5..toFixed(2);
+    if (t.isLiteral(obj) && util.isInteger(obj.value) && !SCIENTIFIC_NOTATION.test(obj.value.toString())) {
+      this.push(".");
+    }
+
     this.push(".");
     print(node.property);
   }

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

@@ -0,0 +1,3 @@
+exports.ClassProperty = function () {
+  throw new Error("not implemented");
+};

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

@@ -74,5 +74,5 @@ exports.XJSClosingElement = function (node, print) {
 };
 
 exports.XJSEmptyExpression = function () {
-  this.push("null");
+
 };

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

@@ -41,6 +41,8 @@ exports._method = function (node, print) {
     this.push(kind + " ");
   }
 
+  if (value.async) this.push("async ");
+
   if (node.computed) {
     this.push("[");
     print(key);
@@ -54,16 +56,9 @@ exports._method = function (node, print) {
   print(value.body);
 };
 
-exports.MethodDefinition = function (node, print) {
-  if (node.static) {
-    this.push("static ");
-  }
-
-  this._method(node, print);
-};
-
 exports.FunctionDeclaration =
 exports.FunctionExpression = function (node, print) {
+  if (node.async) this.push("async ");
   this.push("function");
   if (node.generator) this.push("*");
   this.space();
@@ -74,6 +69,8 @@ exports.FunctionExpression = function (node, print) {
 };
 
 exports.ArrowFunctionExpression = function (node, print) {
+  if (node.async) this.push("async ");
+
   if (node.params.length === 1 && !node.defaults.length && !node.rest && t.isIdentifier(node.params[0])) {
     print(node.params[0]);
   } else {

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

@@ -1,7 +1,14 @@
 var t = require("../../types");
 var _ = require("lodash");
 
-exports.ImportSpecifier =
+exports.ImportSpecifier = function (node, print) {
+  if (node.id && node.id.name === "default") {
+    print(node.name);
+  } else {
+    return exports.ExportSpecifier.apply(this, arguments);
+  }
+};
+
 exports.ExportSpecifier = function (node, print) {
   print(node.id);
   if (node.name) {
@@ -25,9 +32,10 @@ exports.ExportDeclaration = function (node, print) {
 
   if (node.declaration) {
     print(node.declaration);
+    if (t.isStatement(node.declaration)) return;
   } else {
     if (specifiers.length === 1 && t.isExportBatchSpecifier(specifiers[0])) {
-      this.push("*");
+      print(specifiers[0]);
     } else {
       this.push("{");
       if (specifiers.length) {
@@ -61,7 +69,9 @@ exports.ImportDeclaration = function (node, print) {
         self.push(", ");
       }
 
-      if (!spec.default && spec.type !== "ImportBatchSpecifier" && !foundImportSpecifier) {
+      var isDefault = spec.id && spec.id.name === "default";
+
+      if (!isDefault && spec.type !== "ImportBatchSpecifier" && !foundImportSpecifier) {
         foundImportSpecifier = true;
         self.push("{ ");
       }

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

@@ -0,0 +1,7 @@
+var _ = require("lodash");
+
+_.each(["BindMemberExpression", "BindFunctionExpression"], function (type) {
+  exports[type] = function () {
+    throw new ReferenceError("Trying to render non-standard playground node " + JSON.stringify(type));
+  };
+});

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

@@ -1,9 +1,11 @@
-var t = require("../../types");
+var util = require("../../util");
+var t    = require("../../types");
 
 exports.WithStatement = function (node, print) {
   this.keyword("with");
   this.push("(");
   print(node.object);
+  this.push(")");
   print.block(node.body);
 };
 
@@ -134,15 +136,6 @@ exports.SwitchStatement = function (node, print) {
   this.push(") {");
   print.sequence(node.cases, { indent: true });
   this.push("}");
-
-  //if (node.cases.length) {
-  //  this.newline();
-  //  print.sequence(node.cases, { indent: true });
-  //  this.newline();
-  //  this.rightBrace();
-  //} else {
-  //  this.push("}");
-  //}
 };
 
 exports.SwitchCase = function (node, print) {
@@ -154,13 +147,8 @@ exports.SwitchCase = function (node, print) {
     this.push("default:");
   }
 
-  if (node.consequent.length === 1) {
-    this.space();
-    print(node.consequent[0]);
-  } else if (node.consequent.length > 1) {
-    this.newline();
-    print.sequence(node.consequent, { indent: true });
-  }
+  this.newline();
+  print.sequence(node.consequent, { indent: true });
 };
 
 exports.DebuggerStatement = function () {
@@ -170,13 +158,36 @@ 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();
   }
 };
 
+exports.PrivateDeclaration = function (node, print) {
+  this.push("private ");
+  print.join(node.declarations, { separator: ", " });
+  this.semicolon();
+};
+
 exports.VariableDeclarator = function (node, print) {
   if (node.init) {
     print(node.id);

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

@@ -4,11 +4,18 @@ exports.Identifier = function (node) {
   this.push(node.name);
 };
 
-exports.SpreadElement = function (node, print) {
+exports.SpreadElement =
+exports.SpreadProperty = function (node, print) {
   this.push("...");
   print(node.argument);
 };
 
+exports.VirtualPropertyExpression = function (node, print) {
+  print(node.object);
+  this.push("::");
+  print(node.property);
+};
+
 exports.ObjectExpression =
 exports.ObjectPattern = function (node, print) {
   var props = node.properties;
@@ -74,13 +81,20 @@ exports.Literal = function (node) {
   var val  = node.value;
   var type = typeof val;
 
-  if (type === "boolean" || type === "number" || type === "string") {
+  if (type === "string") {
+    val = JSON.stringify(val);
+
+    // escape illegal js but valid json unicode characters
+    val = val.replace(/[\u000A\u000D\u2028\u2029]/g, function (c) {
+      return "\\u" + ("0000" + c.charCodeAt(0).toString(16)).slice(-4);
+    });
+
+    this.push(val);
+  } else if (type === "boolean" || type === "number") {
     this.push(JSON.stringify(val));
   } else if (node.regex) {
     this.push("/" + node.regex.pattern + "/" + node.regex.flags);
   } else if (val === null) {
     this.push("null");
-  } else if (node.raw) {
-    this.push(node.raw);
   }
 };

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

@@ -2,8 +2,8 @@ module.exports = Node;
 
 var whitespace = require("./whitespace");
 var parens     = require("./parentheses");
-var t           = require("../../types");
-var _           = require("lodash");
+var t          = require("../../types");
+var _          = require("lodash");
 
 var find = function (obj, node, parent) {
   var result;
@@ -24,18 +24,7 @@ function Node(node, parent) {
 }
 
 Node.prototype.isUserWhitespacable = function () {
-  //var parent = this.parent;
-  var node = this.node;
-
-  if (t.isUserWhitespacable(node)) {
-    return true;
-  }
-
-  //if (t.isArrayExpression(parent)) {
-  //  return true;
-  //}
-
-  return false;
+  return t.isUserWhitespacable(this.node);
 };
 
 Node.prototype.needsWhitespace = function (type) {
@@ -72,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,37 @@ _.each([
   ["<", ">", "<=", ">=", "in", "instanceof"],
   [">>", "<<", ">>>"],
   ["+", "-"],
-  ["*", "/", "%"]
+  ["*", "/", "%"],
+  ["**"]
 ], function (tier, i) {
   _.each(tier, function (op) {
     PRECEDENCE[op] = i;
   });
 });
 
+exports.UpdateExpression = function (node, parent) {
+  if (t.isMemberExpression(parent) && parent.object === node) {
+    // (foo++).test()
+    return true;
+  }
+};
+
+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;
   }
 
@@ -92,13 +114,6 @@ exports.YieldExpression = function (node, parent) {
          t.isYieldExpression(parent);
 };
 
-exports.Literal = function (node, parent) {
-  // (1).valueOf()
-  if (_.isNumber(node.value) && t.isMemberExpression(parent) && parent.object === node) {
-    return true;
-  }
-};
-
 exports.ClassExpression = function (node, parent) {
   return t.isExpressionStatement(parent);
 };

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

@@ -9,6 +9,10 @@ exports.before = {
       }
     },
 
+    SpreadProperty: function (node, parent) {
+      return exports.before.nodes.Property(node, parent);
+    },
+
     SwitchCase: function (node, parent) {
       if (parent.cases[0] === node) {
         return 1;
@@ -24,7 +28,13 @@ exports.before = {
 };
 
 exports.after = {
-  nodes: {},
+  nodes: {
+    AssignmentExpression: function (node) {
+      if (t.isFunction(node.right)) {
+        return 1;
+      }
+    }
+  },
 
   list: {
     VariableDeclaration: function (node) {
@@ -45,6 +55,8 @@ _.each({
   Function: 1,
   Class: 1,
   For: 1,
+  ArrayExpression: { after: 1 },
+  ObjectExpression: { after: 1 },
   SwitchStatement: 1,
   IfStatement: { before: 1 },
   CallExpression: { after: 1 },

lib/6to5/generation/source-map.js

@@ -9,7 +9,8 @@ function SourceMap(position, opts, code) {
 
   if (opts.sourceMap) {
     this.map = new sourceMap.SourceMapGenerator({
-      file: opts.sourceMapName
+      file: opts.sourceMapName,
+      sourceRoot: opts.sourceRoot
     });
 
     this.map.setSourceContent(opts.sourceFileName, code);

lib/6to5/generation/whitespace.js

@@ -38,7 +38,11 @@ Whitespace.prototype.getNewlinesAfter = function (node) {
     }
   });
 
-  return this.getNewlinesBetween(startToken, endToken);
+  if (endToken.type.type === "eof") {
+    return 1;
+  } else {
+    return this.getNewlinesBetween(startToken, endToken);
+  }
 };
 
 Whitespace.prototype.getNewlinesBetween = function (startToken, endToken) {

lib/6to5/index.js

@@ -3,7 +3,11 @@ var util      = require("./util");
 var fs        = require("fs");
 var _         = require("lodash");
 
-exports.runtime = require("./runtime");
+exports.version = require("../../package").version;
+
+exports.types = require("./types");
+
+exports.runtime = require("./runtime-generator");
 
 exports.register = function (opts) {
   var register = require("./register");
@@ -17,6 +21,9 @@ exports.polyfill = function () {
 
 exports.canCompile = util.canCompile;
 
+// do not use this - this is for use by official maintained 6to5 plugins
+exports._util = util;
+
 exports.transform = transform;
 
 exports.transformFile = function (filename, opts, callback) {

lib/6to5/patch.js

@@ -1,28 +1,53 @@
 var t = require("./types");
 var _ = require("lodash");
 
+// estraverse
+
+var estraverse = require("estraverse");
+_.extend(estraverse.VisitorKeys, t.VISITOR_KEYS);
+
+// regenerator/recast/ast-types
+
 var types = require("ast-types");
 var def   = types.Type.def;
+var or    = types.Type.or;
 
-// Program wrapper
-def("File")
-  .bases("Node")
-  .build("program")
-  .field("program", def("Program"));
+def("AssignmentPattern")
+    .bases("Pattern")
+    .build("left", "right")
+    .field("left", def("Pattern"))
+    .field("right", def("Expression"));
 
-// Non-standard Acorn type
-def("ParenthesizedExpression")
-  .bases("Expression")
-  .build("expression")
-  .field("expression", def("Expression"));
-
-// Same as ImportNamespaceSpecifier but `id` is `name`
+// Acorn - Same as ImportNamespaceSpecifier but `id` is `name`
 def("ImportBatchSpecifier")
   .bases("Specifier")
   .build("name")
   .field("name", def("Identifier"));
 
-types.finalize();
+// Abstract references
+def("VirtualPropertyExpression")
+  .bases("Expression")
+  .build("object", "property")
+  .field("object", def("Expression"))
+  .field("property", or(def("Identifier"), def("Expression")));
 
-var estraverse = require("estraverse");
-_.extend(estraverse.VisitorKeys, t.VISITOR_KEYS);
+def("PrivateDeclaration")
+  .bases("Declaration")
+  .build("declarations")
+  .field("declarations", [def("Identifier")]);
+
+// Playground
+def("BindMemberExpression")
+  .bases("Expression")
+  .build("object", "property", "arguments")
+  .field("object", def("Expression"))
+  .field("property", or(def("Identifier"), def("Expression")))
+  .field("arguments", [def("Expression")]);
+
+def("BindFunctionExpression")
+  .bases("Expression")
+  .build("callee", "arguments")
+  .field("callee", def("Expression"))
+  .field("arguments", [def("Expression")]);
+
+types.finalize();

lib/6to5/polyfill.js

@@ -1,6 +1,2 @@
-if (typeof Symbol === "undefined") {
-  require("es6-symbol/implement");
-}
-
-require("es6-shim");
-require("regenerator-6to5/runtime");
+require("core-js/shim");
+require("regenerator/runtime");

lib/6to5/register-browser.js

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

lib/6to5/register.js

@@ -1,7 +1,10 @@
 require("./polyfill");
 
 var sourceMapSupport = require("source-map-support");
+var roadrunner       = require("roadrunner");
+var util             = require("./util");
 var to5              = require("./index");
+var fs               = require("fs");
 var _                = require("lodash");
 
 sourceMapSupport.install({
@@ -36,15 +39,22 @@ var blacklistTest = function (transformer, code) {
 };
 
 blacklistTest("arrayComprehension", "var foo = [for (foo of bar) foo * foo];");
-//blacklistTest("generatorComprehension", "");
+blacklistTest("generatorComprehension", "var foo = (for (foo of bar) foo * foo)");
 blacklistTest("arrowFunctions", "var foo = x => x * x;");
 blacklistTest("classes", "class Foo {}");
 blacklistTest("computedPropertyNames", "var foo = { [foo]: bar };");
-//blacklistTest("constants", "const foo = 0;");
+blacklistTest("constants", function () {
+  try {
+    new Function("const foo = 'foo';\nfoo = 'wow';");
+  } catch (err) {
+    return; // constants are supported
+  }
+  throw new SyntaxError;
+});
 blacklistTest("defaultParamaters", "var foo = function (bar = 0) {};");
 blacklistTest("destructuring", "var { x, y } = { x: 0, y: 0 };");
 blacklistTest("forOf", "for (var foo of bar) {}");
-blacklistTest("generators", "function* foo() {}");
+blacklistTest("generators", "function* foo() {}\nasync function bar() {}"); // generators/async functions delegated to same transformer
 blacklistTest("letScoping", "let foo = 0;");
 blacklistTest("modules", 'import foo from "from";');
 blacklistTest("propertyMethodAssignment", "{ get foo() {} }");
@@ -56,23 +66,44 @@ blacklistTest("unicodeRegex", function () { new RegExp("foo", "u"); });
 
 //
 
-var ignoreRegex = /node_modules/;
+var transformOpts = {};
+var ignoreRegex   = /node_modules/;
 var onlyRegex;
-var whitelist   = [];
-var exts        = {};
-var maps        = {};
-var old         = require.extensions[".js"];
+var whitelist     = [];
+var cache;
+var exts          = {};
+var maps          = {};
+var old           = require.extensions[".js"];
+
+var mtime = function (filename) {
+  return +fs.statSync(filename).mtime;
+};
 
 var loader = function (m, filename) {
   if ((ignoreRegex && ignoreRegex.test(filename)) || (onlyRegex && !onlyRegex.test(filename))) {
     return old.apply(this, arguments);
   }
 
-  var result = to5.transformFileSync(filename, {
+  var result;
+
+  if (cache) {
+    var cached = cache[filename];
+    if (cached && cached.mtime === mtime(filename)) {
+      result = cached;
+    }
+  }
+
+  result = result || to5.transformFileSync(filename, _.extend({
     whitelist: whitelist,
     blacklist: blacklist,
-    sourceMap: true
-  });
+    sourceMap: true,
+    ast:       false
+  }, transformOpts));
+
+  if (cache) {
+    result.mtime = mtime(filename);
+    cache[filename] = result;
+  }
 
   maps[filename] = result.map;
 
@@ -92,7 +123,7 @@ var hookExtensions = function (_exts) {
   });
 };
 
-hookExtensions([".es6", ".js"]);
+hookExtensions([".es6", ".es", ".js"]);
 
 module.exports = function (opts) {
   // normalise options
@@ -100,11 +131,18 @@ module.exports = function (opts) {
   if (_.isRegExp(opts)) opts = { ignore: opts };
   if (opts.ignoreRegex != null) opts.ignore = opts.ignoreRegex;
 
-  if (opts.only != null) onlyRegex = opts.only;
-  if (opts.ignore != null) ignoreRegex = opts.ignore;
+  if (opts.only != null) onlyRegex = util.regexify(opts.only);
+  if (opts.ignore != null) ignoreRegex = util.regexify(opts.ignore);
 
-  if (opts.extensions) hookExtensions(opts.extensions);
+  if (opts.extensions) hookExtensions(util.arrayify(opts.extensions));
 
-  if (opts.blacklist) blacklist = opts.blacklist;
-  if (opts.whitelist) whitelist = opts.whitelist;
+  if (opts.cache) cache = opts.cache;
+  if (opts.cache === false) cache = null;
+  if (opts.cache === true) {
+    roadrunner.load();
+    roadrunner.setup();
+    cache = roadrunner.get("6to5");
+  }
+
+  _.extend(transformOpts, opts);
 };

lib/6to5/runtime-generator.js

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

lib/6to5/templates/apply-constructor.js

@@ -1,5 +0,0 @@
-(function (Constructor, args) {
-  var bindArgs = [null].concat(args);
-  var Factory = Constructor.bind.apply(Constructor, bindArgs);
-  return new Factory;
-});

lib/6to5/templates/arguments-slice-assign-arg.js

@@ -1 +0,0 @@
-var VARIABLE_NAME = SLICE_KEY.call(arguments, SLICE_ARG);

lib/6to5/templates/arguments-slice-assign.js

@@ -1 +0,0 @@
-var VARIABLE_NAME = SLICE_KEY.call(arguments);

lib/6to5/templates/arguments-slice.js

@@ -1 +0,0 @@
-SLICE_KEY.call(arguments);

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

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

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

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

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

@@ -1,2 +0,0 @@
-SUPER_NAME.apply(this, arguments);
-

lib/6to5/templates/class.js

@@ -1,7 +0,0 @@
-(function () {
-  var CLASS_NAME = function () {
-
-  };
-
-  return CLASS_NAME;
-})()

lib/6to5/templates/exports-assign-key.js

@@ -1 +0,0 @@
-exports.VARIABLE_NAME = OBJECT.KEY;

lib/6to5/templates/exports-default.js

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

lib/6to5/templates/exports-wildcard.js

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

lib/6to5/templates/extends.js

@@ -1,11 +0,0 @@
-(function (child, parent) {
-  child.prototype = Object.create(parent.prototype, {
-    constructor: {
-      value: child,
-      enumerable: false,
-      writable: true,
-      configurable: true
-    }
-  });
-  child.__proto__ = parent;
-})

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

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

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

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

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

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

lib/6to5/templates/self-global.js

@@ -1 +0,0 @@
-var self = typeof global === "undefined" ? window : global;

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

@@ -0,0 +1,268 @@
+module.exports = DefaultFormatter;
+
+var traverse = require("../../traverse");
+var util     = require("../../util");
+var t        = require("../../types");
+var _        = require("lodash");
+
+function DefaultFormatter(file) {
+  this.file = file;
+
+  this.localExports = this.getLocalExports();
+  this.localImports = this.getLocalImports();
+
+  this.remapAssignments();
+
+  //this.checkCollisions();
+}
+
+DefaultFormatter.prototype.getLocalExports = function () {
+  var localExports = {};
+
+  traverse(this.file.ast, {
+    enter: function (node) {
+      var declar = node && node.declaration;
+      if (t.isExportDeclaration(node) && declar && t.isStatement(declar)) {
+        _.extend(localExports, t.getIds(declar, true));
+      }
+    }
+  });
+
+  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(
+    "=",
+    node.left,
+    t.assignmentExpression(
+      node.operator,
+      t.memberExpression(t.identifier("exports"), node.left),
+      node.right
+    )
+  );
+};
+
+DefaultFormatter.prototype.remapAssignments = function () {
+  var localExports = this.localExports;
+  var self = this;
+
+  var isLocalReference = function (node, scope) {
+    var name = node.name;
+    return t.isIdentifier(node) && localExports[name] && localExports[name] === scope.get(name, true);
+  };
+
+  traverse(this.file.ast, {
+    enter: function (node, parent, scope) {
+      if (t.isUpdateExpression(node) && isLocalReference(node.argument, scope)) {
+        this.skip();
+
+        // expand to long file assignment expression
+        var assign = t.assignmentExpression(node.operator[0] + "=", node.argument, t.literal(1));
+
+        // remap this assignment expression
+        var remapped = self.remapExportAssignment(assign);
+
+        // we don't need to change the result
+        if (t.isExpressionStatement(parent) || node.prefix) {
+          return remapped;
+        }
+
+        var nodes = [];
+        nodes.push(remapped);
+
+        var operator;
+        if (node.operator === "--") {
+          operator = "+";
+        } else { // "++"
+          operator = "-";
+        }
+        nodes.push(t.binaryExpression(operator, node.argument, t.literal(1)));
+
+        return t.sequenceExpression(nodes);
+      }
+
+      if (t.isAssignmentExpression(node) && isLocalReference(node.left, scope)) {
+        this.skip();
+        return self.remapExportAssignment(node);
+      }
+    }
+  });
+};
+
+DefaultFormatter.prototype.getModuleName = function () {
+  var opts = this.file.opts;
+  var filenameRelative = opts.filenameRelative;
+  var moduleName = "";
+
+  if (opts.moduleRoot) {
+    moduleName = opts.moduleRoot + "/";
+  }
+
+  if (!opts.filenameRelative) {
+    return moduleName + opts.filename.replace(/^\//, "");
+  }
+
+  if (opts.sourceRoot) {
+    // remove sourceRoot from filename
+    var sourceRootRegEx = new RegExp("^" + opts.sourceRoot + "\/?");
+    filenameRelative = filenameRelative.replace(sourceRootRegEx, "");
+  }
+
+  // remove extension
+  filenameRelative = filenameRelative.replace(/\.(.*?)$/, "");
+
+  moduleName += filenameRelative;
+
+  // normalise path separators
+  moduleName = moduleName.replace(/\\/g, "/");
+
+  return moduleName;
+};
+
+DefaultFormatter.prototype._pushStatement = function (ref, nodes) {
+  if (t.isClass(ref) || t.isFunction(ref)) {
+    if (ref.id) {
+      nodes.push(t.toStatement(ref));
+      ref = ref.id;
+    }
+  }
+
+  return ref;
+};
+
+DefaultFormatter.prototype._hoistExport = function (declar, assign, priority) {
+  if (t.isFunctionDeclaration(declar)) {
+    assign._blockHoist = priority || 2;
+  }
+
+  return assign;
+};
+
+DefaultFormatter.prototype._exportSpecifier = function (getRef, specifier, node, nodes) {
+  var inherits = false;
+  if (node.specifiers.length === 1) inherits = node;
+
+  if (node.source) {
+    if (t.isExportBatchSpecifier(specifier)) {
+      // 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),
+        ref,
+        node
+      ));
+    }
+  } else {
+    // export { foo };
+    nodes.push(this._exportsAssign(t.getSpecifierName(specifier), specifier.id, node));
+  }
+};
+
+DefaultFormatter.prototype._exportsWildcard = function (objectIdentifier) {
+  return t.expressionStatement(t.callExpression(this.file.addHelper("defaults"), [
+    t.identifier("exports"),
+    t.callExpression(this.file.addHelper("interop-require-wildcard"), [objectIdentifier])
+  ]));
+};
+
+DefaultFormatter.prototype._exportsAssign = function (id, init) {
+  return util.template("exports-assign", {
+    VALUE: init,
+    KEY:   id
+  }, true);
+};
+
+DefaultFormatter.prototype.exportDeclaration = function (node, nodes) {
+  var declar = node.declaration;
+
+  var id = declar.id;
+
+  if (node.default) {
+    id = t.identifier("default");
+  }
+
+  var assign;
+
+  if (t.isVariableDeclaration(declar)) {
+    for (var i in declar.declarations) {
+      var decl = declar.declarations[i];
+
+      decl.init = this._exportsAssign(decl.id, decl.init, node).expression;
+
+      var newDeclar = t.variableDeclaration(declar.kind, [decl]);
+      if (i === "0") t.inherits(newDeclar, declar);
+      nodes.push(newDeclar);
+    }
+  } else {
+    var ref = declar;
+
+    if (t.isFunctionDeclaration(declar) || t.isClassDeclaration(declar)) {
+      ref = declar.id;
+      nodes.push(declar);
+    }
+
+    assign = this._exportsAssign(id, ref, node);
+
+    nodes.push(assign);
+
+    this._hoistExport(declar, assign);
+  }
+};

lib/6to5/transformation/modules/_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,16 +1,29 @@
 module.exports = AMDFormatter;
 
-var CommonJSFormatter = require("./common");
-var util              = require("../../util");
-var t                 = require("../../types");
-var _                 = require("lodash");
+var DefaultFormatter = require("./_default");
+var CommonFormatter  = require("./common");
+var util             = require("../../util");
+var t                = require("../../types");
+var _                = require("lodash");
 
-function AMDFormatter(file) {
-  this.file = file;
-  this.ids  = {};
+function AMDFormatter() {
+  CommonFormatter.apply(this, arguments);
+  this.ids = {};
 }
 
-util.inherits(AMDFormatter, CommonJSFormatter);
+util.inherits(AMDFormatter, DefaultFormatter);
+
+AMDFormatter.prototype.buildDependencyLiterals = function () {
+  var names = [];
+  for (var name in this.ids) {
+    names.push(t.literal(name));
+  }
+  return names;
+};
+
+/**
+ * Wrap the entire body in a `define` wrapper.
+ */
 
 AMDFormatter.prototype.transform = function (ast) {
   var program = ast.program;
@@ -19,22 +32,40 @@ AMDFormatter.prototype.transform = function (ast) {
   // build an array of module names
 
   var names = [t.literal("exports")];
-  _.each(this.ids, function (id, name) {
-    names.push(t.literal(name));
-  });
+  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));
-  var call = t.callExpression(t.identifier("define"), [names, container]);
+
+  var defineArgs = [names, container];
+  var moduleName = this.getModuleName();
+  if (moduleName) defineArgs.unshift(t.literal(moduleName));
+
+  var call = t.callExpression(t.identifier("define"), defineArgs);
 
   program.body = [t.expressionStatement(call)];
 };
 
+/**
+ * Get the AMD module name that we'll prepend to the wrapper
+ * to define this module
+ */
+
+AMDFormatter.prototype.getModuleName = function () {
+  if (this.file.opts.moduleIds) {
+    return DefaultFormatter.prototype.getModuleName.apply(this, arguments);
+  } else {
+    return null;
+  }
+};
+
 AMDFormatter.prototype._push = function (node) {
   var id  = node.source.value;
   var ids = this.ids;
@@ -42,31 +73,26 @@ AMDFormatter.prototype._push = function (node) {
   if (ids[id]) {
     return ids[id];
   } else {
-    return this.ids[id] = t.identifier(this.file.generateUid(id));
+    return this.ids[id] = this.file.generateUidIdentifier(id);
   }
 };
 
-AMDFormatter.prototype.import = function (node) {
+AMDFormatter.prototype.importDeclaration = function (node) {
   this._push(node);
 };
 
 AMDFormatter.prototype.importSpecifier = function (specifier, node, nodes) {
   var key = t.getSpecifierName(specifier);
-  var id  = specifier.id;
-
-  // import foo from "foo";
-  if (specifier.default) {
-    id = t.identifier("default");
-  }
-
-  var ref;
+  var ref = this._push(node);
 
   if (t.isImportBatchSpecifier(specifier)) {
     // import * as bar from "foo";
-    ref = this._push(node);
-  } else {
+  } else if (t.isSpecifierDefault(specifier) && !this.noInteropRequire) {
     // import foo from "foo";
-    ref = t.memberExpression(this._push(node), id, false);
+    ref = t.callExpression(this.file.addHelper("interop-require"), [ref]);
+  } else {
+    // import {foo} from "foo";
+    ref = t.memberExpression(ref, specifier.id, false);
   }
 
   nodes.push(t.variableDeclaration("var", [
@@ -74,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

@@ -1,132 +1,105 @@
 module.exports = CommonJSFormatter;
 
-var util = require("../../util");
-var t    = require("../../types");
+var DefaultFormatter = require("./_default");
+var traverse         = require("../../traverse");
+var util             = require("../../util");
+var t                = require("../../types");
 
 function CommonJSFormatter(file) {
-  this.file = file;
+  DefaultFormatter.apply(this, arguments);
+
+  var hasNonDefaultExports = false;
+  traverse(file.ast, {
+    enter: function (node) {
+      if (t.isExportDeclaration(node) && !node.default) hasNonDefaultExports = true;
+    }
+  });
+  this.hasNonDefaultExports = hasNonDefaultExports;
 }
 
-CommonJSFormatter.prototype.import = function (node, nodes) {
-  // import "foo";
-  nodes.push(util.template("require", {
-    //inherits: node,
-
-    MODULE_NAME: node.source.raw
-  }, true));
-};
+util.inherits(CommonJSFormatter, DefaultFormatter);
 
 CommonJSFormatter.prototype.importSpecifier = function (specifier, node, nodes) {
   var variableName = t.getSpecifierName(specifier);
 
   // import foo from "foo";
-  if (specifier.default) {
-    specifier.id = t.identifier("default");
+  if (t.isSpecifierDefault(specifier)) {
+    nodes.push(t.variableDeclaration("var", [
+      t.variableDeclarator(variableName,
+        t.callExpression(this.file.addHelper("interop-require"), [util.template("require", {
+          MODULE_NAME: node.source
+        })])
+      )
+    ]));
+  } else {
+    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
+      }));
+    }
   }
-
-  var templateName = "require-assign";
-
-  // import * as bar from "foo";
-  if (specifier.type !== "ImportBatchSpecifier") templateName += "-key";
-
-  nodes.push(util.template(templateName, {
-    //inherits: node.specifiers.length === 1 && node,
-
-    VARIABLE_NAME: variableName,
-    MODULE_NAME:   node.source.raw,
-    KEY:           specifier.id
-  }));
 };
 
-CommonJSFormatter.prototype.export = function (node, nodes) {
-  var declar = node.declaration;
+CommonJSFormatter.prototype.importDeclaration = function (node, nodes) {
+  // import "foo";
+  nodes.push(util.template("require", {
+    MODULE_NAME: node.source
+  }, true));
+};
 
-  if (node.default) {
-    var ref = declar;
-
-    if (t.isClass(ref) || t.isFunction(ref)) {
-      if (ref.id) {
-        nodes.push(t.toStatement(ref));
-        ref = ref.id;
-      }
-    }
-
-    nodes.push(util.template("exports-default", {
-      //inherits: node,
-
-      VALUE: ref
-    }, true));
-  } else {
+CommonJSFormatter.prototype.exportDeclaration = function (node, nodes) {
+  if (node.default && !this.noInteropRequire && !this.noInteropExport) {
+    var declar = node.declaration;
     var assign;
 
-    if (t.isVariableDeclaration(declar)) {
-      var decl = declar.declarations[0];
+    // module.exports = VALUE;
+    var templateName = "exports-default-module";
 
-      if (decl.init) {
-        decl.init = util.template("exports-assign", {
-          //inherits: node,
+    // exports = module.exports = VALUE;
+    if (this.hasNonDefaultExports) templateName = "exports-default-module-override";
 
-          VALUE: decl.init,
-          KEY:   decl.id
-        });
-      }
-
-      nodes.push(declar);
-    } else {
-      assign = util.template("exports-assign", {
-        //inherits: node,
-
-        VALUE: declar.id,
-        KEY:   declar.id
+    if (t.isFunctionDeclaration(declar) || !this.hasNonDefaultExports) {
+      assign = util.template(templateName, {
+        VALUE: this._pushStatement(declar, nodes)
       }, true);
 
-      nodes.push(t.toStatement(declar));
-      nodes.push(assign);
-
-      if (t.isFunctionDeclaration(declar)) {
-        assign._blockHoist = true;
-      }
-    }
-  }
-};
-
-CommonJSFormatter.prototype._exportSpecifier = function (getRef, specifier, node, nodes) {
-  var variableName = t.getSpecifierName(specifier);
-
-  var inherits = false;
-  if (node.specifiers.length === 1) inherits = node;
-
-  if (node.source) {
-    if (t.isExportBatchSpecifier(specifier)) {
-      // export * from "foo";
-      nodes.push(util.template("exports-wildcard", {
-        //inherits: inherits,
-
-        OBJECT: getRef()
-      }, true));
+      // hoist to the top if this default is a function
+      nodes.push(this._hoistExport(declar, assign, 3));
+      return;
     } else {
-      // export { foo } from "test";
-      nodes.push(util.template("exports-assign-key", {
-        //inherits: inherits,
+      // this export isn't a function so we can't hoist it to the top so we need to set it
+      // at the very end of the file with something like:
+      //
+      //   module.exports = _extends(exports["default"], exports)
+      //
 
-        VARIABLE_NAME: variableName.name,
-        OBJECT:        getRef(),
-        KEY:           specifier.id
-      }, true));
+      assign = util.template("common-export-default-assign", {
+        EXTENDS_HELPER: this.file.addHelper("extends")
+      }, true);
+      assign._blockHoist = 0;
+
+      nodes.push(assign);
     }
-  } else {
-    // export { foo };
-    nodes.push(util.template("exports-assign", {
-      //inherits: inherits,
-
-      VALUE: specifier.id,
-      KEY:   variableName
-    }, true));
   }
+
+  DefaultFormatter.prototype.exportDeclaration.apply(this, arguments);
 };
 
 CommonJSFormatter.prototype.exportSpecifier = function (specifier, node, nodes) {
-  return this._exportSpecifier(function () {
+  this._exportSpecifier(function () {
     return t.callExpression(t.identifier("require"), [node.source]);
   }, specifier, node, nodes);
 };

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

@@ -6,19 +6,13 @@ function IgnoreFormatter() {
 
 }
 
-IgnoreFormatter.prototype.import = function () {
-
-};
-
-IgnoreFormatter.prototype.importSpecifier = function () {
-
-};
-
-IgnoreFormatter.prototype.export = function (node, nodes) {
+IgnoreFormatter.prototype.exportDeclaration = function (node, nodes) {
   var declar = t.toStatement(node.declaration, true);
   if (declar) nodes.push(t.inherits(declar, node));
 };
 
+IgnoreFormatter.prototype.importDeclaration =
+IgnoreFormatter.prototype.importSpecifier =
 IgnoreFormatter.prototype.exportSpecifier = function () {
 
 };

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

@@ -0,0 +1,179 @@
+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");
+var _            = require("lodash");
+
+function SystemFormatter(file) {
+  this.exportIdentifier  = file.generateUidIdentifier("export");
+  this.noInteropRequire = true;
+
+  AMDFormatter.apply(this, arguments);
+}
+
+util.inherits(SystemFormatter, AMDFormatter);
+
+SystemFormatter.prototype._addImportSource = function (node, exportNode) {
+  node._importSource = exportNode.source && exportNode.source.value;
+  return node;
+};
+
+SystemFormatter.prototype._exportsWildcard = function (objectIdentifier, node) {
+  var leftIdentifier = this.file.generateUidIdentifier("key");
+  var valIdentifier  = t.memberExpression(objectIdentifier, leftIdentifier, true);
+
+  var left = t.variableDeclaration("var", [
+    t.variableDeclarator(leftIdentifier)
+  ]);
+
+  var right = objectIdentifier;
+
+  var block = t.blockStatement([
+    t.expressionStatement(this.buildExportCall(leftIdentifier, valIdentifier))
+  ]);
+
+  return this._addImportSource(t.forInStatement(left, right, block), node);
+};
+
+SystemFormatter.prototype._exportsAssign = function (id, init, node) {
+  var call = this.buildExportCall(t.literal(id.name), init, true);
+  return this._addImportSource(call, node);
+};
+
+SystemFormatter.prototype.remapExportAssignment = function (node) {
+  return this.buildExportCall(t.literal(node.left.name), node);
+};
+
+SystemFormatter.prototype.buildExportCall = function (id, init, isStatement) {
+  var call = t.callExpression(this.exportIdentifier, [id, init]);
+  if (isStatement) {
+    return t.expressionStatement(call);
+  } else {
+    return call;
+  }
+};
+
+SystemFormatter.prototype.importSpecifier = function (specifier, node, nodes) {
+  AMDFormatter.prototype.importSpecifier.apply(this, arguments);
+  this._addImportSource(_.last(nodes), node);
+};
+
+SystemFormatter.prototype.buildRunnerSetters = function (block, hoistDeclarators) {
+  return t.arrayExpression(_.map(this.ids, function (uid, source) {
+    var nodes = [];
+
+    traverse(block, {
+      enter: function (node) {
+        if (node._importSource === source) {
+          if (t.isVariableDeclaration(node)) {
+            _.each(node.declarations, function (declar) {
+              hoistDeclarators.push(t.variableDeclarator(declar.id));
+              nodes.push(t.expressionStatement(
+                t.assignmentExpression("=", declar.id, declar.init)
+              ));
+            });
+          } else {
+            nodes.push(node);
+          }
+
+          this.remove();
+        }
+      }
+    });
+
+    return t.functionExpression(null, [uid], t.blockStatement(nodes));
+  }));
+};
+
+SystemFormatter.prototype.transform = function (ast) {
+  var program = ast.program;
+
+  var hoistDeclarators = [];
+  var moduleName = this.getModuleName();
+  var moduleNameLiteral = t.literal(moduleName);
+
+  var block = t.blockStatement(program.body);
+
+  var runner = util.template("system", {
+    MODULE_NAME: moduleNameLiteral,
+    MODULE_DEPENDENCIES: t.arrayExpression(this.buildDependencyLiterals()),
+    EXPORT_IDENTIFIER: this.exportIdentifier,
+    SETTERS: this.buildRunnerSetters(block, hoistDeclarators),
+    EXECUTE: t.functionExpression(null, [], block)
+  }, true);
+
+  var handlerBody = runner.expression.arguments[2].body.body;
+  if (!moduleName) runner.expression.arguments.shift();
+
+  var returnStatement = handlerBody.pop();
+
+  // hoist up all variable declarations
+  traverse(block, {
+    enter: function (node, parent, scope) {
+      if (t.isFunction(node)) {
+        // nothing inside is accessible
+        return this.skip();
+      }
+
+      if (t.isVariableDeclaration(node)) {
+        if (node.kind !== "var" && !t.isProgram(parent)) { // let, const
+          // can't be accessed
+          return;
+        }
+
+        var nodes = [];
+
+        _.each(node.declarations, function (declar) {
+          hoistDeclarators.push(t.variableDeclarator(declar.id));
+          if (declar.init) {
+            // no initializer so we can just hoist it as-is
+            var assign = t.expressionStatement(t.assignmentExpression("=", declar.id, declar.init));
+            nodes.push(assign);
+          }
+        });
+
+        // for (var i in test)
+        // for (var i = 0;;)
+        if (t.isFor(parent)) {
+          if (parent.left === node) {
+            return node.declarations[0].id;
+          }
+
+          if (parent.init === node) {
+            return t.toSequenceExpression(nodes, scope);
+          }
+        }
+
+        return nodes;
+      }
+    }
+  });
+  if (hoistDeclarators.length) {
+    var hoistDeclar = t.variableDeclaration("var", hoistDeclarators);
+    hoistDeclar._blockHoist = true;
+    handlerBody.unshift(hoistDeclar);
+  }
+
+  // hoist up function declarations for circular references
+  traverse(block, {
+    enter: function (node) {
+      if (t.isFunction(node)) this.skip();
+
+      if (t.isFunctionDeclaration(node) || node._blockHoist) {
+        handlerBody.push(node);
+        this.remove();
+      }
+    }
+  });
+
+  handlerBody.push(returnStatement);
+
+  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

@@ -5,9 +5,8 @@ var util         = require("../../util");
 var t            = require("../../types");
 var _            = require("lodash");
 
-function UMDFormatter(file) {
-  this.file = file;
-  this.ids  = {};
+function UMDFormatter() {
+  AMDFormatter.apply(this, arguments);
 }
 
 util.inherits(UMDFormatter, AMDFormatter);
@@ -19,25 +18,43 @@ UMDFormatter.prototype.transform = function (ast) {
   // build an array of module names
 
   var names = [];
-  _.each(this.ids, function (id, name) {
+  for (var name in this.ids) {
     names.push(t.literal(name));
-  });
+  }
 
   // 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 runner = util.template("umd-runner-body", {
-    AMD_ARGUMENTS: 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)];
 
-    COMMON_ARGUMENTS: names.map(function (name) {
-      return t.callExpression(t.identifier("require"), [name]);
-    })
+  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_TEST: commonTests,
+    COMMON_ARGUMENTS: commonArgs
   });
 
   //

lib/6to5/transformation/templates/abstract-expression-call.js

@@ -0,0 +1 @@
+PROPERTY[Symbol.referenceGet](OBJECT).call(OBJECT)

lib/6to5/transformation/templates/abstract-expression-delete.js

@@ -0,0 +1 @@
+PROPERTY[Symbol.referenceDelete](OBJECT)

lib/6to5/transformation/templates/abstract-expression-get.js

@@ -0,0 +1 @@
+PROPERTY[Symbol.referenceGet](OBJECT)

lib/6to5/transformation/templates/abstract-expression-set.js

@@ -0,0 +1 @@
+PROPERTY[Symbol.referenceSet](OBJECT, VALUE)

lib/6to5/transformation/templates/apply-constructor.js

@@ -0,0 +1,5 @@
+(function (Constructor, args) {
+  var instance = Object.create(Constructor.prototype);
+  var result = Constructor.apply(instance, args);
+  return result != null && (typeof result == "object" || typeof result == "function") ? result : instance;
+});

lib/6to5/transformation/templates/array-from.js

@@ -0,0 +1 @@
+Array.from(VALUE);

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

@@ -0,0 +1,37 @@
+(function (fn) {
+  return function () {
+    var gen = fn.apply(this, arguments);
+
+    return new Promise(function (resolve, reject) {
+      function step(getNext) {
+        var next;
+
+        try {
+          next = getNext();
+        } catch(e) {
+          reject(e);
+          return;
+        }
+
+        if (next.done) {
+          resolve(next.value);
+          return;
+        }
+
+        Promise.resolve(next.value).then(function (v) {
+          step(function () {
+            return gen.next(v);
+          });
+        }, function (e) {
+          step(function () {
+            return gen["throw"](e);
+          });
+        });
+      }
+
+      step(function () {
+        return gen.next();
+      });
+    });
+  }
+})

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

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

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

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

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

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

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

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

lib/6to5/transformation/templates/default-parameter.js

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

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

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

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

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

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

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

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

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

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/has-own.js

@@ -0,0 +1 @@
+Object.prototype.hasOwnProperty;

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

@@ -0,0 +1,14 @@
+(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,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    }
+  });
+  if (parent) child.__proto__ = parent;
+})