v1.14.14

Only slice arguments when necessary - fixes #239

CHANGELOG.md

@@ -1,3 +1,102 @@
+# 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.

CONTRIBUTING.md

@@ -9,7 +9,6 @@
    * CamelCase all class names
    * camelBack all variable names
  * **Spacing**
-   * 80 character line max
    * Spaces after all keywords
    * Spaces before all left curly braces
  * **Comments**

Makefile

@@ -16,7 +16,7 @@ bench:
 	node node_modules/matcha/bin/_matcha
 
 lint:
-	$(JSHINT_CMD) lib bin benchmark/index.js
+	$(JSHINT_CMD) --reporter node_modules/jshint-stylish/stylish.js lib bin benchmark/index.js
 
 test-clean:
 	rm -rf test/tmp

README.md

@@ -4,7 +4,7 @@
 
 <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">
+    <img alt="Travis Status" src="http://img.shields.io/travis/6to5/6to5/master.svg?style=flat&amp;label=travis">
   </a>
 
   <a href="https://ci.appveyor.com/project/sebmck/6to5">
@@ -26,4 +26,5 @@
 
 **6to5** turns ES6+ code into vanilla ES5, so you can use next generation features **today.**
 
-For more information view the [documentation](https://6to5.github.io).
+For more information view the [documentation](https://6to5.github.io). For
+support visit the [gitter room](https://gitter.im/6to5/6to5).

bin/6to5-node

@@ -14,18 +14,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,16 +38,20 @@ 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 (){
+  process.on("exit", function () {
     if (signal) {
       process.kill(process.pid, signal);
     } else {

bin/6to5/index.js

@@ -12,6 +12,7 @@ commander.option("-f, --filename [filename]", "Filename to use when reading from
 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);
@@ -90,6 +91,7 @@ exports.opts = {
   sourceMapName: commander.outFile,
   amdModuleIds:  commander.amdModuleIds,
   experimental:  commander.experimental,
+  playground:    commander.playground,
   blacklist:     commander.blacklist,
   whitelist:     commander.whitelist,
   sourceMap:     commander.sourceMaps || commander.sourceMapsInline,

bin/_6to5-node

@@ -13,6 +13,7 @@ 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");
 
 var pkg = require("../package.json");
 commander.version(pkg.version);
@@ -30,7 +31,12 @@ to5.register({
 //
 
 var _eval = function (code, filename) {
-  code = to5.transform(code, { filename: filename, blacklist: ["useStrict"] }).code;
+  code = to5.transform(code, {
+    modules: "commonInterop",
+    filename: filename,
+    blacklist: ["useStrict"],
+    experimental: commander.experimental
+  }).code;
   return vm.runInThisContext(code, filename);
 };
 

doc/browser.md

@@ -30,7 +30,9 @@ test.test();
 You can build a browser version of the compiler by running the following in the
 6to5 directory:
 
-    $ make build
+```sh
+$ make build
+```
 
 This will output the files `dist/6to5.js` and `dist/6to5.min.js`.
 
@@ -38,7 +40,9 @@ This will output the files `dist/6to5.js` and `dist/6to5.min.js`.
 
 To test 6to5 in your browser run:
 
-    $ make test-browser
+```sh
+$ make test-browser
+```
 
 And open `test/browser.html` in your browser if it doesn't open automatically.
 

doc/caveats.md

@@ -1,19 +1,18 @@
 # Caveats
 
-## Async/Generators
+In order for certain features to work they require certain polyfills. You can
+satisfy **all** 6to5 feature requirements by using the included
+[polyfill](polyfill.md). You may alternatively selectively include what you need:
 
-The [regenerator runtime](https://github.com/facebook/regenerator/blob/master/runtime.js)
-and an [ES6 polyfill](polyfill.md) are required in order for generators to work.
-
-### Async/Comprehensions
-
-[Experimental support](usage.md#experimental) must be enabled for these proposed
-ES7 features to work.
-
-### Array comprehension/Array destructuring/Spread
-
-An [ES6 polyfill](polyfill.md) is required. More specifically a polyfill for
-`Array.isArray` and `Array.from`.
+| Feature                     | Requirements                                                                                                                 |
+| --------------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
+| Abstract References         | [experimental](usage.md#experimental), `Symbol`                                                                              |
+| Array destructuring         | `Array.isArray`, `Array.from`                                                                                                |
+| Async functions, Generators | [experimental](usage.md#experimental), [regenerator runtime](https://github.com/facebook/regenerator/blob/master/runtime.js) |
+| Comprehensions              | [experimental](usage.md#experimental), `Array.isArray`, `Array.from`                                                         |
+| For Of                      | `Symbol`, `prototype[Symbol.iterator]`                                                                                       |
+| Object spread/rest          | [experimental](usage.md#experimental), `Object.assign`                                                                       |
+| Spread                      | `Array.isArray`, `Array.from`                                                                                                |
 
 ## Classes
 
@@ -40,14 +39,3 @@ class Bar extends Foo {
   }
 }
 ```
-
-## Constructor spread
-
-Constructor spreads do not currently support built-ins. ie.
-`new Array(...items)`.
-
-## 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.md) suffices.

doc/differences.md

@@ -62,13 +62,14 @@ better suited if you'd like a full ES6 environment with polyfills and all.
 | ---------------------------- | ---- | ------- | -------------- | ------ | ------ | ----------- |
 | Source maps                  | ✓    | ✓       | ✓              | ✓      |        | ✓           |
 | No compiler global pollution | ✓    |         | ✓              | ✓      |        | ✓           |
-| No runtime                   | ✓    |         | ✓              |        |        | ✓           |
+| Optional runtime             | ✓    |         | ✓              |        |        | ✓           |
 | Browser support              | ✓    | ✓       |                | ✓      |        |             |
 
 ### Language Support
 
 |                              | 6to5  | Traceur | es6-transpiler | esnext | es6now | jstransform |
 | ---------------------------- | ----- | ------- | -------------- | ------ | ------ | ----------- |
+| Abstract references          | ✓     |         |                |        |        |             |
 | Array comprehension          | ✓     | ✓       | ✓              |        |        |             |
 | Arrow functions              | ✓     | ✓       | ✓              | ✓      | ✓      | ✓           |
 | Async functions              | ✓     | ✓       |                | ✓      |        |             |
@@ -77,11 +78,13 @@ better suited if you'd like a full ES6 environment with polyfills and all.
 | Constants                    | ✓     | ✓       | ✓              |        |        |             |
 | Default parameters           | ✓     | ✓       | ✓              | ✓      | ✓      |             |
 | Destructuring                | ✓     | ✓       | ✓              | ✓      | ✓      | ✓           |
+| Exponentiation operator      | ✓     | ✓       |                |        |        |             |
 | For-of                       | ✓     | ✓       | ✓              | ✓      | ✓      |             |
 | Generators                   | ✓     | ✓       |                | ✓      |        |             |
 | Generator comprehension      | ✓     | ✓       |                |        |        |             |
 | Let scoping                  | ✓     | ✓       | ✓              |        |        |             |
 | Modules                      | ✓     | ✓       |                |        | ✓      |             |
+| Object rest/spread           | ✓     |         |                |        |        | ✓           |
 | Property method assignment   | ✓     | ✓       | ✓              | ✓      | ✓      | ✓           |
 | Property name shorthand      | ✓     | ✓       | ✓              | ✓      | ✓      | ✓           |
 | Rest parameters              | ✓     | ✓       | ✓              | ✓      | ✓      | ✓           |
@@ -89,15 +92,11 @@ better suited if you'd like a full ES6 environment with polyfills and all.
 | 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.
+unneccesary step when a large runtime can be eliminated entirely.
 
 ### [es6now](https://github.com/zenparsing/es6now)
 

doc/features.md

@@ -1,6 +1,14 @@
 # Features
 
-## Array comprehension ([experimental](usage.md#experimental))
+## Abstract references ([experimental](usage.md#experimental)) ([spec](https://github.com/zenparsing/es-abstract-refs))
+
+```javascript
+foo::bar;
+foo::bar = baz;
+delete foo::bar;
+```
+
+## Array comprehensions ([experimental](usage.md#experimental))
 
 ```javascript
 var results = [for (c of customers) if (c.city == "Seattle") { name: c.name, age: c.age }]
@@ -31,7 +39,7 @@ var bob = {
 };
 ```
 
-## Async functions ([experimental](usage.md#experimental))
+## Async functions ([experimental](usage.md#experimental)) ([spec](https://github.com/lukehoban/ecmascript-asyncawait))
 
 ```javascript
 async function chainAnimationsAsync(elem, animations) {
@@ -122,6 +130,15 @@ var [a] = [];
 a === undefined;
 ```
 
+## Exponentiation operator ([experimental](usage.md#experimental)) ([spec](https://github.com/rwaldron/exponentiation-operator))
+
+```javascript
+var a = 2;
+a **= 2;
+
+var squared = 2 ** 2;
+```
+
 ## For-of
 
 ```javascript
@@ -150,7 +167,7 @@ for (var n of fibonacci()) {
 }
 ```
 
-## Generator comprehension ([experimental](usage.md#experimental))
+## Generator comprehensions ([experimental](usage.md#experimental))
 
 ```javascript
 var nums = [1, 2, 3, 4, 5, 6];
@@ -191,6 +208,13 @@ export default test;
 0o767 === 503; // true
 ```
 
+## Object spread/rest ([experimental](usage.md#experimental)) ([spec](https://github.com/sebmarkbage/ecmascript-rest-spread))
+
+```javascript
+var n = { x, y, ...z };
+var { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };
+```
+
 ## Property method assignment
 
 ```javascript
@@ -244,7 +268,6 @@ var x = 5;
 var y = 10;
 console.log(`${x} + ${y} = ${x + y}`); // "5 + 10 = 15"
 ```
-
 ## Unicode regex
 
 ```javascript

doc/index.md

@@ -19,18 +19,23 @@ how you want to use it.
 6to5 will simply compile your ES6+ script to ES5 if you pass it as an argument
 to the command-line tool `6to5`:
 
-    $ 6to5 script.js
+```sh
+$ 6to5 script.js
+```
 
 If you have a file written using ES6+ and you just want to run it, `6to5-node`
 has you covered:
 
-    $ 6to5-node script.js
+```sh
+$ 6to5-node script.js
+```
 
 And it doesn't end here! To see all the ways you can use 6to5, check out the
 [Usage](http://6to5.github.io/usage.html) page.
 
 ## [Features](features.md)
 
+ - [Abstract references](features.md#abstract-references) ([experimental](usage.md#experimental))
  - [Array comprehension](features.md#array-comprehension) ([experimental](usage.md#experimental))
  - [Async functions](features.md#async-functions) ([experimental](usage.md#experimental))
  - [Arrow functions](features.md#arrow-functions)
@@ -39,12 +44,14 @@ And it doesn't end here! To see all the ways you can use 6to5, check out the
  - [Constants](features.md#constants)
  - [Default parameters](features.md#default-parameters)
  - [Destructuring](features.md#destructuring)
+ - [Exponentiation operator](features.md#exponentiation-operator) ([experimental](usage.md#experimental))
  - [For-of](features.md#for-of)
  - [Generators](features.md#generators)
  - [Generator comprehension](features.md#generator-comprehension) ([experimental](usage.md#experimental))
  - [Let scoping](features.md#let-scoping)
  - [Modules](features.md#modules)
  - [Numeric literals](features.md#numeric-literals)
+ - [Object Rest/Spread](features.md#object-rest-spread) ([experimental](usage.md#experimental))
  - [Property method assignment](features.md#property-method-assignment)
  - [Property name shorthand](features.md#property-name-shorthand)
  - [React/JSX](react.md)

doc/modules.md

@@ -4,7 +4,9 @@
 
 ### CLI
 
-    $ 6to5 --modules common script.js
+```sh
+$ 6to5 --modules common script.js
+```
 
 ### Node
 
@@ -15,8 +17,19 @@ to5.transform('import "foo";', { modules: "common" });
 
 ## Formats
 
+ * [AMD](#amd)
+ * [Common (Default)](#common-default)
+ * [Common Interop](#common-interop)
+ * [Ignore](#ignore)
+ * [System](#system)
+ * [UMD](#umd)
+
 ### Common (Default)
 
+```sh
+$ 6to5 --modules common
+```
+
 **In**
 
 ```javascript
@@ -51,8 +64,79 @@ var test = 5; exports.test = test;
 exports.default = test;
 ```
 
+### Common interop
+
+```sh
+$ 6to5 --modules commonInterop
+```
+
+**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
+var _interopRequire = function (obj) {
+  return obj && (obj["default"] || obj);
+};
+
+require("foo");
+
+var foo = _interopRequire(require("foo"));
+var foo = require("foo");
+
+var bar = require("foo").bar;
+var bar = require("foo").foo;
+
+exports.test = test;
+var test = exports.test = 5;
+
+exports["default"] = test;
+```
+
+#### module.exports behaviour
+
+If there exist no other non-default `export`s then `default exports` are
+exported as `module.exports` instead of `exports.default`.
+
+**In**
+
+```javascript
+export default function foo() {
+
+}
+```
+
+**Out**
+
+```javascript
+module.exports = foo;
+
+function foo() {
+
+}
+```
+
 ### AMD
 
+```sh
+$ 6to5 --modules amd
+```
+
 **In**
 
 ```javascript
@@ -85,6 +169,10 @@ define("filename", ["exports", "foo"], function (exports, _foo) {})
 
 ### UMD
 
+```sh
+$ 6to5 --modules umd
+```
+
 **In**
 
 ```javascript
@@ -117,6 +205,10 @@ export function bar() {
 
 ### Ignore
 
+```sh
+$ 6to5 --modules ignore
+```
+
 **In**
 
 ```javascript
@@ -135,11 +227,52 @@ function bar() {
 }
 ```
 
+### System
+
+```sh
+$ 6to5 --modules system
+```
+
+**In**
+
+```javascript
+import foo from "foo";
+
+export function bar() {
+  return foo("foobar");
+}
+```
+
+**Out**
+
+```javascript
+System.register("bar", ["foo"], function (_export) {
+  "use strict";
+
+  var __moduleName = "bar";
+
+  var foo;
+  function bar() {
+    return foo("foobar");
+  }
+  return {
+    setters: [function (m) {
+      foo = m.default;
+    }],
+    execute: function () {
+      _export("bar", bar);
+    }
+  };
+});
+```
+
 ## Custom
 
 You can alternatively specify module names instead of one of the built-in types.
 
-    $ 6to5 --modules custom-module-formatter
+```sh
+$ 6to5 --modules custom-module-formatter
+```
 
 **node_modules/custom-module-formatter/index.js**
 

doc/optional-runtime.md

@@ -18,7 +18,9 @@ Simply use the following option if you're using the [Node API](usage.md#node):
 
 or the following flag if you're using the [CLI](usage.md#cli):
 
-    $ 6to5 --runtime
+```ssh
+$ 6to5 --runtime
+```
 
 Then just include the runtime before your generated code.
 
@@ -26,7 +28,9 @@ Then just include the runtime before your generated code.
 
 You can get the runtime via either:
 
-    $ 6to5-runtime
+```sh
+$ 6to5-runtime
+```
 
 or
 
@@ -45,7 +49,9 @@ argument:
 require("6to5").runtime("myCustomNamespace");
 ```
 
-    $ 6to5-runtime myCustomNamespace
+```sh
+$ 6to5-runtime myCustomNamespace
+```
 
 See [Options - runtime](usage.md#options) for documentation on changing the
 reference in generated code.

doc/playground.md

@@ -0,0 +1,68 @@
+# Playground
+
+Playground is a proving ground for **possible** ES7 proposals.
+
+**NOTE: These features are in no way endorsed by Ecma International and are not a part of ES6. They might become a part of ECMAScript in the future.**
+
+## Usage
+
+    $ 6to5 --playground
+
+```javascript
+to5.transform("code", { playground: true });
+```
+
+**NOTE:** Enabling `playground` also enables [experimental support](usage.md#experimental).
+
+## Features
+
+ * [Memoization operator](#memoization-operator)
+ * [Method binding](#method-binding)
+
+### Memoization assignment operator
+
+```javascript
+var obj = {};
+obj.x ?= 2;
+obj.x; // 2
+
+obj = { x: 1 };
+obj.x ?= 2;
+obj.x; // 1
+
+obj = { x: undefined }
+obj.x ?= 2;
+obj.x; // undefined
+```
+
+```javascript
+var obj = {};
+obj.x ?= 2;
+```
+
+equivalent to:
+
+```javascript
+var obj = {};
+if (!Object.prototype.hasOwnProperty.call(obj, "x")) obj.x = 2;
+```
+
+### Method binding
+
+```javascript
+var fn = obj:method;
+var fn = obj:method("foob");
+
+["foo", "bar"].map(:toUpperCase); // ["FOO", "BAR"]
+[1.1234, 23.53245, 3].map(:toFixed(2)); // ["1.12", "23.53", "3.00"]
+```
+
+equivalent to:
+
+```javascript
+var fn = obj.method.bind(obj);
+var fn = obj.method.bind(obj, "foob");
+
+["foo", "bar"].map(function (val) { return val.toUpperCase(); });
+[1.1234, 23.53245, 3].map(function (val) { return val.toFixed(2); });
+```

doc/plugins.md

@@ -8,9 +8,10 @@
  - [Gobble](https://github.com/gobblejs/gobble-6to5)
  - [Gulp](https://github.com/sindresorhus/gulp-6to5)
  - [Grunt](https://github.com/sindresorhus/grunt-6to5)
+ - [Isparta](https://github.com/douglasduteil/isparta) - Code coverage with `karma` and `instanbul` using 6to5
  - [Jade](https://github.com/Apoxx/jade-6to5)
  - [Jest](https://github.com/6to5/6to5-jest)
- - [JSXHint](https://github.com/STRML/JSXHint) (A wrapper around JSHint to allow linting of JSX files)
+ - [JSXHint](https://github.com/STRML/JSXHint) - A wrapper around JSHint to allow linting of JSX files
  - [Karma](https://github.com/shuhei/karma-6to5-preprocessor)
  - [Mocha](https://github.com/6to5/6to5-mocha)
  - [Rails](https://github.com/josh/sprockets-es6) or via [browserify-rails](https://github.com/6to5/6to5-rails)

doc/polyfill.md

@@ -5,13 +5,23 @@
 [es6-shim](https://github.com/paulmillr/es6-shim) and
 [es6-symbol](https://github.com/medikoo/es6-symbol) polyfills.
 
-## Node
+This will emulate a full ES6 environment. This polyfill is automatically loaded
+when using [6to5-node](usage.md#node).
+
+## Usage
+
+### Node
+
+You need to include the polyfill require at the top the **entry point** to your
+application.
 
 ```javascript
 require("6to5/polyfill");
 ```
 
-## Browser
+### Browser
 
 Available from the `browser-polyfill.js` file within the 6to5 directory of an
-npm release.
+npm release. This needs to be included **before** all your compiled 6to5 code.
+You can either prepend it to your compiled code or include it in a `<script>`
+before it.

doc/react.md

@@ -12,5 +12,6 @@ To disable this behaviour add `react` to your blacklist:
 to5.transform("code", { blacklist: ["react"] });
 ```
 
-
-    $ 6to5 --blacklist react
+```sh
+$ 6to5 --blacklist react
+```

doc/usage.md

@@ -4,47 +4,67 @@
 
 Compile the file `script.js` and output it to stdout.
 
-    $ 6to5 script.js
+```sh
+$ 6to5 script.js
+```
 
 Compile the file `script.js` and output it to `script-compiled.js`.
 
-    $ 6to5 script.js --out-file script-compiled.js
+```sh
+$ 6to5 script.js --out-file script-compiled.js
+```
 
 Compile the file `script.js` and output it to `script-compiled.js` and save a
 source map to `script-compiled.js.map`.
 
-    $ 6to5 script.js --source-maps --out-file script-compiled.js
+```sh
+$ 6to5 script.js --source-maps --out-file script-compiled.js
+```
 
 Compile the file `script.js` and output it to `script-compiled.js` with a source
 map embedded in a comment at the bottom.
 
-    $ 6to5 script.js --source-maps-inline --out-file script-compiled.js
+```sh
+$ 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
+```sh
+$ 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
+```sh
+$ 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
+```sh
+$ 6to5 --out-file script-compiled.js < script.js
+```
 
 ### Node
 
 Launch a repl.
 
-    $ 6to5-node
+```sh
+$ 6to5-node
+```
 
 Evaluate code.
 
-    $ 6to5-node -e "class Test { }"
+```sh
+$ 6to5-node -e "class Test { }"
+```
 
 Compile and run `test.js`.
 
-    $ 6to5-node test
+```sh
+$ 6to5-node test
+```
 
 ## Node
 
@@ -192,4 +212,5 @@ require("6to5/register")({
 the `experimental: true` option when using the [Node API](#node) or
 `--experimental` when using the [CLI](#cli).
 
-**NOTE:** That these are subject to change as their proposal status progresses.
+**WARNING:** These proposals are subject to change so use with
+**extreme caution**.

lib/6to5/file.js

@@ -10,22 +10,29 @@ 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.opts = File.normaliseOptions(opts);
+  this.uids = {};
+  this.ast  = {};
 }
 
-File.declarations = ["extends", "class-props", "slice", "apply-constructor",
-                     "tagged-template-literal", "interop-require", "to-array"];
+File.declarations = [
+  "extends",
+  "class-props",
+  "apply-constructor",
+  "tagged-template-literal",
+  "interop-require",
+  "to-array",
+  "object-spread",
+  "has-own",
+  "slice"
+];
 
 File.normaliseOptions = function (opts) {
   opts = _.cloneDeep(opts || {});
 
   _.defaults(opts, {
     experimental: false,
+    playground:   false,
     whitespace:   true,
     blacklist:    [],
     whitelist:    [],
@@ -34,7 +41,8 @@ File.normaliseOptions = function (opts) {
     filename:     "unknown",
     modules:      "common",
     runtime:      false,
-    code:         true
+    code:         true,
+    ast:          true
   });
 
   // normalise windows path separators to unix
@@ -64,6 +72,10 @@ File.normaliseOptions = function (opts) {
     opts.runtime = "to5Runtime";
   }
 
+  if (opts.playground) {
+    opts.experimental = true;
+  }
+
   transform._ensureTransformerNames("blacklist", opts.blacklist);
   transform._ensureTransformerNames("whitelist", opts.whitelist);
 
@@ -73,6 +85,8 @@ File.normaliseOptions = function (opts) {
 File.prototype.toArray = function (node) {
   if (t.isArrayExpression(node)) {
     return node;
+  } else if (t.isIdentifier(node) && node.name === "arguments") {
+    return t.callExpression(t.memberExpression(this.addDeclaration("slice"), t.identifier("call")), [node]);
   } else {
     return t.callExpression(this.addDeclaration("to-array"), [node]);
   }
@@ -110,8 +124,10 @@ File.prototype.addDeclaration = function (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;
@@ -122,11 +138,12 @@ File.prototype.addDeclaration = function (name) {
     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;
 };
 
@@ -157,6 +174,7 @@ File.prototype.parse = function (code) {
 File.prototype.transform = function (ast) {
   this.ast = ast;
   this.scope = new Scope(ast.program);
+  this.moduleFormatter = this.getModuleFormatter(this.opts.modules);
 
   var self = this;
 
@@ -169,15 +187,18 @@ 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
@@ -188,8 +209,6 @@ File.prototype.generate = function () {
     result.code += "\n" + util.sourceMapToComment(result.map);
   }
 
-  result.ast = result;
-
   return result;
 };
 

lib/6to5/generation/generator.js

@@ -53,6 +53,7 @@ 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"),
@@ -160,7 +161,7 @@ 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 " + node.type);
   }
 };
 

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/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;

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

@@ -24,15 +24,7 @@ function Node(node, parent) {
 }
 
 Node.prototype.isUserWhitespacable = function () {
-  var parent = this.parent;
-  var node = this.node;
-
-  if (t.isUserWhitespacable(node) ||
-      t.isSequenceExpression(parent)) {
-    return true;
-  }
-
-  return false;
+  return t.isUserWhitespacable(this.node);
 };
 
 Node.prototype.needsWhitespace = function (type) {

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) {

lib/6to5/patch.js

@@ -3,6 +3,7 @@ var _ = require("lodash");
 
 var types = require("ast-types");
 var def   = types.Type.def;
+var or    = types.Type.or;
 
 // Program wrapper
 def("File")
@@ -16,12 +17,33 @@ def("ParenthesizedExpression")
   .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"));
 
+// Abstract references
+def("VirtualPropertyExpression")
+  .bases("Expression")
+  .build("object", "property")
+  .field("object", def("Expression"))
+  .field("property", or(def("Identifier"), def("Expression")));
+
+// 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();
 
 var estraverse = require("estraverse");

lib/6to5/polyfill.js

@@ -1,6 +1,37 @@
+/* jshint newcap: false */
+
+var ensureSymbol = function (key) {
+  Symbol[key] = Symbol[key] || Symbol();
+};
+
+var ensureProto = function (Constructor, key, val) {
+  var proto = Constructor.prototype;
+  proto[key] = proto[key] || val;
+};
+
+//
+
 if (typeof Symbol === "undefined") {
   require("es6-symbol/implement");
 }
 
 require("es6-shim");
-require("./transformation/transformers/generators/runtime");
+require("./transformation/transformers/es6-generators/runtime");
+
+// Abstract references
+
+ensureSymbol("referenceGet");
+ensureSymbol("referenceSet");
+ensureSymbol("referenceDelete");
+
+ensureProto(Function, Symbol.referenceGet, function () { return this; });
+
+ensureProto(Map, Symbol.referenceGet, Map.prototype.get);
+ensureProto(Map, Symbol.referenceSet, Map.prototype.set);
+ensureProto(Map, Symbol.referenceDelete, Map.prototype.delete);
+
+if (global.WeakMap) {
+  ensureProto(WeakMap, Symbol.referenceGet, WeakMap.prototype.get);
+  ensureProto(WeakMap, Symbol.referenceSet, WeakMap.prototype.set);
+  ensureProto(WeakMap, Symbol.referenceDelete, WeakMap.prototype.delete);
+}

lib/6to5/register.js

@@ -3,6 +3,7 @@ require("./polyfill");
 var sourceMapSupport = require("source-map-support");
 var util             = require("./util");
 var to5              = require("./index");
+var fs               = require("fs");
 var _                = require("lodash");
 
 sourceMapSupport.install({
@@ -61,22 +62,42 @@ var transformOpts = {};
 var ignoreRegex   = /node_modules/;
 var onlyRegex;
 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, _.extend({
+  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,
-    modules:   "commonInterop"
+    modules:   "commonInterop",
+    ast:       false
   }, transformOpts));
 
+  if (cache) {
+    result.mtime = mtime(filename);
+    cache[filename] = result;
+  }
+
   maps[filename] = result.map;
 
   m._compile(result.code, filename);
@@ -108,5 +129,8 @@ module.exports = function (opts) {
 
   if (opts.extensions) hookExtensions(util.arrayify(opts.extensions));
 
+  if (opts.cache) cache = opts.cache;
+  if (opts.cache === false) cache = null;
+
   _.extend(transformOpts, opts);
 };

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

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

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

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

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

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

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

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

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

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

lib/6to5/templates/has-own.js

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

lib/6to5/templates/object-spread.js

@@ -0,0 +1,9 @@
+(function (obj, keys) {
+  var target = {};
+  for (var i in obj) {
+    if (keys.indexOf(i) >= 0) continue;
+    if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;
+    target[i] = obj[i];
+  }
+  return target;
+})

lib/6to5/templates/register.js

@@ -0,0 +1 @@
+System.register(MODULE_NAME, MODULE_DEPENDENCIES, MODULE_BODY);

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

@@ -41,34 +41,11 @@ AMDFormatter.prototype.transform = function (ast) {
 };
 
 AMDFormatter.prototype.getModuleName = function () {
-  var opts = this.file.opts;
-  var filenameRelative = opts.filenameRelative;
-  var moduleName = "";
-
-  if (!opts.amdModuleIds) {
+  if (this.file.opts.amdModuleIds) {
+    return CommonJSFormatter.prototype.getModuleName.apply(this, arguments);
+  } else {
     return null;
   }
-
-  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;
-
-  return moduleName;
 };
 
 AMDFormatter.prototype._push = function (node) {

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

@@ -3,9 +3,16 @@ module.exports = CommonJSInteropFormatter;
 var CommonJSFormatter = require("./common");
 var util              = require("../../util");
 var t                 = require("../../types");
+var _                 = require("lodash");
 
 function CommonJSInteropFormatter(file) {
-  this.file = file;
+  CommonJSFormatter.apply(this, arguments);
+
+  var has = false;
+  _.each(file.ast.program.body, function (node) {
+    if (t.isExportDeclaration(node) && !node.default) has = true;
+  });
+  this.has = has;
 }
 
 util.inherits(CommonJSInteropFormatter, CommonJSFormatter);
@@ -26,3 +33,24 @@ CommonJSInteropFormatter.prototype.importSpecifier = function (specifier, node,
     CommonJSFormatter.prototype.importSpecifier.apply(this, arguments);
   }
 };
+
+CommonJSInteropFormatter.prototype.export = function (node, nodes) {
+  if (node.default && !this.has) {
+    var declar = node.declaration;
+
+    // module.exports = VALUE;
+    var assign = util.template("exports-default-module", {
+      VALUE: this._pushStatement(declar, nodes)
+    }, true);
+
+    // hoist to the top if this default is a function
+    nodes.push(this._hoistExport(declar, assign));
+    return;
+  }
+
+  CommonJSFormatter.prototype.export.apply(this, arguments);
+};
+
+CommonJSInteropFormatter.prototype.exportSpecifier = function () {
+  CommonJSFormatter.prototype.exportSpecifier.apply(this, arguments);
+};

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

@@ -7,6 +7,33 @@ function CommonJSFormatter(file) {
   this.file = file;
 }
 
+CommonJSFormatter.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;
+
+  return moduleName;
+};
+
 CommonJSFormatter.prototype.import = function (node, nodes) {
   // import "foo";
   nodes.push(util.template("require", {
@@ -38,23 +65,32 @@ CommonJSFormatter.prototype.importSpecifier = function (specifier, node, nodes)
   }));
 };
 
+CommonJSFormatter.prototype._hoistExport = function (declar, assign) {
+  if (t.isFunctionDeclaration(declar)) {
+    assign._blockHoist = true;
+  }
+
+  return assign;
+};
+
+CommonJSFormatter.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;
+};
+
 CommonJSFormatter.prototype.export = function (node, nodes) {
   var declar = node.declaration;
 
   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
+      VALUE: this._pushStatement(declar, nodes)
     }, true));
   } else {
     var assign;
@@ -83,9 +119,7 @@ CommonJSFormatter.prototype.export = function (node, nodes) {
       nodes.push(t.toStatement(declar));
       nodes.push(assign);
 
-      if (t.isFunctionDeclaration(declar)) {
-        assign._blockHoist = true;
-      }
+      this._hoistExport(declar, assign);
     }
   }
 };
@@ -126,7 +160,7 @@ CommonJSFormatter.prototype._exportSpecifier = function (getRef, specifier, node
 };
 
 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/system.js

@@ -0,0 +1,202 @@
+module.exports = SystemFormatter;
+
+var util = require("../../util");
+var t    = require("../../types");
+var _    = require("lodash");
+
+var SETTER_MODULE_NAMESPACE = t.identifier("m");
+var DEFAULT_IDENTIFIER      = t.identifier("default");
+var NULL_SETTER             = t.literal(null);
+
+function SystemFormatter(file) {
+  this.exportedStatements = [];
+  this.importedModule     = {};
+
+  this.exportIdentifier   = file.generateUidIdentifier("export");
+  this.file               = file;
+}
+
+SystemFormatter.prototype.transform = function (ast) {
+  var program = ast.program;
+  var body    = program.body;
+
+  // extract the module name
+  var moduleName = this.file.opts.filename
+    .replace(/^.*\//, "").replace(/\..*$/, "");
+
+  // build an array of module names
+  var dependencies = Object.keys(this.importedModule).map(t.literal);
+
+  // generate the __moduleName variable
+  var moduleNameVariableNode = t.variableDeclaration("var", [
+    t.variableDeclarator(
+      t.identifier("__moduleName"),
+      t.literal(moduleName)
+    )
+  ]);
+  body.splice(1, 0, moduleNameVariableNode);
+
+  // generate an array of import variables
+
+  var declaredSetters = _(this.importedModule)
+    .map()
+    .flatten()
+    .pluck("variableName")
+    .pluck("name")
+    .uniq()
+    .map(t.identifier)
+    .map(function (name) {
+      return t.variableDeclarator(name);
+    })
+    .value();
+
+  if (declaredSetters.length) {
+    body.splice(2, 0, t.variableDeclaration("var", declaredSetters));
+  }
+
+  // generate the execute function expression
+  var executeFunctionExpression = t.functionExpression(
+    null, [], t.blockStatement(this.exportedStatements)
+  );
+
+  // generate the execute function expression
+  var settersArrayExpression = t.arrayExpression(this._buildSetters());
+
+  // generate the return statement
+  var moduleReturnStatement = t.returnStatement(t.objectExpression([
+    t.property("init", t.identifier("setters"), settersArrayExpression),
+    t.property("init", t.identifier("execute"), executeFunctionExpression)
+  ]));
+  body.push(moduleReturnStatement);
+
+  // runner
+  var runner = util.template("register", {
+    MODULE_NAME: t.literal(moduleName),
+    MODULE_DEPENDENCIES: t.arrayExpression(dependencies),
+    MODULE_BODY: t.functionExpression(
+      null,
+      [this.exportIdentifier],
+      t.blockStatement(body)
+    )
+  });
+
+  program.body = [t.expressionStatement(runner)];
+};
+
+SystemFormatter.prototype._buildSetters = function () {
+  // generate setters array expression elements
+  return _.map(this.importedModule, function (specs) {
+    if (!specs.length) {
+      return NULL_SETTER;
+    }
+
+    var expressionStatements = _.map(specs, function (spec) {
+      var right = SETTER_MODULE_NAMESPACE;
+      if (!spec.isBatch) {
+        right = t.memberExpression(right, spec.key);
+      }
+
+      return t.expressionStatement(
+        t.assignmentExpression("=", spec.variableName, right
+        )
+      );
+    });
+
+    return t.functionExpression(
+      null, [SETTER_MODULE_NAMESPACE], t.blockStatement(expressionStatements)
+    );
+  });
+};
+
+SystemFormatter.prototype.import = function (node) {
+  var MODULE_NAME = node.source.value;
+  this.importedModule[MODULE_NAME] = this.importedModule[MODULE_NAME] || [];
+};
+
+SystemFormatter.prototype.importSpecifier = function (specifier, node) {
+  var variableName = t.getSpecifierName(specifier);
+
+  // import foo from "foo";
+  if (specifier.default) {
+    specifier.id = DEFAULT_IDENTIFIER;
+  }
+
+  var MODULE_NAME = node.source.value;
+
+  this.importedModule[MODULE_NAME] = this.importedModule[MODULE_NAME] || [];
+
+  this.importedModule[MODULE_NAME].push({
+    variableName: variableName,
+    isBatch:      specifier.type === "ImportBatchSpecifier",
+    key:          specifier.id
+  });
+};
+
+SystemFormatter.prototype._export = function (name, identifier) {
+  this.exportedStatements.push(t.expressionStatement(
+    t.callExpression(this.exportIdentifier, [t.literal(name), identifier])
+  ));
+};
+
+SystemFormatter.prototype.export = function (node, nodes) {
+  var declar = node.declaration;
+  var variableName, identifier;
+
+  if (node.default) {
+    // export default foo
+    variableName = DEFAULT_IDENTIFIER.name;
+    if (t.isClass(declar) || t.isFunction(declar)) {
+      if (!declar.id) {
+        declar.id = this.file.generateUidIdentifier("anonymous");
+      }
+
+      nodes.push(t.toStatement(declar));
+      declar = declar.id;
+    }
+
+    identifier = declar;
+  } else if (t.isVariableDeclaration(declar)) {
+    // export var foo
+    variableName = declar.declarations[0].id.name;
+    identifier = declar.declarations[0].id;
+
+    nodes.push(declar);
+  } else {
+    // export function foo () {}
+    variableName = declar.id.name;
+    identifier = declar.id;
+
+    nodes.push(declar);
+  }
+
+  this._export(variableName, identifier);
+};
+
+SystemFormatter.prototype.exportSpecifier = function (specifier, node) {
+  var variableName = t.getSpecifierName(specifier);
+
+  if (node.source) {
+    if (t.isExportBatchSpecifier(specifier)) {
+      // export * from "foo";
+      var exportIdentifier = t.identifier("exports");
+      this.exportedStatements.push(
+        t.variableDeclaration("var", [
+          t.variableDeclarator(exportIdentifier, this.exportIdentifier)
+        ])
+      );
+
+      this.exportedStatements.push(util.template("exports-wildcard", {
+        OBJECT: t.identifier(node.source.value)
+      }, true));
+    } else {
+      // export { foo } from "test";
+      this._export(variableName.name, t.memberExpression(
+        t.identifier(node.source.value),
+        specifier.id
+      ));
+    }
+  } else {
+    // export { foo };
+    this._export(variableName.name, specifier.id);
+  }
+};

lib/6to5/transformation/transform.js

@@ -22,36 +22,43 @@ transform.transformers = {};
 transform.moduleFormatters = {
   common:        require("./modules/common"),
   commonInterop: require("./modules/common-interop"),
+  system:        require("./modules/system"),
   ignore:        require("./modules/ignore"),
   amd:           require("./modules/amd"),
   umd:           require("./modules/umd")
 };
 
 _.each({
-  modules:                   require("./transformers/modules"),
-  propertyNameShorthand:     require("./transformers/property-name-shorthand"),
-  arrayComprehension:        require("./transformers/array-comprehension"),
-  generatorComprehension:    require("./transformers/generator-comprehension"),
-  arrowFunctions:            require("./transformers/arrow-functions"),
-  classes:                   require("./transformers/classes"),
+  modules:                   require("./transformers/es6-modules"),
+  propertyNameShorthand:     require("./transformers/es6-property-name-shorthand"),
+  arrayComprehension:        require("./transformers/es7-array-comprehension"),
+  generatorComprehension:    require("./transformers/es7-generator-comprehension"),
+  arrowFunctions:            require("./transformers/es6-arrow-functions"),
+  classes:                   require("./transformers/es6-classes"),
 
-  _propertyLiterals:         require("./transformers/_property-literals"),
-  computedPropertyNames:     require("./transformers/computed-property-names"),
+  computedPropertyNames:     require("./transformers/es6-computed-property-names"),
 
-  spread:                    require("./transformers/spread"),
-  templateLiterals:          require("./transformers/template-literals"),
-  propertyMethodAssignment:  require("./transformers/property-method-assignment"),
-  defaultParameters:         require("./transformers/default-parameters"),
-  restParameters:            require("./transformers/rest-parameters"),
-  destructuring:             require("./transformers/destructuring"),
-  forOf:                     require("./transformers/for-of"),
-  unicodeRegex:              require("./transformers/unicode-regex"),
+  objectSpread:              require("./transformers/es7-object-spread"),
+  exponentiationOperator:    require("./transformers/es7-exponentiation-operator"),
+  spread:                    require("./transformers/es6-spread"),
+  templateLiterals:          require("./transformers/es6-template-literals"),
+  propertyMethodAssignment:  require("./transformers/es5-property-method-assignment"),
+  defaultParameters:         require("./transformers/es6-default-parameters"),
+  restParameters:            require("./transformers/es6-rest-parameters"),
+  destructuring:             require("./transformers/es6-destructuring"),
+  forOf:                     require("./transformers/es6-for-of"),
+  unicodeRegex:              require("./transformers/es6-unicode-regex"),
+  abstractReferences:        require("./transformers/es7-abstract-references"),
   react:                     require("./transformers/react"),
 
-  constants:                 require("./transformers/constants"),
-  letScoping:                require("./transformers/let-scoping"),
+  constants:                 require("./transformers/es6-constants"),
+  letScoping:                require("./transformers/es6-let-scoping"),
 
-  generators:                require("./transformers/generators"),
+  generators:                require("./transformers/es6-generators"),
+
+  // plyground
+  methodBinding:             require("./transformers/playground-method-binding"),
+  memoizationOperator:       require("./transformers/playground-memoization-operator"),
 
   _blockHoist:               require("./transformers/_block-hoist"),
   _declarations:             require("./transformers/_declarations"),
@@ -59,7 +66,8 @@ _.each({
 
   useStrict:                 require("./transformers/use-strict"),
 
-  _memberExpressionKeywords: require("./transformers/_member-expression-keywords"),
+  _propertyLiterals:         require("./transformers/_property-literals"),
+  _memberExpressioLiterals:  require("./transformers/_member-expression-literals"),
   _moduleFormatter:          require("./transformers/_module-formatter")
 }, function (transformer, key) {
   transform.transformers[key] = new Transformer(key, transformer);

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

@@ -31,7 +31,7 @@ var go = function (getBody, node, file, scope) {
         return false;
       }
 
-      if (node._ignoreAliasFunctions) return;
+      if (node._ignoreAliasFunctions) return false;
 
       var getId;
 

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

@@ -1,12 +1,23 @@
 var t = require("../../types");
+var _ = require("lodash");
 
-module.exports = function (ast, file) {
-  var body = ast.program.body;
+exports.BlockStatement =
+exports.Program = function (node) {
+  var kinds = {};
 
-  for (var i in file.declarations) {
-    var declar = file.declarations[i];
-    body.unshift(t.variableDeclaration("var", [
-      t.variableDeclarator(declar.uid, declar.node)
-    ]));
-  }
+  _.each(node._declarations, function (declar) {
+    var kind = declar.kind || "var";
+    var declarNode = t.variableDeclarator(declar.id, declar.init);
+
+    if (!declar.init) {
+      kinds[kind] = kinds[kind] || [];
+      kinds[kind].push(declarNode);
+    } else {
+      node.body.unshift(t.variableDeclaration(kind, [declarNode]));
+    }
+  });
+
+  _.each(kinds, function (declars, kind) {
+    node.body.unshift(t.variableDeclaration(kind, declars));
+  });
 };

lib/6to5/transformation/transformers/_member-expression-keywords.js

@@ -1,10 +0,0 @@
-var esutils = require("esutils");
-var t = require("../../types");
-
-exports.MemberExpression = function (node) {
-  var prop = node.property;
-  if (t.isIdentifier(prop) && esutils.keyword.isKeywordES6(prop.name, true)) {
-    node.property = t.literal(prop.name);
-    node.computed = true;
-  }
-};

lib/6to5/transformation/transformers/_member-expression-literals.js

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

lib/6to5/transformation/transformers/_property-literals.js

@@ -1,15 +1,14 @@
 var esutils = require("esutils");
 var t       = require("../../types");
-var _       = require("lodash");
 
 exports.Property = function (node) {
-  // ignore key literals that are valid identifiers
   var key = node.key;
-  if (t.isLiteral(key) && _.isString(key.value) && esutils.keyword.isIdentifierName(key.value)) {
-    key.type = "Identifier";
-    key.name = key.value;
-    delete key.value;
-
+  if (t.isLiteral(key) && t.isValidIdentifier(key.value)) {
+    // property key is a literal but a valid identifier
+    node.key = t.identifier(key.value);
     node.computed = false;
+  } else if (!node.computed && t.isIdentifier(key) && esutils.keyword.isKeywordES6(key.name, true)) {
+    // property key is a keyword
+    node.key = t.literal(key.name);
   }
 };

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

@@ -4,9 +4,13 @@ var t        = require("../../types");
 var _        = require("lodash");
 
 exports.ClassDeclaration = function (node, parent, file, scope) {
-  return t.variableDeclaration("let", [
-    t.variableDeclarator(node.id, new Class(node, file, scope).run())
+  var built = new Class(node, file, scope).run();
+
+  var declar = t.variableDeclaration("let", [
+    t.variableDeclarator(node.id, built)
   ]);
+  t.inheritsComments(declar, node);
+  return declar;
 };
 
 exports.ClassExpression = function (node, parent, file, scope) {
@@ -158,17 +162,22 @@ Class.prototype.buildBody = function () {
 Class.prototype.pushMethod = function (node) {
   var methodName = node.key;
 
-  var mutatorMap = this.instanceMutatorMap;
-  if (node.static) mutatorMap = this.staticMutatorMap;
-
   var kind = node.kind;
 
   if (kind === "") {
-    kind = "value";
-    util.pushMutatorMap(mutatorMap, methodName, "writable", t.identifier("true"));
-  }
+    // method
 
-  util.pushMutatorMap(mutatorMap, methodName, kind, node);
+    var className = this.className;
+    if (!node.static) className = t.memberExpression(className, t.identifier("prototype"));
+    methodName = t.memberExpression(className, methodName, node.computed);
+
+    this.body.push(t.expressionStatement(t.assignmentExpression("=", methodName, node.value)));
+  } else {
+    // mutator
+    var mutatorMap = this.instanceMutatorMap;
+    if (node.static) mutatorMap = this.staticMutatorMap;
+    util.pushMutatorMap(mutatorMap, methodName, kind, node);
+  }
 };
 
 /**

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

@@ -11,7 +11,7 @@ exports.Function = function (node, parent, file, scope) {
     return t.getIds(param);
   });
 
-  var closure = false;
+  var iife = false;
 
   _.each(node.defaults, function (def, i) {
     if (!def) return;
@@ -29,7 +29,7 @@ exports.Function = function (node, parent, file, scope) {
         }
 
         if (scope.has(node.name)) {
-          closure = true;
+          iife = true;
         }
       };
 
@@ -40,7 +40,7 @@ exports.Function = function (node, parent, file, scope) {
     // we're accessing a variable that's already defined within this function
     var has = scope.get(param.name);
     if (has && !_.contains(node.params, has)) {
-      closure = true;
+      iife = true;
     }
   });
 
@@ -55,7 +55,7 @@ exports.Function = function (node, parent, file, scope) {
     }, true));
   });
 
-  if (closure) {
+  if (iife) {
     var container = t.functionExpression(null, [], node.body, node.generator);
     container._aliasFunction = true;
 

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

@@ -1,11 +1,16 @@
+// TODO: Clean up
+
 var t = require("../../types");
 var _ = require("lodash");
 
-var buildVariableAssign = function (kind, id, init) {
-  if (kind === false) {
+var buildVariableAssign = function (opts, id, init) {
+  var op = opts.operator;
+  if (t.isMemberExpression(id)) op = "=";
+
+  if (op) {
     return t.expressionStatement(t.assignmentExpression("=", id, init));
   } else {
-    return t.variableDeclaration(kind, [
+    return t.variableDeclaration(opts.kind, [
       t.variableDeclarator(id, init)
     ]);
   }
@@ -16,22 +21,39 @@ var push = function (opts, nodes, elem, parentId) {
     pushObjectPattern(opts, nodes, elem, parentId);
   } else if (t.isArrayPattern(elem)) {
     pushArrayPattern(opts, nodes, elem, parentId);
-  } else if (t.isMemberExpression(elem)) {
-    nodes.push(buildVariableAssign(false, elem, parentId));
   } else {
-    nodes.push(buildVariableAssign(opts.kind, elem, parentId));
+    nodes.push(buildVariableAssign(opts, elem, parentId));
   }
 };
 
 var pushObjectPattern = function (opts, nodes, pattern, parentId) {
-  _.each(pattern.properties, function (prop) {
-    var pattern2   = prop.value;
-    var patternId2 = t.memberExpression(parentId, prop.key, prop.computed);
+  _.each(pattern.properties, function (prop, i) {
+    if (t.isSpreadProperty(prop)) {
+        // get all the keys that appear in this object before the current spread
+        var keys = [];
+        _.each(pattern.properties, function (prop2, i2) {
+          if (i2 >= i) return false;
+          if (t.isSpreadProperty(prop2)) return;
 
-    if (t.isPattern(pattern2)) {
-      push(opts, nodes, pattern2, patternId2);
+          var key = prop2.key;
+          if (t.isIdentifier(key)) {
+            key = t.literal(prop2.key.name);
+          }
+          keys.push(key);
+        });
+        keys = t.arrayExpression(keys);
+
+        var value = t.callExpression(opts.file.addDeclaration("object-spread"), [parentId, keys]);
+        nodes.push(buildVariableAssign(opts, prop.argument, value));
     } else {
-      nodes.push(buildVariableAssign(opts.kind, pattern2, patternId2));
+      var pattern2   = prop.value;
+      var patternId2 = t.memberExpression(parentId, prop.key, prop.computed);
+
+      if (t.isPattern(pattern2)) {
+        push(opts, nodes, pattern2, patternId2);
+      } else {
+        nodes.push(buildVariableAssign(opts, pattern2, patternId2));
+      }
     }
   });
 };
@@ -156,7 +178,7 @@ exports.ExpressionStatement = function (node, parent, file, scope) {
   ]));
 
   push({
-    kind: false,
+    operator: expr.operator,
     file: file,
     scope: scope
   }, nodes, expr.left, ref);
@@ -164,10 +186,29 @@ exports.ExpressionStatement = function (node, parent, file, scope) {
   return nodes;
 };
 
-exports.AssignmentExpression = function (node, parent, file) {
+exports.AssignmentExpression = function (node, parent, file, scope) {
   if (parent.type === "ExpressionStatement") return;
   if (!t.isPattern(node.left)) return;
-  throw file.errorWithNode(node, "AssignmentExpression destructuring outside of a ExpressionStatement is forbidden due to current 6to5 limitations");
+
+  var tempName = file.generateUid("temp", scope);
+  var ref = t.identifier(tempName);
+  scope.push({
+    key: tempName,
+    id: ref
+  });
+
+  var nodes = [];
+  nodes.push(t.assignmentExpression("=", ref, node.right));
+
+  push({
+    operator: node.operator,
+    file: file,
+    scope: scope
+  }, nodes, node.left, ref);
+
+  nodes.push(ref);
+
+  return t.toSequenceExpression(nodes, scope);
 };
 
 exports.VariableDeclaration = function (node, parent, file, scope) {
@@ -187,17 +228,18 @@ exports.VariableDeclaration = function (node, parent, file, scope) {
   _.each(node.declarations, function (declar) {
     var patternId = declar.init;
     var pattern   = declar.id;
+    var opts = {
+      kind:    node.kind,
+      nodes:   nodes,
+      pattern: pattern,
+      id:      patternId,
+      file:    file,
+      scope:   scope
+    };
     if (t.isPattern(pattern) && patternId) {
-      pushPattern({
-        kind:    node.kind,
-        nodes:   nodes,
-        pattern: pattern,
-        id:      patternId,
-        file:    file,
-        scope:   scope
-      });
+      pushPattern(opts);
     } else {
-      nodes.push(buildVariableAssign(node.kind, declar.id, declar.init));
+      nodes.push(buildVariableAssign(opts, declar.id, declar.init));
     }
   });
 
@@ -219,4 +261,3 @@ exports.VariableDeclaration = function (node, parent, file, scope) {
 
   return nodes;
 };
-

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

@@ -56,7 +56,7 @@ var visitor = function (path, file) {
   );
 
   var innerFnId = t.identifier(node.id.name + "$");
-  var contextId = file.generateUidIdentifier("context$", scope);
+  var contextId = file.generateUidIdentifier("context", scope);
   var vars = hoist(path);
 
   var emitter = new Emitter(contextId);

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

@@ -260,16 +260,14 @@ LetScoping.prototype.checkFor = function () {
     hasBreak:    false,
   };
 
-  var forParent = this.forParent;
-
   traverse(this.block, function (node) {
     var replace;
 
-    if (t.isFunction(node) || t.isFor(node)) {
+    if (t.isFunction(node) || t.isLoop(node) || t.isSwitchStatement(node)) {
       return false;
     }
 
-    if (forParent && node && !node.label) {
+    if (node && !node.label) {
       if (t.isBreakStatement(node)) {
         has.hasBreak = true;
         replace = t.returnStatement(t.literal("break"));

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

@@ -5,10 +5,10 @@ exports.ImportDeclaration = function (node, parent, file) {
 
   if (node.specifiers.length) {
     _.each(node.specifiers, function (specifier) {
-      file.moduleFormatter.importSpecifier(specifier, node, nodes);
+      file.moduleFormatter.importSpecifier(specifier, node, nodes, parent);
     });
   } else {
-    file.moduleFormatter.import(node, nodes);
+    file.moduleFormatter.import(node, nodes, parent);
   }
 
   return nodes;
@@ -18,10 +18,10 @@ exports.ExportDeclaration = function (node, parent, file) {
   var nodes = [];
 
   if (node.declaration) {
-    file.moduleFormatter.export(node, nodes);
+    file.moduleFormatter.export(node, nodes, parent);
   } else {
     _.each(node.specifiers, function (specifier) {
-      file.moduleFormatter.exportSpecifier(specifier, node, nodes);
+      file.moduleFormatter.exportSpecifier(specifier, node, nodes, parent);
     });
   }
 

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

@@ -0,0 +1,4 @@
+exports.Property = function (node) {
+  if (!node.shorthand) return;
+  node.shorthand = false;
+};

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

@@ -0,0 +1,22 @@
+var t = require("../../types");
+
+exports.Function = function (node, parent, file) {
+  if (!node.rest) return;
+
+  var rest = node.rest;
+  delete node.rest;
+
+  t.ensureBlock(node);
+
+  var call = file.toArray(t.identifier("arguments"));
+
+  if (node.params.length) {
+    call.arguments.push(t.literal(node.params.length));
+  }
+
+  call._ignoreAliasFunctions = true;
+
+  node.body.body.unshift(t.variableDeclaration("var", [
+    t.variableDeclarator(rest, call)
+  ]));
+};

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

@@ -48,12 +48,15 @@ exports.ArrayExpression = function (node, parent, file) {
   var nodes = build(elements, file);
   var first = nodes.shift();
 
-  if (!nodes.length) return first;
+  if (!t.isArrayExpression(first)) {
+    nodes.unshift(first);
+    first = t.arrayExpression([]);
+  }
 
   return t.callExpression(t.memberExpression(first, t.identifier("concat")), nodes);
 };
 
-exports.CallExpression = function (node, parent, file) {
+exports.CallExpression = function (node, parent, file, scope) {
   var args = node.arguments;
   if (!hasSpread(args)) return;
 
@@ -61,7 +64,12 @@ exports.CallExpression = function (node, parent, file) {
 
   node.arguments = [];
 
-  var nodes = build(args, file);
+  var nodes;
+  if (args.length === 1 && args[0].argument.name === 'arguments') {
+    nodes = [args[0].argument];
+  } else {
+    nodes = build(args, file);
+  }
   var first = nodes.shift();
 
   if (nodes.length) {
@@ -71,10 +79,16 @@ exports.CallExpression = function (node, parent, file) {
   }
 
   var callee = node.callee;
+  var temp;
 
   if (t.isMemberExpression(callee)) {
     contextLiteral = callee.object;
 
+    if (t.isDynamic(contextLiteral)) {
+      temp = contextLiteral = scope.generateTemp(file);
+      callee.object = t.assignmentExpression("=", temp, callee.object);
+    }
+
     if (callee.computed) {
       callee.object = t.memberExpression(callee.object, callee.property, true);
       callee.property = t.identifier("apply");

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

@@ -31,7 +31,7 @@ exports.TemplateLiteral = function (node) {
   var nodes = [];
 
   _.each(node.quasis, function (elem) {
-    nodes.push(t.literal(elem.value.raw));
+    nodes.push(t.literal(elem.value.cooked));
 
     var expr = node.expressions.shift();
     if (expr) {

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

@@ -0,0 +1,98 @@
+// https://github.com/zenparsing/es-abstract-refs
+
+var util = require("../../util");
+var t    = require("../../types");
+
+var container = function (parent, call, ret) {
+  if (t.isExpressionStatement(parent)) {
+    // we don't need to worry about return values
+    return call;
+  } else {
+    var exprs = [];
+    if (t.isSequenceExpression(call)) {
+      exprs = call.expressions;
+    } else {
+      exprs.push(call);
+    }
+    exprs.push(ret);
+    return t.sequenceExpression(exprs);
+  }
+};
+
+exports.AssignmentExpression = function (node, parent, file, scope) {
+  var left = node.left;
+  if (!t.isVirtualPropertyExpression(left)) return;
+
+  var value = node.right;
+  var temp;
+
+  // we need to return `node.right`
+  if (!t.isExpressionStatement(parent)) {
+    // `node.right` isn't a simple identifier so we need to reference it
+    if (t.isDynamic(value)) {
+      temp = value = scope.generateTemp(file);
+    }
+  }
+
+  var call = util.template("abstract-expression-set", {
+    PROPERTY: left.property,
+    OBJECT:   left.object,
+    VALUE:    value
+  });
+
+  if (temp) {
+    call = t.sequenceExpression([
+      t.assignmentExpression("=", temp, node.right),
+      call
+    ]);
+  }
+
+  return container(parent, call, value);
+};
+
+exports.UnaryExpression = function (node, parent) {
+  var arg = node.argument;
+  if (!t.isVirtualPropertyExpression(arg)) return;
+  if (node.operator !== "delete") return;
+
+  var call = util.template("abstract-expression-delete", {
+    PROPERTY: arg.property,
+    OBJECT:   arg.object
+  });
+
+  return container(parent, call, t.literal(true));
+};
+
+exports.CallExpression = function (node, parent, file, scope) {
+  var callee = node.callee;
+  if (!t.isVirtualPropertyExpression(callee)) return;
+
+  var temp;
+  if (t.isDynamic(callee.object)) {
+    // we need to save `callee.object` so we can call it again
+    temp = scope.generateTemp(file);
+  }
+
+  var call = util.template("abstract-expression-call", {
+    PROPERTY: callee.property,
+    OBJECT:   temp || callee.object
+  });
+
+  call.arguments = call.arguments.concat(node.arguments);
+
+  if (temp) {
+    return t.sequenceExpression([
+      t.assignmentExpression("=", temp, callee.object),
+      call
+    ]);
+  } else {
+    return call;
+  }
+};
+
+exports.VirtualPropertyExpression = function (node) {
+  return util.template("abstract-expression-get", {
+    PROPERTY: node.property,
+    OBJECT:   node.object
+  });
+};

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

@@ -0,0 +1,16 @@
+// https://github.com/rwaldron/exponentiation-operator
+
+var t = require("../../types");
+var pow = t.memberExpression(t.identifier("Math"), t.identifier("pow"));
+
+exports.AssignmentExpression = function (node) {
+  if (node.operator !== "**=") return;
+  node.operator = "=";
+  node.right = t.callExpression(pow, [node.left, node.right]);
+};
+
+exports.BinaryExpression = function (node) {
+  if (node.operator !== "**") return;
+
+  return t.callExpression(pow, [node.left, node.right]);
+};

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

@@ -1,4 +1,4 @@
-var arrayComprehension = require("./array-comprehension");
+var arrayComprehension = require("./es7-array-comprehension");
 var t                  = require("../../types");
 
 exports.ComprehensionExpression = function (node) {

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

@@ -0,0 +1,41 @@
+// https://github.com/sebmarkbage/ecmascript-rest-spread
+
+var t = require("../../types");
+var _ = require("lodash");
+
+exports.ObjectExpression = function (node) {
+  var hasSpread = false;
+  _.each(node.properties, function (prop) {
+    if (t.isSpreadProperty(prop)) {
+      hasSpread = true;
+      return false;
+    }
+  });
+  if (!hasSpread) return;
+
+  var args = [];
+  var props = [];
+
+  var push = function () {
+    if (!props.length) return;
+    args.push(t.objectExpression(props));
+    props = [];
+  };
+
+  _.each(node.properties, function (prop) {
+    if (t.isSpreadProperty(prop)) {
+      push();
+      args.push(prop.argument);
+    } else {
+      props.push(prop);
+    }
+  });
+
+  push();
+
+  if (!t.isObjectExpression(args[0])) {
+    args.unshift(t.objectExpression([]));
+  }
+
+  return t.callExpression(t.memberExpression(t.identifier("Object"), t.identifier("assign")), args);
+};

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

@@ -0,0 +1,90 @@
+var t = require("../../types");
+
+var isMemo = function (node) {
+  var is = t.isAssignmentExpression(node) && node.operator === "?=";
+  if (is) t.assertMemberExpression(node.left);
+  return is;
+};
+
+var getPropRef = function (nodes, prop, file, scope) {
+  if (t.isIdentifier(prop)) {
+    return t.literal(prop.name);
+  } else {
+    var temp = file.generateUidIdentifier("propKey", scope);
+    nodes.push(t.variableDeclaration("var", [
+      t.variableDeclarator(temp, prop)
+    ]));
+    return temp;
+  }
+};
+
+var getObjRef = function (nodes, obj, file, scope) {
+  if (t.isDynamic(obj)) {
+    var temp = file.generateUidIdentifier("obj", scope);
+    nodes.push(t.variableDeclaration("var", [
+      t.variableDeclarator(temp, obj)
+    ]));
+    return temp;
+  } else {
+    return obj;
+  }
+};
+
+var buildHasOwn = function (obj, prop, file) {
+  return t.unaryExpression(
+    "!",
+    t.callExpression(
+      t.memberExpression(file.addDeclaration("has-own"), t.identifier("call")),
+      [obj, prop]
+    ),
+    true
+  );
+};
+
+var buildAbsoluteRef = function (left, obj, prop) {
+  var computed = left.computed || t.isLiteral(prop);
+  return t.memberExpression(obj, prop, computed);
+};
+
+var buildAssignment = function (expr, obj, prop) {
+  return t.assignmentExpression("=", buildAbsoluteRef(expr.left, obj, prop), expr.right);
+};
+
+exports.ExpressionStatement = function (node, parent, file, scope) {
+  var expr = node.expression;
+  if (!isMemo(expr)) return;
+
+  var nodes = [];
+
+  var left = expr.left;
+  var obj  = getObjRef(nodes, left.object, file, scope);
+  var prop = getPropRef(nodes, left.property, file, scope);
+
+  nodes.push(t.ifStatement(
+    buildHasOwn(obj, prop, file),
+    t.expressionStatement(buildAssignment(expr, obj, prop))
+  ));
+
+  return nodes;
+};
+
+exports.AssignmentExpression = function (node, parent, file, scope) {
+  if (t.isExpressionStatement(parent)) return;
+  if (!isMemo(node)) return;
+
+  var nodes = [];
+
+  var left = node.left;
+  var obj  = getObjRef(nodes, left.object, file, scope);
+  var prop = getPropRef(nodes, left.property, file, scope);
+
+  nodes.push(t.logicalExpression(
+    "&&",
+    buildHasOwn(obj, prop, file),
+    buildAssignment(node, obj, prop)
+  ));
+
+  nodes.push(buildAbsoluteRef(left, obj, prop));
+
+  return t.toSequenceExpression(nodes, scope);
+};

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

@@ -0,0 +1,48 @@
+var t = require("../../types");
+var _ = require("lodash");
+
+exports.BindMemberExpression = function (node, parent, file, scope) {
+  var object = node.object;
+  var prop   = node.property;
+
+  var temp;
+  if (t.isDynamic(object)) {
+    temp = object = scope.generateTemp(file);
+  }
+
+  var call = t.callExpression(
+    t.memberExpression(t.memberExpression(object, prop), t.identifier("bind")),
+    [object].concat(node.arguments)
+  );
+
+  if (temp) {
+    return t.sequenceExpression([
+      t.assignmentExpression("=", temp, node.object),
+      call
+    ]);
+  } else {
+    return call;
+  }
+};
+
+exports.BindFunctionExpression = function (node, parent, file, scope) {
+  var buildCall = function (args) {
+    var param = file.generateUidIdentifier("val", scope);
+    return t.functionExpression(null, [param], t.blockStatement([
+      t.returnStatement(t.callExpression(t.memberExpression(param, node.callee), args))
+    ]));
+  };
+
+  if (_.find(node.arguments, t.isDynamic)) {
+    var temp = scope.generateTemp(file, "args");
+
+    return t.sequenceExpression([
+      t.assignmentExpression("=", temp, t.arrayExpression(node.arguments)),
+      buildCall(node.arguments.map(function (node, i) {
+        return t.memberExpression(temp, t.literal(i), true);
+      }))
+    ]);
+  } else {
+    return buildCall(node.arguments);
+  }
+};

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

@@ -1,3 +0,0 @@
-exports.Property = function (node) {
-  if (node.shorthand) node.shorthand = false;
-};

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

@@ -132,6 +132,8 @@ exports.XJSElement = {
           }
         });
 
+        return;
+      } else if (t.isXJSEmptyExpression(child)) {
         return;
       }
 

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

@@ -1,24 +0,0 @@
-var util = require("../../util");
-var t    = require("../../types");
-
-exports.Function = function (node, parent, file) {
-  if (!node.rest) return;
-
-  var rest = node.rest;
-  delete node.rest;
-
-  var templateName = "arguments-slice-assign";
-  if (node.params.length) templateName += "-arg";
-
-  t.ensureBlock(node);
-
-  var template = util.template(templateName, {
-    SLICE_KEY: file.addDeclaration("slice"),
-    VARIABLE_NAME: rest,
-    SLICE_ARG: t.literal(node.params.length)
-  });
-
-  template.declarations[0].init.arguments[0]._ignoreAliasFunctions = true;
-
-  node.body.body.unshift(template);
-};

lib/6to5/traverse/index.js

@@ -50,6 +50,10 @@ function traverse(parent, callbacks, opts) {
         if (result != null) {
           updated = true;
           node = obj[key] = result;
+
+          if (_.isArray(result) && _.contains(t.STATEMENT_OR_BLOCK_KEYS, key) && !t.isBlockStatement(obj)) {
+            t.ensureBlock(obj, key);
+          }
         }
       };
 
@@ -90,6 +94,7 @@ function traverse(parent, callbacks, opts) {
 traverse.removeProperties = function (tree) {
   var clear = function (node) {
     delete node._scopeReferences;
+    delete node._declarations;
     delete node.extendedRange;
     delete node._parent;
     delete node._scope;

lib/6to5/traverse/scope.js

@@ -21,15 +21,28 @@ function Scope(block, parent) {
   this.references = this.getReferences();
 }
 
+Scope.add = function (node, references) {
+  if (!node) return;
+  _.defaults(references, t.getIds(node, true));
+};
+
+Scope.prototype.generateTemp = function (file, name) {
+    var id = file.generateUidIdentifier(name || "temp", this);
+    this.push({
+      key: id.name,
+      id: id
+    });
+    return id;
+};
+
 Scope.prototype.getReferences = function () {
   var block = this.block;
   if (block._scopeReferences) return block._scopeReferences;
 
-  var self       = this;
   var references = block._scopeReferences = {};
 
   var add = function (node) {
-    self.add(node, references);
+    Scope.add(node, references);
   };
 
   // ForStatement - left, init
@@ -97,9 +110,28 @@ Scope.prototype.getReferences = function () {
   return references;
 };
 
-Scope.prototype.add = function (node, references) {
-  if (!node) return;
-  _.merge(references || this.references, t.getIds(node, true));
+Scope.prototype.push = function (opts) {
+  var block = this.block;
+
+  if (t.isFor(block) || t.isCatchClause(block) || t.isFunction(block)) {
+    t.ensureBlock(block);
+    block = block.body;
+  }
+
+  if (t.isBlockStatement(block) || t.isProgram(block)) {
+    block._declarations = block._declarations || {};
+    block._declarations[opts.key] = {
+      kind: opts.kind,
+      id: opts.id,
+      init: opts.init
+    };
+  } else {
+    throw new TypeError("cannot add a declaration here in node type " + block.type);
+  }
+};
+
+Scope.prototype.add = function (node) {
+  Scope.add(node, this.references);
 };
 
 Scope.prototype.get = function (id) {

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

@@ -3,14 +3,14 @@
   "BreakStatement":      ["Statement"],
   "ContinueStatement":   ["Statement"],
   "DebuggerStatement":   ["Statement"],
-  "DoWhileStatement":    ["Statement"],
+  "DoWhileStatement":    ["Statement", "Loop", "With"],
   "IfStatement":         ["Statement"],
   "ReturnStatement":     ["Statement"],
   "SwitchStatement":     ["Statement"],
   "ThrowStatement":      ["Statement"],
   "TryStatement":        ["Statement"],
   "WhileStatement":      ["Statement"],
-  "WithStatement":       ["Statement"],
+  "WithStatement":       ["Statement", "Loop", "With"],
   "EmptyStatement":      ["Statement"],
   "LabeledStatement":    ["Statement"],
   "VariableDeclaration": ["Statement", "Declaration"],
@@ -35,9 +35,9 @@
   "ClassDeclaration": ["Statement", "Declaration", "Class"],
   "ClassExpression":  ["Class"],
 
-  "ForOfStatement": ["Statement", "For", "Scope"],
-  "ForInStatement": ["Statement", "For", "Scope"],
-  "ForStatement":   ["Statement", "For", "Scope"],
+  "ForOfStatement": ["Statement", "For", "Scope", "Loop"],
+  "ForInStatement": ["Statement", "For", "Scope", "Loop"],
+  "ForStatement":   ["Statement", "For", "Scope", "Loop"],
 
   "ObjectPattern": ["Pattern"],
   "ArrayPattern":  ["Pattern"],

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

@@ -11,6 +11,7 @@
   "Identifier":              ["name"],
   "IfStatement":             ["test", "consequent", "alternate"],
   "Literal":                 ["value"],
+  "LogicalExpression":       ["operator", "left", "right"],
   "MemberExpression":        ["object", "property", "computed"],
   "NewExpression":           ["callee", "arguments"],
   "ObjectExpression":        ["properties"],

lib/6to5/types/index.js

@@ -1,4 +1,5 @@
-var _ = require("lodash");
+var esutils = require("esutils");
+var _       = require("lodash");
 
 var t = exports;
 
@@ -11,6 +12,8 @@ var addAssert = function (type, is) {
   };
 };
 
+t.STATEMENT_OR_BLOCK_KEYS = ["consequent", "body"];
+
 //
 
 t.VISITOR_KEYS = require("./visitor-keys");
@@ -71,6 +74,31 @@ addAssert("Expression", t.isExpression);
 
 //
 
+t.toSequenceExpression = function (nodes, scope) {
+  var exprs = [];
+
+  _.each(nodes, function (node) {
+    if (t.isExpression(node)) {
+      exprs.push(node);
+    } if (t.isExpressionStatement(node)) {
+      exprs.push(node.expression);
+    } else if (t.isVariableDeclaration(node)) {
+      _.each(node.declarations, function (declar) {
+        scope.push({
+          kind: node.kind,
+          key: declar.id.name,
+          id: declar.id
+        });
+        exprs.push(t.assignmentExpression("=", declar.id, declar.init));
+      });
+    }
+  });
+
+  return t.sequenceExpression(exprs);
+};
+
+//
+
 t.shallowEqual = function (actual, expected) {
   var same = true;
 
@@ -87,6 +115,18 @@ t.shallowEqual = function (actual, expected) {
 
 //
 
+t.isDynamic = function (node) {
+  if (t.isParenthesizedExpression(node) || t.isExpressionStatement(node)) {
+    return t.isDynamic(node.expression);
+  } else if (t.isIdentifier(node) || t.isLiteral(node) || t.isThisExpression(node)) {
+    return false;
+  } else if (t.isMemberExpression(node)) {
+    return t.isDynamic(node.object) || t.isDynamic(node.property);
+  } else {
+    return true;
+  }
+};
+
 t.isReferenced = function (node, parent) {
   // we're a property key so we aren't referenced
   if (t.isProperty(parent) && parent.key === node) return false;
@@ -122,11 +162,16 @@ t.toIdentifier = function (name) {
     return c ? c.toUpperCase() : "";
   });
 
-  return name;
+  return name || '_';
 };
 
-t.ensureBlock = function (node) {
-  node.body = t.toBlock(node.body, node);
+t.isValidIdentifier = function (name) {
+  return _.isString(name) && esutils.keyword.isIdentifierName(name) && !esutils.keyword.isKeywordES6(name, true);
+};
+
+t.ensureBlock = function (node, key) {
+  key = key || "body";
+  node[key] = t.toBlock(node[key], node);
 };
 
 t.toStatement = function (node, ignore) {

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

@@ -1,76 +1,80 @@
 {
-  "ArrayExpression":          ["elements"],
-  "ArrayPattern":             ["elements"],
-  "ArrowFunctionExpression":  ["params", "defaults", "rest", "body"],
-  "AssignmentExpression":     ["left", "right"],
-  "AwaitExpression":          ["argument"],
-  "BinaryExpression":         ["left", "right"],
-  "BlockStatement":           ["body"],
-  "BreakStatement":           ["label"],
-  "CallExpression":           ["callee", "arguments"],
-  "CatchClause":              ["param", "body"],
-  "ClassBody":                ["body"],
-  "ClassDeclaration":         ["id", "body", "superClass"],
-  "ClassExpression":          ["id", "body", "superClass"],
-  "ComprehensionBlock":       ["left", "right", "body"],
-  "ComprehensionExpression":  ["filter", "blocks", "body"],
-  "ConditionalExpression":    ["test", "consequent", "alternate"],
-  "ContinueStatement":        ["label"],
-  "DebuggerStatement":        [],
-  "DoWhileStatement":         ["body", "test"],
-  "EmptyStatement":           [],
-  "ExportBatchSpecifier":     [],
-  "ExportDeclaration":        ["declaration", "specifiers", "source"],
-  "ExportSpecifier":          ["id", "name"],
-  "ExpressionStatement":      ["expression"],
-  "File":                     ["program"],
-  "ForInStatement":           ["left", "right", "body"],
-  "ForOfStatement":           ["left", "right", "body"],
-  "ForStatement":             ["init", "test", "update", "body"],
-  "FunctionDeclaration":      ["id", "params", "defaults", "rest", "body"],
-  "FunctionExpression":       ["id", "params", "defaults", "rest", "body"],
-  "Identifier":               [],
-  "IfStatement":              ["test", "consequent", "alternate"],
-  "ImportBatchSpecifier":     ["id"],
-  "ImportDeclaration":        ["specifiers", "source"],
-  "ImportSpecifier":          ["id", "name"],
-  "LabeledStatement":         ["label", "body"],
-  "Literal":                  [],
-  "LogicalExpression":        ["left", "right"],
-  "MemberExpression":         ["object", "property"],
-  "MethodDefinition":         ["key", "value"],
-  "NewExpression":            ["callee", "arguments"],
-  "ObjectExpression":         ["properties"],
-  "ObjectPattern":            ["properties"],
-  "ParenthesizedExpression":  ["expression"],
-  "Program":                  ["body"],
-  "Property":                 ["key", "value"],
-  "ReturnStatement":          ["argument"],
-  "SequenceExpression":       ["expressions"],
-  "SpreadElement":            ["argument"],
-  "SwitchCase":               ["test", "consequent"],
-  "SwitchStatement":          ["discriminant", "cases"],
-  "TaggedTemplateExpression": ["tag", "quasi"],
-  "TemplateElement":          [],
-  "TemplateLiteral":          ["quasis", "expressions"],
-  "ThisExpression":           [],
-  "ThrowStatement":           ["argument"],
-  "TryStatement":             ["block", "handlers", "handler", "guardedHandlers", "finalizer"],
-  "UnaryExpression":          ["argument"],
-  "UpdateExpression":         ["argument"],
-  "VariableDeclaration":      ["declarations"],
-  "VariableDeclarator":       ["id", "init"],
-  "WhileStatement":           ["test", "body"],
-  "WithStatement":            ["object", "body"],
-  "XJSAttribute":             ["name", "value"],
-  "XJSClosingElement":        ["name"],
-  "XJSElement":               ["openingElement", "closingElement", "children"],
-  "XJSEmptyExpression":       [],
-  "XJSExpressionContainer":   ["expression"],
-  "XJSIdentifier":            [],
-  "XJSMemberExpression":      ["object", "property"],
-  "XJSNamespacedName":        ["namespace", "name"],
-  "XJSOpeningElement":        ["name", "attributes"],
-  "XJSSpreadAttribute":       ["argument"],
-  "YieldExpression":          ["argument"]
+  "ArrayExpression":           ["elements"],
+  "ArrayPattern":              ["elements"],
+  "ArrowFunctionExpression":   ["params", "defaults", "rest", "body"],
+  "AssignmentExpression":      ["left", "right"],
+  "AwaitExpression":           ["argument"],
+  "BinaryExpression":          ["left", "right"],
+  "BindMemberExpression":      ["object", "property", "arguments"],
+  "BlockStatement":            ["body"],
+  "BreakStatement":            ["label"],
+  "CallExpression":            ["callee", "arguments"],
+  "CatchClause":               ["param", "body"],
+  "ClassBody":                 ["body"],
+  "ClassDeclaration":          ["id", "body", "superClass"],
+  "ClassExpression":           ["id", "body", "superClass"],
+  "ComprehensionBlock":        ["left", "right", "body"],
+  "ComprehensionExpression":   ["filter", "blocks", "body"],
+  "ConditionalExpression":     ["test", "consequent", "alternate"],
+  "ContinueStatement":         ["label"],
+  "DebuggerStatement":         [],
+  "DoWhileStatement":          ["body", "test"],
+  "EmptyStatement":            [],
+  "ExportBatchSpecifier":      [],
+  "ExportDeclaration":         ["declaration", "specifiers", "source"],
+  "ExportSpecifier":           ["id", "name"],
+  "ExpressionStatement":       ["expression"],
+  "File":                      ["program"],
+  "ForInStatement":            ["left", "right", "body"],
+  "ForOfStatement":            ["left", "right", "body"],
+  "ForStatement":              ["init", "test", "update", "body"],
+  "FunctionDeclaration":       ["id", "params", "defaults", "rest", "body"],
+  "FunctionExpression":        ["id", "params", "defaults", "rest", "body"],
+  "Identifier":                [],
+  "IfStatement":               ["test", "consequent", "alternate"],
+  "ImportBatchSpecifier":      ["id"],
+  "ImportDeclaration":         ["specifiers", "source"],
+  "ImportSpecifier":           ["id", "name"],
+  "LabeledStatement":          ["label", "body"],
+  "Literal":                   [],
+  "LogicalExpression":         ["left", "right"],
+  "MemberExpression":          ["object", "property"],
+  "MethodDefinition":          ["key", "value"],
+  "NewExpression":             ["callee", "arguments"],
+  "ObjectExpression":          ["properties"],
+  "ObjectPattern":             ["properties"],
+  "ParenthesizedExpression":   ["expression"],
+  "BindFunctionExpression":    ["callee", "arguments"],
+  "Program":                   ["body"],
+  "Property":                  ["key", "value"],
+  "ReturnStatement":           ["argument"],
+  "SequenceExpression":        ["expressions"],
+  "SpreadElement":             ["argument"],
+  "SpreadProperty":            ["argument"],
+  "SwitchCase":                ["test", "consequent"],
+  "SwitchStatement":           ["discriminant", "cases"],
+  "TaggedTemplateExpression":  ["tag", "quasi"],
+  "TemplateElement":           [],
+  "TemplateLiteral":           ["quasis", "expressions"],
+  "ThisExpression":            [],
+  "ThrowStatement":            ["argument"],
+  "TryStatement":              ["block", "handlers", "handler", "guardedHandlers", "finalizer"],
+  "UnaryExpression":           ["argument"],
+  "UpdateExpression":          ["argument"],
+  "VariableDeclaration":       ["declarations"],
+  "VariableDeclarator":        ["id", "init"],
+  "VirtualPropertyExpression": ["object", "property"],
+  "WhileStatement":            ["test", "body"],
+  "WithStatement":             ["object", "body"],
+  "XJSAttribute":              ["name", "value"],
+  "XJSClosingElement":         ["name"],
+  "XJSElement":                ["openingElement", "closingElement", "children"],
+  "XJSEmptyExpression":        [],
+  "XJSExpressionContainer":    ["expression"],
+  "XJSIdentifier":             [],
+  "XJSMemberExpression":       ["object", "property"],
+  "XJSNamespacedName":         ["namespace", "name"],
+  "XJSOpeningElement":         ["name", "attributes"],
+  "XJSSpreadAttribute":        ["argument"],
+  "YieldExpression":           ["argument"]
 }

lib/6to5/util.js

@@ -38,9 +38,9 @@ exports.list = function (val) {
 };
 
 exports.regexify = function (val) {
-  if (!val) return new RegExp;
+  if (!val) return new RegExp(/.^/);
   if (_.isArray(val)) val = val.join("|");
-  if (_.isString(val)) return new RegExp(val || "");
+  if (_.isString(val)) return new RegExp(val);
   if (_.isRegExp(val)) return val;
   throw new TypeError("illegal type for regexify");
 };
@@ -219,6 +219,7 @@ exports.parse = function (opts, code, callback) {
       allowReturnOutsideFunction: true,
       preserveParens:             true,
       ecmaVersion:                opts.experimental ? 7 : 6,
+      playground:                 opts.playground,
       strictMode:                 true,
       onComment:                  comments,
       locations:                  true,

package.json

@@ -1,7 +1,7 @@
 {
   "name": "6to5",
   "description": "Turn ES6 code into readable vanilla ES5 with source maps",
-  "version": "1.13.2",
+  "version": "1.14.14",
   "author": "Sebastian McKenzie <sebmck@gmail.com>",
   "homepage": "https://github.com/6to5/6to5",
   "repository": {
@@ -35,30 +35,31 @@
     "test": "make test"
   },
   "dependencies": {
+    "acorn-6to5": "0.9.1-11",
     "ast-types": "0.6.5",
+    "chokidar": "0.11.1",
     "commander": "2.5.0",
+    "es6-shim": "0.21.0",
+    "es6-symbol": "0.1.1",
+    "estraverse": "1.8.0",
+    "esutils": "1.1.6",
     "fs-readdir-recursive": "0.1.0",
     "lodash": "2.4.1",
     "mkdirp": "0.5.0",
-    "es6-shim": "0.20.3",
-    "es6-symbol": "0.1.1",
+    "private": "0.1.6",
     "regexpu": "0.3.0",
     "source-map": "0.1.40",
-    "chokidar": "0.11.1",
-    "source-map-support": "0.2.8",
-    "esutils": "1.1.4",
-    "acorn-6to5": "0.9.1-4",
-    "estraverse": "1.8.0",
-    "private": "0.1.6"
+    "source-map-support": "0.2.8"
   },
   "devDependencies": {
-    "istanbul": "0.3.2",
-    "matcha": "0.6.0",
-    "mocha": "2.0.1",
-    "uglify-js": "2.4.15",
     "browserify": "6.3.2",
-    "rimraf": "2.2.8",
+    "chai": "^1.9.2",
+    "istanbul": "0.3.2",
     "jshint": "2.5.10",
-    "chai": "^1.9.2"
+    "jshint-stylish": "^1.0.0",
+    "matcha": "0.6.0",
+    "mocha": "1.21.4",
+    "rimraf": "2.2.8",
+    "uglify-js": "2.4.15"
   }
 }

test/fixtures/bin/6to5/stdin --filename/stderr.txt

@@ -1 +1 @@
-SyntaxError: test.js: Unexpected character '@'
+SyntaxError: test.js: Unexpected character '#'

test/fixtures/bin/6to5/stdin --filename/stdin.txt

@@ -1,3 +1,3 @@
 arr.map(x => {
-  $@!
+  $#!
 });

test/fixtures/generation/types/SequenceExpression/expected.js

@@ -1,4 +1,3 @@
 foo, bar;
 
-foo,
-bar;
+foo, bar;

test/fixtures/generation/types/VirualPropertyExpression/actual.js

@@ -0,0 +1,3 @@
+foo::bar;
+foo::bar = baz;
+delete foo::bar;

test/fixtures/generation/types/VirualPropertyExpression/expected.js

@@ -0,0 +1,3 @@
+foo::bar;
+foo::bar = baz;
+delete foo::bar;