v1.12.2

CHANGELOG.md

@@ -1,3 +1,13 @@
+# 1.12.2
+
+ * Upgrade `matcha` to `0.6.0` and `browserify` to `6.3.2`.
+ * Add own `trimRight` helper instead of relying on the string instance method.
+ * Support JSX spreads that aren't the first.
+
+# 1.12.1
+
+ * Fix `this` and `arguments` mapping in the `_aliasFunctions` transformer.
+
 # 1.12.0
 
  * Combine `jsx` and `react` transformers to `react`.

FEATURES.md

@@ -6,6 +6,16 @@
 [for (i of [1, 2, 3]) i * i]; // [1, 4, 9]
 ```
 
+## Async functions
+
+```javascript
+async function chainAnimationsAsync(elem, animations) {
+  for (var anim of animations) {
+    await anim(elem);
+  }
+}
+```
+
 ## Arrow functions
 
 ```javascript

Makefile

@@ -6,7 +6,7 @@ MOCHA_CMD = node_modules/mocha/bin/_mocha
 
 export NODE_ENV = test
 
-.PHONY: clean test test-cov tlint est-travis test-appveyor test-browser publish bench build
+.PHONY: clean test test-cov test-clean lint test-travis test-spec test-browser publish bench build
 
 clean:
 	rm -rf coverage templates.json test/tmp dist
@@ -18,19 +18,23 @@ bench:
 lint:
 	$(JSHINT_CMD) lib bin benchmark/index.js
 
+test-clean:
+	rm -rf test/tmp
+
 test:
 	make lint
 	$(MOCHA_CMD)
+	make test-clean
 
 test-cov:
 	rm -rf coverage
 	node $(ISTANBUL_CMD) $(MOCHA_CMD) --
 
-test-appveyor:
+test-spec:
 	node $(ISTANBUL_CMD) $(MOCHA_CMD) -- --reporter spec
 
 test-travis:
-	make test-appveyor
+	make test-spec
 	if test -n "$$CODECLIMATE_REPO_TOKEN"; then codeclimate < coverage/lcov.info; fi
 
 test-browser:

README.md

