v1.12.19

Remove comments

CHANGELOG.md

@@ -1,3 +1,52 @@
+# 1.12.19
+
+ * Add `comments` option and `--remove-comments` flag. Thanks @[webpro](htps://github.com/webpro)!
+ * Embed `regenerator`.
+
+# 1.12.18
+
+ * Use `global` reference instead of `window`.
+
+# 1.12.17
+
+ * Add `moduleName`, `sourceRoot` and `filenameRelative` options - thanks @[darvelo](https://github.com/darvelo)!
+ * Traversal optimisations.
+
+# 1.12.16
+
+ * Fix comments not being retained from `MethodDefinition` in classes.
+ * Add temporal dead zone in default parameters.
+
+# 1.12.15
+
+ * Update `acorn-6to5`.
+
+# 1.12.14
+
+ * Fix duplicate let scoping in functions.
+ * Make JSX whitespace more React-compliant.
+ * Add `_memberExpressionKeywords` transformer that turns keyword identifiers to computed literals.
+ * Upgrade `regenerator-6to5`.
+
+# 1.12.13
+
+ * Support duplicate constants within different block scopes.
+ * Fix for-head duplication testing and replacement.
+ * Support `raw` property on tagged template literals.
+
+# 1.12.12
+
+ * Make scope tracker more reliable to handle all edgecases.
+
+# 1.12.11
+
+ * Block scope classes.
+ * Fix generation of integer `Literal`s in `MemberExpression`.
+
+# 1.12.10
+
+ * Fix let scoping var hoisting.
+
 # 1.12.9
 
  * Escape unicode characters when generating string `Literal`s.

bin/6to5/index.js

@@ -17,6 +17,7 @@ commander.option("-w, --whitelist [whitelist]", "Whitelist of transformers to ON
 commander.option("-b, --blacklist [blacklist]", "Blacklist of transformers to NOT use", util.list);
 commander.option("-o, --out-file [out]", "Compile all input files into a single file");
 commander.option("-d, --out-dir [out]", "Compile an input directory of modules into an output directory");
+commander.option("-c, --remove-comments", "Remove comments from the compiled code", false);
 
 commander.on("--help", function(){
   var outKeys = function (title, obj) {
@@ -88,6 +89,7 @@ exports.opts = {
   blacklist:     commander.blacklist,
   whitelist:     commander.whitelist,
   sourceMap:     commander.sourceMaps || commander.sourceMapsInline,
+  comments:      !commander.removeComments,
   runtime:       commander.runtime,
   modules:       commander.modules
 };

doc/features.md

@@ -133,11 +133,13 @@ for (var i of [1, 2, 3]) {
 ## Generators
 
 ```javascript
+
 ```
 
 ## Generator comprehension
 
 ```javascript
+
 ```
 
 ## Let scoping
@@ -151,6 +153,7 @@ for (let i in arr) {
 ## Modules
 
 ```javascript
+
 ```
 
 ## Numeric literals

doc/modules.md

@@ -66,7 +66,7 @@ export function bar() {
 **Out**
 
 ```javascript
-define(["exports", "foo"], function (exports, _foo) {
+define("filename", ["exports", "foo"], function (exports, _foo) {
   exports.bar = bar;
 
   var foo = _foo.default;
@@ -94,7 +94,7 @@ export function bar() {
 ```javascript
 (function (factory) {
   if (typeof define === "function" && define.amd) {
-    define(["exports", "foo"], factory);
+    define("filename", ["exports", "foo"], factory);
   } else if (typeof exports !== "undefined") {
     factory(exports, require("foo"));
   }
@@ -111,7 +111,6 @@ export function bar() {
 
 ### Ignore
 
-
 **In**
 
 ```javascript

doc/plugins.md

@@ -5,11 +5,13 @@
  - [Brunch](https://github.com/es128/6to5-brunch)
  - [Duo](https://github.com/bdo-labs/duo6to5)
  - [Connect](https://github.com/6to5/6to5-connect)
+ - [Gobble](https://github.com/gobblejs/gobble-6to5)
  - [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)
+ - [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/6to5/6to5-rails)
+ - [Rails](https://github.com/josh/sprockets-es6) or via [browserify-rails](https://github.com/6to5/6to5-rails)
  - [webpack](https://github.com/Couto/6to5-loader)

doc/usage.md

@@ -83,6 +83,10 @@ to5.transformFile("filename.js", options, function (err, result) {
   // Default: "unknown"
   filename: "filename",
 
+  // Filename relative to `sourceRoot`
+  // Default: `filename` option.
+  filenameRelative: "",
+
   // List of transformers to EXCLUDE.
   // Run `6to5 --help` to see a full list of transformers.
   blacklist: [],
@@ -103,17 +107,28 @@ to5.transformFile("filename.js", options, function (err, result) {
   sourceMap: true,
 
   // Set `file` on returned source map.
-  // Default: `filename` option.
+  // Default: `filenameRelative` option.
   sourceMapName: "filename",
 
   // Set `sources[0]` on returned source map.
-  // Default: `filename` option.
+  // Default: `filenameRelative` option.
   sourceFileName: "filename",
 
+  // The root from which all sources are relative
+  sourceRoot: "assets/scripts",
+
+  // Optional prefix for the AMD module formatter that will be prepend to the
+  // filename on module definitions
+  moduleRoot: "my-app",
+
   // Optionally replace all 6to5 helper declarations with a referenece to this
   // variable. If set to `true` then the default namespace is used "to5Runtime".
   // Default: false
-  runtime: true
+  runtime: true,
+
+  // Output comments in generated output
+  // Default: true
+  comments: false
 }
 ```
 

lib/6to5/browser.js

@@ -12,7 +12,7 @@ transform.load = function (url, callback, opts, hold) {
   opts = opts || {};
   opts.filename = opts.filename || url;
 
-  var xhr = window.ActiveXObject ? new window.ActiveXObject("Microsoft.XMLHTTP") : new window.XMLHttpRequest();
+  var xhr = global.ActiveXObject ? new global.ActiveXObject("Microsoft.XMLHTTP") : new global.XMLHttpRequest();
   xhr.open("GET", url, true);
   if ("overrideMimeType" in xhr) xhr.overrideMimeType("text/plain");
 
@@ -60,7 +60,7 @@ var runScripts = function () {
     }
   };
 
-  var _scripts = window.document.getElementsByTagName("script");
+  var _scripts = global.document.getElementsByTagName("script");
   for (var i in _scripts) {
     var _script = _scripts[i];
     if (types.indexOf(_script.type) >= 0) scripts.push(_script);
@@ -73,8 +73,8 @@ var runScripts = function () {
   exec();
 };
 
-if (window.addEventListener) {
-  window.addEventListener("DOMContentLoaded", runScripts, false);
-} else {
-  window.attachEvent("onload", runScripts);
+if (global.addEventListener) {
+  global.addEventListener("DOMContentLoaded", runScripts, false);
+} else if (global.attachEvent) {
+  global.attachEvent("onload", runScripts);
 }

lib/6to5/file.js

@@ -18,7 +18,8 @@ function File(opts) {
   this.ast          = {};
 }
 
-File.declarations = ["extends", "class-props", "slice", "apply-constructor"];
+File.declarations = ["extends", "class-props", "slice", "apply-constructor",
+                     "tagged-template-literal"];
 
 File.normaliseOptions = function (opts) {
   opts = _.cloneDeep(opts || {});
@@ -28,6 +29,7 @@ File.normaliseOptions = function (opts) {
     blacklist:  [],
     whitelist:  [],
     sourceMap:  false,
+    comments:   true,
     filename:   "unknown",
     modules:    "common",
     runtime:    false,
@@ -38,8 +40,12 @@ File.normaliseOptions = function (opts) {
   opts.filename = opts.filename.replace(/\\/g, "/");
 
   _.defaults(opts, {
-    sourceFileName: opts.filename,
-    sourceMapName:  opts.filename
+    filenameRelative: opts.filename
+  });
+
+  _.defaults(opts, {
+    sourceFileName: opts.filenameRelative,
+    sourceMapName:  opts.filenameRelative
   });
 
   if (opts.runtime === true) {

lib/6to5/generation/generator.js

@@ -35,21 +35,17 @@ _.each(Buffer.prototype, function (fn, key) {
 });
 
 CodeGenerator.normaliseOptions = function (opts) {
-  opts = opts.format || {};
-
-  opts = _.merge({
+  return _.merge({
     parentheses: true,
     semicolons: true,
-    comments: true,
+    comments: opts.comments == null || opts.comments,
     compact: false,
     indent: {
       adjustMultilineComment: true,
       style: "  ",
       base: 0
     }
-  }, opts);
-
-  return opts;
+  }, opts.format || {});
 };
 
 CodeGenerator.generators = {

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

@@ -1,4 +1,5 @@
-var t = require("../../types");
+var util = require("../../util");
+var t    = require("../../types");
 
 exports.UnaryExpression = function (node, print) {
   var hasSpace = /[a-z]$/.test(node.operator);
@@ -105,6 +106,11 @@ exports.MemberExpression = function (node, print) {
     print(node.property);
     this.push("]");
   } else {
+    // 5..toFixed(2);
+    if (t.isLiteral(node.object) && util.isInteger(node.object.value)) {
+      this.push(".");
+    }
+
     this.push(".");
     print(node.property);
   }

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

@@ -2,8 +2,8 @@ module.exports = Node;
 
 var whitespace = require("./whitespace");
 var parens     = require("./parentheses");
-var t           = require("../../types");
-var _           = require("lodash");
+var t          = require("../../types");
+var _          = require("lodash");
 
 var find = function (obj, node, parent) {
   var result;

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

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

lib/6to5/polyfill.js

@@ -3,4 +3,4 @@ if (typeof Symbol === "undefined") {
 }
 
 require("es6-shim");
-require("regenerator-6to5/runtime");
+require("./transformation/transformers/generators/runtime");

lib/6to5/runtime.js

@@ -5,7 +5,7 @@ var t         = require("./types");
 var _         = require("lodash");
 
 module.exports = function (namespace) {
-  namespace = t.identifier(namespace || "to5Runtime");
+  namespace = t.identifier(t.toIdentifier(namespace || "to5Runtime"));
 
   var body      = [];
   var container = t.functionExpression(null, [], t.blockStatement(body));

lib/6to5/templates/tagged-template-literal.js

@@ -0,0 +1,4 @@
+(function (strings, raw) {
+  return Object.defineProperties(strings, { raw: { value: raw } });
+});
+

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

@@ -29,12 +29,41 @@ AMDFormatter.prototype.transform = function (ast) {
   var params = _.values(this.ids);
   params.unshift(t.identifier("exports"));
 
+  var moduleName = this.getModuleName();
+
   var container = t.functionExpression(null, params, t.blockStatement(body));
-  var call = t.callExpression(t.identifier("define"), [names, container]);
+  var call = t.callExpression(t.identifier("define"), [t.literal(moduleName), names, container]);
 
   program.body = [t.expressionStatement(call)];
 };
 
+AMDFormatter.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;
+};
+
 AMDFormatter.prototype._push = function (node) {
   var id  = node.source.value;
   var ids = this.ids;

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

@@ -32,8 +32,10 @@ UMDFormatter.prototype.transform = function (ast) {
 
   // runner
 
+  var moduleName = this.getModuleName();
+
   var runner = util.template("umd-runner-body", {
-    AMD_ARGUMENTS: t.arrayExpression([t.literal("exports")].concat(names)),
+    AMD_ARGUMENTS: [t.literal(moduleName), t.arrayExpression([t.literal("exports")].concat(names))],
 
     COMMON_ARGUMENTS: names.map(function (name) {
       return t.callExpression(t.identifier("require"), [name]);

lib/6to5/transformation/transform.js

@@ -27,37 +27,39 @@ transform.moduleFormatters = {
 };
 
 _.each({
-  modules:                  require("./transformers/modules"),
-  propertyNameShorthand:    require("./transformers/property-name-shorthand"),
-  constants:                require("./transformers/constants"),
-  arrayComprehension:       require("./transformers/array-comprehension"),
-  generatorComprehension:   require("./transformers/generator-comprehension"),
-  arrowFunctions:           require("./transformers/arrow-functions"),
-  classes:                  require("./transformers/classes"),
+  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"),
 
-  _propertyLiterals:        require("./transformers/_property-literals"),
-  computedPropertyNames:    require("./transformers/computed-property-names"),
+  _propertyLiterals:         require("./transformers/_property-literals"),
+  computedPropertyNames:     require("./transformers/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"),
-  letScoping:               require("./transformers/let-scoping"),
-  forOf:                    require("./transformers/for-of"),
-  unicodeRegex:             require("./transformers/unicode-regex"),
+  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"),
+  react:                     require("./transformers/react"),
 
-  react:                    require("./transformers/react"),
+  constants:                 require("./transformers/constants"),
+  letScoping:                require("./transformers/let-scoping"),
 
-  _aliasFunctions:          require("./transformers/_alias-functions"),
-  _blockHoist:              require("./transformers/_block-hoist"),
-  _declarations:            require("./transformers/_declarations"),
+  generators:                require("./transformers/generators"),
 
-  generators:               require("./transformers/generators"),
-  useStrict:                require("./transformers/use-strict"),
+  _blockHoist:               require("./transformers/_block-hoist"),
+  _declarations:             require("./transformers/_declarations"),
+  _aliasFunctions:           require("./transformers/_alias-functions"),
 
-  _moduleFormatter:         require("./transformers/_module-formatter")
+  useStrict:                 require("./transformers/use-strict"),
+
+  _memberExpressionKeywords: require("./transformers/_member-expression-keywords"),
+  _moduleFormatter:          require("./transformers/_module-formatter")
 }, function (transformer, key) {
   transform.transformers[key] = new Transformer(key, transformer);
 });

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

@@ -0,0 +1,10 @@
+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/classes.js

@@ -4,7 +4,7 @@ var t        = require("../../types");
 var _        = require("lodash");
 
 exports.ClassDeclaration = function (node, parent, file, scope) {
-  return t.variableDeclaration("var", [
+  return t.variableDeclaration("let", [
     t.variableDeclarator(node.id, new Class(node, file, scope).run())
   ]);
 };
@@ -254,6 +254,7 @@ Class.prototype.pushConstructor = function (method) {
 
   this.hasConstructor = true;
   t.inherits(construct, fn);
+  t.inheritsComments(construct, method);
 
   construct.defaults = fn.defaults;
   construct.params   = fn.params;

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

@@ -7,26 +7,30 @@ exports.BlockStatement =
 exports.ForInStatement =
 exports.ForOfStatement =
 exports.ForStatement = function (node, parent, file) {
-  var constants = [];
+  var constants = {};
 
-  var check = function (node, names) {
-    _.each(names, function (name) {
-      if (constants.indexOf(name) >= 0) {
-        throw file.errorWithNode(node, name + " is read-only");
-      }
+  var check = function (parent, names) {
+    _.each(names, function (nameNode, name) {
+      if (!_.has(constants, name)) return;
+      if (parent && t.isBlockStatement(parent) && parent !== constants[name]) return;
+
+      throw file.errorWithNode(nameNode, name + " is read-only");
     });
   };
 
   var getIds = function (node) {
-    return t.getIds(node, false, ["MemberExpression"]);
+    return t.getIds(node, true, ["MemberExpression"]);
   };
 
-  _.each(node.body, function (child) {
+  _.each(node.body, function (child, parent) {
     if (child && t.isVariableDeclaration(child, { kind: "const" })) {
       _.each(child.declarations, function (declar) {
-        _.each(getIds(declar), function (name) {
-          check(declar, [name]);
-          constants.push(name);
+        _.each(getIds(declar), function (nameNode, name) {
+          var names = {};
+          names[name] = nameNode;
+          check(parent, names);
+
+          constants[name] = parent;
         });
 
         declar._ignoreConstant = true;
@@ -37,13 +41,14 @@ exports.ForStatement = function (node, parent, file) {
     }
   });
 
-  if (!constants.length) return;
+  if (_.isEmpty(constants)) return;
 
-  traverse(node, function (child) {
+  traverse(node, function (child, parent) {
     if (child._ignoreConstant) return;
+    if (t.isVariableDeclaration(child)) return;
 
     if (t.isVariableDeclarator(child) || t.isDeclaration(child) || t.isAssignmentExpression(child)) {
-      check(child, getIds(child));
+      check(parent, getIds(child));
     }
   });
 };

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

@@ -1,21 +1,70 @@
-var util = require("../../util");
-var t    = require("../../types");
-var _    = require("lodash");
+var traverse = require("../../traverse");
+var util     = require("../../util");
+var t        = require("../../types");
+var _        = require("lodash");
 
-exports.Function = function (node) {
+exports.Function = function (node, parent, file, scope) {
   if (!node.defaults || !node.defaults.length) return;
   t.ensureBlock(node);
 
+  var ids = node.params.map(function (param) {
+    return t.getIds(param);
+  });
+
+  var closure = false;
+
   _.each(node.defaults, function (def, i) {
     if (!def) return;
 
     var param = node.params[i];
 
-    node.body.body.unshift(util.template("if-undefined-set-to", {
-      VARIABLE: param,
-      DEFAULT: def
+    // temporal dead zone check - here we prevent accessing of params that
+    // are to the right - ie. uninitialized parameters
+    _.each(ids.slice(i), function (ids) {
+      var check = function (node, parent) {
+        if (!t.isIdentifier(node) || !t.isReferenced(node, parent)) return;
+
+        if (_.contains(ids, node.name)) {
+          throw file.errorWithNode(node, "Temporal dead zone - accessing a variable before it's initialized");
+        }
+
+        if (scope.has(node.name)) {
+          closure = true;
+        }
+      };
+
+      check(def, node);
+      traverse(def, check);
+    });
+
+    // 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;
+    }
+  });
+
+  var body = [];
+
+  _.each(node.defaults, function (def, i) {
+    if (!def) return;
+
+    body.push(util.template("if-undefined-set-to", {
+      VARIABLE: node.params[i],
+      DEFAULT:  def
     }, true));
   });
 
+  if (closure) {
+    var container = t.functionExpression(null, [], node.body, node.generator);
+    container._aliasFunction = true;
+
+    body.push(t.returnStatement(t.callExpression(container, [])));
+
+    node.body = t.blockStatement(body);
+  } else {
+    node.body.body = body.concat(node.body.body);
+  }
+
   node.defaults = [];
 };

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

@@ -1,3 +0,0 @@
-var regenerator = require("regenerator-6to5");
-
-module.exports = regenerator.transform;

lib/6to5/transformation/transformers/generators/hoist.js

@@ -0,0 +1,152 @@
+/**
+ * Copyright (c) 2014, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * https://raw.github.com/facebook/regenerator/master/LICENSE file. An
+ * additional grant of patent rights can be found in the PATENTS file in
+ * the same directory.
+ */
+
+var assert = require("assert");
+var types = require("ast-types");
+var n = types.namedTypes;
+var b = types.builders;
+var hasOwn = Object.prototype.hasOwnProperty;
+
+// The hoist function takes a FunctionExpression or FunctionDeclaration
+// and replaces any Declaration nodes in its body with assignments, then
+// returns a VariableDeclaration containing just the names of the removed
+// declarations.
+exports.hoist = function(funPath) {
+  assert.ok(funPath instanceof types.NodePath);
+  n.Function.assert(funPath.value);
+
+  var vars = {};
+
+  function varDeclToExpr(vdec, includeIdentifiers) {
+    n.VariableDeclaration.assert(vdec);
+    var exprs = [];
+
+    vdec.declarations.forEach(function(dec) {
+      vars[dec.id.name] = dec.id;
+
+      if (dec.init) {
+        exprs.push(b.assignmentExpression(
+          "=", dec.id, dec.init
+        ));
+      } else if (includeIdentifiers) {
+        exprs.push(dec.id);
+      }
+    });
+
+    if (exprs.length === 0)
+      return null;
+
+    if (exprs.length === 1)
+      return exprs[0];
+
+    return b.sequenceExpression(exprs);
+  }
+
+  types.visit(funPath.get("body"), {
+    visitVariableDeclaration: function(path) {
+      var expr = varDeclToExpr(path.value, false);
+      if (expr === null) {
+        path.replace();
+      } else {
+        // We don't need to traverse this expression any further because
+        // there can't be any new declarations inside an expression.
+        return b.expressionStatement(expr);
+      }
+
+      // Since the original node has been either removed or replaced,
+      // avoid traversing it any further.
+      return false;
+    },
+
+    visitForStatement: function(path) {
+      var init = path.value.init;
+      if (n.VariableDeclaration.check(init)) {
+        path.get("init").replace(varDeclToExpr(init, false));
+      }
+      this.traverse(path);
+    },
+
+    visitForInStatement: function(path) {
+      var left = path.value.left;
+      if (n.VariableDeclaration.check(left)) {
+        path.get("left").replace(varDeclToExpr(left, true));
+      }
+      this.traverse(path);
+    },
+
+    visitFunctionDeclaration: function(path) {
+      var node = path.value;
+      vars[node.id.name] = node.id;
+
+      var assignment = b.expressionStatement(
+        b.assignmentExpression(
+          "=",
+          node.id,
+          b.functionExpression(
+            node.id,
+            node.params,
+            node.body,
+            node.generator,
+            node.expression
+          )
+        )
+      );
+
+      if (n.BlockStatement.check(path.parent.node)) {
+        // Insert the assignment form before the first statement in the
+        // enclosing block.
+        path.parent.get("body").unshift(assignment);
+
+        // Remove the function declaration now that we've inserted the
+        // equivalent assignment form at the beginning of the block.
+        path.replace();
+
+      } else {
+        // If the parent node is not a block statement, then we can just
+        // replace the declaration with the equivalent assignment form
+        // without worrying about hoisting it.
+        path.replace(assignment);
+      }
+
+      // Don't hoist variables out of inner functions.
+      return false;
+    },
+
+    visitFunctionExpression: function() {
+      // Don't descend into nested function expressions.
+      return false;
+    }
+  });
+
+  var paramNames = {};
+  funPath.get("params").each(function(paramPath) {
+    var param = paramPath.value;
+    if (n.Identifier.check(param)) {
+      paramNames[param.name] = param;
+    } else {
+      // Variables declared by destructuring parameter patterns will be
+      // harmlessly re-declared.
+    }
+  });
+
+  var declarations = [];
+
+  Object.keys(vars).forEach(function(name) {
+    if (!hasOwn.call(paramNames, name)) {
+      declarations.push(b.variableDeclarator(vars[name], null));
+    }
+  });
+
+  if (declarations.length === 0) {
+    return null; // Be sure to handle this case!
+  }
+
+  return b.variableDeclaration("var", declarations);
+};

lib/6to5/transformation/transformers/generators/index.js

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

lib/6to5/transformation/transformers/generators/leap.js

@@ -0,0 +1,179 @@
+/**
+ * Copyright (c) 2014, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * https://raw.github.com/facebook/regenerator/master/LICENSE file. An
+ * additional grant of patent rights can be found in the PATENTS file in
+ * the same directory.
+ */
+
+var assert = require("assert");
+var types = require("ast-types");
+var n = types.namedTypes;
+var inherits = require("util").inherits;
+
+function Entry() {
+  assert.ok(this instanceof Entry);
+}
+
+function FunctionEntry(returnLoc) {
+  Entry.call(this);
+
+  n.Literal.assert(returnLoc);
+
+  Object.defineProperties(this, {
+    returnLoc: { value: returnLoc }
+  });
+}
+
+inherits(FunctionEntry, Entry);
+exports.FunctionEntry = FunctionEntry;
+
+function LoopEntry(breakLoc, continueLoc, label) {
+  Entry.call(this);
+
+  n.Literal.assert(breakLoc);
+  n.Literal.assert(continueLoc);
+
+  if (label) {
+    n.Identifier.assert(label);
+  } else {
+    label = null;
+  }
+
+  Object.defineProperties(this, {
+    breakLoc: { value: breakLoc },
+    continueLoc: { value: continueLoc },
+    label: { value: label }
+  });
+}
+
+inherits(LoopEntry, Entry);
+exports.LoopEntry = LoopEntry;
+
+function SwitchEntry(breakLoc) {
+  Entry.call(this);
+
+  n.Literal.assert(breakLoc);
+
+  Object.defineProperties(this, {
+    breakLoc: { value: breakLoc }
+  });
+}
+
+inherits(SwitchEntry, Entry);
+exports.SwitchEntry = SwitchEntry;
+
+function TryEntry(firstLoc, catchEntry, finallyEntry) {
+  Entry.call(this);
+
+  n.Literal.assert(firstLoc);
+
+  if (catchEntry) {
+    assert.ok(catchEntry instanceof CatchEntry);
+  } else {
+    catchEntry = null;
+  }
+
+  if (finallyEntry) {
+    assert.ok(finallyEntry instanceof FinallyEntry);
+  } else {
+    finallyEntry = null;
+  }
+
+  // Have to have one or the other (or both).
+  assert.ok(catchEntry || finallyEntry);
+
+  Object.defineProperties(this, {
+    firstLoc: { value: firstLoc },
+    catchEntry: { value: catchEntry },
+    finallyEntry: { value: finallyEntry }
+  });
+}
+
+inherits(TryEntry, Entry);
+exports.TryEntry = TryEntry;
+
+function CatchEntry(firstLoc, paramId) {
+  Entry.call(this);
+
+  n.Literal.assert(firstLoc);
+  n.Identifier.assert(paramId);
+
+  Object.defineProperties(this, {
+    firstLoc: { value: firstLoc },
+    paramId: { value: paramId }
+  });
+}
+
+inherits(CatchEntry, Entry);
+exports.CatchEntry = CatchEntry;
+
+function FinallyEntry(firstLoc) {
+  Entry.call(this);
+
+  n.Literal.assert(firstLoc);
+
+  Object.defineProperties(this, {
+    firstLoc: { value: firstLoc }
+  });
+}
+
+inherits(FinallyEntry, Entry);
+exports.FinallyEntry = FinallyEntry;
+
+function LeapManager(emitter) {
+  assert.ok(this instanceof LeapManager);
+
+  var Emitter = require("./emit").Emitter;
+  assert.ok(emitter instanceof Emitter);
+
+  Object.defineProperties(this, {
+    emitter: { value: emitter },
+    entryStack: {
+      value: [new FunctionEntry(emitter.finalLoc)]
+    }
+  });
+}
+
+var LMp = LeapManager.prototype;
+exports.LeapManager = LeapManager;
+
+LMp.withEntry = function(entry, callback) {
+  assert.ok(entry instanceof Entry);
+  this.entryStack.push(entry);
+  try {
+    callback.call(this.emitter);
+  } finally {
+    var popped = this.entryStack.pop();
+    assert.strictEqual(popped, entry);
+  }
+};
+
+LMp._findLeapLocation = function(property, label) {
+  for (var i = this.entryStack.length - 1; i >= 0; --i) {
+    var entry = this.entryStack[i];
+    var loc = entry[property];
+    if (loc) {
+      if (label) {
+        if (entry.label &&
+            entry.label.name === label.name) {
+          return loc;
+        }
+      } else {
+        return loc;
+      }
+    }
+  }
+
+  return null;
+};
+
+LMp.getBreakLoc = function(label) {
+  return this._findLeapLocation("breakLoc", label);
+};
+
+LMp.getContinueLoc = function(label) {
+  return this._findLeapLocation("continueLoc", label);
+};

lib/6to5/transformation/transformers/generators/meta.js

@@ -0,0 +1,100 @@
+/**
+ * Copyright (c) 2014, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * https://raw.github.com/facebook/regenerator/master/LICENSE file. An
+ * additional grant of patent rights can be found in the PATENTS file in
+ * the same directory.
+ */
+
+var assert = require("assert");
+var types = require("ast-types");
+var m = require("private").makeAccessor();
+var isArray = types.builtInTypes.array;
+var n = types.namedTypes;
+var hasOwn = Object.prototype.hasOwnProperty;
+
+function makePredicate(propertyName, knownTypes) {
+  function onlyChildren(node) {
+    n.Node.assert(node);
+
+    // Assume no side effects until we find out otherwise.
+    var result = false;
+
+    function check(child) {
+      if (result) {
+        // Do nothing.
+      } else if (isArray.check(child)) {
+        child.some(check);
+      } else if (n.Node.check(child)) {
+        assert.strictEqual(result, false);
+        result = predicate(child);
+      }
+      return result;
+    }
+
+    types.eachField(node, function(name, child) {
+      check(child);
+    });
+
+    return result;
+  }
+
+  function predicate(node) {
+    n.Node.assert(node);
+
+    var meta = m(node);
+    if (hasOwn.call(meta, propertyName))
+      return meta[propertyName];
+
+    // Certain types are "opaque," which means they have no side
+    // effects or leaps and we don't care about their subexpressions.
+    if (hasOwn.call(opaqueTypes, node.type))
+      return meta[propertyName] = false;
+
+    if (hasOwn.call(knownTypes, node.type))
+      return meta[propertyName] = true;
+
+    return meta[propertyName] = onlyChildren(node);
+  }
+
+  predicate.onlyChildren = onlyChildren;
+
+  return predicate;
+}
+
+var opaqueTypes = {
+  FunctionExpression: true
+};
+
+// These types potentially have side effects regardless of what side
+// effects their subexpressions have.
+var sideEffectTypes = {
+  CallExpression: true, // Anything could happen!
+  ForInStatement: true, // Modifies the key variable.
+  UnaryExpression: true, // Think delete.
+  BinaryExpression: true, // Might invoke .toString() or .valueOf().
+  AssignmentExpression: true, // Side-effecting by definition.
+  UpdateExpression: true, // Updates are essentially assignments.
+  NewExpression: true // Similar to CallExpression.
+};
+
+// These types are the direct cause of all leaps in control flow.
+var leapTypes = {
+  YieldExpression: true,
+  BreakStatement: true,
+  ContinueStatement: true,
+  ReturnStatement: true,
+  ThrowStatement: true
+};
+
+// All leap types are also side effect types.
+for (var type in leapTypes) {
+  if (hasOwn.call(leapTypes, type)) {
+    sideEffectTypes[type] = leapTypes[type];
+  }
+}
+
+exports.hasSideEffects = makePredicate("hasSideEffects", sideEffectTypes);
+exports.containsLeap = makePredicate("containsLeap", leapTypes);

lib/6to5/transformation/transformers/generators/runtime.js

@@ -0,0 +1,459 @@
+/**
+* Copyright (c) 2014, Facebook, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the BSD-style license found in the
+* https://raw.github.com/facebook/regenerator/master/LICENSE file. An
+* additional grant of patent rights can be found in the PATENTS file in
+* the same directory.
+*/
+
+if (typeof global.regeneratorRuntime === "object") {
+  return;
+}
+
+var hasOwn = Object.prototype.hasOwnProperty;
+var iteratorSymbol = typeof Symbol === "function" && Symbol.iterator || "@@iterator";
+var runtime = global.regeneratorRuntime = exports;
+
+var wrap = runtime.wrap = function wrap(innerFn, outerFn, self, tryList) {
+  return new Generator(innerFn, outerFn, self || null, tryList || []);
+};
+
+var GenStateSuspendedStart = "suspendedStart";
+var GenStateSuspendedYield = "suspendedYield";
+var GenStateExecuting = "executing";
+var GenStateCompleted = "completed";
+
+// Returning this object from the innerFn has the same effect as
+// breaking out of the dispatch switch statement.
+var ContinueSentinel = {};
+
+// Dummy constructor that we use as the .constructor property for
+// functions that return Generator objects.
+var GF = function GeneratorFunction() {};
+var GFp = function GeneratorFunctionPrototype() {};
+var Gp = GFp.prototype = Generator.prototype;
+(GFp.constructor = GF).prototype =
+  Gp.constructor = GFp;
+
+// Ensure isGeneratorFunction works when Function#name not supported.
+var GFName = "GeneratorFunction";
+if (GF.name !== GFName) GF.name = GFName;
+if (GF.name !== GFName) throw new Error(GFName + " renamed?");
+
+runtime.isGeneratorFunction = function(genFun) {
+  var ctor = genFun && genFun.constructor;
+  return ctor ? GF.name === ctor.name : false;
+};
+
+runtime.mark = function(genFun) {
+  genFun.__proto__ = GFp;
+  genFun.prototype = Object.create(Gp);
+  return genFun;
+};
+
+runtime.async = function(innerFn, outerFn, self, tryList) {
+  return new Promise(function(resolve, reject) {
+    var generator = wrap(innerFn, outerFn, self, tryList);
+    var callNext = step.bind(generator.next);
+    var callThrow = step.bind(generator["throw"]);
+
+    function step(arg) {
+      var info;
+      var value;
+
+      try {
+        info = this(arg);
+        value = info.value;
+      } catch (error) {
+        return reject(error);
+      }
+
+      if (info.done) {
+        resolve(value);
+      } else {
+        Promise.resolve(value).then(callNext, callThrow);
+      }
+    }
+
+    callNext();
+  });
+};
+
+function Generator(innerFn, outerFn, self, tryList) {
+  var generator = outerFn ? Object.create(outerFn.prototype) : this;
+  var context = new Context(tryList);
+  var state = GenStateSuspendedStart;
+
+  function invoke(method, arg) {
+    if (state === GenStateExecuting) {
+      throw new Error("Generator is already running");
+    }
+
+    if (state === GenStateCompleted) {
+      throw new Error("Generator has already finished");
+    }
+
+    while (true) {
+      var delegate = context.delegate;
+      var info;
+
+      if (delegate) {
+        try {
+          info = delegate.iterator[method](arg);
+
+          // Delegate generator ran and handled its own exceptions so
+          // regardless of what the method was, we continue as if it is
+          // "next" with an undefined arg.
+          method = "next";
+          arg = undefined;
+
+        } catch (uncaught) {
+          context.delegate = null;
+
+          // Like returning generator.throw(uncaught), but without the
+          // overhead of an extra function call.
+          method = "throw";
+          arg = uncaught;
+
+          continue;
+        }
+
+        if (info.done) {
+          context[delegate.resultName] = info.value;
+          context.next = delegate.nextLoc;
+        } else {
+          state = GenStateSuspendedYield;
+          return info;
+        }
+
+        context.delegate = null;
+      }
+
+      if (method === "next") {
+        if (state === GenStateSuspendedStart &&
+            typeof arg !== "undefined") {
+          // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
+          throw new TypeError(
+            "attempt to send " + JSON.stringify(arg) + " to newborn generator"
+          );
+        }
+
+        if (state === GenStateSuspendedYield) {
+          context.sent = arg;
+        } else {
+          delete context.sent;
+        }
+
+      } else if (method === "throw") {
+        if (state === GenStateSuspendedStart) {
+          state = GenStateCompleted;
+          throw arg;
+        }
+
+        if (context.dispatchException(arg)) {
+          // If the dispatched exception was caught by a catch block,
+          // then let that catch block handle the exception normally.
+          method = "next";
+          arg = undefined;
+        }
+
+      } else if (method === "return") {
+        context.abrupt("return", arg);
+      }
+
+      state = GenStateExecuting;
+
+      try {
+        var value = innerFn.call(self, context);
+
+        // If an exception is thrown from innerFn, we leave state ===
+        // GenStateExecuting and loop back for another invocation.
+        state = context.done ? GenStateCompleted : GenStateSuspendedYield;
+
+        info = {
+          value: value,
+          done: context.done
+        };
+
+        if (value === ContinueSentinel) {
+          if (context.delegate && method === "next") {
+            // Deliberately forget the last sent value so that we don't
+            // accidentally pass it on to the delegate.
+            arg = undefined;
+          }
+        } else {
+          return info;
+        }
+
+      } catch (thrown) {
+        state = GenStateCompleted;
+
+        if (method === "next") {
+          context.dispatchException(thrown);
+        } else {
+          arg = thrown;
+        }
+      }
+    }
+  }
+
+  generator.next = invoke.bind(generator, "next");
+  generator["throw"] = invoke.bind(generator, "throw");
+  generator["return"] = invoke.bind(generator, "return");
+
+  return generator;
+}
+
+Gp[iteratorSymbol] = function() {
+  return this;
+};
+
+Gp.toString = function() {
+  return "[object Generator]";
+};
+
+function pushTryEntry(triple) {
+  var entry = { tryLoc: triple[0] };
+
+  if (1 in triple) {
+    entry.catchLoc = triple[1];
+  }
+
+  if (2 in triple) {
+    entry.finallyLoc = triple[2];
+  }
+
+  this.tryEntries.push(entry);
+}
+
+function resetTryEntry(entry, i) {
+  var record = entry.completion || {};
+  record.type = i === 0 ? "normal" : "return";
+  delete record.arg;
+  entry.completion = record;
+}
+
+function Context(tryList) {
+  // The root entry object (effectively a try statement without a catch
+  // or a finally block) gives us a place to store values thrown from
+  // locations where there is no enclosing try statement.
+  this.tryEntries = [{ tryLoc: "root" }];
+  tryList.forEach(pushTryEntry, this);
+  this.reset();
+}
+
+runtime.keys = function(object) {
+  var keys = [];
+  for (var key in object) {
+    keys.push(key);
+  }
+  keys.reverse();
+
+  // Rather than returning an object with a next method, we keep
+  // things simple and return the next function itself.
+  return function next() {
+    while (keys.length) {
+      var key = keys.pop();
+      if (key in object) {
+        next.value = key;
+        next.done = false;
+        return next;
+      }
+    }
+
+    // To avoid creating an additional object, we just hang the .value
+    // and .done properties off the next function object itself. This
+    // also ensures that the minifier will not anonymize the function.
+    next.done = true;
+    return next;
+  };
+};
+
+function values(iterable) {
+  var iterator = iterable;
+  if (iteratorSymbol in iterable) {
+    iterator = iterable[iteratorSymbol]();
+  } else if (!isNaN(iterable.length)) {
+    var i = -1;
+    iterator = function next() {
+      while (++i < iterable.length) {
+        if (i in iterable) {
+          next.value = iterable[i];
+          next.done = false;
+          return next;
+        }
+      }
+      next.done = true;
+      return next;
+    };
+    iterator.next = iterator;
+  }
+  return iterator;
+}
+runtime.values = values;
+
+Context.prototype = {
+  constructor: Context,
+
+  reset: function() {
+    this.prev = 0;
+    this.next = 0;
+    this.sent = undefined;
+    this.done = false;
+    this.delegate = null;
+
+    this.tryEntries.forEach(resetTryEntry);
+
+    // Pre-initialize at least 20 temporary variables to enable hidden
+    // class optimizations for simple generators.
+    for (var tempIndex = 0, tempName;
+         hasOwn.call(this, tempName = "t" + tempIndex) || tempIndex < 20;
+         ++tempIndex) {
+      this[tempName] = null;
+    }
+  },
+
+  stop: function() {
+    this.done = true;
+
+    var rootEntry = this.tryEntries[0];
+    var rootRecord = rootEntry.completion;
+    if (rootRecord.type === "throw") {
+      throw rootRecord.arg;
+    }
+
+    return this.rval;
+  },
+
+  dispatchException: function(exception) {
+    if (this.done) {
+      throw exception;
+    }
+
+    var context = this;
+    function handle(loc, caught) {
+      record.type = "throw";
+      record.arg = exception;
+      context.next = loc;
+      return !!caught;
+    }
+
+    for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+      var entry = this.tryEntries[i];
+      var record = entry.completion;
+
+      if (entry.tryLoc === "root") {
+        // Exception thrown outside of any try block that could handle
+        // it, so set the completion value of the entire function to
+        // throw the exception.
+        return handle("end");
+      }
+
+      if (entry.tryLoc <= this.prev) {
+        var hasCatch = hasOwn.call(entry, "catchLoc");
+        var hasFinally = hasOwn.call(entry, "finallyLoc");
+
+        if (hasCatch && hasFinally) {
+          if (this.prev < entry.catchLoc) {
+            return handle(entry.catchLoc, true);
+          } else if (this.prev < entry.finallyLoc) {
+            return handle(entry.finallyLoc);
+          }
+
+        } else if (hasCatch) {
+          if (this.prev < entry.catchLoc) {
+            return handle(entry.catchLoc, true);
+          }
+
+        } else if (hasFinally) {
+          if (this.prev < entry.finallyLoc) {
+            return handle(entry.finallyLoc);
+          }
+
+        } else {
+          throw new Error("try statement without catch or finally");
+        }
+      }
+    }
+  },
+
+  _findFinallyEntry: function(finallyLoc) {
+    for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+      var entry = this.tryEntries[i];
+      if (entry.tryLoc <= this.prev &&
+          hasOwn.call(entry, "finallyLoc") && (
+            entry.finallyLoc === finallyLoc ||
+            this.prev < entry.finallyLoc)) {
+        return entry;
+      }
+    }
+  },
+
+  abrupt: function(type, arg) {
+    var entry = this._findFinallyEntry();
+    var record = entry ? entry.completion : {};
+
+    record.type = type;
+    record.arg = arg;
+
+    if (entry) {
+      this.next = entry.finallyLoc;
+    } else {
+      this.complete(record);
+    }
+
+    return ContinueSentinel;
+  },
+
+  complete: function(record) {
+    if (record.type === "throw") {
+      throw record.arg;
+    }
+
+    if (record.type === "break" ||
+        record.type === "continue") {
+      this.next = record.arg;
+    } else if (record.type === "return") {
+      this.rval = record.arg;
+      this.next = "end";
+    }
+
+    return ContinueSentinel;
+  },
+
+  finish: function(finallyLoc) {
+    var entry = this._findFinallyEntry(finallyLoc);
+    return this.complete(entry.completion);
+  },
+
+  "catch": function(tryLoc) {
+    for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+      var entry = this.tryEntries[i];
+      if (entry.tryLoc === tryLoc) {
+        var record = entry.completion;
+        var thrown;
+        if (record.type === "throw") {
+          thrown = record.arg;
+          resetTryEntry(entry, i);
+        }
+        return thrown;
+      }
+    }
+
+    // The context.catch method must only be called with a location
+    // argument that corresponds to a known catch block.
+    throw new Error("illegal catch attempt");
+  },
+
+  delegateYield: function(iterable, resultName, nextLoc) {
+    this.delegate = {
+      iterator: values(iterable),
+      resultName: resultName,
+      nextLoc: nextLoc
+    };
+
+    return ContinueSentinel;
+  }
+};

lib/6to5/transformation/transformers/generators/util.js

@@ -0,0 +1,37 @@
+/**
+ * Copyright (c) 2014, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * https://raw.github.com/facebook/regenerator/master/LICENSE file. An
+ * additional grant of patent rights can be found in the PATENTS file in
+ * the same directory.
+ */
+
+var b = require("ast-types").builders;
+var hasOwn = Object.prototype.hasOwnProperty;
+
+exports.defaults = function(obj) {
+  var len = arguments.length;
+  var extension;
+
+  for (var i = 1; i < len; ++i) {
+    if ((extension = arguments[i])) {
+      for (var key in extension) {
+        if (hasOwn.call(extension, key) && !hasOwn.call(obj, key)) {
+          obj[key] = extension[key];
+        }
+      }
+    }
+  }
+
+  return obj;
+};
+
+exports.runtimeProperty = function(name) {
+  return b.memberExpression(
+    b.identifier("regeneratorRuntime"),
+    b.identifier(name),
+    false
+  );
+};

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

@@ -0,0 +1,222 @@
+/**
+ * Copyright (c) 2014, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * https://raw.github.com/facebook/regenerator/master/LICENSE file. An
+ * additional grant of patent rights can be found in the PATENTS file in
+ * the same directory.
+ */
+
+var types = require("ast-types");
+var n = types.namedTypes;
+var b = types.builders;
+var hoist = require("./hoist").hoist;
+var Emitter = require("./emit").Emitter;
+var runtimeProperty = require("./util").runtimeProperty;
+var runtimeWrapMethod = runtimeProperty("wrap");
+var runtimeMarkMethod = runtimeProperty("mark");
+var runtimeAsyncMethod = runtimeProperty("async");
+
+exports.transform = function transform(node) {
+  return types.visit(node, visitor);
+};
+
+var visitor = types.PathVisitor.fromMethodsObject({
+  visitFunction: function(path) {
+    // Calling this.traverse(path) first makes for a post-order traversal.
+    this.traverse(path);
+
+    var node = path.value;
+
+    if (!node.generator && !node.async) {
+      return;
+    }
+
+    node.generator = false;
+
+    if (node.expression) {
+      // Transform expression lambdas into normal functions.
+      node.expression = false;
+      node.body = b.blockStatement([
+        b.returnStatement(node.body)
+      ]);
+    }
+
+    if (node.async) {
+      awaitVisitor.visit(path.get("body"));
+    }
+
+    var outerFnId = node.id || (
+      node.id = path.scope.parent.declareTemporary("callee$")
+    );
+
+    var innerFnId = b.identifier(node.id.name + "$");
+    var contextId = path.scope.declareTemporary("context$");
+    var vars = hoist(path);
+
+    var emitter = new Emitter(contextId);
+    emitter.explode(path.get("body"));
+
+    var outerBody = [];
+
+    if (vars && vars.declarations.length > 0) {
+      outerBody.push(vars);
+    }
+
+    var wrapArgs = [
+      emitter.getContextFunction(innerFnId),
+      // Async functions don't care about the outer function because they
+      // don't need it to be marked and don't inherit from its .prototype.
+      node.async ? b.literal(null) : outerFnId,
+      b.thisExpression()
+    ];
+
+    var tryEntryList = emitter.getTryEntryList();
+    if (tryEntryList) {
+      wrapArgs.push(tryEntryList);
+    }
+
+    var wrapCall = b.callExpression(
+      node.async ? runtimeAsyncMethod : runtimeWrapMethod,
+      wrapArgs
+    );
+
+    outerBody.push(b.returnStatement(wrapCall));
+    node.body = b.blockStatement(outerBody);
+
+    if (node.async) {
+      node.async = false;
+      return;
+    }
+
+    if (n.FunctionDeclaration.check(node)) {
+      var pp = path.parent;
+
+      while (pp && !(n.BlockStatement.check(pp.value) ||
+                     n.Program.check(pp.value))) {
+        pp = pp.parent;
+      }
+
+      if (!pp) {
+        return;
+      }
+
+      // Here we turn the FunctionDeclaration into a named
+      // FunctionExpression that will be assigned to a variable of the
+      // same name at the top of the enclosing block. This is important
+      // for a very subtle reason: named function expressions can refer to
+      // themselves by name without fear that the binding may change due
+      // to code executing outside the function, whereas function
+      // declarations are vulnerable to the following rebinding:
+      //
+      //   function f() { return f }
+      //   var g = f;
+      //   f = "asdf";
+      //   g(); // "asdf"
+      //
+      // One way to prevent the problem illustrated above is to transform
+      // the function declaration thus:
+      //
+      //   var f = function f() { return f };
+      //   var g = f;
+      //   f = "asdf";
+      //   g(); // f
+      //   g()()()()(); // f
+      //
+      // In the code below, we transform generator function declarations
+      // in the following way:
+      //
+      //   gen().next(); // { value: gen, done: true }
+      //   function *gen() {
+      //     return gen;
+      //   }
+      //
+      // becomes something like
+      //
+      //   var gen = runtime.mark(function *gen() {
+      //     return gen;
+      //   });
+      //   gen().next(); // { value: gen, done: true }
+      //
+      // which ensures that the generator body can always reliably refer
+      // to gen by name.
+
+      // Remove the FunctionDeclaration so that we can add it back as a
+      // FunctionExpression passed to runtime.mark.
+      path.replace();
+
+      // Change the type of the function to be an expression instead of a
+      // declaration. Note that all the other fields are the same.
+      node.type = "FunctionExpression";
+
+      var varDecl = b.variableDeclaration("var", [
+        b.variableDeclarator(
+          node.id,
+          b.callExpression(runtimeMarkMethod, [node])
+        )
+      ]);
+
+      if (node.comments) {
+        // Copy any comments preceding the function declaration to the
+        // variable declaration, to avoid weird formatting consequences.
+        varDecl.comments = node.comments;
+        node.comments = null;
+      }
+
+      var bodyPath = pp.get("body");
+      var bodyLen = bodyPath.value.length;
+
+      for (var i = 0; i < bodyLen; ++i) {
+        var firstStmtPath = bodyPath.get(i);
+        if (!shouldNotHoistAbove(firstStmtPath)) {
+          firstStmtPath.insertBefore(varDecl);
+          return;
+        }
+      }
+
+      bodyPath.push(varDecl);
+
+    } else {
+      n.FunctionExpression.assert(node);
+      return b.callExpression(runtimeMarkMethod, [node]);
+    }
+  }
+});
+
+function shouldNotHoistAbove(stmtPath) {
+  var value = stmtPath.value;
+  n.Statement.assert(value);
+
+  // If the first statement is a "use strict" declaration, make sure to
+  // insert hoisted declarations afterwards.
+  if (n.ExpressionStatement.check(value) &&
+      n.Literal.check(value.expression) &&
+      value.expression.value === "use strict") {
+    return true;
+  }
+
+  if (n.VariableDeclaration.check(value)) {
+    for (var i = 0; i < value.declarations.length; ++i) {
+      var decl = value.declarations[i];
+      if (n.CallExpression.check(decl.init) &&
+          types.astNodesAreEquivalent(decl.init.callee,
+                                      runtimeMarkMethod)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+var awaitVisitor = types.PathVisitor.fromMethodsObject({
+  visitFunction: function() {
+    return false; // Don't descend into nested function scopes.
+  },
+
+  visitAwaitExpression: function(path) {
+    // Convert await expressions to yield expressions.
+    return b.yieldExpression(path.value.argument, false);
+  }
+});

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

@@ -74,7 +74,6 @@ function LetScoping(forParent, block, parent, file, scope) {
 
   this.letReferences = {};
   this.body          = [];
-  this.info          = this.getInfo();
 }
 
 /**
@@ -87,8 +86,10 @@ LetScoping.prototype.run = function () {
   if (block._letDone) return;
   block._letDone = true;
 
+  this.info = this.getInfo();
+
   // this is a block within a `Function` so we can safely leave it be
-  if (t.isFunction(this.parent)) return;
+  if (t.isFunction(this.parent)) return this.noClosure();
 
   // this block has no let references so let's clean up
   if (!this.info.keys.length) return this.noClosure();
@@ -127,6 +128,12 @@ LetScoping.prototype.run = function () {
   var call = t.callExpression(fn, params);
   var ret  = t.identifier(this.file.generateUid("ret", this.scope));
 
+  var hasYield = traverse.hasType(fn.body, "YieldExpression", t.FUNCTION_TYPES);
+  if (hasYield) {
+    fn.generator = true;
+    call = t.yieldExpression(call, true);
+  }
+
   this.build(ret, call);
 };
 
@@ -145,11 +152,25 @@ LetScoping.prototype.noClosure = function () {
 
   if (_.isEmpty(replacements)) return;
 
-  traverse(block, function (node, parent) {
+  var replace = function (node, parent) {
     if (!t.isIdentifier(node)) return;
     if (!t.isReferenced(node, parent)) return;
     node.name = replacements[node.name] || node.name;
-  });
+  };
+
+  var traverseReplace = function (node, parent) {
+    replace(node, parent);
+    traverse(node, replace);
+  };
+
+  var forParent = this.forParent;
+  if (forParent) {
+    traverseReplace(forParent.right, forParent);
+    traverseReplace(forParent.test, forParent);
+    traverseReplace(forParent.update, forParent);
+  }
+
+  traverse(block, replace);
 };
 
 /**
@@ -181,10 +202,23 @@ LetScoping.prototype.getInfo = function () {
     keys:        []
   };
 
+  var duplicates = function (id, key) {
+    var has = scope.parentGet(key);
+
+    if (has && has !== id) {
+      // there's a variable with this exact name in an upper scope so we need
+      // to generate a new name
+      opts.duplicates[key] = id.name = file.generateUid(key, scope);
+    }
+  };
+
   _.each(opts.declarators, function (declar) {
     opts.declarators.push(declar);
 
-    var keys = t.getIds(declar);
+    var keys = t.getIds(declar, true);
+    _.each(keys, duplicates);
+    keys = _.keys(keys);
+
     opts.outsideKeys = opts.outsideKeys.concat(keys);
     opts.keys = opts.keys.concat(keys);
   });
@@ -193,14 +227,7 @@ LetScoping.prototype.getInfo = function () {
     if (!isLet(declar)) return;
 
     _.each(t.getIds(declar, true), function (id, key) {
-      var has = scope.parentGet(key);
-
-      if (has && has !== id) {
-        // there's a variable with this exact name in an upper scope so we need
-        // to generate a new name
-        opts.duplicates[key] = id.name = file.generateUid(key, scope);
-      }
-
+      duplicates(id, key);
       opts.keys.push(key);
     });
   });
@@ -224,28 +251,34 @@ LetScoping.prototype.checkFor = function () {
     hasBreak:    false,
   };
 
-  if (this.forParent) {
-    traverse(this.block, function (node) {
-      var replace;
+  var forParent = this.forParent;
 
-      if (t.isFunction(node) || t.isFor(node)) {
-        return false;
-      } else if (t.isBreakStatement(node) && !node.label) {
+  traverse(this.block, function (node) {
+    var replace;
+
+    if (t.isFunction(node) || t.isFor(node)) {
+      return false;
+    }
+
+    if (forParent && !node.label) {
+      if (t.isBreakStatement(node)) {
         has.hasBreak = true;
         replace = t.returnStatement(t.literal("break"));
-      } else if (t.isContinueStatement(node) && !node.label) {
+      } else if (t.isContinueStatement(node)) {
         has.hasContinue = true;
         replace = t.returnStatement(t.literal("continue"));
-      } else if (t.isReturnStatement(node)) {
-        has.hasReturn = true;
-        replace = t.returnStatement(t.objectExpression([
-          t.property("init", t.identifier("v"), node.argument || t.identifier("undefined"))
-        ]));
       }
+    }
 
-      if (replace) return t.inherits(replace, node);
-    });
-  }
+    if (t.isReturnStatement(node)) {
+      has.hasReturn = true;
+      replace = t.returnStatement(t.objectExpression([
+        t.property("init", t.identifier("v"), node.argument || t.identifier("undefined"))
+      ]));
+    }
+
+    if (replace) return t.inherits(replace, node);
+  });
 
   return has;
 };
@@ -341,7 +374,7 @@ LetScoping.prototype.getLetReferences = function () {
  * @returns {Array}
  */
 
-LetScoping.prototype.buildPushDeclar = function (node) {
+LetScoping.prototype.pushDeclar = function (node) {
   this.body.push(t.variableDeclaration(node.kind, node.declarations.map(function (declar) {
     return t.variableDeclarator(declar.id);
   })));

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

@@ -106,11 +106,35 @@ exports.XJSElement = {
   exit: function (node) {
     var callExpr = node.openingElement;
 
-    var childrenToRender = node.children.filter(function(child) {
-      return !(t.isLiteral(child) && _.isString(child.value) && child.value.match(/^[ \t]*[\r\n][ \t\r\n]*$/));
-    });
+    _.each(node.children, function (child) {
+      if (t.isLiteral(child)) {
+        var lines = child.value.split(/\r\n|\n|\r/);
+
+        _.each(lines, function (line, i) {
+          var isFirstLine = i === 0;
+          var isLastLine = i === lines.length - 1;
+
+          // replace rendered whitespace tabs with spaces
+          var trimmedLine = line.replace(/\t/g, ' ');
+
+          // trim whitespace touching a newline
+          if (!isFirstLine) {
+            trimmedLine = trimmedLine.replace(/^[ ]+/, '');
+          }
+
+          // trim whitespace touching an endline
+          if (!isLastLine) {
+            trimmedLine = trimmedLine.replace(/[ ]+$/, '');
+          }
+
+          if (trimmedLine) {
+            callExpr.arguments.push(t.literal(trimmedLine));
+          }
+        });
+
+        return;
+      }
 
-    _.each(childrenToRender, function (child) {
       callExpr.arguments.push(child);
     });
 

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

@@ -5,14 +5,22 @@ var buildBinaryExpression = function (left, right) {
   return t.binaryExpression("+", left, right);
 };
 
-exports.TaggedTemplateExpression = function (node) {
+exports.TaggedTemplateExpression = function (node, parent, file) {
   var args = [];
   var quasi = node.quasi;
 
-  var strings = quasi.quasis.map(function (elem) {
-    return t.literal(elem.value.raw);
+  var strings = [];
+  var raw = [];
+
+  _.each(quasi.quasis, function (elem) {
+    strings.push(t.literal(elem.value.cooked));
+    raw.push(t.literal(elem.value.raw));
   });
-  args.push(t.arrayExpression(strings));
+
+  args.push(t.callExpression(file.addDeclaration("tagged-template-literal"), [
+    t.arrayExpression(strings),
+    t.arrayExpression(raw)
+  ]));
 
   _.each(quasi.expressions, function (expr) {
     args.push(expr);

lib/6to5/traverse/index.js

@@ -29,25 +29,32 @@ function traverse(parent, callbacks, opts) {
   // normalise callbacks
   if (_.isFunction(callbacks)) callbacks = { enter: callbacks };
 
-  _.each(keys, function (key) {
+  for (var i in keys) {
+    var key = keys[i];
     var nodes = parent[key];
-    if (!nodes) return;
+    if (!nodes) continue;
+
+    var updated = false;
 
     var handle = function (obj, key) {
       var node = obj[key];
       if (!node) return;
 
       // type is blacklisted
-      if (_.contains(blacklistTypes, node.type)) return;
+      if (blacklistTypes.indexOf(node.type) > -1) return;
 
       // replace node
       var maybeReplace = function (result) {
         if (result === false) return;
-        if (result != null) node = obj[key] = result;
+
+        if (result != null) {
+          updated = true;
+          node = obj[key] = result;
+        }
       };
 
       //
-      var opts2 = _.clone(opts);
+      var opts2 = { scope: opts.scope, blacklist: opts.blacklist };
       if (t.isScope(node)) opts2.scope = new Scope(opts.scope, node);
 
       // enter
@@ -69,15 +76,15 @@ function traverse(parent, callbacks, opts) {
     };
 
     if (_.isArray(nodes)) {
-      _.each(nodes, function (node, i) {
+      for (i in nodes) {
         handle(nodes, i);
-      });
+      }
 
-      parent[key] = _.flatten(parent[key]);
+      if (updated) parent[key] = _.flatten(parent[key]);
     } else {
       handle(parent, key);
     }
-  });
+  }
 }
 
 traverse.removeProperties = function (tree) {

lib/6to5/traverse/scope.js

@@ -4,54 +4,93 @@ var traverse = require("./index");
 var t        = require("../types");
 var _        = require("lodash");
 
+var FOR_KEYS = ["left", "init"];
+
 function Scope(parent, block) {
   this.parent = parent;
   this.block  = block;
-  this.ids    = this.getIds();
 
-  this.getIds();
+  this.info         = this.getInfo();
+  this.declarations = this.info.declarations;
 }
 
-Scope.prototype.getIds = function () {
+Scope.prototype.getInfo = function () {
   var block = this.block;
-  if (block._scopeIds) return block._scopeIds;
+  if (block._scope) return block._scope;
 
   var self = this;
-  var ids  = block._scopeIds = {};
+  var info = block._scope = {
+    declarations: {}
+  };
 
-  if (t.isBlockStatement(block)) {
-    _.each(block.body, function (node) {
-      if (t.isVariableDeclaration(node) && node.kind !== "var") {
-        self.add(node, ids);
-      }
-    });
-  } else if (t.isProgram(block) || t.isFunction(block)) {
-    traverse(block, function (node, parent) {
-      if (parent !== block && t.isVariableDeclaration(node) && node.kind !== "var") {
-        return;
-      }
+  var add = function (node) {
+    self.addDeclaration(node, info.declarations);
+  };
 
-      if (t.isDeclaration(node)) {
-        self.add(node, ids);
-      } else if (t.isFunction(node)) {
-        return false;
-      }
+  // ForStatement - left, init
+
+  if (t.isFor(block)) {
+    _.each(FOR_KEYS, function (key) {
+      var node = block[key];
+      if (t.isLet(node)) add(node);
     });
-  } else if (t.isCatchClause(block)) {
-    self.add(block.param, ids);
+
+    block = block.body;
   }
 
+  // Program, BlockStatement - let variables
+
+  if (t.isBlockStatement(block) || t.isProgram(block)) {
+    _.each(block.body, function (node) {
+      // check for non-var `VariableDeclaration`s
+      if (t.isLet(node)) add(node);
+    });
+  }
+
+  // CatchClause - param
+
+  if (t.isCatchClause(block)) {
+    add(block.param);
+  }
+
+  // Program, Function - var variables
+
+  if (t.isProgram(block) || t.isFunction(block)) {
+    traverse(block, function (node) {
+      if (t.isFor(node)) {
+        _.each(FOR_KEYS, function (key) {
+          var declar = node[key];
+          if (t.isVar(declar)) add(declar);
+        });
+      }
+
+      // this block is a function so we'll stop since none of the variables
+      // declared within are accessible
+      if (t.isFunction(node)) return false;
+
+      // we've ran into a declaration!
+      // we'll let the BlockStatement scope deal with `let` declarations
+      if (t.isDeclaration(node) && !t.isLet(node)) {
+        add(node);
+      }
+    });
+  }
+
+  // Function - params, rest
+
   if (t.isFunction(block)) {
+    add(block.rest);
     _.each(block.params, function (param) {
-      self.add(param, ids);
+      add(param);
     });
   }
 
-  return ids;
+  return info;
 };
 
-Scope.prototype.add = function (node, ids) {
-  _.merge(ids || this.ids, t.getIds(node, true));
+Scope.prototype.addDeclaration = function (node, declarations) {
+  if (!node) return;
+  _.merge(declarations || this.declarations, t.getIds(node, true));
 };
 
 Scope.prototype.get = function (id) {
@@ -59,7 +98,7 @@ Scope.prototype.get = function (id) {
 };
 
 Scope.prototype.getOwn = function (id) {
-  return _.has(this.ids, id) && this.ids[id];
+  return _.has(this.declarations, id) && this.declarations[id];
 };
 
 Scope.prototype.parentGet = function (id) {

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

@@ -35,9 +35,9 @@
   "ClassDeclaration": ["Statement", "Declaration", "Class"],
   "ClassExpression":  ["Class"],
 
-  "ForOfStatement": ["Statement", "For"],
-  "ForInStatement": ["Statement", "For"],
-  "ForStatement":   ["Statement", "For"],
+  "ForOfStatement": ["Statement", "For", "Scope"],
+  "ForInStatement": ["Statement", "For", "Scope"],
+  "ForStatement":   ["Statement", "For", "Scope"],
 
   "ObjectPattern": ["Pattern"],
   "ArrayPattern":  ["Pattern"],

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

@@ -21,5 +21,6 @@
   "SequenceExpression":      ["expressions"],
   "UnaryExpression":         ["operator", "argument", "prefix"],
   "VariableDeclaration":     ["kind", "declarations"],
-  "VariableDeclarator":      ["id", "init"]
+  "VariableDeclarator":      ["id", "init"],
+  "YieldExpression":         ["argument", "delegate"]
 }

lib/6to5/types/index.js

@@ -70,6 +70,9 @@ t.isReferenced = function (node, parent) {
   // we're a property key so we aren't referenced
   if (t.isProperty(parent) && parent.key === node) return false;
 
+  // we're a variable declarator id so we aren't referenced
+  if (t.isVariableDeclarator(parent) && parent.id === node) return false;
+
   var isMemberExpression = t.isMemberExpression(parent);
 
   // we're in a member expression and we're the computed property so we're referenced
@@ -161,7 +164,7 @@ t.toBlock = function (node, parent) {
 t.getIds = function (node, map, ignoreTypes) {
   ignoreTypes = ignoreTypes || [];
 
-  var search = [node];
+  var search = [].concat(node);
   var ids    = {};
 
   while (search.length) {
@@ -206,13 +209,32 @@ t.getIds.arrays = {
   ObjectPattern: "properties"
 };
 
+t.isLet = function (node) {
+  return t.isVariableDeclaration(node) && (node.kind !== "var" || node._let);
+};
+
+t.isVar = function (node) {
+  return t.isVariableDeclaration(node, { kind: "var" }) && !node._let;
+};
+
+t.removeComments = function (child) {
+  delete child.leadingComments;
+  delete child.trailingComments;
+  return child;
+};
+
+t.inheritsComments = function (child, parent) {
+  child.leadingComments  = _.compact([].concat(child.leadingComments, parent.leadingComments));
+  child.trailingComments = _.compact([].concat(child.trailingComments, parent.trailingComments));
+  return child;
+};
+
 t.inherits = function (child, parent) {
-  child.loc              = parent.loc;
-  child.end              = parent.end;
-  child.range            = parent.range;
-  child.start            = parent.start;
-  child.leadingComments  = parent.leadingComments;
-  child.trailingComments = parent.trailingComments;
+  child.loc   = parent.loc;
+  child.end   = parent.end;
+  child.range = parent.range;
+  child.start = parent.start;
+  t.inheritsComments(child, parent);
   return child;
 };
 

lib/6to5/util.js

@@ -17,6 +17,10 @@ exports.canCompile = function (filename, altExts) {
   return _.contains(exts, ext);
 };
 
+exports.isInteger = function (i) {
+  return _.isNumber(i) && i % 1 === 0;
+};
+
 exports.resolve = function (loc) {
   try {
     return require.resolve(loc);
@@ -102,8 +106,13 @@ exports.buildDefineProperties = function (mutatorMap) {
       if (key[0] === "_") return;
 
       node = _.clone(node);
+      var inheritNode = node;
       if (t.isMethodDefinition(node)) node = node.value;
-      mapNode.properties.push(t.property("init", t.identifier(key), node));
+
+      var prop = t.property("init", t.identifier(key), node);
+      t.inheritsComments(prop, inheritNode);
+      t.removeComments(inheritNode);
+      mapNode.properties.push(prop);
     });
 
     objExpr.properties.push(propNode);
@@ -123,23 +132,17 @@ exports.template = function (name, nodes, keepExpression) {
 
   template = _.cloneDeep(template);
 
-  var inherits = false;
-  if (nodes) {
-    inherits = nodes.inherits;
-    delete nodes.inherits;
-
-    if (!_.isEmpty(nodes)) {
-      traverse(template, function (node) {
-        if (t.isIdentifier(node) && _.has(nodes, node.name)) {
-          var newNode = nodes[node.name];
-          if (_.isString(newNode)) {
-            node.name = newNode;
-          } else {
-            return newNode;
-          }
+  if (!_.isEmpty(nodes)) {
+    traverse(template, function (node) {
+      if (t.isIdentifier(node) && _.has(nodes, node.name)) {
+        var newNode = nodes[node.name];
+        if (_.isString(newNode)) {
+          node.name = newNode;
+        } else {
+          return newNode;
         }
-      });
-    }
+      }
+    });
   }
 
   var node = template.body[0];
@@ -150,10 +153,6 @@ exports.template = function (name, nodes, keepExpression) {
     if (t.isParenthesizedExpression(node)) node = node.expression;
   }
 
-  if (inherits) {
-    node = t.inherits(node, inherits);
-  }
-
   return node;
 };
 
@@ -277,9 +276,5 @@ try {
 } catch (err) {
   if (err.code !== "MODULE_NOT_FOUND") throw err;
 
-  Object.defineProperty(exports, "templates", {
-    get: function () {
-      return exports.templates = loadTemplates();
-    }
-  });
+  exports.templates = loadTemplates();
 }

package.json

@@ -1,7 +1,7 @@
 {
   "name": "6to5",
   "description": "Turn ES6 code into readable vanilla ES5 with source maps",
-  "version": "1.12.9",
+  "version": "1.12.19",
   "author": "Sebastian McKenzie <sebmck@gmail.com>",
   "homepage": "https://github.com/6to5/6to5",
   "repository": {
@@ -44,12 +44,12 @@
     "es6-symbol": "0.1.1",
     "regexpu": "0.3.0",
     "source-map": "0.1.40",
-    "regenerator-6to5": "https://github.com/6to5/regenerator-6to5/archive/75925940a7bb67d1ee8afec36b6d6eec072fb47c.tar.gz",
     "chokidar": "0.10.5",
     "source-map-support": "0.2.8",
     "esutils": "1.1.4",
-    "acorn-6to5": "https://github.com/6to5/acorn-6to5/archive/a6c34ba73e215bd16ee585f6794f6a6587820c58.tar.gz",
-    "estraverse": "^1.7.0"
+    "acorn-6to5": "https://github.com/6to5/acorn-6to5/archive/74d8e9bed20ba302d3504f53d0b1c649968959e1.tar.gz",
+    "estraverse": "^1.7.0",
+    "private": "^0.1.6"
   },
   "devDependencies": {
     "istanbul": "0.3.2",

test/_generator-helpers.js

@@ -0,0 +1,33 @@
+var assert = require("assert");
+
+exports.check = function check(g, yields, returnValue) {
+  for (var i = 0; i < yields.length; ++i) {
+    var info = i > 0 ? g.next(i) : g.next();
+    assert.deepEqual(info.value, yields[i]);
+    assert.strictEqual(info.done, false);
+  }
+
+  assert.deepEqual(
+    i > 0 ? g.next(i) : g.next(),
+    { value: returnValue, done: true }
+  );
+};
+
+// A version of `throw` whose behavior can't be statically analyzed.
+// Useful for testing dynamic exception dispatching.
+exports.raise = function raise(argument) {
+  throw argument;
+};
+
+exports.assertAlreadyFinished = function assertAlreadyFinished(generator) {
+  try {
+    generator.next();
+    assert.ok(false, "should have thrown an exception");
+  } catch (err) {
+    assert.ok(err instanceof Error);
+    assert.strictEqual(
+      err.message,
+      "Generator has already finished"
+    );
+  }
+};

test/_helper.js

@@ -36,8 +36,6 @@ exports.get = function (entryName) {
     if (fs.existsSync(suiteOptsLoc)) suite.options = require(suiteOptsLoc);
 
     _.each(fs.readdirSync(suite.filename), function (taskName) {
-      if (taskName[0] === ".") return;
-
       var taskDir = suite.filename + "/" + taskName;
       if (fs.statSync(taskDir).isFile()) return;
 
@@ -50,8 +48,9 @@ exports.get = function (entryName) {
       var execLoc   = taskDir + "/exec.js";
 
       var taskOpts = _.merge({
-        filename: actualLocAlias,
-        sourceMapName: expectLocAlias
+        filenameRelative: expectLocAlias,
+        sourceFileName:   actualLocAlias,
+        sourceMapName:    expectLocAlias
       }, _.cloneDeep(suite.options));
 
       var taskOptsLoc = taskDir + "/options.json";
@@ -59,8 +58,10 @@ exports.get = function (entryName) {
 
       var test = {
         title: humanise(taskName),
+        disabled: taskName[0] === ".",
         options: taskOpts,
         exec: {
+          loc: execLoc,
           code: readFile(execLoc),
           filename: execLocAlias,
         },

test/api.js

@@ -0,0 +1,17 @@
+var transform = require("../lib/6to5/transformation/transform");
+var assert    = require("assert");
+var File      = require("../lib/6to5/file");
+
+suite("api", function () {
+  test("{ code: false }", function () {
+    var result = transform("foo('bar');", { code: false });
+    assert.ok(!result.code);
+  });
+
+  test("addDeclaration unknown", function () {
+    var file = new File;
+    assert.throws(function () {
+      file.addDeclaration("foob");
+    }, /unknown declaration foob/);
+  });
+});

test/fixtures/transformation/async/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2014, Facebook, Inc.
+All rights reserved.
+
+This source code is licensed under the BSD-style license found in the
+https://raw.github.com/facebook/regenerator/master/LICENSE file. An
+additional grant of patent rights can be found in the PATENTS file in
+the same directory.

test/fixtures/transformation/async/dependent-promises-should-be-awaitable-out-of-order/exec.js

@@ -0,0 +1,26 @@
+async function outer(value) {
+  var resolved = false;
+  var p1 = new Promise(function(resolve) {
+    setTimeout(function() {
+      resolve(value + 1);
+      resolved = true;
+    }, 0);
+  });
+
+  assert.strictEqual(resolved, false);
+
+  var v2 = await p1.then(function(value) {
+    return value + 1;
+  });
+
+  assert.strictEqual(resolved, true);
+
+  var v1 = await p1;
+
+  return [v1, v2];
+}
+
+outer(1).then(function(pair) {
+  assert.deepEqual(pair, [2, 3]);
+  done();
+}).catch(done);

test/fixtures/transformation/async/nested-async-function-calls-should-evaluate-in-the-right-order/exec.js

@@ -0,0 +1,40 @@
+var markers = [];
+
+async function innerMost(marker) {
+  markers.push(marker);
+  return await marker;
+}
+
+async function inner(marker) {
+  markers.push(marker);
+
+  assert.strictEqual(
+    await innerMost(marker + 1),
+    marker + 1
+  );
+
+  markers.push(marker + 2);
+
+  assert.strictEqual(
+    await innerMost(marker + 3),
+    marker + 3
+  );
+
+  markers.push(marker + 4);
+}
+
+async function outer() {
+  markers.push(0);
+  await inner(1);
+  markers.push(6);
+  await inner(7);
+  markers.push(12);
+}
+
+outer().then(function() {
+  var expected = [];
+  for (var i = 0; i <= 12; ++i)
+    expected.push(i);
+  assert.deepEqual(markers, expected);
+  done();
+}).catch(done);

test/fixtures/transformation/async/no-await-async-function-should-return-a-Promise/exec.js

@@ -0,0 +1,15 @@
+var called = false;
+
+async function noAwait(value) {
+  called = true;
+  return value;
+}
+
+var promise = noAwait("asdf");
+assert.strictEqual(called, true);
+
+promise.then(function(value) {
+  assert.strictEqual(called, true);
+  assert.strictEqual(value, "asdf");
+  done();
+}).catch(done);

test/fixtures/transformation/async/one-await-async-function-should-finish-asynchronously/exec.js

@@ -0,0 +1,19 @@
+var flag1 = false;
+var flag2 = false;
+
+async function oneAwait(value) {
+  flag1 = true;
+  var result = await value;
+  flag2 = true;
+  return result;
+}
+
+var promise = oneAwait("asdf");
+assert.strictEqual(flag1, true);
+assert.strictEqual(flag2, false);
+
+promise.then(function(value) {
+  assert.strictEqual(flag2, true);
+  assert.strictEqual(value, "asdf");
+  done();
+}).catch(done);

test/fixtures/transformation/async/options.json

@@ -0,0 +1,3 @@
+{
+  "asyncExec": true
+}

test/fixtures/transformation/async/rejected-promises-should-be-returned-by-exceptional-async-functions/exec.js

@@ -0,0 +1,42 @@
+var error = new Error("rejected");
+
+async function e(arg) {
+  if (arg) {
+    throw arg;
+  }
+  return "did not throw";
+}
+
+async function f(arg) {
+  return await e(arg);
+}
+
+async function g(arg) {
+  return await f(arg);
+}
+
+async function h(arg) {
+  return await Promise.all([
+    g(arg),
+    Promise.resolve("dummy")
+  ]);
+}
+
+Promise.all([
+  h(error).then(function() {
+    done(new Error("should not have resolved"));
+  }, function(e) {
+    assert.strictEqual(e, error);
+    return "ok1";
+  }),
+  h(null).then(function(result) {
+    assert.deepEqual(result, [
+      "did not throw",
+      "dummy"
+    ]);
+    return "ok2";
+  })
+]).then(function(results) {
+  assert.deepEqual(results, ["ok1", "ok2"]);
+  done();
+}).catch(done);

test/fixtures/transformation/async/rejected-promises-should-cause-await-expressions-to-throw/exec.js

@@ -0,0 +1,21 @@
+var error = new Error("rejected");
+
+async function f(arg) {
+  try {
+    return await arg;
+  } catch (e) {
+    assert.strictEqual(e, error);
+    return "did throw";
+  }
+}
+
+Promise.all([
+  f(Promise.reject(error)),
+  f(Promise.resolve("did not throw"))
+]).then(function(results) {
+  assert.deepEqual(results, [
+    "did throw",
+    "did not throw"
+  ]);
+  done();
+}).catch(done);

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

@@ -19,7 +19,7 @@ var _extends = function (child, parent) {
 
 var Test = (function (Foo) {
   var Test = function Test() {
-    woops.super.test();
+    woops["super"].test();
     Foo.call(this);
     Foo.prototype.test.call(this);
     foob(Foo);

test/fixtures/transformation/default-parameters/multiple/expected.js

@@ -1,8 +1,8 @@
 "use strict";
 
 var t = function (t, f) {
-  if (f === undefined) f = 5;
   if (t === undefined) t = "foo";
+  if (f === undefined) f = 5;
   return t + " bar " + f;
 };
 

test/fixtures/transformation/default-parameters/tdz-2/actual.js

@@ -0,0 +1 @@
+function foo(a=b, b) {}

test/fixtures/transformation/default-parameters/tdz-2/options.json

@@ -0,0 +1,3 @@
+{
+  "throws": "Temporal dead zone - accessing a variable before it's initialized"
+}

test/fixtures/transformation/default-parameters/tdz-3/exec.js

@@ -0,0 +1,4 @@
+assert.equal((function(a, b=a++){
+  function b(){}
+  return a;
+})(1), 2);

test/fixtures/transformation/default-parameters/tdz/actual.js

@@ -0,0 +1 @@
+function foo(a=a) {}

test/fixtures/transformation/default-parameters/tdz/options.json

@@ -0,0 +1,3 @@
+{
+  "throws": "Temporal dead zone - accessing a variable before it's initialized"
+}

test/fixtures/transformation/generators/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2014, Facebook, Inc.
+All rights reserved.
+
+This source code is licensed under the BSD-style license found in the
+https://raw.github.com/facebook/regenerator/master/LICENSE file. An
+additional grant of patent rights can be found in the PATENTS file in
+the same directory.

test/fixtures/transformation/generators/block-binding-should-translate-block-binding-correctly/exec.js

@@ -0,0 +1,24 @@
+function *gen() {
+  var a$0 = 0, a$1 = 1;
+
+  let a = 3;
+
+  {
+    let a = 1;
+    yield a + a$0;
+  }
+
+  {
+    let a = 2;
+    yield a - 1 + a$1;
+  }
+
+  yield a;
+}
+
+var g = gen();
+
+assert.deepEqual(g.next(), { value: 1, done: false });
+assert.deepEqual(g.next(), { value: 2, done: false });
+assert.deepEqual(g.next(), { value: 3, done: false });
+assert.deepEqual(g.next(), { value: void 0, done: true });

test/fixtures/transformation/generators/block-binding-should-translate-block-binding-with-iife-correctly/exec.js

@@ -0,0 +1,22 @@
+function *gen() {
+  let arr = [];
+
+  for (let x = 0; x < 3; x++) {
+    let y = x;
+    arr.push(function() { return y; });
+  }
+
+  {
+    let x;
+    while( x = arr.pop() ) {
+      yield x;
+    }
+  }
+}
+
+var g = gen();
+
+assert.equal(g.next().value(), 2);
+assert.equal(g.next().value(), 1);
+assert.equal(g.next().value(), 0);
+assert.deepEqual(g.next(), { value: void 0, done: true });

test/fixtures/transformation/generators/catch-parameter-shadowing-should-allow-nested-catch-parameters-of-the-same-name/exec.js

@@ -0,0 +1,15 @@
+function *gen() {
+  try {
+    genHelpers.raise("e1");
+  } catch (e) {
+    yield e;
+    try {
+      genHelpers.raise("e2");
+    } catch (e) {
+      yield e;
+    }
+    yield e;
+  }
+}
+
+genHelpers.check(gen(), ["e1", "e2", "e1"]);

test/fixtures/transformation/generators/catch-parameter-shadowing-should-leave-outer-variables-unmodified/exec.js

@@ -0,0 +1,22 @@
+function *gen(x) {
+  var y = x + 1;
+  try {
+    throw x + 2;
+  } catch (x) {
+    yield x;
+    x += 1;
+    yield x;
+  }
+  yield x;
+  try {
+    throw x + 3;
+  } catch (y) {
+    yield y;
+    y *= 2;
+    yield y;
+  }
+  yield y;
+}
+
+genHelpers.check(gen(1), [3, 4, 1, 4, 8, 2]);
+genHelpers.check(gen(2), [4, 5, 2, 5, 10, 3]);

test/fixtures/transformation/generators/catch-parameter-shadowing-should-not-replace-variables-defined-in-inner-scopes/exec.js

@@ -0,0 +1,32 @@
+function *gen(x) {
+  try {
+    throw x;
+  } catch (x) {
+    yield x;
+
+    yield (function(x) {
+      return x += 1;
+    }(x + 1));
+
+    yield (function() {
+      var x = arguments[0];
+      return x * 2;
+    }(x + 2));
+
+    yield (function() {
+      function notCalled(x) {
+        throw x;
+      }
+
+      x >>= 1;
+      return x;
+    }());
+
+    yield x -= 1;
+  }
+
+  yield x;
+}
+
+genHelpers.check(gen(10), [10, 12, 24, 5, 4, 10]);
+genHelpers.check(gen(11), [11, 13, 26, 5, 4, 11]);

test/fixtures/transformation/generators/collatz-generator/exec.js

@@ -0,0 +1,42 @@
+function *gen(n) {
+  var count = 0;
+
+  yield n;
+
+  while (n !== 1) {
+    count += 1;
+
+    if (n % 2) {
+      yield n = n * 3 + 1;
+    } else {
+      yield n >>= 1;
+    }
+  }
+
+  return count;
+}
+
+function collatz(n) {
+  var result = [n];
+
+  while (n !== 1) {
+    if (n % 2) {
+      n *= 3;
+      n += 1;
+    } else {
+      n >>= 1;
+    }
+
+    result.push(n);
+  }
+
+  return result;
+}
+
+var seven = collatz(7);
+var fiftyTwo = seven.slice(seven.indexOf(52));
+var eightyTwo = collatz(82);
+
+genHelpers.check(gen(7), seven, 16);
+genHelpers.check(gen(52), fiftyTwo, 11);
+genHelpers.check(gen(82), eightyTwo, 110);

test/fixtures/transformation/generators/completed-generator/exec.js

@@ -0,0 +1,11 @@
+function *gen() {
+  return "ALL DONE";
+}
+
+var g = gen();
+
+assert.deepEqual(g.next(), {
+  value: "ALL DONE", done: true
+});
+
+genHelpers.assertAlreadyFinished(g);

test/fixtures/transformation/generators/delegated-yield-should-be-governed-by-enclosing-try-statements/exec.js

@@ -0,0 +1,27 @@
+var error = new Error("thrown");
+
+function *outer(n) {
+  try {
+    yield 0;
+    yield* inner(n);
+    yield 1;
+  } catch (err) {
+    yield err.message;
+  }
+  yield 4;
+}
+
+function *inner(n) {
+  while (n --> 0) {
+    try {
+      if (n === 3) {
+        genHelpers.raise(error);
+      }
+    } finally {
+      yield n;
+    }
+  }
+}
+
+genHelpers.check(outer(3), [0, 2, 1, 0, 1, 4]);
+genHelpers.check(outer(5), [0, 4, 3, "thrown", 4]);

test/fixtures/transformation/generators/delegated-yield-should-cope-with-empty-delegatees/exec.js

@@ -0,0 +1,10 @@
+function *gen(condition) {
+  if (condition) {
+    yield 0;
+    yield* gen(false);
+    yield 1;
+  }
+}
+
+genHelpers.check(gen(true), [0, 1]);
+genHelpers.check(gen(false), []);

test/fixtures/transformation/generators/delegated-yield-should-delegate-correctly/exec.js

@@ -0,0 +1,12 @@
+function *gen(condition) {
+  yield 0;
+  if (condition) {
+    yield 1;
+    yield* gen(false);
+    yield 2;
+  }
+  yield 3;
+}
+
+genHelpers.check(gen(true), [0, 1, 0, 3, 2, 3]);
+genHelpers.check(gen(false), [0, 3]);

test/fixtures/transformation/generators/delegated-yield-should-dispatch-thrown-exceptions-correctly/exec.js

@@ -0,0 +1,37 @@
+var count = 0;
+
+function *gen() {
+  yield* inner();
+  try {
+    yield* inner();
+  } catch (err) {
+    // pass
+  }
+  return yield* inner();
+}
+
+function *inner() {
+  return yield count++;
+}
+
+var g = gen();
+
+assert.deepEqual(g.next(), {
+  value: 0,
+  done: false
+});
+
+assert.deepEqual(g.next(), {
+  value: 1,
+  done: false
+});
+
+assert.deepEqual(g.throw(new Error("lol")), {
+  value: 2,
+  done: false,
+});
+
+assert.deepEqual(g.next("sent"), {
+  value: "sent",
+  done: true
+});

test/fixtures/transformation/generators/delegated-yield-should-pass-sent-values-through/exec.js

@@ -0,0 +1,15 @@
+function *outer(n) {
+  yield* inner(n << 1);
+  yield "zxcv";
+}
+
+function *inner(n) {
+  return yield yield yield n;
+}
+
+var g = outer(3);
+assert.deepEqual(g.next(), { value: 6, done: false });
+assert.deepEqual(g.next(1), { value: 1, done: false });
+assert.deepEqual(g.next(2), { value: 2, done: false });
+assert.deepEqual(g.next(4), { value: "zxcv", done: false });
+assert.deepEqual(g.next(5), { value: void 0, done: true });

test/fixtures/transformation/generators/delegated-yield-should-support-deeper-nesting/exec.js

@@ -0,0 +1,18 @@
+function *outer(n) {
+  yield n;
+  yield* middle(n - 1, inner(n + 10));
+  yield n + 1;
+}
+
+function *middle(n, plusTen) {
+  yield n;
+  yield* inner(n - 1);
+  yield n + 1;
+  yield* plusTen;
+}
+
+function *inner(n) {
+  yield n;
+}
+
+genHelpers.check(outer(5), [5, 4, 3, 5, 15, 6]);

test/fixtures/transformation/generators/delegated-yieldshould-support-any-iterable-argument/exec.js

@@ -0,0 +1,11 @@
+function *gen() {
+  yield 0;
+  yield* [
+    yield "one",
+    yield "two",
+    yield "three"
+  ];
+  yield 5;
+}
+
+genHelpers.check(gen(), [0, "one", "two", "three", 2, 3, 4, 5]);

test/fixtures/transformation/generators/dynamic-exception-should-be-dispatched-correctly/exec.js

@@ -0,0 +1,20 @@
+function *gen(x, fname) {
+    try {
+      return fns[fname](x);
+    } catch (thrown) {
+      yield thrown;
+    }
+  }
+
+  var fns = {
+    f: function(x) {
+      throw x;
+    },
+
+    g: function(x) {
+      return x;
+    }
+  };
+
+  genHelpers.check(gen("asdf", "f"), ["asdf"]);
+  genHelpers.check(gen("asdf", "g"), [], "asdf");

test/fixtures/transformation/generators/empty-while-loops-should-be-preserved-in-generated-code/exec.js

@@ -0,0 +1,16 @@
+function *gen(x) {
+  while (x) {
+    // empty while loop
+  }
+
+  do {
+    // empty do-while loop
+  } while (x);
+
+  return gen.toString();
+}
+
+var info = gen(false).next();
+assert.strictEqual(info.done, true);
+assert.ok(/do \{/.test(info.value));
+assert.ok(/while \(/.test(info.value));

test/fixtures/transformation/generators/for-in-loop-generator-should-handle-break-in-loop/exec.js

@@ -0,0 +1,19 @@
+function *gen(obj) {
+  var count = 0;
+  for (var key in (yield "why not", obj)) {
+    if (obj.hasOwnProperty(key)) {
+      if (key === "skip") {
+        break;
+      }
+      count += 1;
+      yield [key, obj[key]];
+    }
+  }
+  return count;
+}
+
+genHelpers.check(
+  gen({ a: 1, b: 2, skip: 3, c: 4 }),
+  ["why not", ["a", 1], ["b", 2]],
+  2
+);

test/fixtures/transformation/generators/for-in-loop-generator-should-handle-property-deletion-in-loop/exec.js

@@ -0,0 +1,13 @@
+function *gen() {
+  var count = 0;
+  var obj = {foo: 1, bar: 2};
+  for (var key in obj) {
+    assert(obj.hasOwnProperty(key), key + " must be own property");
+    yield [key, obj[key]];
+    delete obj.bar;
+    count += 1;
+  }
+  return count;
+}
+
+genHelpers.check(gen(), [["foo", 1]], 1);

test/fixtures/transformation/generators/for-in-loop-generator-should-handle-risky-object-expressions/exec.js

@@ -0,0 +1,26 @@
+function a(sent) {
+  assert.strictEqual(sent, 1);
+  a.called = true;
+}
+
+function b(sent) {
+  assert.strictEqual(sent, 2);
+  b.called = true;
+  return { callee: b };
+}
+
+function *gen() {
+  assert.ok(!a.called);
+  assert.ok(!b.called);
+  for (var key in a(yield 0), b(yield 1)) {
+    assert.ok(a.called);
+    assert.ok(b.called);
+    assert.strictEqual(yield key, 3);
+  }
+
+  for (var key in a(1), { foo: "foo", bar: "bar" }) {
+    yield key;
+  }
+}
+
+genHelpers.check(gen(), [0, 1, "callee", "foo", "bar"]);

test/fixtures/transformation/generators/for-in-loop-generator-should-handle-the-simple-case/exec.js

@@ -0,0 +1,12 @@
+function *gen() {
+  var count = 0;
+  var obj = {foo: 1, bar: 2};
+  for (var key in obj) {
+    assert(obj.hasOwnProperty(key), key + " must be own property");
+    yield [key, obj[key]];
+    count += 1;
+  }
+  return count;
+}
+
+genHelpers.check(gen(), [["foo", 1], ["bar", 2]], 2);

test/fixtures/transformation/generators/for-in-loop-generator-should-loop-over-inherited-properties/exec.js

@@ -0,0 +1,16 @@
+function *gen() {
+  var count = 0;
+  function Foo() {
+    this.baz = 1
+  }
+  Foo.prototype.bar = 2;
+
+  var foo = new Foo();
+  for (var key in foo) {
+    yield [key, foo[key]];
+    count += 1;
+  }
+  return count;
+}
+
+genHelpers.check(gen(), [["baz", 1], ["bar", 2]], 2);

test/fixtures/transformation/generators/for-loop-with-var-decl-and-no-update-expression-should-compile-and-run/exec.js

@@ -0,0 +1,7 @@
+// https://github.com/facebook/regenerator/issues/103
+function *range() {
+  for (var i = 0; false; ) {
+  }
+}
+
+genHelpers.check(range(), []);

test/fixtures/transformation/generators/for-of-loops-should-work-for-Arrays/exec.js

@@ -0,0 +1,5 @@
+var sum = 0;
+for (var x of [1, 2].concat(3)) {
+  sum += x;
+}
+assert.strictEqual(sum, 6);

test/fixtures/transformation/generators/for-of-loops-should-work-for-generators/exec.js

@@ -0,0 +1,10 @@
+function *range(n) {
+  for (var i = 0; i < n; ++i) {
+    yield i;
+  }
+}
+
+var value, values = [];
+for (value of range(3))
+  values.push(value);
+assert.deepEqual(values, [0, 1, 2]);

test/fixtures/transformation/generators/for-of-loops-should-work-inside-of-generators/exec.js

@@ -0,0 +1,45 @@
+function *yieldPermutations(list) {
+  if (list.length < 2) {
+    yield list;
+    return 1;
+  }
+
+  var count = 0;
+  var first = list.slice(0, 1);
+  var genRest = yieldPermutations(list.slice(1));
+
+  for (var perm of genRest) {
+    for (var i = 0; i < list.length; ++i) {
+      var prefix = perm.slice(0, i);
+      var suffix = perm.slice(i);
+      yield prefix.concat(first, suffix);
+    }
+
+    count += i;
+  }
+
+  return count;
+}
+
+var count = 0;
+for (var perm of yieldPermutations([])) {
+  assert.deepEqual(perm, []);
+  ++count;
+}
+assert.strictEqual(count, 1);
+
+genHelpers.check(yieldPermutations([1]), [[1]], 1);
+
+genHelpers.check(yieldPermutations([2, 1]), [
+  [2, 1],
+  [1, 2]
+], 2);
+
+genHelpers.check(yieldPermutations([1,3,2]), [
+  [1, 3, 2],
+  [3, 1, 2],
+  [3, 2, 1],
+  [1, 2, 3],
+  [2, 1, 3],
+  [2, 3, 1]
+], 6);

test/fixtures/transformation/generators/for-of/exec.js

@@ -1,20 +0,0 @@
-function *range(max, step) {
-  var count = 0;
-  step = step || 1;
-
-  for (var i = 0; i < max; i += step) {
-  count++;
-  yield i;
-  }
-
-  return count;
-}
-
-var gen = range(20, 3);
-var values = [];
-
-for (var value of gen) {
-  values.push(value);
-}
-
-assert.deepEqual(values, [0, 3, 6, 9, 12, 15, 18]);

test/fixtures/transformation/generators/function-declaration-hoisting-should-work-even-if-the-declarations-are-out-of-order/exec.js

@@ -0,0 +1,32 @@
+function *gen(n) {
+  yield increment(n);
+
+  function increment(x) {
+    return x + 1;
+  }
+
+  if (n % 2) {
+    yield halve(decrement(n));
+
+    function halve(x) {
+      return x >> 1;
+    }
+
+    function decrement(x) {
+      return x - 1;
+    }
+  } else {
+    // The behavior of function declarations nested inside conditional
+    // blocks is notoriously underspecified, and in V8 it appears the
+    // halve function is still defined when we take this branch, so
+    // "undefine" it for consistency with regenerator semantics.
+    halve = void 0;
+  }
+
+  yield typeof halve;
+
+  yield increment(increment(n));
+}
+
+genHelpers.check(gen(3), [4, 1, "function", 5]);
+genHelpers.check(gen(4), [5, "undefined", 6]);

test/fixtures/transformation/generators/function-declaration-hoisting-should-work-for-nested-generator-function-declarations/exec.js

@@ -0,0 +1,15 @@
+function *outer(n) {
+  yield 0;
+  assert.ok(regeneratorRuntime.isGeneratorFunction(inner));
+  return yield* inner(n);
+
+  // Note that this function declaration comes after everything else
+  // in the outer function, but needs to be fully available above.
+  function *inner(n) {
+    yield n - 1;
+    yield n;
+    return yield n + 1;
+  }
+}
+
+genHelpers.check(outer(2), [0, 1, 2, 3], 4);

test/fixtures/transformation/generators/generator-function-expression-should-behave-just-like-a-declared-generator/exec.js

@@ -0,0 +1,6 @@
+genHelpers.check(function *(x, y) {
+  yield x;
+  yield y;
+  yield x + y;
+  return x * y;
+}(3, 7), [3, 7, 10], 21);

test/fixtures/transformation/generators/generator-function-prototype-should-follow-the-expected-object-model/exec.js

@@ -0,0 +1,60 @@
+
+var GeneratorFunctionPrototype = f.__proto__;
+var GeneratorFunction = GeneratorFunctionPrototype.constructor;
+
+assert.strictEqual(GeneratorFunction.name, 'GeneratorFunction');
+assert.strictEqual(GeneratorFunction.prototype,
+                   GeneratorFunctionPrototype);
+assert.strictEqual(GeneratorFunctionPrototype.prototype.constructor,
+                   GeneratorFunctionPrototype);
+assert.strictEqual(GeneratorFunctionPrototype.prototype,
+                   f.prototype.__proto__);
+assert.strictEqual(GeneratorFunctionPrototype.__proto__,
+                   Function.prototype);
+assert.strictEqual(GeneratorFunctionPrototype.name,
+                   "GeneratorFunctionPrototype");
+
+assert.strictEqual(typeof f2, "function");
+assert.strictEqual(f2.constructor, GeneratorFunction);
+assert.ok(f2 instanceof GeneratorFunction);
+assert.strictEqual(f2.name, "f2");
+
+var g = f();
+assert.ok(g instanceof f);
+assert.strictEqual(g.__proto__, f.prototype);
+
+assert.deepEqual([], Object.getOwnPropertyNames(f.prototype));
+// assert.deepEqual([], Object.getOwnPropertyNames(g));
+
+f.prototype.x = 42;
+
+var g2 = f();
+assert.strictEqual(g2.x, 42);
+
+var g3 = new f();
+assert.strictEqual(g3.x, 42);
+
+function* f2() {
+  yield 1;
+}
+
+assert.strictEqual(f.__proto__, f2.__proto__);
+assert.strictEqual(f.hasOwnProperty('constructor'), false);
+assert.strictEqual(f.__proto__.constructor.name, 'GeneratorFunction');
+
+// Intentionally at the end to test hoisting.
+function* f() {
+  yield this;
+}
+
+function* f() {
+  yield 1;
+}
+
+var f2 = f;
+f = 42;
+var g = f2();
+
+assert.deepEqual(g.next(), { value: 1, done: false });
+assert.deepEqual(g.next(), { value: void 0, done: true });
+assert.ok(g instanceof f2);

test/fixtures/transformation/generators/generator-reentry-attempt-should-complain-with-a-TypeError/exec.js

@@ -0,0 +1,18 @@
+function *gen(x) {
+  try {
+    (yield x).next(x);
+  } catch (err) {
+    yield err;
+  }
+  return x + 1;
+}
+
+var g = gen(3);
+assert.deepEqual(g.next(), { value: 3, done: false });
+var complaint = g.next(g); // Sending the generator to itself.
+assert.ok(complaint.value instanceof Error);
+assert.strictEqual(
+  complaint.value.message,
+  "Generator is already running"
+);
+assert.deepEqual(g.next(), { value: 4, done: true });

test/fixtures/transformation/generators/generator-return-method-should-behave-as-if-generator-actually-returned/exec.js

@@ -0,0 +1,22 @@
+var executedFinally = false;
+
+function *gen() {
+  try {
+    yield 0;
+  } catch (err) {
+    assert.ok(false, "should not have executed the catch handler");
+  } finally {
+    executedFinally = true;
+  }
+}
+
+var g = gen();
+assert.deepEqual(g.next(), { value: 0, done: false });
+
+assert.deepEqual(g.return("argument"), {
+  value: "argument",
+  done: true
+});
+
+assert.strictEqual(executedFinally, true);
+genHelpers.assertAlreadyFinished(g);

test/fixtures/transformation/generators/generator-return-method-should-work-with-newborn-generators/exec.js

@@ -0,0 +1,12 @@
+function *gen() {
+  yield 0;
+}
+
+var g = gen();
+
+assert.deepEqual(g.return("argument"), {
+  value: "argument",
+  done: true
+});
+
+genHelpers.assertAlreadyFinished(g);

test/fixtures/transformation/generators/generator-throw-method-should-complete-generator/exec.js

@@ -0,0 +1,16 @@
+function *gen(x) {
+  yield 2;
+  throw 1;
+}
+
+var u = gen();
+
+u.next();
+
+try {
+  u.throw(2);
+} catch (err) {
+  assert.strictEqual(err, 2);
+}
+
+genHelpers.assertAlreadyFinished(u);

test/fixtures/transformation/generators/generator-throw-method-should-immediately-complete-a-new-born-generator/exec.js

@@ -0,0 +1,16 @@
+var began = false;
+
+function *gen() {
+  began = true;
+  yield 1;
+}
+
+var g = gen();
+var exception = new Error("unhandled exception");
+try {
+  g.throw(exception);
+  assert.ok(false, "should have thrown an exception");
+} catch (err) {
+  assert.strictEqual(err, exception);
+  assert.strictEqual(began, false);
+}

test/fixtures/transformation/generators/generator-throw-method-should-not-propagate-errors-handled-inside-a-delegate/exec.js

@@ -0,0 +1,20 @@
+function *outer() {
+  try {
+    yield* inner();
+  } catch (err) {
+    return -1;
+  }
+  return 1;
+}
+
+function *inner() {
+  try {
+    yield void 0;
+  } catch (e) {
+    return;
+  }
+}
+
+var g = outer();
+g.next();
+assert.equal(g.throw(new Error('foo')).value, 1);

test/fixtures/transformation/generators/generator-throw-method-should-propagate-errors-unhandled-inside-a-delegate/exec.js

@@ -0,0 +1,16 @@
+function *outer() {
+  try {
+    yield* inner();
+  } catch (err) {
+    return -1;
+  }
+  return 1;
+}
+
+function *inner() {
+  yield void 0;
+}
+
+var g = outer();
+g.next();
+assert.equal(g.throw(new Error('foo')).value, -1);

test/fixtures/transformation/generators/generator-throw-method-should-work-after-the-final-call-to-next/exec.js

@@ -0,0 +1,14 @@
+function *gen() {
+  yield 1;
+}
+
+var g = gen();
+assert.deepEqual(g.next(), { value: 1, done: false });
+
+var exception = new Error("unhandled exception");
+try {
+  g.throw(exception);
+  assert.ok(false, "should have thrown an exception");
+} catch (err) {
+  assert.strictEqual(err, exception);
+}

test/fixtures/transformation/generators/infinite-sequence-generator/exec.js

@@ -0,0 +1,41 @@
+function *gen(start, step) {
+  step = step || 1;
+  while (true) {
+    yield start;
+    start += step;
+  }
+}
+
+function *limit(g, stop) {
+  while (true) {
+    var info = g.next();
+    if (info.done) {
+      return;
+    } else if (info.value < stop) {
+      yield info.value;
+    } else {
+      return;
+    }
+  }
+}
+
+// should generate a lot of plausible values
+var g = gen(10, 2);
+
+assert.deepEqual(g.next(), { value: 10, done: false });
+assert.deepEqual(g.next(), { value: 12, done: false });
+assert.deepEqual(g.next(), { value: 14, done: false });
+assert.deepEqual(g.next(), { value: 16, done: false });
+
+var sum = 10 + 12 + 14 + 16;
+
+for (var n = 0; n < 1000; ++n) {
+  var info = g.next();
+  sum += info.value;
+  assert.strictEqual(info.done, false);
+}
+
+assert.strictEqual(sum, 1017052);
+
+// should allow limiting
+genHelpers.check(limit(gen(10, 3), 20), [10, 13, 16, 19]);

test/fixtures/transformation/generators/isGeneratorFunction-should-work-for-function-declarations/exec.js

@@ -0,0 +1,19 @@
+// Do the assertions up here to make sure the generator function is
+// marked at the beginning of the block the function is declared in.
+assert.strictEqual(
+  regeneratorRuntime.isGeneratorFunction(genFun),
+  true
+);
+
+assert.strictEqual(
+  regeneratorRuntime.isGeneratorFunction(normalFun),
+  false
+);
+
+function normalFun() {
+  return 0;
+}
+
+function *genFun() {
+  yield 0;
+}