first commit

2023-07-12 16:31:19 +01:00
commit 3424b1927b
23306 changed files with 2217776 additions and 0 deletions
@@ -0,0 +1 @@
+../JSONStream/bin.js
@@ -0,0 +1 @@
+../acorn/bin/acorn
@@ -0,0 +1 @@
+../atob/bin/atob.js
@@ -0,0 +1 @@
+../browser-pack/bin/cmd.js
@@ -0,0 +1 @@
+../browser-sync/dist/bin.js
@@ -0,0 +1 @@
+../browserify/bin/cmd.js
@@ -0,0 +1 @@
+../browserslist/cli.js
@@ -0,0 +1 @@
+../color-support/bin.js
@@ -0,0 +1 @@
+../commoner/bin/commonize
@@ -0,0 +1 @@
+../customizr/bin/customizr
@@ -0,0 +1 @@
+../deps-sort/bin/cmd.js
@@ -0,0 +1 @@
+../detect-indent/cli.js
@@ -0,0 +1 @@
+../detective/bin/detective.js
@@ -0,0 +1 @@
+../dev-ip/lib/dev-ip.js
@@ -0,0 +1 @@
+../esprima/bin/esparse.js
@@ -0,0 +1 @@
+../esprima/bin/esvalidate.js
@@ -0,0 +1 @@
+../gulp-cli/bin/gulp.js
@@ -0,0 +1 @@
+../in-publish/in-install.js
@@ -0,0 +1 @@
+../in-publish/in-publish.js
@@ -0,0 +1 @@
+../insert-module-globals/bin/cmd.js
@@ -0,0 +1 @@
+../jsesc/bin/jsesc
@@ -0,0 +1 @@
+../json5/lib/cli.js
@@ -0,0 +1 @@
+../loose-envify/cli.js
@@ -0,0 +1 @@
+../localtunnel/bin/client
@@ -0,0 +1 @@
+../markdown-it/bin/markdown-it.js
@@ -0,0 +1 @@
+../miller-rabin/bin/miller-rabin
@@ -0,0 +1 @@
+../mime/cli.js
@@ -0,0 +1 @@
+../mkdirp/bin/cmd.js
@@ -0,0 +1 @@
+../modernizr/bin/modernizr
@@ -0,0 +1 @@
+../module-deps/bin/cmd.js
@@ -0,0 +1 @@
+../node-gyp/bin/node-gyp.js
@@ -0,0 +1 @@
+../node-sass/bin/node-sass
@@ -0,0 +1 @@
+../nopt/bin/nopt.js
@@ -0,0 +1 @@
+../in-publish/not-in-install.js
@@ -0,0 +1 @@
+../in-publish/not-in-publish.js
@@ -0,0 +1 @@
+../@babel/parser/bin/babel-parser.js
@@ -0,0 +1 @@
+../requirejs/bin/r.js
@@ -0,0 +1 @@
+../requirejs/bin/r.js
@@ -0,0 +1 @@
+../regenerator-6to5/bin/regenerator
@@ -0,0 +1 @@
+../regexp-tree/bin/regexp-tree
@@ -0,0 +1 @@
+../regexpu/bin/regexpu
@@ -0,0 +1 @@
+../regjsparser/bin/parser
@@ -0,0 +1 @@
+../rimraf/bin.js
@@ -0,0 +1 @@
+../sass-graph/bin/sassgraph
@@ -0,0 +1 @@
+../semver/bin/semver
@@ -0,0 +1 @@
+../sha.js/bin.js
@@ -0,0 +1 @@
+../sshpk/bin/sshpk-conv
@@ -0,0 +1 @@
+../sshpk/bin/sshpk-sign
@@ -0,0 +1 @@
+../sshpk/bin/sshpk-verify
@@ -0,0 +1 @@
+../strip-indent/cli.js
@@ -0,0 +1 @@
+../stream-throttle/bin/throttleproxy.js
@@ -0,0 +1 @@
+../uglify-js/bin/uglifyjs
@@ -0,0 +1 @@
+../umd/bin/cli.js
@@ -0,0 +1 @@
+../undeclared-identifiers/bin.js
@@ -0,0 +1 @@
+../uuid/bin/uuid
@@ -0,0 +1 @@
+../which/bin/which
@@ -0,0 +1 @@
+../window-size/cli.js
@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)
@@ -0,0 +1,53 @@
+# Contributing
+
+Contributions are always welcome, no matter how large or small. Before
+contributing, please read the
+[code of conduct](https://github.com/6to5/6to5/blob/master/CODE_OF_CONDUCT.md).
+
+**NOTE:** Please do not send pull requests that fix linting issues. It's highly
+likely that they've already been fixed by the time it's submitted and it just
+pollutes the git tree.
+
+## Developing
+
+#### Workflow
+
+* Fork the repository
+* Clone your fork and change directory to it (`git clone git@github.com:yourUserName/6to5.git && cd 6to5`)
+* Install the project dependencies (`make bootstrap`)
+* Link your forked clone (`npm link`)
+* Develop your changes ensuring you're fetching updates from upstream often
+* Ensure the test are passing (`make test`)
+* Create new pull request explaining your proposed change or reference an issue
+  in your commit message
+
+#### Code Standards
+
+ * **General**
+   * No ES6 syntax features or methods, exclusively ES5.
+   * Max of five arguments for functions
+   * Max depth of four nested blocks
+   * 2-spaced soft tabs
+ * **Naming**
+   * CamelCase all class names
+   * camelBack all variable names
+ * **Spacing**
+   * Spaces after all keywords
+   * Spaces before all left curly braces
+ * **Comments**
+   * Use JSDoc-style comments for methods
+   * Single-line comments for ambiguous code
+ * **Quotes**
+   * Always use double quotes
+   * Only use single quotes when the string contains a double quote
+ * **Declaration**
+   * No unused variables
+   * No pollution of global variables and prototypes
+
+## Testing
+
+    $ make test
+
+## Linting
+
+    $ make lint
@@ -0,0 +1,22 @@
+Copyright (c) 2014-2015 Sebastian McKenzie
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
@@ -0,0 +1,3 @@
+# Notes
+
+ * Wildcard exports/imports wont normalize if `export default` is a non-object. See [#224](https://github.com/6to5/6to5/issues/224).
@@ -0,0 +1,12 @@
+<p align="center">
+  <img alt="6to5" src="https://raw.githubusercontent.com/6to5/logo/master/logo.png" width="546">
+</p>
+
+<p align="center">
+  <strong>6to5</strong> turns ES6+ code into vanilla ES5, so you can use next generation features <strong>today.</strong>
+</p>
+
+<p align="center">
+  For more information view the <a href="https://6to5.github.io">documentation</a>. For
+  support visit the <a href="https://gitter.im/6to5/6to5">gitter room</a>.
+</p>
@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+var opts = require("./6to5").opts;
+opts.optional = (opts.optional || []).concat("minification");
+opts.format = {
+  compact: true
+};
@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+
+/**
+ * This tiny wrapper file checks for known node flags and appends them
+ * when found, before invoking the "real" _6to5-node(1) executable.
+ */
+
+var args  = [__dirname + "/_6to5-node"];
+
+process.argv.slice(2).forEach(function(arg){
+  var flag = arg.split("=")[0];
+
+  switch (flag) {
+    case "-d":
+      args.unshift("--debug");
+      break;
+
+    case "debug":
+    case "--debug":
+    case "--debug-brk":
+      args.unshift(arg);
+      break;
+
+    case "-gc":
+    case "--expose-gc":
+      args.unshift("--expose-gc");
+      break;
+
+    case "--gc-global":
+    case "--harmony":
+    case "--harmony-proxies":
+    case "--harmony-collections":
+    case "--harmony-generators":
+    case "--no-deprecation":
+    case "--prof":
+    case "--throw-deprecation":
+    case "--trace-deprecation":
+    case "--use-strict":
+      args.unshift(arg);
+      break;
+
+    default:
+      if (arg.indexOf("--trace") === 0) {
+        args.unshift(arg);
+      } else {
+        args.push(arg);
+      }
+      break;
+  }
+});
+
+try {
+  var kexec = require("kexec");
+  kexec(process.argv[0], args);
+} catch (err) {
+  if (err.code !== "MODULE_NOT_FOUND") throw err;
+
+  var child_process = require("child_process");
+  var proc = child_process.spawn(process.argv[0], args, { stdio: "inherit" });
+  proc.on("exit", function (code, signal) {
+    process.on("exit", function () {
+      if (signal) {
+        process.kill(process.pid, signal);
+      } else {
+        process.exit(code);
+      }
+    })
+  });
+}
@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+
+var runtime = require("../lib/6to5/build-runtime");
+console.log(runtime());
@@ -0,0 +1,72 @@
+var outputFileSync = require("output-file-sync");
+var chokidar       = require("chokidar");
+var path           = require("path");
+var util           = require("./util");
+var fs             = require("fs");
+var _              = require("lodash");
+
+module.exports = function (commander, filenames, opts) {
+  if (commander.sourceMapsInline) {
+    opts.sourceMap = "inline";
+  }
+
+  var write = function (src, relative) {
+    // remove extension and then append back on .js
+    relative = relative.replace(/\.(\w*?)$/, "") + ".js";
+
+    var dest = path.join(commander.outDir, relative);
+
+    var data = util.compile(src, {
+      sourceFileName: path.relative(dest + "/..", src)
+    });
+
+    if (commander.sourceMaps) {
+      var mapLoc = dest + ".map";
+      data.code = util.addSourceMappingUrl(data.code, mapLoc);
+      outputFileSync(mapLoc, JSON.stringify(data.map));
+    }
+
+    outputFileSync(dest, data.code);
+
+    console.log(src + " -> " + dest);
+  };
+
+  var handle = function (filename) {
+    if (!fs.existsSync(filename)) return;
+
+    var stat = fs.statSync(filename);
+
+    if (stat.isDirectory(filename)) {
+      var dirname = filename;
+
+      _.each(util.readdir(dirname), function (filename) {
+        var src = path.join(dirname, filename);
+        if (util.canCompile(filename)) {
+          write(src, filename);
+        } else {
+          outputFileSync(path.join(commander.outDir, filename), fs.readFileSync(src));
+        }
+      });
+    } else {
+      write(filename, filename);
+    }
+  };
+
+  _.each(filenames, handle);
+
+  if (commander.watch) {
+    _.each(filenames, function (dirname) {
+      var watcher = chokidar.watch(dirname, {
+        persistent: true,
+        ignoreInitial: true
+      });
+
+      _.each(["add", "change"], function (type) {
+        watcher.on(type, function (filename) {
+          var relative = path.relative(dirname, filename) || filename;
+          write(filename, relative);
+        });
+      });
+    });
+  }
+};
@@ -0,0 +1,133 @@
+var sourceMap = require("source-map");
+var chokidar  = require("chokidar");
+var util2     = require("../../lib/6to5/util");
+var path      = require("path");
+var util      = require("./util");
+var fs        = require("fs");
+var _         = require("lodash");
+
+module.exports = function (commander, filenames) {
+  var results = [];
+
+  var buildResult = function () {
+    var map = new sourceMap.SourceMapGenerator({
+      file: commander.outFile || "stdout"
+    });
+
+    var code = "";
+    var offset = 0;
+
+    _.each(results, function (result) {
+      var filename = result.filename;
+      code += result.code + "\n";
+
+      if (result.map) {
+        var consumer = new sourceMap.SourceMapConsumer(result.map);
+
+        map._sources.add(filename);
+        map.setSourceContent(filename, result.actual);
+
+        consumer.eachMapping(function (mapping) {
+          map._mappings.add({
+            generatedLine: mapping.generatedLine + offset,
+            generatedColumn: mapping.generatedColumn,
+            originalLine: mapping.originalLine,
+            originalColumn: mapping.originalColumn,
+            source: filename
+          });
+        });
+
+        offset = code.split("\n").length;
+      }
+    });
+
+    if (commander.sourceMapsInline || (!commander.outFile && commander.sourceMaps)) {
+      code += "\n" + util2.sourceMapToComment(map);
+    }
+
+    return {
+      map: map,
+      code: code
+    };
+  };
+
+  var output = function () {
+    var result = buildResult();
+
+    if (commander.outFile) {
+      if (commander.sourceMaps) {
+        var mapLoc = commander.outFile + ".map";
+        result.code = util.addSourceMappingUrl(result.code, mapLoc);
+        fs.writeFileSync(mapLoc, JSON.stringify(result.map));
+      }
+
+      fs.writeFileSync(commander.outFile, result.code);
+    } else {
+      process.stdout.write(result.code + "\n");
+    }
+  };
+
+  var stdin = function () {
+    var code = "";
+
+    process.stdin.setEncoding("utf8");
+
+    process.stdin.on("readable", function () {
+      var chunk = process.stdin.read();
+      if (chunk !== null) code += chunk;
+    });
+
+    process.stdin.on("end", function () {
+      results.push(util.transform(commander.filename, code));
+      output();
+    });
+  };
+
+  var walk = function () {
+    var _filenames = [];
+    results = [];
+
+    _.each(filenames, function (filename) {
+      if (!fs.existsSync(filename)) return;
+
+      var stat = fs.statSync(filename);
+      if (stat.isDirectory()) {
+        var dirname = filename;
+
+        _.each(util.readdirFilter(filename), function (filename) {
+          _filenames.push(path.join(dirname, filename));
+        });
+      } else {
+        _filenames.push(filename);
+      }
+    });
+
+    _.each(_filenames, function (filename) {
+      results.push(util.compile(filename));
+    });
+
+    output();
+  };
+
+  var files = function () {
+    walk();
+
+    if (commander.watch) {
+      chokidar.watch(filenames, {
+        persistent: true,
+        ignoreInitial: true
+      }).on("all", function (type, filename) {
+        if (type === "add" || type === "change") {
+          console.log(type, filename);
+          walk();
+        }
+      });
+    }
+  };
+
+  if (filenames.length) {
+    files();
+  } else {
+    stdin();
+  }
+};
@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+
+var commander = require("commander");
+var transform = require("../../lib/6to5/transformation");
+var util      = require("../../lib/6to5/util");
+var fs        = require("fs");
+var each      = require("lodash/collection/each");
+var keys      = require("lodash/object/keys");
+
+commander.option("-t, --source-maps-inline", "Append sourceMappingURL comment to bottom of code");
+commander.option("-s, --source-maps", "Save source map alongside the compiled code");
+commander.option("-f, --filename [filename]", "Filename to use when reading from stdin - this will be used in source-maps, errors etc [stdin]", "stdin");
+commander.option("-w, --watch", "Recompile files on changes");
+commander.option("-r, --runtime", "Replace 6to5 declarations with references to a runtime");
+commander.option("-e, --experimental", "Enable experimental support for proposed ES7 features");
+commander.option("-p, --playground", "Enable playground support");
+
+commander.option("-m, --modules [modules]", "Module formatter type to use [common]", "common");
+commander.option("-l, --whitelist [whitelist]", "Whitelist of transformers to ONLY use", util.list);
+commander.option("-b, --blacklist [blacklist]", "Blacklist of transformers to NOT use", util.list);
+commander.option("-i, --optional [list]", "List of optional transformers to enable", util.list);
+commander.option("-L, --loose [list]", "List of transformers to enable loose mode ON", util.list);
+commander.option("-o, --out-file [out]", "Compile all input files into a single file");
+commander.option("-d, --out-dir [out]", "Compile an input directory of modules into an output directory");
+commander.option("-c, --remove-comments", "Remove comments from the compiled code", false);
+commander.option("-M, --module-ids", "Insert module id in modules", false);
+commander.option("-R, --react-compat", "Makes the react transformer produce pre-v0.12 code");
+commander.option("--keep-module-id-extensions", "Keep extensions when generating module ids", false);
+commander.option("-a, --auxilary-comment [comment]", "Comment text to prepend to all auxilary code");
+
+commander.on("--help", function () {
+  var outKeys = function (title, obj) {
+    console.log("  " + title + ":");
+    console.log();
+
+    each(keys(obj).sort(), function (key) {
+      if (key[0] === "_") return;
+
+      if (obj[key].optional) {
+        key = "[" + key + "]";
+      }
+
+      console.log("    - " + key);
+    });
+
+    console.log();
+  };
+
+  outKeys("Transformers", transform.transformers);
+  outKeys("Module formatters", transform.moduleFormatters);
+});
+
+var pkg = require("../../package.json");
+commander.version(pkg.version);
+commander.usage("[options] <files ...>");
+commander.parse(process.argv);
+
+//
+
+var errors = [];
+
+var filenames = commander.args;
+
+each(filenames, function (filename) {
+  if (!fs.existsSync(filename)) {
+    errors.push(filename + " doesn't exist");
+  }
+});
+
+if (commander.outDir && !filenames.length) {
+  errors.push("filenames required for --out-dir");
+}
+
+if (commander.outFile && commander.outDir) {
+  errors.push("cannot have --out-file and --out-dir");
+}
+
+if (commander.watch) {
+  if (!commander.outFile && !commander.outDir) {
+    errors.push("--watch requires --out-file or --out-dir");
+  }
+
+  if (!filenames.length) {
+    errors.push("--watch requires filenames");
+  }
+}
+
+if (commander.sourceMaps) {
+  if (!commander.outFile && !commander.outDir) {
+    errors.push("--source-maps requires --out-file or --out-dir");
+  }
+}
+
+if (errors.length) {
+  console.error(errors.join(". "));
+  process.exit(2);
+}
+
+//
+
+exports.opts = {
+  keepModuleIdExtensions: commander.keepModuleIdExtensions,
+  auxilaryComment:        commander.auxilaryComment,
+  sourceMapName:          commander.outFile,
+  experimental:           commander.experimental,
+  reactCompat:            commander.reactCompat,
+  playground:             commander.playground,
+  moduleIds:              commander.moduleIds,
+  blacklist:              commander.blacklist,
+  whitelist:              commander.whitelist,
+  sourceMap:              commander.sourceMaps || commander.sourceMapsInline,
+  optional:               commander.optional,
+  comments:               !commander.removeComments,
+  runtime:                commander.runtime,
+  modules:                commander.modules,
+  loose:                  commander.loose
+};
+
+setTimeout(function () {
+  // this is just a hack to give `6to5-minify` and other files including this
+  // time to modify `exports.opts`
+
+  var fn;
+
+  if (commander.outDir) {
+    fn = require("./dir");
+  } else {
+    fn = require("./file");
+  }
+
+  fn(commander, filenames, exports.opts);
+}, 0);
@@ -0,0 +1,46 @@
+var readdir = require("fs-readdir-recursive");
+var index   = require("./index");
+var util    = require("../../lib/6to5/util");
+var path    = require("path");
+var to5     = require("../../lib/6to5/api/node");
+var fs      = require("fs");
+var _       = require("lodash");
+
+exports.readdirFilter = function (filename) {
+  return readdir(filename).filter(function (filename) {
+    return util.canCompile(filename);
+  });
+};
+
+exports.readdir = readdir;
+
+exports.canCompile = util.canCompile;
+
+exports.addSourceMappingUrl = function (code, loc) {
+  return code + "\n//# sourceMappingURL=" + path.basename(loc);
+};
+
+exports.transform = function (filename, code, opts) {
+  opts = _.defaults(opts || {}, index.opts);
+  opts.filename = filename;
+
+  var result;
+  try {
+    result = to5.transform(code, opts);
+  } catch (e) {
+    if (e instanceof SyntaxError) {
+      console.error("SyntaxError:", e.message);
+      process.exit(1);
+    } else {
+      throw e;
+    }
+  }
+  result.filename = filename;
+  result.actual = code;
+  return result;
+};
+
+exports.compile = function (filename, opts) {
+  var code = fs.readFileSync(filename, "utf8");
+  return exports.transform(filename, code, opts);
+};
@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+
+var commander = require("commander");
+var Module    = require("module");
+var path      = require("path");
+var repl      = require("repl");
+var to5       = require("../lib/6to5/api/node");
+var util      = require("../lib/6to5/util");
+var vm        = require("vm");
+var _         = require("lodash");
+
+var program = new commander.Command("6to5-node");
+
+program.option("-e, --eval [script]", "Evaluate script");
+program.option("-p, --print [code]", "Evaluate script and print result");
+program.option("-i, --ignore [regex]", "Ignore all files that match this regex when using the require hook");
+program.option("-x, --extensions [extensions]", "List of extensions to hook into [.es6,.js,.es,.jsx]");
+program.option("-r, --experimental", "Enable experimental support for proposed ES7 features");
+program.option("-g, --playground", "Enable playground support");
+program.option("-w, --whitelist [whitelist]", "Whitelist of transformers to ONLY use", util.list);
+program.option("-b, --blacklist [blacklist]", "Blacklist of transformers to NOT use", util.list);
+program.option("-o, --optional [optional]", "List of optional transformers to enable", util.list);
+
+var pkg = require("../package.json");
+program.version(pkg.version);
+program.usage("[options] [ -e script | script.js ] [arguments]");
+program.parse(process.argv);
+
+//
+
+to5.register({
+  experimental: program.experimental,
+  extensions:   program.extensions,
+  playground:   program.playground,
+  blacklist:    program.blacklist,
+  whitelist:    program.whitelist,
+  optional:     program.optional,
+  ignore:       program.ignore
+});
+
+//
+
+var _eval = function (code, filename) {
+  code = to5.transform(code, {
+    filename: filename,
+    blacklist: ["useStrict"].concat(program.blacklist || []),
+    whitelist: program.whitelist,
+    optional: program.optional,
+    experimental: program.experimental,
+    playground: program.playground
+  }).code;
+  return vm.runInThisContext(code, filename);
+};
+
+if (program.eval || program.print) {
+  var code = program.eval;
+  if (!code || code === true) code = program.print;
+
+  var result = _eval(code, "eval");
+  if (program.print) console.log(result);
+} else {
+  if (program.args.length) {
+    // slice all arguments up to the first filename since they're 6to5 args that we handle
+    var args = process.argv.slice(2);
+
+    var i = 0;
+    var ignoreNext = false;
+    _.each(args, function (arg, i2) {
+      if (ignoreNext) {
+        ignoreNext = false;
+        return;
+      }
+
+      if (arg[0] === "-") {
+        var parsedArg = program[arg.slice(2)];
+        if (parsedArg && parsedArg !== true) {
+          ignoreNext = true;
+        }
+      } else {
+        i = i2;
+        return false;
+      }
+    });
+    args = args.slice(i);
+
+    // make the filename absolute
+    var filename = args[0]
+    if (!util.isAbsolute(filename)) args[0] = path.join(process.cwd(), filename);
+
+    // add back on node and concat the sliced args
+    process.argv = ["node"].concat(args);
+
+    Module.runMain();
+  } else {
+    replStart();
+  }
+}
+
+function replStart() {
+  repl.start({
+    prompt: "> ",
+    input: process.stdin,
+    output: process.stdout,
+    eval: replEval,
+    useGlobal: true
+  });
+}
+
+function replEval(code, context, filename, callback) {
+  var err;
+  var result;
+
+  try {
+    if (code[0] === "(" && code[code.length - 1] === ")") {
+      code = code.slice(1, -1); // remove "(" and ")"
+    }
+
+    result = _eval(code, filename);
+  } catch (e) {
+    err = e;
+  }
+
+  callback(err, result);
+}
@@ -0,0 +1 @@
+See [6to5.github.io/docs](https://github.com/6to5/6to5.github.io/tree/master/docs).
@@ -0,0 +1,85 @@
+"use strict";
+
+var transform = module.exports = require("../transformation");
+
+transform.version = require("../../../package").version;
+
+transform.transform = transform;
+
+transform.run = function (code, opts) {
+  opts = opts || {};
+  opts.sourceMap = "inline";
+  return new Function(transform(code, opts).code)();
+};
+
+transform.load = function (url, callback, opts, hold) {
+  opts = opts || {};
+  opts.filename = opts.filename || url;
+
+  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");
+
+  xhr.onreadystatechange = function () {
+    if (xhr.readyState !== 4) return;
+
+    var status = xhr.status;
+    if (status === 0 || status === 200) {
+      var param = [xhr.responseText, opts];
+      if (!hold) transform.run.apply(transform, param);
+      if (callback) callback(param);
+    } else {
+      throw new Error("Could not load " + url);
+    }
+  };
+
+  xhr.send(null);
+};
+
+var runScripts = function () {
+  var scripts = [];
+  var types   = ["text/ecmascript-6", "text/6to5", "module"];
+  var index   = 0;
+
+  var exec = function () {
+    var param = scripts[index];
+    if (param instanceof Array) {
+      transform.run.apply(transform, param);
+      index++;
+      exec();
+    }
+  };
+
+  var run = function (script, i) {
+    var opts = {};
+
+    if (script.src) {
+      transform.load(script.src, function (param) {
+        scripts[i] = param;
+        exec();
+      }, opts, true);
+    } else {
+      opts.filename = "embedded";
+      scripts[i] = [script.innerHTML, opts];
+    }
+  };
+
+  var _scripts = global.document .getElementsByTagName("script");
+
+  for (var i = 0; i < _scripts.length; ++i) {
+    var _script = _scripts[i];
+    if (types.indexOf(_script.type) >= 0) scripts.push(_script);
+  }
+
+  for (i in scripts) {
+    run(scripts[i], i);
+  }
+
+  exec();
+};
+
+if (global.addEventListener) {
+  global.addEventListener("DOMContentLoaded", runScripts, false);
+} else if (global.attachEvent) {
+  global.attachEvent("onload", runScripts);
+}
@@ -0,0 +1,58 @@
+"use strict";
+
+var isFunction = require("lodash/lang/isFunction");
+var transform  = require("../transformation");
+var util       = require("../util");
+var fs         = require("fs");
+
+exports.version = require("../../../package").version;
+
+exports.runtime = require("../build-runtime");
+
+exports.types = require("../types");
+
+exports.register = function (opts) {
+  var register = require("./register/node");
+  if (opts != null) register(opts);
+  return register;
+};
+
+exports.polyfill = function () {
+  require("../polyfill");
+};
+
+exports.canCompile = util.canCompile;
+
+// do not use this - this is for use by official maintained 6to5 plugins
+exports._util = util;
+
+exports.transform = transform;
+
+exports.transformFile = function (filename, opts, callback) {
+  if (isFunction(opts)) {
+    callback = opts;
+    opts = {};
+  }
+
+  opts.filename = filename;
+
+  fs.readFile(filename, function (err, code) {
+    if (err) return callback(err);
+
+    var result;
+
+    try {
+      result = transform(code, opts);
+    } catch (err) {
+      return callback(err);
+    }
+
+    callback(null, result);
+  });
+};
+
+exports.transformFileSync = function (filename, opts) {
+  opts = opts || {};
+  opts.filename = filename;
+  return transform(fs.readFileSync(filename), opts);
+};
@@ -0,0 +1,7 @@
+"use strict";
+
+// required to safely use 6to5/register within a browserify codebase
+
+module.exports = function () {};
+
+require("../../polyfill");
@@ -0,0 +1,36 @@
+"use strict";
+
+var path = require("path");
+var os   = require("os");
+var fs   = require("fs");
+
+var FILENAME = path.join(os.tmpdir(), "6to5.json");
+var data = {};
+
+exports.save = function () {
+  fs.writeFileSync(FILENAME, JSON.stringify(data, null, "  "));
+};
+
+exports.load = function () {
+  process.on("exit", exports.save);
+
+  var sigint = function () {
+    process.removeListener("SIGINT", sigint);
+    exports.save();
+    process.kill(process.pid, "SIGINT");
+  };
+
+  process.on("SIGINT", sigint);
+
+  if (!fs.existsSync(FILENAME)) return;
+
+  try {
+    data = JSON.parse(fs.readFileSync(FILENAME));
+  } catch (err) {
+    return;
+  }
+};
+
+exports.get = function () {
+  return data;
+};
@@ -0,0 +1,152 @@
+"use strict";
+
+require("../../polyfill");
+
+var sourceMapSupport = require("source-map-support");
+var registerCache    = require("./cache");
+var extend           = require("lodash/object/extend");
+var each             = require("lodash/collection/each");
+var util             = require("../../util");
+var to5              = require("../node");
+var fs               = require("fs");
+
+sourceMapSupport.install({
+  retrieveSourceMap: function (source) {
+    var map = maps && maps[source];
+    if (map) {
+      return {
+        url: null,
+        map: map
+      };
+    } else {
+      return null;
+    }
+  }
+});
+
+//
+
+registerCache.load();
+var cache = registerCache.get();
+
+//
+
+var transformOpts = {};
+var ignoreRegex   = /node_modules/;
+var onlyRegex;
+var exts          = {};
+var maps          = {};
+
+var mtime = function (filename) {
+  return +fs.statSync(filename).mtime;
+};
+
+var compile = function (filename) {
+  var result;
+
+  var cacheKey = filename + ":" + JSON.stringify(transformOpts);
+
+  if (cache) {
+    var cached = cache[cacheKey];
+    if (cached && cached.mtime === mtime(filename)) {
+      result = cached;
+    }
+  }
+
+  if (!result) {
+    result = to5.transformFileSync(filename, extend({
+      sourceMap: true,
+      ast:       false
+    }, transformOpts));
+  }
+
+  if (cache) {
+    result.mtime = mtime(filename);
+    cache[cacheKey] = result;
+  }
+
+  maps[filename] = result.map;
+
+  return result.code;
+};
+
+var shouldIgnore = function (filename) {
+  return (ignoreRegex && ignoreRegex.test(filename)) || (onlyRegex && !onlyRegex.test(filename));
+};
+
+var istanbulMonkey = {};
+
+if (process.env.running_under_istanbul) { // jshint ignore:line
+  // we need to monkey patch fs.readFileSync so we can hook into
+  // what istanbul gets, it's extremely dirty but it's the only way
+  var _readFileSync = fs.readFileSync;
+
+  fs.readFileSync = function (filename) {
+    if (istanbulMonkey[filename]) {
+      delete istanbulMonkey[filename];
+      var code = compile(filename);
+      istanbulMonkey[filename] = true;
+      return code;
+    } else {
+      return _readFileSync.apply(this, arguments);
+    }
+  };
+}
+
+var istanbulLoader = function (m, filename, old) {
+  istanbulMonkey[filename] = true;
+  old(m, filename);
+};
+
+var normalLoader = function (m, filename) {
+  m._compile(compile(filename), filename);
+};
+
+var registerExtension = function (ext) {
+  var old = require.extensions[ext];
+
+  var loader = normalLoader;
+  if (process.env.running_under_istanbul) loader = istanbulLoader; // jshint ignore:line
+
+  require.extensions[ext] = function (m, filename) {
+    if (shouldIgnore(filename)) {
+      old(m, filename);
+    } else {
+      loader(m, filename, old);
+    }
+  };
+};
+
+var hookExtensions = function (_exts) {
+  each(exts, function (old, ext) {
+    require.extensions[ext] = old;
+  });
+
+  exts = {};
+
+  each(_exts, function (ext) {
+    exts[ext] = require.extensions[ext];
+    registerExtension(ext);
+  });
+};
+
+hookExtensions(util.canCompile.EXTENSIONS);
+
+module.exports = function (opts) {
+  // normalize options
+  opts = opts || {};
+
+  if (opts.only != null) onlyRegex = util.regexify(opts.only);
+  if (opts.ignore != null) ignoreRegex = util.regexify(opts.ignore);
+
+  if (opts.extensions) hookExtensions(util.arrayify(opts.extensions));
+
+  if (opts.cache === false) cache = null;
+
+  delete opts.extensions;
+  delete opts.ignore;
+  delete opts.cache;
+  delete opts.only;
+
+  extend(transformOpts, opts);
+};
@@ -0,0 +1,13 @@
+var File = require("./transformation/file");
+var util = require("./util");
+var each = require("lodash/collection/each");
+var t    = require("./types");
+
+module.exports = function (body, namespace) {
+  each(File.helpers, function (name) {
+    var key = t.identifier(t.toIdentifier(name));
+    body.push(t.expressionStatement(
+      t.assignmentExpression("=", t.memberExpression(namespace, key), util.template(name))
+    ));
+  });
+};
@@ -0,0 +1,25 @@
+"use strict";
+
+var buildHelpers = require("./build-helpers");
+var generator    = require("./generation");
+var util         = require("./util");
+var t            = require("./types");
+
+module.exports = function () {
+  var namespace = t.identifier("to5Runtime");
+
+  var body      = [];
+  var container = t.functionExpression(null, [t.identifier("global")], t.blockStatement(body));
+  var tree      = t.program([t.expressionStatement(t.callExpression(container, [util.template("self-global")]))]);
+
+  body.push(t.variableDeclaration("var", [
+    t.variableDeclarator(
+      namespace,
+      t.assignmentExpression("=", t.memberExpression(t.identifier("global"), namespace), t.objectExpression([]))
+    )
+  ]));
+
+  buildHelpers(body, namespace);
+
+  return generator(tree).code;
+};
@@ -0,0 +1,29 @@
+module.exports = detect;
+
+var SYNTAX_KEYS = require("./syntax-keys");
+var traverse    = require("../traversal");
+var visitors    = traverse.explode(require("./visitors"));
+
+function detect(ast) {
+  var stats = {
+    syntax: {},
+    builtins: {}
+  };
+
+  var detectedSyntax = function (name) {
+    stats.syntax[name] = true;
+  };
+
+  traverse(ast, {
+    enter: function (node, parent) {
+      if (SYNTAX_KEYS[node.type]) {
+        detectedSyntax(SYNTAX_KEYS[node.type]);
+      }
+
+      var visitor = visitors[node.type];
+      if (visitor) visitor(node, parent, detectedSyntax);
+    }
+  });
+
+  return stats;
+}
@@ -0,0 +1,84 @@
+{
+  "ArrowFunctionExpression":   "es6.arrowFunctions",
+
+  "AwaitExpression":           "es7.asyncFunctions",
+
+  "ClassBody":                 "es6.classes",
+  "ClassDeclaration":          "es6.classes",
+  "ClassExpression":           "es6.classes",
+  "MethodDefinition":          "es6.classes",
+
+  "ComprehensionBlock":        "es7.comprehensions",
+  "ComprehensionExpression":   "es7.comprehensions",
+
+  "ForOfStatement":            "es6.forOf",
+
+  "ExportBatchSpecifier":      "es6.modules",
+  "ExportDeclaration":         "es6.modules",
+  "ExportSpecifier":           "es6.modules",
+  "ImportBatchSpecifier":      "es6.modules",
+  "ImportDeclaration":         "es6.modules",
+  "ImportSpecifier":           "es6.modules",
+
+  "ArrayPattern":              "es6.destructuring",
+  "AssignmentPattern":         "es6.destructuring",
+  "ObjectPattern":             "es6.destructuring",
+
+  "RestElement":               "es6.parameters.rest",
+
+  "SpreadElement":             "es6.spread",
+
+  "SpreadProperty":            "es7.objectSpread",
+
+  "TaggedTemplateExpression":  "es6.templateLiterals",
+  "TemplateElement":           "es6.templateLiterals",
+  "TemplateLiteral":           "es6.templateLiterals",
+
+  "VirtualPropertyExpression": "es7.abstractReferences",
+  "PrivateDeclaration":        "es7.abstractReferences",
+
+  "YieldExpression":           "es6.generators",
+
+  "AnyTypeAnnotation":           "flow",
+  "ArrayTypeAnnotation":         "flow",
+  "BooleanTypeAnnotation":       "flow",
+  "ClassProperty":               "flow",
+  "DeclareClass":                "flow",
+  "DeclareFunction":             "flow",
+  "DeclareModule":               "flow",
+  "DeclareVariable":             "flow",
+  "FunctionTypeAnnotation":      "flow",
+  "FunctionTypeParam":           "flow",
+  "GenericTypeAnnotation":       "flow",
+  "InterfaceExtends":            "flow",
+  "InterfaceDeclaration":        "flow",
+  "IntersectionTypeAnnotation":  "flow",
+  "NullableTypeAnnotation":      "flow",
+  "NumberTypeAnnotation":        "flow",
+  "StringLiteralTypeAnnotation": "flow",
+  "StringTypeAnnotation":        "flow",
+  "TupleTypeAnnotation":         "flow",
+  "TypeofTypeAnnotation":        "flow",
+  "TypeAlias":                   "flow",
+  "TypeAnnotation":              "flow",
+  "TypeParameterDeclaration":    "flow",
+  "TypeParameterInstantiation":  "flow",
+  "ObjectTypeAnnotation":        "flow",
+  "ObjectTypeCallProperty":      "flow",
+  "ObjectTypeIndexer":           "flow",
+  "ObjectTypeProperty":          "flow",
+  "QualifiedTypeIdentifier":     "flow",
+  "UnionTypeAnnotation":         "flow",
+  "VoidTypeAnnotation":          "flow",
+
+  "JSXAttribute":              "jsx",
+  "JSXClosingElement":         "jsx",
+  "JSXElement":                "jsx",
+  "JSXEmptyExpression":        "jsx",
+  "JSXExpressionContainer":    "jsx",
+  "JSXIdentifier":             "jsx",
+  "JSXMemberExpression":       "jsx",
+  "JSXNamespacedName":         "jsx",
+  "JSXOpeningElement":         "jsx",
+  "JSXSpreadAttribute":        "jsx"
+}
@@ -0,0 +1,54 @@
+var t = require("../types");
+var includes = require("lodash/collection/includes");
+
+exports.AssignmentExpression = function (node, parent, detected) {
+  if (node.operator === "**=") {
+    detected("es6.exponentation");
+  }
+};
+
+exports.BinaryExpression = function (node, parent, detected) {
+  if (node.operator === "**") {
+    detected("es6.exponentation");
+  }
+};
+
+exports.VariableDeclaration = function (node, parent, detected) {
+  if (node.kind === "let" || node.kind === "const") {
+    detected("es6.blockScoping");
+  }
+
+  if (node.kind === "const") {
+    detected("es6.constants");
+  }
+};
+
+exports.Property = function (node, parent, detected) {
+  if (node.shorthand || node.method) {
+    detected("es6.properties.shorthand");
+  }
+
+  if (node.kind === "set" || node.kind === "get") {
+    detected("es5.properties.mutators");
+  }
+
+  if (node.computed) {
+    detected("es6.properties.computed");
+  }
+};
+
+exports.AssignmentPattern = function (node, parent, detected) {
+  if (t.isFunction(parent) && includes(parent.params, node)) {
+    detected("es6.parameters.default");
+  }
+};
+
+exports.Function = function (node, parent, detected) {
+  if (node.generator) {
+    detected("es6.generators");
+  }
+
+  if (node.async) {
+    detected("es7.asyncFunctions");
+  }
+};
@@ -0,0 +1,166 @@
+"use strict";
+
+module.exports = Buffer;
+
+var isBoolean = require("lodash/lang/isBoolean");
+var includes  = require("lodash/collection/includes");
+var isNumber  = require("lodash/lang/isNumber");
+var util      = require("../util");
+
+function Buffer(position, format) {
+  this.position = position;
+  this._indent  = format.indent.base;
+  this.format   = format;
+  this.buf      = "";
+}
+
+Buffer.prototype.get = function () {
+  return util.trimRight(this.buf);
+};
+
+Buffer.prototype.getIndent = function () {
+  if (this.format.compact || this.format.concise) {
+    return "";
+  } else {
+    return util.repeat(this._indent, this.format.indent.style);
+  }
+};
+
+Buffer.prototype.indentSize = function () {
+  return this.getIndent().length;
+};
+
+Buffer.prototype.indent = function () {
+  this._indent++;
+};
+
+Buffer.prototype.dedent = function () {
+  this._indent--;
+};
+
+Buffer.prototype.semicolon = function () {
+  this.push(";");
+};
+
+Buffer.prototype.ensureSemicolon = function () {
+  if (!this.isLast(";")) this.semicolon();
+};
+
+Buffer.prototype.rightBrace = function () {
+  this.newline(true);
+  this.push("}");
+};
+
+Buffer.prototype.keyword = function (name) {
+  this.push(name);
+  this.space();
+};
+
+Buffer.prototype.space = function () {
+  if (this.format.compact) return;
+
+  if (this.buf && !this.isLast([" ", "\n"])) {
+    this.push(" ");
+  }
+};
+
+Buffer.prototype.removeLast = function (cha) {
+  if (!this.isLast(cha)) return;
+
+  this.buf = this.buf.substr(0, this.buf.length - 1);
+  this.position.unshift(cha);
+};
+
+Buffer.prototype.newline = function (i, removeLast) {
+  if (this.format.compact || this.format.concise) {
+    this.space();
+    return;
+  }
+
+  removeLast = removeLast || false;
+
+  if (isNumber(i)) {
+    if (this.endsWith("{\n")) i--;
+    if (this.endsWith(util.repeat(i, "\n"))) return;
+
+    while (i--) {
+      this._newline(removeLast);
+    }
+    return;
+  }
+
+  if (isBoolean(i)) {
+    removeLast = i;
+  }
+
+  this._newline(removeLast);
+};
+
+Buffer.prototype._newline = function (removeLast) {
+  if (removeLast && this.isLast("\n")) this.removeLast("\n");
+
+  this.removeLast(" ");
+
+  // remove whitespace if last character was a newline
+  this._removeSpacesAfterLastNewline();
+  this._push("\n");
+};
+
+/**
+ * If buffer ends with a newline and some spaces after it, trim those spaces.
+ */
+Buffer.prototype._removeSpacesAfterLastNewline = function () {
+  var lastNewlineIndex = this.buf.lastIndexOf("\n");
+  if (lastNewlineIndex === -1)
+    return;
+
+  var index = this.buf.length - 1;
+  while (index > lastNewlineIndex) {
+    if (this.buf[index] !== " ") {
+      break;
+    }
+
+    index--;
+  }
+
+  if (index === lastNewlineIndex) {
+    this.buf = this.buf.substring(0, index + 1);
+  }
+};
+
+Buffer.prototype.push = function (str, noIndent) {
+  if (this._indent && !noIndent && str !== "\n") {
+    // we have an indent level and we aren't pushing a newline
+    var indent = this.getIndent();
+
+    // replace all newlines with newlines with the indentation
+    str = str.replace(/\n/g, "\n" + indent);
+
+    // we've got a newline before us so prepend on the indentation
+    if (this.isLast("\n")) str = indent + str;
+  }
+
+  this._push(str);
+};
+
+Buffer.prototype._push = function (str) {
+  this.position.push(str);
+  this.buf += str;
+};
+
+Buffer.prototype.endsWith = function (str) {
+  var d = this.buf.length - str.length;
+  return d >= 0 && this.buf.lastIndexOf(str) === d;
+};
+
+Buffer.prototype.isLast = function (cha, trimRight) {
+  var buf = this.buf;
+  if (trimRight) buf = util.trimRight(buf);
+  var last = buf[buf.length - 1];
+
+  if (Array.isArray(cha)) {
+    return includes(cha, last);
+  } else {
+    return cha === last;
+  }
+};
@@ -0,0 +1,21 @@
+"use strict";
+
+exports.File = function (node, print) {
+  print(node.program);
+};
+
+exports.Program = function (node, print) {
+  print.sequence(node.body);
+};
+
+exports.BlockStatement = function (node, print) {
+  if (node.body.length === 0) {
+    this.push("{}");
+  } else {
+    this.push("{");
+    this.newline();
+    print.sequence(node.body, { indent: true });
+    this.removeLast("\n");
+    this.rightBrace();
+  }
+};
@@ -0,0 +1,42 @@
+"use strict";
+
+exports.ClassExpression =
+exports.ClassDeclaration = function (node, print) {
+  this.push("class");
+
+  if (node.id) {
+    this.space();
+    print(node.id);
+  }
+
+  if (node.superClass) {
+    this.push(" extends ");
+    print(node.superClass);
+  }
+
+  this.space();
+  print(node.body);
+};
+
+exports.ClassBody = function (node, print) {
+  if (node.body.length === 0) {
+    this.push("{}");
+  } else {
+    this.push("{");
+    this.newline();
+
+    this.indent();
+    print.sequence(node.body);
+    this.dedent();
+
+    this.rightBrace();
+  }
+};
+
+exports.MethodDefinition = function (node, print) {
+  if (node.static) {
+    this.push("static ");
+  }
+
+  this._method(node, print);
+};
@@ -0,0 +1,29 @@
+"use strict";
+
+exports.ComprehensionBlock = function (node, print) {
+  this.keyword("for");
+  this.push("(");
+  print(node.left);
+  this.push(" of ");
+  print(node.right);
+  this.push(")");
+};
+
+exports.ComprehensionExpression = function (node, print) {
+  this.push(node.generator ? "(" : "[");
+
+  print.join(node.blocks, { separator: " " });
+  this.space();
+
+  if (node.filter) {
+    this.keyword("if");
+    this.push("(");
+    print(node.filter);
+    this.push(")");
+    this.space();
+  }
+
+  print(node.body);
+
+  this.push(node.generator ? ")" : "]");
+};
@@ -0,0 +1,156 @@
+"use strict";
+
+var util     = require("../../util");
+var t        = require("../../types");
+var isNumber = require("lodash/lang/isNumber");
+
+exports.UnaryExpression = function (node, print) {
+  var hasSpace = /[a-z]$/.test(node.operator);
+  var arg = node.argument;
+
+  if (t.isUpdateExpression(arg) || t.isUnaryExpression(arg)) {
+    hasSpace = true;
+  }
+
+  if (t.isUnaryExpression(arg) && arg.operator === "!") {
+    hasSpace = false;
+  }
+
+  this.push(node.operator);
+  if (hasSpace) this.push(" ");
+  print(node.argument);
+};
+
+exports.UpdateExpression = function (node, print) {
+  if (node.prefix) {
+    this.push(node.operator);
+    print(node.argument);
+  } else {
+    print(node.argument);
+    this.push(node.operator);
+  }
+};
+
+exports.ConditionalExpression = function (node, print) {
+  print(node.test);
+  this.space();
+  this.push("?");
+  this.space();
+  print(node.consequent);
+  this.space();
+  this.push(":");
+  this.space();
+  print(node.alternate);
+};
+
+exports.NewExpression = function (node, print) {
+  this.push("new ");
+  print(node.callee);
+  if (node.arguments.length || this.format.parentheses) {
+    this.push("(");
+    print.list(node.arguments);
+    this.push(")");
+  }
+};
+
+exports.SequenceExpression = function (node, print) {
+  print.list(node.expressions);
+};
+
+exports.ThisExpression = function () {
+  this.push("this");
+};
+
+exports.CallExpression = function (node, print) {
+  print(node.callee);
+
+  this.push("(");
+
+  var separator = ",";
+
+  if (node._prettyCall) {
+    separator += "\n";
+    this.newline();
+    this.indent();
+  } else {
+    separator += " ";
+  }
+
+  print.list(node.arguments, { separator: separator });
+
+  if (node._prettyCall) {
+    this.newline();
+    this.dedent();
+  }
+
+  this.push(")");
+};
+
+var buildYieldAwait = function (keyword) {
+  return function (node, print) {
+    this.push(keyword);
+
+    if (node.delegate || node.all) {
+      this.push("*");
+    }
+
+    if (node.argument) {
+      this.space();
+      print(node.argument);
+    }
+  };
+};
+
+exports.YieldExpression = buildYieldAwait("yield");
+exports.AwaitExpression = buildYieldAwait("await");
+
+exports.EmptyStatement = function () {
+  this.semicolon();
+};
+
+exports.ExpressionStatement = function (node, print) {
+  print(node.expression);
+  this.semicolon();
+};
+
+exports.BinaryExpression =
+exports.LogicalExpression =
+exports.AssignmentPattern =
+exports.AssignmentExpression = function (node, print) {
+  // todo: add cases where the spaces can be dropped when in compact mode
+  print(node.left);
+  this.push(" ");
+  this.push(node.operator);
+  this.push(" ");
+  print(node.right);
+};
+
+var SCIENTIFIC_NOTATION = /e/i;
+
+exports.MemberExpression = function (node, print) {
+  var obj = node.object;
+  print(obj);
+
+  if (!node.computed && t.isMemberExpression(node.property)) {
+    throw new TypeError("Got a MemberExpression for MemberExpression property");
+  }
+
+  var computed = node.computed;
+  if (t.isLiteral(node.property) && isNumber(node.property.value)) {
+    computed = true;
+  }
+
+  if (computed) {
+    this.push("[");
+    print(node.property);
+    this.push("]");
+  } else {
+    // 5..toFixed(2);
+    if (t.isLiteral(obj) && util.isInteger(obj.value) && !SCIENTIFIC_NOTATION.test(obj.value.toString())) {
+      this.push(".");
+    }
+
+    this.push(".");
+    print(node.property);
+  }
+};
@@ -0,0 +1,36 @@
+"use strict";
+
+exports.AnyTypeAnnotation =
+exports.ArrayTypeAnnotation =
+exports.BooleanTypeAnnotation =
+exports.ClassProperty =
+exports.DeclareClass =
+exports.DeclareFunction =
+exports.DeclareModule =
+exports.DeclareVariable =
+exports.FunctionTypeAnnotation =
+exports.FunctionTypeParam =
+exports.GenericTypeAnnotation =
+exports.InterfaceExtends =
+exports.InterfaceDeclaration =
+exports.IntersectionTypeAnnotation =
+exports.NullableTypeAnnotation =
+exports.NumberTypeAnnotation =
+exports.StringLiteralTypeAnnotation =
+exports.StringTypeAnnotation =
+exports.TupleTypeAnnotation =
+exports.TypeofTypeAnnotation =
+exports.TypeAlias =
+exports.TypeAnnotation =
+exports.TypeParameterDeclaration =
+exports.TypeParameterInstantiation =
+exports.ObjectTypeAnnotation =
+exports.ObjectTypeCallProperty =
+exports.ObjectTypeIndexer =
+exports.ObjectTypeProperty =
+exports.QualifiedTypeIdentifier =
+exports.UnionTypeAnnotation =
+exports.TypeCastExpression =
+exports.VoidTypeAnnotation = function () {
+  // todo: implement these once we have a `--keep-types` option
+};
@@ -0,0 +1,78 @@
+"use strict";
+
+var t    = require("../../types");
+var each = require("lodash/collection/each");
+
+exports.JSXAttribute = function (node, print) {
+  print(node.name);
+  if (node.value) {
+    this.push("=");
+    print(node.value);
+  }
+};
+
+exports.JSXIdentifier = function (node) {
+  this.push(node.name);
+};
+
+exports.JSXNamespacedName = function (node, print) {
+  print(node.namespace);
+  this.push(":");
+  print(node.name);
+};
+
+exports.JSXMemberExpression = function (node, print) {
+  print(node.object);
+  this.push(".");
+  print(node.property);
+};
+
+exports.JSXSpreadAttribute = function (node, print) {
+  this.push("{...");
+  print(node.argument);
+  this.push("}");
+};
+
+exports.JSXExpressionContainer = function (node, print) {
+  this.push("{");
+  print(node.expression);
+  this.push("}");
+};
+
+exports.JSXElement = function (node, print) {
+  var self = this;
+
+  var open = node.openingElement;
+  print(open);
+  if (open.selfClosing) return;
+
+  this.indent();
+  each(node.children, function (child) {
+    if (t.isLiteral(child)) {
+      self.push(child.value);
+    } else {
+      print(child);
+    }
+  });
+  this.dedent();
+
+  print(node.closingElement);
+};
+
+exports.JSXOpeningElement = function (node, print) {
+  this.push("<");
+  print(node.name);
+  if (node.attributes.length > 0) {
+    this.push(" ");
+    print.join(node.attributes, { separator: " " });
+  }
+  this.push(node.selfClosing ? " />" : ">");
+};
+
+exports.JSXClosingElement = function (node, print) {
+  this.push("</");
+  print(node.name);
+  this.push(">");
+};
+
+exports.JSXEmptyExpression = function () {};
@@ -0,0 +1,68 @@
+"use strict";
+
+var t = require("../../types");
+
+exports._params = function (node, print) {
+  this.push("(");
+  print.list(node.params);
+  this.push(")");
+};
+
+exports._method = function (node, print) {
+  var value = node.value;
+  var kind  = node.kind;
+  var key   = node.key;
+
+  if (!kind || kind === "init") {
+    if (value.generator) {
+      this.push("*");
+    }
+  } else {
+    this.push(kind + " ");
+  }
+
+  if (value.async) this.push("async ");
+
+  if (node.computed) {
+    this.push("[");
+    print(key);
+    this.push("]");
+  } else {
+    print(key);
+  }
+
+  this._params(value, print);
+  this.push(" ");
+  print(value.body);
+};
+
+exports.FunctionDeclaration =
+exports.FunctionExpression = function (node, print) {
+  if (node.async) this.push("async ");
+  this.push("function");
+  if (node.generator) this.push("*");
+
+  if (node.id) {
+    this.push(" ");
+    print(node.id);
+  } else {
+    this.space();
+  }
+
+  this._params(node, print);
+  this.space();
+  print(node.body);
+};
+
+exports.ArrowFunctionExpression = function (node, print) {
+  if (node.async) this.push("async ");
+
+  if (node.params.length === 1 && t.isIdentifier(node.params[0])) {
+    print(node.params[0]);
+  } else {
+    this._params(node, print);
+  }
+
+  this.push(" => ");
+  print(node.body);
+};
@@ -0,0 +1,98 @@
+"use strict";
+
+var t    = require("../../types");
+var each = require("lodash/collection/each");
+
+exports.ImportSpecifier = function (node, print) {
+  if (t.isSpecifierDefault(node)) {
+    print(t.getSpecifierName(node));
+  } else {
+    return exports.ExportSpecifier.apply(this, arguments);
+  }
+};
+
+exports.ExportSpecifier = function (node, print) {
+  print(node.id);
+  if (node.name) {
+    this.push(" as ");
+    print(node.name);
+  }
+};
+
+exports.ExportBatchSpecifier = function () {
+  this.push("*");
+};
+
+exports.ExportDeclaration = function (node, print) {
+  this.push("export ");
+
+  var specifiers = node.specifiers;
+
+  if (node.default) {
+    this.push("default ");
+  }
+
+  if (node.declaration) {
+    print(node.declaration);
+    if (t.isStatement(node.declaration)) return;
+  } else {
+    if (specifiers.length === 1 && t.isExportBatchSpecifier(specifiers[0])) {
+      print(specifiers[0]);
+    } else {
+      this.push("{");
+      if (specifiers.length) {
+        this.space();
+        print.join(specifiers, { separator: ", " });
+        this.space();
+      }
+      this.push("}");
+    }
+
+    if (node.source) {
+      this.push(" from ");
+      print(node.source);
+    }
+  }
+
+  this.ensureSemicolon();
+};
+
+exports.ImportDeclaration = function (node, print) {
+  var self = this;
+
+  this.push("import ");
+
+  var specfiers = node.specifiers;
+  if (specfiers && specfiers.length) {
+    var foundImportSpecifier = false;
+
+    each(node.specifiers, function (spec, i) {
+      if (+i > 0) {
+        self.push(", ");
+      }
+
+      var isDefault = t.isSpecifierDefault(spec);
+
+      if (!isDefault && spec.type !== "ImportBatchSpecifier" && !foundImportSpecifier) {
+        foundImportSpecifier = true;
+        self.push("{ ");
+      }
+
+      print(spec);
+    });
+
+    if (foundImportSpecifier) {
+      this.push(" }");
+    }
+
+    this.push(" from ");
+  }
+
+  print(node.source);
+  this.semicolon();
+};
+
+exports.ImportBatchSpecifier = function (node, print) {
+  this.push("* as ");
+  print(node.name);
+};
@@ -0,0 +1,9 @@
+"use strict";
+
+var each = require("lodash/collection/each");
+
+each(["BindMemberExpression", "BindFunctionExpression"], function (type) {
+  exports[type] = function () {
+    throw new ReferenceError("Trying to render non-standard playground node " + JSON.stringify(type));
+  };
+});
@@ -0,0 +1,221 @@
+"use strict";
+
+var util = require("../../util");
+var t    = require("../../types");
+
+exports.WithStatement = function (node, print) {
+  this.keyword("with");
+  this.push("(");
+  print(node.object);
+  this.push(")");
+  print.block(node.body);
+};
+
+exports.IfStatement = function (node, print) {
+  this.keyword("if");
+  this.push("(");
+  print(node.test);
+  this.push(")");
+  this.space();
+
+  print.indentOnComments(node.consequent);
+
+  if (node.alternate) {
+    if (this.isLast("}")) this.space();
+    this.keyword("else");
+
+    if (this.format.format && !t.isBlockStatement(node.alternate)) {
+      this.push(" ");
+    }
+
+    print.indentOnComments(node.alternate);
+  }
+};
+
+exports.ForStatement = function (node, print) {
+  this.keyword("for");
+  this.push("(");
+
+  print(node.init);
+  this.push(";");
+
+  if (node.test) {
+    this.push(" ");
+    print(node.test);
+  }
+  this.push(";");
+
+  if (node.update) {
+    this.push(" ");
+    print(node.update);
+  }
+
+  this.push(")");
+  print.block(node.body);
+};
+
+exports.WhileStatement = function (node, print) {
+  this.keyword("while");
+  this.push("(");
+  print(node.test);
+  this.push(")");
+  print.block(node.body);
+};
+
+var buildForXStatement = function (op) {
+  return function (node, print) {
+    this.keyword("for");
+    this.push("(");
+    print(node.left);
+    this.push(" " + op + " ");
+    print(node.right);
+    this.push(")");
+    print.block(node.body);
+  };
+};
+
+exports.ForInStatement = buildForXStatement("in");
+exports.ForOfStatement = buildForXStatement("of");
+
+exports.DoWhileStatement = function (node, print) {
+  this.keyword("do");
+  print(node.body);
+  this.space();
+  this.keyword("while");
+  this.push("(");
+  print(node.test);
+  this.push(");");
+};
+
+var buildLabelStatement = function (prefix, key) {
+  return function (node, print) {
+    this.push(prefix);
+
+    var label = node[key || "label"];
+    if (label) {
+      this.push(" ");
+      print(label);
+    }
+
+    this.semicolon();
+  };
+};
+
+exports.ContinueStatement = buildLabelStatement("continue");
+exports.ReturnStatement   = buildLabelStatement("return", "argument");
+exports.BreakStatement    = buildLabelStatement("break");
+
+exports.LabeledStatement = function (node, print) {
+  print(node.label);
+  this.push(": ");
+  print(node.body);
+};
+
+exports.TryStatement = function (node, print) {
+  this.keyword("try");
+  print(node.block);
+  this.space();
+
+  // Esprima bug puts the catch clause in a `handlers` array.
+  // see https://code.google.com/p/esprima/issues/detail?id=433
+  // We run into this from regenerator generated ast.
+  if (node.handlers) {
+    print(node.handlers[0]);
+  } else {
+    print(node.handler);
+  }
+
+  if (node.finalizer) {
+    this.space();
+    this.push("finally ");
+    print(node.finalizer);
+  }
+};
+
+exports.CatchClause = function (node, print) {
+  this.keyword("catch");
+  this.push("(");
+  print(node.param);
+  this.push(") ");
+  print(node.body);
+};
+
+exports.ThrowStatement = function (node, print) {
+  this.push("throw ");
+  print(node.argument);
+  this.semicolon();
+};
+
+exports.SwitchStatement = function (node, print) {
+  this.keyword("switch");
+  this.push("(");
+  print(node.discriminant);
+  this.push(")");
+  this.space();
+  this.push("{");
+  print.sequence(node.cases, { indent: true });
+  this.push("}");
+};
+
+exports.SwitchCase = function (node, print) {
+  if (node.test) {
+    this.push("case ");
+    print(node.test);
+    this.push(":");
+  } else {
+    this.push("default:");
+  }
+
+  this.newline();
+  print.sequence(node.consequent, { indent: true });
+};
+
+exports.DebuggerStatement = function () {
+  this.push("debugger;");
+};
+
+exports.VariableDeclaration = function (node, print, parent) {
+  this.push(node.kind + " ");
+
+  var hasInits = false;
+  // don't add whitespace to loop heads
+  if (!t.isFor(parent)) {
+    for (var i = 0; i < node.declarations.length; i++) {
+      if (node.declarations[i].init) {
+        // has an init so let's split it up over multiple lines
+        hasInits = true;
+      }
+    }
+  }
+
+  var sep = ",";
+  if (hasInits) {
+    sep += "\n" + util.repeat(node.kind.length + 1);
+  } else {
+    sep += " ";
+  }
+
+  print.list(node.declarations, { separator: sep });
+
+  if (!t.isFor(parent)) {
+    this.semicolon();
+  }
+};
+
+exports.PrivateDeclaration = function (node, print) {
+  this.push("private ");
+  print.join(node.declarations, { separator: ", " });
+  this.semicolon();
+};
+
+exports.VariableDeclarator = function (node, print) {
+  if (node.init) {
+    print(node.id);
+    this.space();
+    this.push("=");
+    this.space();
+    print(node.init);
+  } else {
+    print(node.id);
+  }
+};
@@ -0,0 +1,32 @@
+"use strict";
+
+var each = require("lodash/collection/each");
+
+exports.TaggedTemplateExpression = function (node, print) {
+  print(node.tag);
+  print(node.quasi);
+};
+
+exports.TemplateElement = function (node) {
+  this._push(node.value.raw);
+};
+
+exports.TemplateLiteral = function (node, print) {
+  this.push("`");
+
+  var quasis = node.quasis;
+  var self   = this;
+  var len    = quasis.length;
+
+  each(quasis, function (quasi, i) {
+    print(quasi);
+
+    if (i + 1 < len) {
+      self.push("${ ");
+      print(node.expressions[i]);
+      self.push(" }");
+    }
+  });
+
+  this._push("`");
+};
@@ -0,0 +1,106 @@
+"use strict";
+
+var each = require("lodash/collection/each");
+
+exports.Identifier = function (node) {
+  this.push(node.name);
+};
+
+exports.RestElement =
+exports.SpreadElement =
+exports.SpreadProperty = function (node, print) {
+  this.push("...");
+  print(node.argument);
+};
+
+exports.VirtualPropertyExpression = function (node, print) {
+  print(node.object);
+  this.push("::");
+  print(node.property);
+};
+
+exports.ObjectExpression =
+exports.ObjectPattern = function (node, print) {
+  var props = node.properties;
+
+  if (props.length) {
+    this.push("{");
+    this.space();
+
+    print.list(props, { indent: true });
+
+    this.space();
+    this.push("}");
+  } else {
+    this.push("{}");
+  }
+};
+
+exports.Property = function (node, print) {
+  if (node.method || node.kind === "get" || node.kind === "set") {
+    this._method(node, print);
+  } else {
+    if (node.computed) {
+      this.push("[");
+      print(node.key);
+      this.push("]");
+    } else {
+      print(node.key);
+      if (node.shorthand) return;
+    }
+
+    this.push(":");
+    this.space();
+    print(node.value);
+  }
+};
+
+exports.ArrayExpression =
+exports.ArrayPattern = function (node, print) {
+  var elems = node.elements;
+  var self  = this;
+  var len   = elems.length;
+
+  this.push("[");
+
+  each(elems, function (elem, i) {
+    if (!elem) {
+      // If the array expression ends with a hole, that hole
+      // will be ignored by the interpreter, but if it ends with
+      // two (or more) holes, we need to write out two (or more)
+      // commas so that the resulting code is interpreted with
+      // both (all) of the holes.
+      self.push(",");
+    } else {
+      if (i > 0 && !self.format.compact) self.push(" ");
+      print(elem);
+      if (i < len - 1) self.push(",");
+    }
+  });
+
+  this.push("]");
+};
+
+exports.Literal = function (node) {
+  var val  = node.value;
+  var type = typeof val;
+
+  if (type === "string") {
+    val = JSON.stringify(val);
+
+    // escape illegal js but valid json unicode characters
+    val = val.replace(/[\u000A\u000D\u2028\u2029]/g, function (c) {
+      return "\\u" + ("0000" + c.charCodeAt(0).toString(16)).slice(-4);
+    });
+
+    this.push(val);
+  } else if (type === "number") {
+    this.push(val + "");
+  } else if (type === "boolean") {
+    this.push(val ? "true" : "false");
+  } else if (node.regex) {
+    this.push("/" + node.regex.pattern + "/" + node.regex.flags);
+  } else if (val === null) {
+    this.push("null");
+  }
+};
@@ -0,0 +1,361 @@
+"use strict";
+
+module.exports = function (ast, opts, code) {
+  var gen = new CodeGenerator(ast, opts, code);
+  return gen.generate();
+};
+
+module.exports.CodeGenerator = CodeGenerator;
+
+var detectIndent = require("detect-indent");
+var Whitespace   = require("./whitespace");
+var SourceMap    = require("./source-map");
+var Position     = require("./position");
+var Buffer       = require("./buffer");
+var extend       = require("lodash/object/extend");
+var merge        = require("lodash/object/merge");
+var each         = require("lodash/collection/each");
+var util         = require("../util");
+var n            = require("./node");
+var t            = require("../types");
+
+function CodeGenerator(ast, opts, code) {
+  opts = opts || {};
+
+  this.comments = ast.comments || [];
+  this.tokens   = ast.tokens || [];
+  this.format   = CodeGenerator.normalizeOptions(code, opts);
+  this.opts     = opts;
+  this.ast      = ast;
+
+  this.whitespace = new Whitespace(this.tokens, this.comments);
+  this.position   = new Position;
+  this.map        = new SourceMap(this.position, opts, code);
+  this.buffer     = new Buffer(this.position, this.format);
+}
+
+each(Buffer.prototype, function (fn, key) {
+  CodeGenerator.prototype[key] = function () {
+    return fn.apply(this.buffer, arguments);
+  };
+});
+
+CodeGenerator.normalizeOptions = function (code, opts) {
+  var style = "  ";
+  if (code) {
+    var indent = detectIndent(code).indent;
+    if (indent && indent !== " ") style = indent;
+  }
+
+  return merge({
+    parentheses: true,
+    comments: opts.comments == null || opts.comments,
+    compact: false,
+    concise: false,
+    indent: {
+      adjustMultilineComment: true,
+      style: style,
+      base: 0
+    }
+  }, opts.format || {});
+};
+
+CodeGenerator.generators = {
+  templateLiterals: require("./generators/template-literals"),
+  comprehensions:   require("./generators/comprehensions"),
+  expressions:      require("./generators/expressions"),
+  statements:       require("./generators/statements"),
+  playground:       require("./generators/playground"),
+  classes:          require("./generators/classes"),
+  methods:          require("./generators/methods"),
+  modules:          require("./generators/modules"),
+  types:            require("./generators/types"),
+  flow:             require("./generators/flow"),
+  base:             require("./generators/base"),
+  jsx:              require("./generators/jsx")
+};
+
+each(CodeGenerator.generators, function (generator) {
+  extend(CodeGenerator.prototype, generator);
+});
+
+CodeGenerator.prototype.generate = function () {
+  var ast = this.ast;
+
+  this.print(ast);
+
+  var comments = [];
+  each(ast.comments, function (comment) {
+    if (!comment._displayed) comments.push(comment);
+  });
+  this._printComments(comments);
+
+  return {
+    map:  this.map.get(),
+    code: this.buffer.get()
+  };
+};
+
+CodeGenerator.prototype.buildPrint = function (parent) {
+  var self = this;
+
+  var print = function (node, opts) {
+    return self.print(node, parent, opts);
+  };
+
+  print.sequence = function (nodes, opts) {
+    opts = opts || {};
+    opts.statement = true;
+    return self.printJoin(print, nodes, opts);
+  };
+
+  print.join = function (nodes, opts) {
+    return self.printJoin(print, nodes, opts);
+  };
+
+  print.list = function (items, opts) {
+    opts = opts || {};
+
+    var sep = opts.separator || ", ";
+    if (self.format.compact) sep = ",";
+    opts.separator = sep;
+
+    print.join(items, opts);
+  };
+
+  print.block = function (node) {
+    return self.printBlock(print, node);
+  };
+
+  print.indentOnComments = function (node) {
+    return self.printAndIndentOnComments(print, node);
+  };
+
+  return print;
+};
+
+CodeGenerator.prototype.print = function (node, parent, opts) {
+  if (!node) return "";
+
+  if (parent && parent._compact) {
+    node._compact = true;
+  }
+
+  var oldConcise = this.format.concise;
+  if (node._compact) {
+    this.format.concise = true;
+  }
+
+  var self = this;
+
+  opts = opts || {};
+
+  var newline = function (leading) {
+    if (!opts.statement && !n.isUserWhitespacable(node, parent)) {
+      return;
+    }
+
+    var lines = 0;
+
+    if (node.start != null && !node._ignoreUserWhitespace) {
+      // user node
+      if (leading) {
+        lines = self.whitespace.getNewlinesBefore(node);
+      } else {
+        lines = self.whitespace.getNewlinesAfter(node);
+      }
+    } else {
+      // generated node
+      if (!leading) lines++; // always include at least a single line after
+
+      var needs = n.needsWhitespaceAfter;
+      if (leading) needs = n.needsWhitespaceBefore;
+      lines += needs(node, parent);
+
+      // generated nodes can't add starting file whitespace
+      if (!self.buffer.get()) lines = 0;
+    }
+
+    self.newline(lines);
+  };
+
+  if (this[node.type]) {
+    var needsNoLineTermParens = n.needsParensNoLineTerminator(node, parent);
+    var needsParens           = needsNoLineTermParens || n.needsParens(node, parent);
+
+    if (needsParens) this.push("(");
+    if (needsNoLineTermParens) this.indent();
+
+    this.printLeadingComments(node, parent);
+
+    newline(true);
+
+    if (opts.before) opts.before();
+    this.map.mark(node, "start");
+
+    this[node.type](node, this.buildPrint(node), parent);
+
+    if (needsNoLineTermParens) {
+      this.newline();
+      this.dedent();
+    }
+    if (needsParens) this.push(")");
+
+    this.map.mark(node, "end");
+    if (opts.after) opts.after();
+
+    newline(false);
+
+    this.printTrailingComments(node, parent);
+  } else {
+    throw new ReferenceError("unknown node of type " + JSON.stringify(node.type) + " with constructor " + JSON.stringify(node && node.constructor.name));
+  }
+
+  this.format.concise = oldConcise;
+};
+
+CodeGenerator.prototype.printJoin = function (print, nodes, opts) {
+  if (!nodes || !nodes.length) return;
+
+  opts = opts || {};
+
+  var self = this;
+  var len  = nodes.length;
+
+  if (opts.indent) self.indent();
+
+  each(nodes, function (node, i) {
+    print(node, {
+      statement: opts.statement,
+      after: function () {
+        if (opts.iterator) {
+          opts.iterator(node, i);
+        }
+
+        if (opts.separator && i < len - 1) {
+          self.push(opts.separator);
+        }
+      }
+    });
+  });
+
+  if (opts.indent) self.dedent();
+};
+
+CodeGenerator.prototype.printAndIndentOnComments = function (print, node) {
+  var indent = !!node.leadingComments;
+  if (indent) this.indent();
+  print(node);
+  if (indent) this.dedent();
+};
+
+CodeGenerator.prototype.printBlock = function (print, node) {
+  if (t.isEmptyStatement(node)) {
+    this.semicolon();
+  } else {
+    this.push(" ");
+    print(node);
+  }
+};
+
+CodeGenerator.prototype.generateComment = function (comment) {
+  var val = comment.value;
+  if (comment.type === "Line") {
+    val = "//" + val;
+  } else {
+    val = "/*" + val + "*/";
+  }
+  return val;
+};
+
+CodeGenerator.prototype.printTrailingComments = function (node, parent) {
+  this._printComments(this.getComments("trailingComments", node, parent));
+};
+
+CodeGenerator.prototype.printLeadingComments = function (node, parent) {
+  this._printComments(this.getComments("leadingComments", node, parent));
+};
+
+CodeGenerator.prototype.getComments = function (key, node, parent) {
+  if (t.isExpressionStatement(parent)) {
+    return [];
+  }
+
+  var comments = [];
+  var nodes    = [node];
+  var self     = this;
+
+  if (t.isExpressionStatement(node)) {
+    nodes.push(node.argument);
+  }
+
+  each(nodes, function (node) {
+    comments = comments.concat(self._getComments(key, node));
+  });
+
+  return comments;
+};
+
+CodeGenerator.prototype._getComments = function (key, node) {
+  return (node && node[key]) || [];
+};
+
+CodeGenerator.prototype._printComments = function (comments) {
+  if (this.format.compact) return;
+  if (!this.format.comments) return;
+  if (!comments || !comments.length) return;
+
+  var self = this;
+
+  each(comments, function (comment) {
+    var skip = false;
+
+    // find the original comment in the ast and set it as displayed
+    each(self.ast.comments, function (origComment) {
+      if (origComment.start === comment.start) {
+        // comment has already been output
+        if (origComment._displayed) skip = true;
+
+        origComment._displayed = true;
+        return false;
+      }
+    });
+
+    if (skip) return;
+
+    // whitespace before
+    self.newline(self.whitespace.getNewlinesBefore(comment));
+
+    var column = self.position.column;
+    var val    = self.generateComment(comment);
+
+    if (column && !self.isLast(["\n", " ", "[", "{"])) {
+      self._push(" ");
+      column++;
+    }
+
+    //
+
+    if (comment.type === "Block" && self.format.indent.adjustMultilineComment) {
+      var offset = comment.loc.start.column;
+      if (offset) {
+        var newlineRegex = new RegExp("\\n\\s{1," + offset + "}", "g");
+        val = val.replace(newlineRegex, "\n");
+      }
+
+      var indent = Math.max(self.indentSize(), column);
+      val = val.replace(/\n/g, "\n" + util.repeat(indent));
+    }
+
+    if (column === 0) {
+      val = self.getIndent() + val;
+    }
+
+    //
+
+    self._push(val);
+
+    // whitespace after
+    self.newline(self.whitespace.getNewlinesAfter(comment));
+  });
+};
@@ -0,0 +1,112 @@
+"use strict";
+
+module.exports = Node;
+
+var whitespace = require("./whitespace");
+var parens     = require("./parentheses");
+var t          = require("../../types");
+var each       = require("lodash/collection/each");
+var some       = require("lodash/collection/some");
+
+var find = function (obj, node, parent) {
+  if (!obj) return;
+  var result;
+
+  var types = Object.keys(obj);
+  for (var i = 0; i < types.length; i++) {
+    var type = types[i];
+
+    if (t.is(type, node)) {
+      var fn = obj[type];
+      result = fn(node, parent);
+      if (result != null) break;
+    }
+  }
+
+  return result;
+};
+
+function Node(node, parent) {
+  this.parent = parent;
+  this.node   = node;
+}
+
+Node.isUserWhitespacable = function (node) {
+  return t.isUserWhitespacable(node);
+};
+
+Node.needsWhitespace = function (node, parent, type) {
+  if (!node) return 0;
+
+  if (t.isExpressionStatement(node)) {
+    node = node.expression;
+  }
+
+  var lines = find(whitespace[type].nodes, node, parent);
+  if (lines) return lines;
+
+  each(find(whitespace[type].list, node, parent), function (expr) {
+    lines = Node.needsWhitespace(expr, node, type);
+    if (lines) return false;
+  });
+  return lines || 0;
+};
+
+Node.needsWhitespaceBefore = function (node, parent) {
+  return Node.needsWhitespace(node, parent, "before");
+};
+
+Node.needsWhitespaceAfter = function (node, parent) {
+  return Node.needsWhitespace(node, parent, "after");
+};
+
+Node.needsParens = function (node, parent) {
+  if (!parent) return false;
+
+  if (t.isNewExpression(parent) && parent.callee === node) {
+    if (t.isCallExpression(node)) return true;
+
+    var hasCall = some(node, function (val) {
+      return t.isCallExpression(val);
+    });
+    if (hasCall) return true;
+  }
+
+  return find(parens, node, parent);
+};
+
+Node.needsParensNoLineTerminator = function (node, parent) {
+  if (!parent) return false;
+
+  // no comments
+  if (!node.leadingComments || !node.leadingComments.length) {
+    return false;
+  }
+
+  if (t.isYieldExpression(parent) || t.isAwaitExpression(parent)) {
+    return true;
+  }
+
+  if (t.isContinueStatement(parent) || t.isBreakStatement(parent) ||
+      t.isReturnStatement(parent) || t.isThrowStatement(parent)) {
+    return true;
+  }
+
+  return false;
+};
+
+each(Node, function (fn, key) {
+  Node.prototype[key] = function () {
+    // Avoid leaking arguments to prevent deoptimization
+    var args = new Array(arguments.length + 2);
+
+    args[0] = this.node;
+    args[1] = this.parent;
+
+    for (var i = 0; i < args.length; i++) {
+      args[i + 2] = arguments[i];
+    }
+
+    return Node[key].apply(null, args);
+  };
+});
@@ -0,0 +1,169 @@
+"use strict";
+
+var t    = require("../../types");
+var each = require("lodash/collection/each");
+
+var PRECEDENCE = {};
+
+each([
+  ["||"],
+  ["&&"],
+  ["|"],
+  ["^"],
+  ["&"],
+  ["==", "===", "!=", "!=="],
+  ["<", ">", "<=", ">=", "in", "instanceof"],
+  [">>", "<<", ">>>"],
+  ["+", "-"],
+  ["*", "/", "%"],
+  ["**"]
+], function (tier, i) {
+  each(tier, function (op) {
+    PRECEDENCE[op] = i;
+  });
+});
+
+exports.UpdateExpression = function (node, parent) {
+  if (t.isMemberExpression(parent) && parent.object === node) {
+    // (foo++).test()
+    return true;
+  }
+};
+
+exports.ObjectExpression = function (node, parent) {
+  if (t.isExpressionStatement(parent)) {
+    // ({ foo: "bar" });
+    return true;
+  }
+
+  if (t.isMemberExpression(parent) && parent.object === node) {
+    // ({ foo: "bar" }).foo
+    return true;
+  }
+
+  return false;
+};
+
+exports.Binary = function (node, parent) {
+  if ((t.isCallExpression(parent) || t.isNewExpression(parent)) && parent.callee === node) {
+    return true;
+  }
+
+  if (t.isUnaryLike(parent)) {
+    return true;
+  }
+
+  if (t.isMemberExpression(parent) && parent.object === node) {
+    return true;
+  }
+
+  if (t.isBinary(parent)) {
+    var parentOp  = parent.operator;
+    var parentPos = PRECEDENCE[parentOp];
+
+    var nodeOp = node.operator;
+    var nodePos = PRECEDENCE[nodeOp];
+
+    if (parentPos > nodePos) {
+      return true;
+    }
+
+    if (parentPos === nodePos && parent.right === node) {
+      return true;
+    }
+  }
+};
+
+exports.BinaryExpression = function (node, parent) {
+  if (node.operator === "in") {
+    // var i = (1 in []);
+    if (t.isVariableDeclarator(parent)) {
+      return true;
+    }
+
+    // for ((1 in []);;);
+    if (t.isFor(parent)) {
+      return true;
+    }
+  }
+};
+
+exports.SequenceExpression = function (node, parent) {
+  if (t.isForStatement(parent)) {
+    // Although parentheses wouldn't hurt around sequence
+    // expressions in the head of for loops, traditional style
+    // dictates that e.g. i++, j++ should not be wrapped with
+    // parentheses.
+    return false;
+  }
+
+  if (t.isExpressionStatement(parent) && parent.expression === node) {
+    return false;
+  }
+
+  // Otherwise err on the side of overparenthesization, adding
+  // explicit exceptions above if this proves overzealous.
+  return true;
+};
+
+exports.YieldExpression = function (node, parent) {
+  return t.isBinary(parent) ||
+         t.isUnaryLike(parent) ||
+         t.isCallExpression(parent) ||
+         t.isMemberExpression(parent) ||
+         t.isNewExpression(parent) ||
+         t.isConditionalExpression(parent) ||
+         t.isYieldExpression(parent);
+};
+
+exports.ClassExpression = function (node, parent) {
+  return t.isExpressionStatement(parent);
+};
+
+exports.UnaryLike = function (node, parent) {
+  return t.isMemberExpression(parent) && parent.object === node;
+};
+
+exports.FunctionExpression = function (node, parent) {
+  // function () {};
+  if (t.isExpressionStatement(parent)) {
+    return true;
+  }
+
+  // (function test() {}).name;
+  if (t.isMemberExpression(parent) && parent.object === node) {
+    return true;
+  }
+
+  // (function () {})();
+  if (t.isCallExpression(parent) && parent.callee === node) {
+    return true;
+  }
+};
+
+exports.AssignmentExpression =
+exports.ConditionalExpression = function (node, parent) {
+  if (t.isUnaryLike(parent)) {
+    return true;
+  }
+
+  if (t.isBinary(parent)) {
+    return true;
+  }
+
+  if (t.isCallExpression(parent) || t.isNewExpression(parent)) {
+    if (parent.callee === node) {
+      return true;
+    }
+  }
+
+  if (t.isConditionalExpression(parent) && parent.test === node) {
+    return true;
+  }
+
+  if (t.isMemberExpression(parent) && parent.object === node) {
+    return true;
+  }
+
+  return false;
+};
@@ -0,0 +1,84 @@
+"use strict";
+
+var t        = require("../../types");
+var each     = require("lodash/collection/each");
+var map      = require("lodash/collection/map");
+var isNumber = require("lodash/lang/isNumber");
+
+exports.before = {
+  nodes: {
+    Property: function (node, parent) {
+      if (parent.properties[0] === node) {
+        return 1;
+      }
+    },
+
+    SpreadProperty: function (node, parent) {
+      return exports.before.nodes.Property(node, parent);
+    },
+
+    SwitchCase: function (node, parent) {
+      if (parent.cases[0] === node) {
+        return 1;
+      }
+    },
+
+    CallExpression: function (node) {
+      if (t.isFunction(node.callee)) {
+        return 1;
+      }
+    }
+  }
+};
+
+exports.after = {
+  nodes: {
+    LogicalExpression: function (node) {
+      return t.isFunction(node.left) || t.isFunction(node.right);
+    },
+
+    AssignmentExpression: function (node) {
+      if (t.isFunction(node.right)) {
+        return 1;
+      }
+    }
+  },
+
+  list: {
+    VariableDeclaration: function (node) {
+      return map(node.declarations, "init");
+    },
+
+    ArrayExpression: function (node) {
+      return node.elements;
+    },
+
+    ObjectExpression: function (node) {
+      return node.properties;
+    }
+  }
+};
+
+each({
+  Function: 1,
+  Class: 1,
+  For: 1,
+  ArrayExpression: { after: 1 },
+  ObjectExpression: { after: 1 },
+  SwitchStatement: 1,
+  IfStatement: { before: 1 },
+  CallExpression: { after: 1 },
+  Literal: { after: 1 }
+}, function (amounts, type) {
+  if (isNumber(amounts)) {
+    amounts = { after: amounts, before: amounts };
+  }
+
+  each([type].concat(t.FLIPPED_ALIAS_KEYS[type] || []), function (type) {
+    each(amounts, function (amount, key) {
+      exports[key].nodes[type] = function () {
+        return amount;
+      };
+    });
+  });
+});
--- a/Show More
+++ b/Show More
				`@@ -0,0 +1 @@`
				`See [6to5.github.io/docs](https://github.com/6to5/6to5.github.io/tree/master/docs).`