@@ -49,11 +49,13 @@ It's as easy as:
 - [Caveats](#caveats)
 - [Polyfill](#polyfill)
 - [Optional runtime](#optional-runtime)
+- [React/JSX](#reactjsx)
 - [Differences](#differences)
 
 ## [Features](FEATURES.md)
 
  - [Array comprehension](FEATURES.md#array-comprehension)
+ - [Async functions](FEATURES.md#async-functions) via [regenerator](https://github.com/facebook/regenerator)
  - [Arrow functions](FEATURES.md#arrow-functions)
  - [Classes](FEATURES.md#classes)
  - [Computed property names](FEATURES.md#computed-property-names)
@@ -84,7 +86,10 @@ It's as easy as:
  - [Gulp](https://github.com/sindresorhus/gulp-6to5)
  - [Grunt](https://github.com/sindresorhus/grunt-6to5)
  - [Jade](https://github.com/Apoxx/jade-6to5)
+ - [Jest](https://github.com/6to5/6to5-jest)
  - [Karma](https://github.com/shuhei/karma-6to5-preprocessor)
+ - [Mocha](https://github.com/6to5/6to5-mocha)
+ - [Rails](https://github.com/6to5/6to5-rails)
  - [webpack](https://github.com/Couto/6to5-loader)
 
 ### CLI
@@ -401,6 +406,14 @@ require("6to5").runtime("myCustomNamespace");
 See [Options - runtime](#options) for documentation on changing the reference in
 generated code.
 
+## React/JSX
+
+6to5 has built-in support for React v0.12. Tags are automatically transformed to
+their equivalent `React.createElement(...)` and `displayName` is automatically
+inferred and added to all `React.createClass` calls.
+
+To disable this behaviour add `react` to your blacklist.
+
 ## Differences
 
 ### Philosophy

appveyor.yml

@@ -10,7 +10,7 @@ install:
 test_script:
  - "node --version"
  - "npm --version"
- - "make test-appveyor"
+ - "make test-spec"
 
 build: "off"
 

lib/6to5/generation/buffer.js

@@ -0,0 +1,123 @@
+module.exports = Buffer;
+
+var util = require("../util");
+var _    = require("lodash");
+
+function Buffer(position, format) {
+  this.position = position;
+  this._indent  = format.indent.base;
+  this.format   = format;
+  this.buf      = "";
+}
+
+Buffer.prototype.get = function () {
+  return util.trimRight(this.buf);
+};
+
+Buffer.prototype.getIndent = function () {
+  if (this.format.compact) {
+    return "";
+  } else {
+    return util.repeat(this._indent, this.format.indent.style);
+  }
+};
+
+Buffer.prototype.indentSize = function () {
+  return this.getIndent().length;
+};
+
+Buffer.prototype.indent = function () {
+  this._indent++;
+};
+
+Buffer.prototype.dedent = function () {
+  this._indent--;
+};
+
+Buffer.prototype.semicolon = function () {
+  if (this.format.semicolons) this.push(";");
+};
+
+Buffer.prototype.ensureSemicolon = function () {
+  if (!this.isLast(";")) this.semicolon();
+};
+
+Buffer.prototype.rightBrace = function () {
+  this.newline(true);
+  this.push("}");
+};
+
+Buffer.prototype.keyword = function (name) {
+  this.push(name);
+  this.push(" ");
+};
+
+Buffer.prototype.space = function () {
+  if (this.buf && !this.isLast([" ", "\n"])) {
+    this.push(" ");
+  }
+};
+
+Buffer.prototype.removeLast = function (cha) {
+  if (!this.isLast(cha)) return;
+
+  this.buf = this.buf.slice(0, -1);
+  this.position.unshift(cha);
+};
+
+Buffer.prototype.newline = function (i, removeLast) {
+  if (!this.buf) return;
+  if (this.format.compact) return;
+  if (this.endsWith("{\n")) return;
+
+  if (_.isBoolean(i)) {
+    removeLast = i;
+    i = null;
+  }
+
+  if (_.isNumber(i)) {
+    var self = this;
+    _.times(i, function () {
+      self.newline(null, removeLast);
+    });
+    return;
+  }
+
+  if (removeLast && this.isLast("\n")) this.removeLast("\n");
+
+  this.removeLast(" ");
+  this.buf = this.buf.replace(/\n(\s+)$/, "\n");
+  this._push("\n");
+};
+
+Buffer.prototype.push = function (str, noIndent) {
+  if (this._indent && !noIndent && str !== "\n") {
+    // we have an indent level and we aren't pushing a newline
+    var indent = this.getIndent();
+
+    // replace all newlines with newlines with the indentation
+    str = str.replace(/\n/g, "\n" + indent);
+
+    // we've got a newline before us so prepend on the indentation
+    if (this.isLast("\n")) str = indent + str;
+  }
+
+  this._push(str);
+};
+
+Buffer.prototype._push = function (str) {
+  this.position.push(str);
+  this.buf += str;
+};
+
+Buffer.prototype.endsWith = function (str) {
+  return this.buf.slice(-str.length) === str;
+};
+
+Buffer.prototype.isLast = function (cha, trimRight) {
+  var buf = this.buf;
+  if (trimRight) buf = util.trimRight(buf);
+
+  var chars = [].concat(cha);
+  return _.contains(chars, _.last(buf));
+};

lib/6to5/generation/generator.js

@@ -8,6 +8,7 @@ module.exports.CodeGenerator = CodeGenerator;
 var Whitespace = require("./whitespace");
 var SourceMap  = require("./source-map");
 var Position   = require("./position");
+var Buffer     = require("./buffer");
 var util       = require("../util");
 var n          = require("./node");
 var t          = require("../types");
@@ -18,18 +19,21 @@ function CodeGenerator(ast, opts, code) {
 
   this.comments = ast.comments || [];
   this.tokens   = ast.tokens || [];
-  this.opts     = opts;
+  this.format   = CodeGenerator.normaliseOptions(opts);
   this.ast      = ast;
-  this.buf      = "";
-
-  this.format  = CodeGenerator.normaliseOptions(opts);
-  this._indent = this.format.indent.base;
 
   this.whitespace = new Whitespace(this.tokens, this.comments);
   this.position   = new Position;
   this.map        = new SourceMap(this.position, opts, code);
+  this.buffer     = new Buffer(this.position, this.format);
 }
 
+_.each(Buffer.prototype, function (fn, key) {
+  CodeGenerator.prototype[key] = function () {
+    return fn.apply(this.buffer, arguments);
+  };
+});
+
 CodeGenerator.normaliseOptions = function (opts) {
   opts = opts.format || {};
 
@@ -65,125 +69,15 @@ _.each(CodeGenerator.generators, function (generator) {
   _.extend(CodeGenerator.prototype, generator);
 });
 
-CodeGenerator.prototype.newline = function (i, removeLast) {
-  if (!this.buf) return;
-  if (this.format.compact) return;
-  if (this.endsWith("{\n")) return;
-
-  if (_.isBoolean(i)) {
-    removeLast = i;
-    i = null;
-  }
-
-  if (_.isNumber(i)) {
-    var self = this;
-    _.times(i, function () {
-      self.newline(null, removeLast);
-    });
-    return;
-  }
-
-  if (removeLast && this.isLast("\n")) this.removeLast("\n");
-
-  this.removeLast(" ");
-  this.buf = this.buf.replace(/\n(\s+)$/, "\n");
-  this._push("\n");
-};
-
-CodeGenerator.prototype.removeLast = function (cha) {
-  if (!this.isLast(cha)) return;
-
-  this.buf = this.buf.slice(0, -1);
-  this.position.unshift(cha);
-};
-
-CodeGenerator.prototype.semicolon = function () {
-  if (this.format.semicolons) this.push(";");
-};
-
-CodeGenerator.prototype.ensureSemicolon = function () {
-  if (!this.isLast(";")) this.semicolon();
-};
-
-CodeGenerator.prototype.rightBrace = function () {
-  this.newline(true);
-  this.push("}");
-};
-
-CodeGenerator.prototype.keyword = function (name) {
-  this.push(name);
-  this.push(" ");
-};
-
-CodeGenerator.prototype.space = function () {
-  if (this.buf && !this.isLast([" ", "\n"])) {
-    this.push(" ");
-  }
-};
-
-CodeGenerator.prototype.push = function (str, noIndent) {
-  if (this._indent && !noIndent && str !== "\n") {
-    // we have an indent level and we aren't pushing a newline
-    var indent = this.getIndent();
-
-    // replace all newlines with newlines with the indentation
-    str = str.replace(/\n/g, "\n" + indent);
-
-    // we've got a newline before us so prepend on the indentation
-    if (this.isLast("\n")) str = indent + str;
-  }
-
-  this._push(str);
-};
-
-CodeGenerator.prototype._push = function (str) {
-  this.position.push(str);
-  this.buf += str;
-};
-
-CodeGenerator.prototype.endsWith = function (str) {
-  return this.buf.slice(-str.length) === str;
-};
-
-CodeGenerator.prototype.isLast = function (cha, trimRight) {
-  var buf = this.buf;
-  if (trimRight) buf = buf.trimRight();
-
-  var chars = [].concat(cha);
-  return _.contains(chars, _.last(buf));
-};
-
-CodeGenerator.prototype.getIndent = function () {
-  if (this.format.compact) {
-    return "";
-  } else {
-    return util.repeat(this._indent, this.format.indent.style);
-  }
-};
-
-CodeGenerator.prototype.indentSize = function () {
-  return this.getIndent().length;
-};
-
-CodeGenerator.prototype.indent = function () {
-  this._indent++;
-};
-
-CodeGenerator.prototype.dedent = function () {
-  this._indent--;
-};
-
 CodeGenerator.prototype.generate = function () {
   var ast = this.ast;
 
   this.print(ast);
 
-  this.buf = this.buf.trimRight();
-
   return {
     map:  this.map.get(),
     ast:  ast,
-    code: this.buf
+    code: this.buffer.get()
   };
 };
 

lib/6to5/generation/node.js

@@ -1,294 +0,0 @@
-module.exports = Node;
-
-var t = require("../types");
-var _ = require("lodash");
-
-function Node(node, parent) {
-  this.parent = parent;
-  this.node   = node;
-}
-
-//
-
-Node.whitespace = {
-  FunctionExpression: 1,
-  FunctionStatement: 1,
-  ClassExpression: 1,
-  ClassStatement: 1,
-  ForOfStatement: 1,
-  ForInStatement: 1,
-  ForStatement: 1,
-  SwitchStatement: 1,
-  IfStatement: { before: 1 },
-  //Property: { before: 1 },
-  Literal: { after: 1 }
-};
-
-_.each(Node.whitespace, function (amounts, type) {
-  if (_.isNumber(amounts)) amounts = { after: amounts, before: amounts };
-  Node.whitespace[type] = amounts;
-});
-
-//
-
-Node.PRECEDENCE = {};
-
-_.each([
-  ["||"],
-  ["&&"],
-  ["|"],
-  ["^"],
-  ["&"],
-  ["==", "===", "!=", "!=="],
-  ["<", ">", "<=", ">=", "in", "instanceof"],
-  [">>", "<<", ">>>"],
-  ["+", "-"],
-  ["*", "/", "%"]
-], function (tier, i) {
-  _.each(tier, function (op) {
-    Node.PRECEDENCE[op] = i;
-  });
-});
-
-//
-
-Node.prototype.isUserWhitespacable = function () {
-  //var parent = this.parent;
-  var node = this.node;
-
-  if (t.isUserWhitespacable(node)) {
-    return true;
-  }
-
-  //if (t.isArrayExpression(parent)) {
-  //  return true;
-  //}
-
-  return false;
-};
-
-Node.prototype.needsWhitespace = function (type) {
-  var parent = this.parent;
-  var node   = this.node;
-  if (!node) return 0;
-
-  if (t.isExpressionStatement(node)) {
-    node = node.expression;
-  }
-
-  if (type === "before") {
-    if (t.isProperty(node) && parent.properties[0] === node) {
-      return 1;
-    }
-
-    if (t.isSwitchCase(node) && parent.cases[0] === node) {
-      return 1;
-    }
-  }
-
-  if (type === "after") {
-    if (t.isCallExpression(node)) {
-      return 1;
-    }
-
-    var exprs = [];
-
-    if (t.isVariableDeclaration(node)) {
-      exprs = _.map(node.declarations, "init");
-    }
-
-    if (t.isArrayExpression(node)) {
-      exprs = node.elements;
-    }
-
-    if (t.isObjectExpression(node)) {
-      exprs = node.properties;
-    }
-
-    var lines = 0;
-
-    _.each(exprs, function (expr) {
-      lines = Node.needsWhitespace(expr, node, type);
-      if (lines) return false;
-    });
-
-    if (lines) return lines;
-  }
-
-  if (t.isCallExpression(node) && t.isFunction(node.callee)) {
-    return 1;
-  }
-
-  var opts = Node.whitespace[node.type];
-  return (opts && opts[type]) || 0;
-};
-
-Node.prototype.needsWhitespaceBefore = function () {
-  return this.needsWhitespace("before");
-};
-
-Node.prototype.needsWhitespaceAfter = function () {
-  return this.needsWhitespace("after");
-};
-
-Node.prototype.needsParens = function () {
-  var parent = this.parent;
-  var node = this.node;
-
-  if (!parent) return false;
-
-  //
-  if (t.isUnaryLike(node)) {
-    return t.isMemberExpression(parent) && parent.object === node;
-  }
-
-  if (t.isBinary(node)) {
-    //
-    if (t.isCallExpression(parent) && parent.callee === node) {
-      return true;
-    }
-
-    //
-    if (t.isUnaryLike(parent)) {
-      return true;
-    }
-
-    //
-    if (t.isMemberExpression(parent) && parent.object === node) {
-      return true;
-    }
-
-    if (t.isBinary(parent)) {
-      var parentOp  = parent.operator;
-      var parentPos = Node.PRECEDENCE[parentOp];
-
-      var nodeOp = node.operator;
-      var nodePos = Node.PRECEDENCE[nodeOp];
-
-      if (parentPos > nodePos) {
-        return true;
-      }
-
-      if (parentPos === nodePos && parent.right === node) {
-        return true;
-      }
-    }
-  }
-
-  if (t.isBinaryExpression(node) && node.operator === "in") {
-    // var i = (1 in []);
-    if (t.isVariableDeclarator(parent)) {
-      return true;
-    }
-
-    // for ((1 in []);;);
-    if (t.isFor(parent)) {
-      return true;
-    }
-  }
-
-  // (class {});
-  if (t.isClassExpression(node) && t.isExpressionStatement(parent)) {
-    return true;
-  }
-
-  if (t.isSequenceExpression(node)) {
-    if (t.isForStatement(parent)) {
-      // Although parentheses wouldn't hurt around sequence
-      // expressions in the head of for loops, traditional style
-      // dictates that e.g. i++, j++ should not be wrapped with
-      // parentheses.
-      return false;
-    }
-
-    if (t.isExpressionStatement(parent) && parent.expression === node) {
-      return false;
-    }
-
-    // Otherwise err on the side of overparenthesization, adding
-    // explicit exceptions above if this proves overzealous.
-    return true;
-  }
-
-  //
-  if (t.isYieldExpression(node)) {
-    return t.isBinary(parent) ||
-           t.isUnaryLike(parent) ||
-           t.isCallExpression(parent) ||
-           t.isMemberExpression(parent) ||
-           t.isNewExpression(parent) ||
-           t.isConditionalExpression(parent) ||
-           t.isYieldExpression(parent);
-  }
-
-  if (t.isNewExpression(parent) && parent.callee === node) {
-    return t.isCallExpression(node) || _.some(node, function (val) {
-      return t.isCallExpression(val);
-    });
-  }
-
-  // (1).valueOf()
-  if (t.isLiteral(node) && _.isNumber(node.value) && t.isMemberExpression(parent) && parent.object === node) {
-    return true;
-  }
-
-  if (t.isAssignmentExpression(node) || t.isConditionalExpression(node)) {
-    //
-    if (t.isUnaryLike(parent)) {
-      return true;
-    }
-
-    //
-    if (t.isBinary(parent)) {
-      return true;
-    }
-
-    //
-    if (t.isCallExpression(parent) && parent.callee === node) {
-      return true;
-    }
-
-    //
-    if (t.isConditionalExpression(parent) && parent.test === node) {
-      return true;
-    }
-
-    //
-    if (t.isMemberExpression(parent) && parent.object === node) {
-      return true;
-    }
-  }
-
-  if (t.isFunctionExpression(node)) {
-    // function () {};
-    if (t.isExpressionStatement(parent)) {
-      return true;
-    }
-
-    // (function test() {}).name;
-    if (t.isMemberExpression(parent) && parent.object === node) {
-      return true;
-    }
-
-    // (function () {})();
-    if (t.isCallExpression(parent) && parent.callee === node) {
-      return true;
-    }
-  }
-
-  // ({ x, y }) = { x: 5, y: 6 };
-  if (t.isObjectPattern(node) && t.isAssignmentExpression(parent) && parent.left == node) {
-    return true;
-  }
-
-  return false;
-};
-
-_.each(Node.prototype, function (fn, key) {
-  Node[key] = function (node, parent) {
-    var n = new Node(node, parent);
-
-    var args = _.toArray(arguments).slice(2);
-    return n[key].apply(n, args);
-  };
-});

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

@@ -0,0 +1,90 @@
+module.exports = Node;
+
+var whitespace = require("./whitespace");
+var parens     = require("./parentheses");
+var t           = require("../../types");
+var _           = require("lodash");
+
+var find = function (obj, node, parent) {
+  var result;
+
+  _.each(obj, function (fn, type) {
+    if (t["is" + type](node)) {
+      result = fn(node, parent);
+      if (result != null) return false;
+    }
+  });
+
+  return result;
+};
+
+function Node(node, parent) {
+  this.parent = parent;
+  this.node   = node;
+}
+
+Node.prototype.isUserWhitespacable = function () {
+  //var parent = this.parent;
+  var node = this.node;
+
+  if (t.isUserWhitespacable(node)) {
+    return true;
+  }
+
+  //if (t.isArrayExpression(parent)) {
+  //  return true;
+  //}
+
+  return false;
+};
+
+Node.prototype.needsWhitespace = function (type) {
+  var parent = this.parent;
+  var node   = this.node;
+  if (!node) return 0;
+
+  if (t.isExpressionStatement(node)) {
+    node = node.expression;
+  }
+
+  var lines = find(whitespace[type].nodes, node, parent);
+  if (lines) return lines;
+
+  _.each(find(whitespace[type].list, node, parent), function (expr) {
+    lines = Node.needsWhitespace(expr, node, type);
+    if (lines) return false;
+  });
+  return lines || 0;
+};
+
+Node.prototype.needsWhitespaceBefore = function () {
+  return this.needsWhitespace("before");
+};
+
+Node.prototype.needsWhitespaceAfter = function () {
+  return this.needsWhitespace("after");
+};
+
+Node.prototype.needsParens = function () {
+  var parent = this.parent;
+  var node   = this.node;
+
+  if (!parent) return false;
+
+  if (t.isNewExpression(parent) && parent.callee === node) {
+    return t.isCallExpression(node) || _.some(node, function (val) {
+      return t.isCallExpression(val);
+    });
+  }
+
+  return find(parens, node, parent);
+};
+
+_.each(Node.prototype, function (fn, key) {
+  Node[key] = function (node, parent) {
+    var n = new Node(node, parent);
+
+    var args = _.toArray(arguments).slice(2);
+    return n[key].apply(n, args);
+  };
+});

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

@@ -0,0 +1,150 @@
+var t = require("../../types");
+var _ = require("lodash");
+
+var PRECEDENCE = {};
+
+_.each([
+  ["||"],
+  ["&&"],
+  ["|"],
+  ["^"],
+  ["&"],
+  ["==", "===", "!=", "!=="],
+  ["<", ">", "<=", ">=", "in", "instanceof"],
+  [">>", "<<", ">>>"],
+  ["+", "-"],
+  ["*", "/", "%"]
+], function (tier, i) {
+  _.each(tier, function (op) {
+    PRECEDENCE[op] = i;
+  });
+});
+
+exports.Binary = function (node, parent) {
+  if (t.isCallExpression(parent) && parent.callee === node) {
+    return true;
+  }
+
+  if (t.isUnaryLike(parent)) {
+    return true;
+  }
+
+  if (t.isMemberExpression(parent) && parent.object === node) {
+    return true;
+  }
+
+  if (t.isBinary(parent)) {
+    var parentOp  = parent.operator;
+    var parentPos = PRECEDENCE[parentOp];
+
+    var nodeOp = node.operator;
+    var nodePos = PRECEDENCE[nodeOp];
+
+    if (parentPos > nodePos) {
+      return true;
+    }
+
+    if (parentPos === nodePos && parent.right === node) {
+      return true;
+    }
+  }
+};
+
+exports.BinaryExpression = function (node, parent) {
+  if (node.operator === "in") {
+    // var i = (1 in []);
+    if (t.isVariableDeclarator(parent)) {
+      return true;
+    }
+
+    // for ((1 in []);;);
+    if (t.isFor(parent)) {
+      return true;
+    }
+  }
+};
+
+exports.SequenceExpression = function (node, parent) {
+  if (t.isForStatement(parent)) {
+    // Although parentheses wouldn't hurt around sequence
+    // expressions in the head of for loops, traditional style
+    // dictates that e.g. i++, j++ should not be wrapped with
+    // parentheses.
+    return false;
+  }
+
+  if (t.isExpressionStatement(parent) && parent.expression === node) {
+    return false;
+  }
+
+  // Otherwise err on the side of overparenthesization, adding
+  // explicit exceptions above if this proves overzealous.
+  return true;
+};
+
+exports.YieldExpression = function (node, parent) {
+  return t.isBinary(parent) ||
+         t.isUnaryLike(parent) ||
+         t.isCallExpression(parent) ||
+         t.isMemberExpression(parent) ||
+         t.isNewExpression(parent) ||
+         t.isConditionalExpression(parent) ||
+         t.isYieldExpression(parent);
+};
+
+exports.Literal = function (node, parent) {
+  // (1).valueOf()
+  if (_.isNumber(node.value) && t.isMemberExpression(parent) && parent.object === node) {
+    return true;
+  }
+};
+
+exports.ClassExpression = function (node, parent) {
+  return t.isExpressionStatement(parent);
+};
+
+exports.UnaryLike = function (node, parent) {
+  return t.isMemberExpression(parent) && parent.object === node;
+};
+
+exports.FunctionExpression = function (node, parent) {
+  // function () {};
+  if (t.isExpressionStatement(parent)) {
+    return true;
+  }
+
+  // (function test() {}).name;
+  if (t.isMemberExpression(parent) && parent.object === node) {
+    return true;
+  }
+
+  // (function () {})();
+  if (t.isCallExpression(parent) && parent.callee === node) {
+    return true;
+  }
+};
+
+exports.AssignmentExpression =
+exports.ConditionalExpression = function (node, parent) {
+  if (t.isUnaryLike(parent)) {
+    return true;
+  }
+
+  if (t.isBinary(parent)) {
+    return true;
+  }
+
+  if (t.isCallExpression(parent) && parent.callee === node) {
+    return true;
+  }
+
+  if (t.isConditionalExpression(parent) && parent.test === node) {
+    return true;
+  }
+
+  if (t.isMemberExpression(parent) && parent.object === node) {
+    return true;
+  }
+
+  return false;
+};

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

@@ -0,0 +1,60 @@
+var _ = require("lodash");
+var t = require("../../types");
+
+exports.before = {
+  nodes: {
+    Property: function (node, parent) {
+      if (parent.properties[0] === node) {
+        return 1;
+      }
+    },
+
+    SwitchCase: function (node, parent) {
+      if (parent.cases[0] === node) {
+        return 1;
+      }
+    },
+
+    CallExpression: function (node) {
+      if (t.isFunction(node.callee)) {
+        return 1;
+      }
+    }
+  }
+};
+
+exports.after = {
+  nodes: {},
+
+  list: {
+    VariableDeclaration: function (node) {
+      return _.map(node.declarations, "init");
+    },
+
+    ArrayExpression: function (node) {
+      return node.elements;
+    },
+
+    ObjectExpression: function (node) {
+      return node.properties;
+    }
+  }
+};
+
+_.each({
+  Function: 1,
+  Class: 1,
+  For: 1,
+  SwitchStatement: 1,
+  IfStatement: { before: 1 },
+  CallExpression: { after: 1 },
+  Literal: { after: 1 }
+}, function (amounts, type) {
+  if (_.isNumber(amounts)) amounts = { after: amounts, before: amounts };
+
+  _.each(amounts, function (amount, key) {
+    exports[key].nodes[type] = function () {
+      return amount;
+    };
+  });
+});

lib/6to5/transformation/transform.js

@@ -46,7 +46,6 @@ _.each({
   letScoping:               require("./transformers/let-scoping"),
   forOf:                    require("./transformers/for-of"),
   unicodeRegex:             require("./transformers/unicode-regex"),
-  numericLiterals:          require("./transformers/numeric-literals"),
 
   react:                    require("./transformers/react"),
 

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

@@ -14,10 +14,9 @@ var go = function (getBody, node, file, scope) {
   };
 
   // traverse the function and find all alias functions so we can alias
-  // arguments and this if necessary
+  // `arguments` and `this` if necessary
   traverse(node, function (node) {
-    var _aliasFunction = node._aliasFunction;
-    if (!_aliasFunction) {
+    if (!node._aliasFunction) {
       if (t.isFunction(node)) {
         // stop traversal of this node as it'll be hit again by this transformer
         return false;
@@ -26,12 +25,10 @@ var go = function (getBody, node, file, scope) {
       }
     }
 
-    // traverse all child nodes of this function and find arguments and this
+    // traverse all child nodes of this function and find `arguments` and `this`
     traverse(node, function (node, parent) {
-      if (_aliasFunction === "arrows") {
-        if (t.isFunction(node) && node._aliasFunction !== "arrows") {
-          return false;
-        }
+      if (t.isFunction(node) && !node._aliasFunction) {
+        return false;
       }
 
       if (node._ignoreAliasFunctions) return;

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

@@ -1,5 +1,6 @@
 var util = require("../../util");
 var t    = require("../../types");
+var _    = require("lodash");
 
 var singleArrayExpression = function (node) {
   var block = node.blocks[0];
@@ -13,7 +14,13 @@ var singleArrayExpression = function (node) {
     ARRAY:     block.right,
     KEY:       block.left
   });
-  result._aliasFunction = true;
+
+  _.each([result.callee.object, result], function (call) {
+    if (t.isCallExpression(call)) {
+      call.arguments[0]._aliasFunction = true;
+    }
+  });
+
   return result;
 };
 
@@ -23,7 +30,7 @@ var multiple = function (node, file) {
   var container = util.template("array-comprehension-container", {
     KEY: uid
   });
-  container._aliasFunction = true;
+  container.callee.expression._aliasFunction = true;
 
   var block = container.callee.expression.body;
   var body  = block.body;

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

@@ -3,7 +3,7 @@ var t = require("../../types");
 exports.ArrowFunctionExpression = function (node) {
   t.ensureBlock(node);
 
-  node._aliasFunction = "arrows";
+  node._aliasFunction = true;
   node.expression = false;
   node.type = "FunctionExpression";
 

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

@@ -5,12 +5,12 @@ var _        = require("lodash");
 
 exports.ClassDeclaration = function (node, parent, file, scope) {
   return t.variableDeclaration("var", [
-    t.variableDeclarator(node.id, buildClass(node, file, scope))
+    t.variableDeclarator(node.id, new Class(node, file, scope).run())
   ]);
 };
 
 exports.ClassExpression = function (node, parent, file, scope) {
-  return buildClass(node, file, scope);
+  return new Class(node, file, scope).run();
 };
 
 var getMemberExpressionObject = function (node) {
@@ -20,31 +20,59 @@ var getMemberExpressionObject = function (node) {
   return node;
 };
 
-var buildClass = function (node, file, scope) {
-  var superName = node.superClass;
-  var className = node.id || t.identifier(file.generateUid("class", scope));
+/**
+ * Description
+ *
+ * @param {Node} node
+ * @param {File} file
+ * @param {Scope} scope
+ */
 
-  var superClassArgument = node.superClass;
-  var superClassCallee   = node.superClass;
+function Class(node, file, scope) {
+  this.scope = scope;
+  this.node  = node;
+  this.file  = file;
+
+  this.instanceMutatorMap = {};
+  this.staticMutatorMap   = {};
+  this.hasConstructor     = false;
+  this.className          = node.id || t.identifier(file.generateUid("class", scope));
+  this.superName          = node.superClass;
+}
+
+/**
+ * Description
+ *
+ * @returns {Array}
+ */
+
+Class.prototype.run = function () {
+  var superClassArgument = this.superName;
+  var superClassCallee   = this.superName;
+  var superName          = this.superName;
+  var className          = this.className;
+  var file               = this.file;
 
   if (superName) {
     if (t.isMemberExpression(superName)) {
       superClassArgument = superClassCallee = getMemberExpressionObject(superName);
     } else if (!t.isIdentifier(superName)) {
       superClassArgument = superName;
-      superClassCallee   = superName = t.identifier(file.generateUid("ref", scope));
+      superClassCallee   = superName = t.identifier(file.generateUid("ref", this.scope));
     }
   }
 
+  this.superName = superName;
+
   var container = util.template("class", {
     CLASS_NAME: className
   });
 
   var block       = container.callee.expression.body;
-  var body        = block.body;
-  var constructor = body[0].declarations[0].init;
+  var body        = this.body = block.body;
+  var constructor = this.constructor = body[0].declarations[0].init;
 
-  if (node.id) constructor.id = className;
+  if (this.node.id) constructor.id = className;
 
   var returnStatement = body.pop();
 
@@ -55,14 +83,7 @@ var buildClass = function (node, file, scope) {
     container.callee.expression.params.push(superClassCallee);
   }
 
-  buildClassBody({
-    file:        file,
-    body:        body,
-    node:        node,
-    className:   className,
-    superName:   superName,
-    constructor: constructor,
-  });
+  this.buildBody();
 
   if (body.length === 1) {
     // only a constructor so no need for a closure container
@@ -73,49 +94,29 @@ var buildClass = function (node, file, scope) {
   }
 };
 
-var buildClassBody = function (opts) {
-  var file        = opts.file;
-  var body        = opts.body;
-  var node        = opts.node;
-  var constructor = opts.constructor;
-  var className   = opts.className;
-  var superName   = opts.superName;
+/**
+ * Description
+ */
 
-  var instanceMutatorMap = {};
-  var staticMutatorMap   = {};
-  var hasConstructor     = false;
-
-  var classBody = node.body.body;
+Class.prototype.buildBody = function () {
+  var constructor = this.constructor;
+  var className   = this.className;
+  var superName   = this.superName;
+  var classBody   = this.node.body.body;
+  var body        = this.body;
+  var self        = this;
 
   _.each(classBody, function (node) {
-    var methodName = node.key;
-    var method     = node.value;
-
-    replaceInstanceSuperReferences(superName, node);
+    self.replaceInstanceSuperReferences(node);
 
     if (node.key.name === "constructor") {
-      if (node.kind === "") {
-        hasConstructor = true;
-        addConstructor(constructor, method);
-      } else {
-        throw file.errorWithNode(node, "illegal kind for constructor method");
-      }
+      self.pushConstructor(node);
     } else {
-      var mutatorMap = instanceMutatorMap;
-      if (node.static) mutatorMap = staticMutatorMap;
-
-      var kind = node.kind;
-
-      if (kind === "") {
-        kind = "value";
-        util.pushMutatorMap(mutatorMap, methodName, "writable", t.identifier("true"));
-      }
-
-      util.pushMutatorMap(mutatorMap, methodName, kind, node);
+      self.pushMethod(node);
     }
   });
 
-  if (!hasConstructor && superName) {
+  if (!this.hasConstructor && superName) {
     constructor.body.body.push(util.template("class-super-constructor-call", {
       SUPER_NAME: superName
     }, true));
@@ -124,16 +125,16 @@ var buildClassBody = function (opts) {
   var instanceProps;
   var staticProps;
 
-  if (!_.isEmpty(instanceMutatorMap)) {
+  if (!_.isEmpty(this.instanceMutatorMap)) {
     var protoId = util.template("prototype-identifier", {
       CLASS_NAME: className
     });
 
-    instanceProps = util.buildDefineProperties(instanceMutatorMap, protoId);
+    instanceProps = util.buildDefineProperties(this.instanceMutatorMap, protoId);
   }
 
-  if (!_.isEmpty(staticMutatorMap)) {
-    staticProps = util.buildDefineProperties(staticMutatorMap, className);
+  if (!_.isEmpty(this.staticMutatorMap)) {
+    staticProps = util.buildDefineProperties(this.staticMutatorMap, className);
   }
 
   if (instanceProps || staticProps) {
@@ -143,17 +144,50 @@ var buildClassBody = function (opts) {
     if (instanceProps) args.push(instanceProps);
 
     body.push(t.expressionStatement(
-      t.callExpression(file.addDeclaration("class-props"), args)
+      t.callExpression(this.file.addDeclaration("class-props"), args)
     ));
   }
 };
 
-var superIdentifier = function (superName, methodNode, node, parent) {
-  var methodName = methodNode.key;
+/**
+ * Push a method to it's respective mutatorMap.
+ *
+ * @param {Node} node MethodDefinition
+ */
 
-  if (parent.property === node) {
+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"));
+  }
+
+  util.pushMutatorMap(mutatorMap, methodName, kind, node);
+};
+
+/**
+ * Given a `methodNode`, produce a `MemberExpression` super class reference.
+ *
+ * @param {Node} methodNode MethodDefinition
+ * @param {Node} node Identifier
+ * @param {Node} parent
+ *
+ * @returns {Node}
+ */
+
+Class.prototype.superIdentifier = function (methodNode, id, parent) {
+  var methodName = methodNode.key;
+  var superName  = this.superName || t.identifier("Function");
+
+  if (parent.property === id) {
     return;
-  } else if (t.isCallExpression(parent, { callee: node })) {
+  } else if (t.isCallExpression(parent, { callee: id })) {
     // super(); -> ClassName.prototype.MethodName.call(this);
     parent.arguments.unshift(t.thisExpression());
 
@@ -161,15 +195,15 @@ var superIdentifier = function (superName, methodNode, node, parent) {
       // constructor() { super(); }
       return t.memberExpression(superName, t.identifier("call"));
     } else {
-      node = superName;
+      id = superName;
 
       // foo() { super(); }
       if (!methodNode.static) {
-        node = t.memberExpression(node, t.identifier("prototype"));
+        id = t.memberExpression(id, t.identifier("prototype"));
       }
 
-      node = t.memberExpression(node, methodName, methodNode.computed);
-      return t.memberExpression(node, t.identifier("call"));
+      id = t.memberExpression(id, methodName, methodNode.computed);
+      return t.memberExpression(id, t.identifier("call"));
     }
   } else if (t.isMemberExpression(parent) && !methodNode.static) {
     // super.test -> ClassName.prototype.test
@@ -179,31 +213,50 @@ var superIdentifier = function (superName, methodNode, node, parent) {
   }
 };
 
-var replaceInstanceSuperReferences = function (superName, methodNode) {
-  var method = methodNode.value;
+/**
+ * Replace all `super` references with a reference to our `superClass`.
+ *
+ * @param {Node} methodNode MethodDefinition
+ */
 
-  superName = superName || t.identifier("Function");
+Class.prototype.replaceInstanceSuperReferences = function (methodNode) {
+  var method = methodNode.value;
+  var self = this;
 
   traverse(method, function (node, parent) {
     if (t.isIdentifier(node, { name: "super" })) {
-      return superIdentifier(superName, methodNode, node, parent);
+      return self.superIdentifier(methodNode, node, parent);
     } else if (t.isCallExpression(node)) {
       var callee = node.callee;
       if (!t.isMemberExpression(callee)) return;
       if (callee.object.name !== "super") return;
 
-      //  super.test(); -> ClassName.prototype.MethodName.call(this);
-      callee.property.name = callee.property.name + ".call";
+      // super.test(); -> ClassName.prototype.MethodName.call(this);
+      callee.property = t.memberExpression(callee.property, t.identifier("call"));
       node.arguments.unshift(t.thisExpression());
     }
   });
 };
 
-var addConstructor = function (construct, method) {
-  construct.defaults = method.defaults;
-  construct.params   = method.params;
-  construct.body     = method.body;
-  construct.rest     = method.rest;
+/**
+ * Replace the constructor body of our class.
+ *
+ * @param {Node} method MethodDefinition
+ */
 
-  t.inherits(construct, method);
+Class.prototype.pushConstructor = function (method) {
+  if (method.kind !== "") {
+    throw this.file.errorWithNode(method, "illegal kind for constructor method");
+  }
+
+  var construct = this.constructor;
+  var fn        = method.value;
+
+  this.hasConstructor = true;
+  t.inherits(construct, fn);
+
+  construct.defaults = fn.defaults;
+  construct.params   = fn.params;
+  construct.body     = fn.body;
+  construct.rest     = fn.rest;
 };

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

@@ -29,7 +29,7 @@ exports.ObjectExpression = function (node, parent, file) {
   var containerCallee = container.callee.expression;
   var containerBody = containerCallee.body.body;
 
-  containerCallee._aliasFunction = "arrows";
+  containerCallee._aliasFunction = true;
 
   _.each(computed, function (prop) {
     containerBody.unshift(

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

@@ -17,6 +17,12 @@ var isVar = function (node) {
   return t.isVariableDeclaration(node, { kind: "var" }) && !isLet(node);
 };
 
+var standardiseLets = function (declars) {
+  _.each(declars, function (declar) {
+    delete declar._let;
+  });
+};
+
 exports.VariableDeclaration = function (node) {
   isLet(node);
 };
@@ -33,7 +39,8 @@ exports.For = function (node, parent, file, scope) {
     node.label = parent.label;
   }
 
-  run(node, node.body, parent, file, scope);
+  var letScoping = new LetScoping(node, node.body, parent, file, scope);
+  letScoping.run();
 
   if (node.label && !t.isLabeledStatement(parent)) {
     // we've been given a label so let's wrap ourselves
@@ -43,12 +50,98 @@ exports.For = function (node, parent, file, scope) {
 
 exports.BlockStatement = function (block, parent, file, scope) {
   if (!t.isFor(parent)) {
-    run(false, block, parent, file, scope);
+    var letScoping = new LetScoping(false, block, parent, file, scope);
+    letScoping.run();
   }
 };
 
-var noClosure = function (letDeclars, block, replacements) {
-  standardiseLets(letDeclars);
+/**
+ * Description
+ *
+ * @param {Boolean|Node} forParent
+ * @param {Node} block
+ * @param {Node} parent
+ * @param {File} file
+ * @param {Scope} scope
+ */
+
+function LetScoping(forParent, block, parent, file, scope) {
+  this.forParent = forParent;
+  this.parent    = parent;
+  this.scope     = scope;
+  this.block     = block;
+  this.file      = file;
+
+  this.letReferences = {};
+  this.body          = [];
+  this.info          = this.getInfo();
+}
+
+/**
+ * Start the ball rolling.
+ */
+
+LetScoping.prototype.run = function () {
+  var block = this.block;
+
+  if (block._letDone) return;
+  block._letDone = true;
+
+  // this is a block within a `Function` so we can safely leave it be
+  if (t.isFunction(this.parent)) return;
+
+  // this block has no let references so let's clean up
+  if (!this.info.keys.length) return this.noClosure();
+
+  // returns whether or not there are any outside let references within any
+  // functions
+  var referencesInClosure = this.getLetReferences();
+
+  // no need for a closure so let's clean up
+  if (!referencesInClosure) return this.noClosure();
+
+  // if we're inside of a for loop then we search to see if there are any
+  // `break`s, `continue`s, `return`s etc
+  this.has = this.checkFor();
+
+  // hoist var references to retain scope
+  this.hoistVarDeclarations();
+
+  // set let references to plain var references
+  standardiseLets(this.info.declarators);
+
+  // turn letReferences into an array
+  var letReferences = _.values(this.letReferences);
+
+  // build the closure that we're going to wrap the block with
+  var fn = t.functionExpression(null, letReferences, t.blockStatement(block.body));
+  fn._aliasFunction = true;
+
+  // replace the current block body with the one we're going to build
+  block.body = this.body;
+
+  // change upper scope references with their uid if they have one
+  var params = this.getParams(letReferences);
+
+  // build a call and a unique id that we can assign the return value to
+  var call = t.callExpression(fn, params);
+  var ret  = t.identifier(this.file.generateUid("ret", this.scope));
+
+  this.build(ret, call);
+};
+
+/**
+ * There are no let references accessed within a closure so we can just traverse
+ * through this block and replace all references that exist in a high scope to
+ * their uids.
+ */
+
+LetScoping.prototype.noClosure = function () {
+  var replacements = this.info.duplicates;
+  var declarators  = this.info.declarators;
+  var block        = this.block;
+
+  standardiseLets(declarators);
 
   if (_.isEmpty(replacements)) return;
 
@@ -59,13 +152,17 @@ var noClosure = function (letDeclars, block, replacements) {
   });
 };
 
-var standardiseLets = function (declars) {
-  _.each(declars, function (declar) {
-    delete declar._let;
-  });
-};
+/**
+ * Description
+ *
+ * @returns {Object}
+ */
+
+LetScoping.prototype.getInfo = function () {
+  var block = this.block;
+  var scope = this.scope;
+  var file  = this.file;
 
-var getInfo = function (block, file, scope) {
   var opts = {
     // array of `Identifier` names of let variables that appear lexically out of
     // this scope but should be accessible - eg. `ForOfStatement`.left
@@ -111,15 +208,23 @@ var getInfo = function (block, file, scope) {
   return opts;
 };
 
-var checkFor = function (forParent, block) {
+/**
+ * If we're inside of a `For*Statement` then traverse it and check if it has one
+ * of the following node types `ReturnStatement`, `BreakStatement`,
+ * `ContinueStatement` and replace it with a return value we can track later on.
+ *
+ * @returns {Object}
+ */
+
+LetScoping.prototype.checkFor = function () {
   var has = {
     hasContinue: false,
     hasReturn:   false,
     hasBreak:    false,
   };
 
-  if (forParent) {
-    traverse(block, function (node) {
+  if (this.forParent) {
+    traverse(this.block, function (node) {
       var replace;
 
       if (t.isFunction(node) || t.isFor(node)) {
@@ -144,38 +249,59 @@ var checkFor = function (forParent, block) {
   return has;
 };
 
-var hoistVarDeclarations = function (block, pushDeclar) {
-  traverse(block, function (node) {
+/**
+ * Hoist all var declarations in this block to before it so they retain scope
+ * once we wrap everything is in a closure.
+ */
+
+LetScoping.prototype.hoistVarDeclarations = function () {
+  var self = this;
+  traverse(this.block, function (node) {
     if (t.isForStatement(node)) {
       if (isVar(node.init)) {
-        node.init = t.sequenceExpression(pushDeclar(node.init));
+        node.init = t.sequenceExpression(self.pushDeclar(node.init));
       }
     } else if (t.isFor(node)) {
       if (isVar(node.left)) {
         node.left = node.left.declarations[0].id;
       }
     } else if (isVar(node)) {
-      return pushDeclar(node).map(t.expressionStatement);
+      return self.pushDeclar(node).map(t.expressionStatement);
     } else if (t.isFunction(node)) {
       return false;
     }
   });
 };
 
-var getParams = function (info, letReferences) {
-  var params = _.cloneDeep(letReferences);
+/**
+ * Build up a parameter list that we'll call our closure wrapper with, replacing
+ * all duplicate ids with their uid.
+ *
+ * @param {Array} params
+ * @returns {Array}
+ */
+
+LetScoping.prototype.getParams = function (params) {
+  var info = this.info;
+  params = _.cloneDeep(params);
   _.each(params, function (param) {
     param.name = info.duplicates[param.name] || param.name;
   });
   return params;
 };
 
-var getLetReferences = function (block, info, letReferences) {
+/**
+ * Get all let references within this block. Stopping whenever we reach another
+ * block.
+ */
+
+LetScoping.prototype.getLetReferences = function () {
   var closurify = false;
+  var self = this;
 
   // traverse through this block, stopping on functions and checking if they
   // contain any outside let references
-  traverse(block, function (node, parent, scope) {
+  traverse(this.block, function (node, parent, scope) {
     if (t.isFunction(node)) {
       traverse(node, function (node, parent) {
         // not an identifier so we have no use
@@ -191,10 +317,10 @@ var getLetReferences = function (block, info, letReferences) {
         closurify = true;
 
         // this key doesn't appear just outside our scope
-        if (!_.contains(info.outsideKeys, node.name)) return;
+        if (!_.contains(self.info.outsideKeys, node.name)) return;
 
         // push this badboy
-        letReferences[node.name] = node;
+        self.letReferences[node.name] = node;
       });
 
       return false;
@@ -206,125 +332,100 @@ var getLetReferences = function (block, info, letReferences) {
   return closurify;
 };
 
-var buildPushDeclar = function (body) {
-  return function (node) {
-    body.push(t.variableDeclaration(node.kind, node.declarations.map(function (declar) {
-      return t.variableDeclarator(declar.id);
-    })));
+/**
+ * Turn a `VariableDeclaration` into an array of `AssignmentExpressions` with
+ * their declarations hoisted to before the closure wrapper.
+ *
+ * @param {Node} node VariableDeclaration
+ * @returns {Array}
+ */
 
-    var replace = [];
+LetScoping.prototype.buildPushDeclar = function (node) {
+  this.body.push(t.variableDeclaration(node.kind, node.declarations.map(function (declar) {
+    return t.variableDeclarator(declar.id);
+  })));
 
-    _.each(node.declarations, function (declar) {
-      if (!declar.init) return;
+  var replace = [];
 
-      var expr = t.assignmentExpression("=", declar.id, declar.init);
-      replace.push(t.inherits(expr, declar));
-    });
+  _.each(node.declarations, function (declar) {
+    if (!declar.init) return;
 
-    return replace;
-  };
+    var expr = t.assignmentExpression("=", declar.id, declar.init);
+    replace.push(t.inherits(expr, declar));
+  });
+
+  return replace;
 };
 
-var run = function (forParent, block, parent, file, scope) {
-  if (block._letDone) return;
-  block._letDone = true;
-
-  var info = getInfo(block, file, scope);
-  var declarators = info.declarators;
-  var letKeys = info.keys;
-
-  // this is a block within a `Function` so we can safely leave it be
-  if (t.isFunction(parent)) return;
-
-  // this block has no let references so let's clean up
-  if (!letKeys.length) return noClosure(declarators, block, info.duplicates);
-
-  // outside let references that we need to wrap
-  var letReferences = {};
-
-  // returns whether or not there are any outside let references within any
-  // functions
-  var closurify = getLetReferences(block, info, letReferences);
-
-  letReferences = _.values(letReferences);
-
-  // no need for a closure so let's clean up
-  if (!closurify) return noClosure(declarators, block, info.duplicates);
-
-  // if we're inside of a for loop then we search to see if there are any
-  // `break`s, `continue`s, `return`s etc
-  var has = checkFor(forParent, block);
-
-  var body = [];
-
-  // hoist a `VariableDeclaration` and add `AssignmentExpression`s in it's place
-  var pushDeclar = buildPushDeclar(body);
-
-  // hoist var references to retain scope
-  hoistVarDeclarations(block, pushDeclar);
-
-  // set let references to plain var references
-  standardiseLets(declarators);
-
-  // build the closure that we're going to wrap the block with
-  var fn = t.functionExpression(null, letReferences, t.blockStatement(block.body));
-  fn._aliasFunction = true;
-
-  // replace the current block body with the one we've built
-  block.body = body;
-
-  // change duplicate let references to their uid if they have one
-  var params = getParams(info, letReferences);
-
-  var call = t.callExpression(fn, params);
-  var ret  = t.identifier(file.generateUid("ret", scope));
+/**
+ * Push the closure to the body.
+ *
+ * @param {Node} ret Identifier
+ * @param {Node} call CallExpression
+ */
 
+LetScoping.prototype.build = function (ret, call) {
+  var has = this.has;
   if (has.hasReturn || has.hasBreak || has.hasContinue) {
-    body.push(t.variableDeclaration("var", [
-      t.variableDeclarator(ret, call)
-    ]));
-
-    var retCheck;
-
-    var cases = [];
-
-    if (has.hasReturn) {
-      // typeof ret === "object"
-      retCheck = util.template("let-scoping-return", {
-        RETURN: ret,
-      });
-    }
-
-    if (has.hasBreak || has.hasContinue) {
-      // ensure that the parent has a label as we're building a switch and we
-      // need to be able to access it
-      var label = forParent.label = forParent.label || t.identifier(file.generateUid("loop", scope));
-
-      if (has.hasBreak) {
-        cases.push(t.switchCase(t.literal("break"), [t.breakStatement(label)]));
-      }
-
-      if (has.hasContinue) {
-        cases.push(t.switchCase(t.literal("continue"), [t.continueStatement(label)]));
-      }
-
-      if (has.hasReturn) {
-        cases.push(t.switchCase(null, [retCheck]));
-      }
-
-      if (cases.length === 1) {
-        var single = cases[0];
-        body.push(t.ifStatement(
-          t.binaryExpression("===", ret, single.test),
-          single.consequent[0]
-        ));
-      } else {
-        body.push(t.switchStatement(ret, cases));
-      }
-    } else {
-      if (has.hasReturn) body.push(retCheck);
-    }
+    this.buildHas(ret, call);
   } else {
-    body.push(t.expressionStatement(call));
+    this.body.push(t.expressionStatement(call));
+  }
+};
+
+/**
+ * Description
+ *
+ * @param {Node} ret Identifier
+ * @param {Node} call CallExpression
+ */
+
+LetScoping.prototype.buildHas = function (ret, call) {
+  var body = this.body;
+
+  body.push(t.variableDeclaration("var", [
+    t.variableDeclarator(ret, call)
+  ]));
+
+  var forParent = this.forParent;
+  var retCheck;
+  var has = this.has;
+  var cases = [];
+
+  if (has.hasReturn) {
+    // typeof ret === "object"
+    retCheck = util.template("let-scoping-return", {
+      RETURN: ret
+    });
+  }
+
+  if (has.hasBreak || has.hasContinue) {
+    // ensure that the parent has a label as we're building a switch and we
+    // need to be able to access it
+    var label = forParent.label = forParent.label || t.identifier(this.file.generateUid("loop", this.scope));
+
+    if (has.hasBreak) {
+      cases.push(t.switchCase(t.literal("break"), [t.breakStatement(label)]));
+    }
+
+    if (has.hasContinue) {
+      cases.push(t.switchCase(t.literal("continue"), [t.continueStatement(label)]));
+    }
+
+    if (has.hasReturn) {
+      cases.push(t.switchCase(null, [retCheck]));
+    }
+
+    if (cases.length === 1) {
+      var single = cases[0];
+      body.push(t.ifStatement(
+        t.binaryExpression("===", ret, single.test),
+        single.consequent[0]
+      ));
+    } else {
+      body.push(t.switchStatement(ret, cases));
+    }
+  } else {
+    if (has.hasReturn) body.push(retCheck);
   }
 };

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

@@ -1,6 +0,0 @@
-var _ = require("lodash");
-
-exports.Literal = function (node) {
-  // TODO: remove this when the new code generator is released
-  if (_.isNumber(node.value)) delete node.raw;
-};

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

@@ -57,15 +57,39 @@ exports.XJSOpeningElement = {
 
     var props = node.attributes;
     if (props.length) {
-      var first = props[0];
-      if (t.isXJSSpreadAttribute(first)) {
-        props.shift();
+      var _props = [];
+      var objs = [];
+
+      var pushProps = function () {
+        if (!_props.length) return;
+
+        objs.push(t.objectExpression(_props));
+        _props = [];
+      };
+
+      while (props.length) {
+        var prop = props.shift();
+        if (t.isXJSSpreadAttribute(prop)) {
+          pushProps();
+          objs.push(prop.argument);
+        } else {
+          _props.push(prop);
+        }
+      }
+
+      pushProps();
+
+      if (objs.length === 1) {
+        props = objs[0];
+      } else {
+        if (!t.isObjectExpression(objs[0])) {
+          objs.unshift(t.objectExpression([]));
+        }
+
         props = t.callExpression(
           t.memberExpression(t.identifier("React"), t.identifier("__spread")),
-          [t.objectExpression([]), first.argument, t.objectExpression(props)]
+          objs
         );
-      } else {
-        props = t.objectExpression(props);
       }
     } else {
       props = t.literal(null);

lib/6to5/util.js

@@ -25,6 +25,10 @@ exports.resolve = function (loc) {
   }
 };
 
+exports.trimRight = function (str) {
+  return str.replace(/[\n\s]+$/g, "");
+};
+
 exports.list = function (val) {
   return val ? val.split(",") : [];
 };

package.json

@@ -1,7 +1,7 @@
 {
   "name": "6to5",
   "description": "Turn ES6 code into readable vanilla ES5 with source maps",
-  "version": "1.12.0",
+  "version": "1.12.2",
   "author": "Sebastian McKenzie <sebmck@gmail.com>",
   "homepage": "https://github.com/6to5/6to5",
   "repository": {
@@ -53,10 +53,10 @@
   },
   "devDependencies": {
     "istanbul": "0.3.2",
-    "matcha": "0.5.0",
+    "matcha": "0.6.0",
     "mocha": "2.0.1",
     "uglify-js": "2.4.15",
-    "browserify": "6.2.0",
+    "browserify": "6.3.2",
     "rimraf": "2.2.8",
     "jshint": "2.5.10",
     "chai": "^1.9.2"

test/bin.js

@@ -149,7 +149,3 @@ _.each(fs.readdirSync(fixtureLoc), function (binName) {
     });
   });
 });
-
-after(function () {
-  rimraf.sync(tmpLoc);
-});

test/fixtures/transformation/react/wraps-props-in-react-spread-for-last-spread-attributes/actual.js

@@ -0,0 +1 @@
+<Component y={2} z { ... x } />

test/fixtures/transformation/react/wraps-props-in-react-spread-for-last-spread-attributes/expected.js

@@ -0,0 +1,4 @@
+React.createElement(Component, React.__spread({
+  y: 2,
+  z: true
+}, x));

test/fixtures/transformation/react/wraps-props-in-react-spread-for-middle-spread-attributes/actual.js

@@ -0,0 +1 @@
+<Component y={2} { ... x } z />

test/fixtures/transformation/react/wraps-props-in-react-spread-for-middle-spread-attributes/expected.js

@@ -0,0 +1,5 @@
+React.createElement(Component, React.__spread({
+  y: 2
+}, x, {
+  z: true
+}));