v3.0.2

Conflicts:
	package.json

.gitignore

@@ -10,3 +10,6 @@ test/tmp
 /runtime.js
 coverage
 dist
+.package.json
+packages/6to5-runtime/*.js
+packages/6to5-runtime/regenerator/*.js

.gitmodules

@@ -3,4 +3,7 @@
 	url = https://github.com/google/traceur-compiler
 [submodule "vendor/regenerator"]
 	path = vendor/regenerator
-	url = https://github.com/facebook/regenerator
+	url = https://github.com/6to5/regenerator-6to5
+[submodule "vendor/test262"]
+	path = vendor/test262
+	url = https://github.com/tc39/test262

.jscsrc

@@ -0,0 +1,60 @@
+{
+  "excludeFiles": ["lib/6to5/transformation/templates"],
+  "disallowSpacesInNamedFunctionExpression": {
+    "beforeOpeningRoundBrace": true
+  },
+  "requireSpacesInAnonymousFunctionExpression": {
+    "beforeOpeningRoundBrace": true
+  },
+  "requireSpacesInAnonymousFunctionExpression": {
+    "beforeOpeningRoundBrace": true
+  },
+  "disallowSpacesInFunctionDeclaration": {
+    "beforeOpeningRoundBrace": true
+  },
+  "disallowSpacesInsideArrayBrackets": true,
+  "disallowSpacesInsideParentheses": true,
+  "disallowQuotedKeysInObjects": true,
+  "disallowSpaceAfterObjectKeys": true,
+  "disallowSpaceAfterPrefixUnaryOperators": true,
+  "disallowSpaceBeforePostfixUnaryOperators": true,
+  "disallowSpaceBeforeBinaryOperators": [
+    ","
+  ],
+  "disallowMixedSpacesAndTabs": true,
+  "disallowTrailingWhitespace": true,
+  "disallowYodaConditions": true,
+  "disallowKeywords": [ "with" ],
+  "disallowMultipleLineBreaks": true,
+  "requireSpaceBeforeBlockStatements": true,
+  "requireParenthesesAroundIIFE": true,
+  "requireSpacesInConditionalExpression": true,
+  "requireBlocksOnNewline": 1,
+  "requireCommaBeforeLineBreak": true,
+  "requireSpaceBeforeBinaryOperators": true,
+  "requireSpaceAfterBinaryOperators": true,
+  "requireCamelCaseOrUpperCaseIdentifiers": true,
+  "requireLineFeedAtFileEnd": true,
+  "requireCapitalizedConstructors": true,
+  "requireDotNotation": true,
+  "requireSpacesInForStatement": true,
+  "requireCurlyBraces": [
+    "do"
+  ],
+  "requireSpaceAfterKeywords": [
+    "if",
+    "else",
+    "for",
+    "while",
+    "do",
+    "switch",
+    "case",
+    "return",
+    "try",
+    "catch",
+    "typeof"
+  ],
+  "validateLineBreaks": "LF",
+  "validateQuoteMarks": "\"",
+  "validateIndentation": 2
+}

.jshintignore

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

.jshintrc

@@ -5,7 +5,6 @@
   "camelcase": true,
   "unused": true,
   "eqnull": true,
-  "proto": true,
   "newcap": true,
   "supernew": true,
   "noyield": true,
@@ -14,8 +13,6 @@
   "boss": true,
   "expr": true,
   "undef": true,
-  "loopfunc": true,
-  "white": true,
   "maxparams": 5,
   "maxdepth": 4,
 

.npmignore

@@ -9,3 +9,7 @@ Makefile
 dist
 tests.json
 CHANGELOG.md
+.package.json
+coverage
+vendor
+packages

.travis.yml

@@ -1,3 +1,4 @@
+sudo: false
 language: node_js
 node_js:
   - "0.10"

CHANGELOG.md

@@ -11,6 +11,339 @@
 
 _Note: Gaps between patch versions are faulty/broken releases._
 
+## 3.0.0
+
+ * **Polish**
+  * Generated code autoindentation.
+  * Moved global uid registry to a scope registry resulting in nicer uids.
+  * `this` is now illegal in the top level scope when using the default `useStrict` transformer.
+  * New `asyncToGenerator` helper that's much more compact.
+  * Throw errors on unknown options.
+  * More reliable default parameter scope.
+  * Helpers are now compact and have no newlines.
+ * **Internal**
+  * Rewritten a lot of the internals to much simpler.
+  * Removed TDZ from default parameters as it was very wonky and unreliable.
+  * Upgrade `core-js` to `0.4.6`.
+  * Upgrade `acorn-6to5`.
+   * JSX support is now on-par with react-tools/esprima.
+   * Shorthand destructuring.
+ * **Bug Fix**
+  * Generators now work flawlessly with any parameter transformers.
+  * Optional async function transformers should not name their functions.
+  * Remove `unlink` event watching in `bin/6to5`.
+  * Fix regenerator variable declarations being incorrectly hoisted breaking scope.
+  * Transformers that attempted to simplify expressions that had no consequence now take into account whether it's one of the last statements/expressions in the script.
+ * **New Feature**
+  * New `selfContained` transformer.
+  * New `undeclaredVariableCheck` optional transformer.
+  * Added `--blacklist` and `--whitelist` options to `6to5-node`.
+ * **Breaking Change**
+  * Caching is now always enabled for the require hook. It also now no longer caches require resolutions.
+  * Bare `super();` only works inside of constructors.
+  * Removed the optional runtime in favor of the `selfContained` transformer.
+  * This shorthand has been removed from the playground.
+  * `6to5/polyfill` can now only be required **once**.
+  * **CLI**
+   * `--indent` option has been removed.
+   * `--include-regenerator` option has been removed.
+   * `--amd-modules-id` option has been removed, use `--module-ids` instead.
+  * **Options**
+   * `amdModuleIds` option has been removed, use `moduleIds` instead.
+   * `includeRegenerator` has been removed.
+   * `ignoreRegex` fallback has now been dropped from the require hook. `register(/foo/);`, `register({ ignoreRegex: /foo/ })` -> `register({ ignore: /foo/ })`.
+  * **Modules**
+    * Module interop now only collapses to `module.exports` when there's a **single** export that's default.
+    * Imports and exports are now illegal anywhere except the root level by default. Set `modules` to [loose mode](http://6to5.org/docs/usage/loose) to allow them everywhere.
+  * **Transformers**
+    * Optional fast transformer backwards compatibility support has been removed. Use [loose mode](https://6to5.org/docs/usage/loose).
+    * Removed the `coreAliasing` transformer in favor of `selfContained`.
+    * Renamed transformers:
+     * `specNoForInOfAssignment` -> `validation.noForInOfAssignment`
+     * `specSetters` -> `validation.setters`
+     * `specBlockScopedFunctions` -> `spec.blockScopedFunctions`
+     * `malletOperator` -> `playground.malletOperator`
+     * `methodBinding` -> `playground.methodBinding`
+     * `memoizationOperator` -> `playground.memoizationOperator`
+     * `objectGetterMemoization` -> `playground.objectGetterMemoization`
+     * `modules` -> `es6.modules`
+     * `propertyNameShorthand` -> `es6.properties.shorthand`
+     * `arrayComprehension` -> `es7.comprehensions`
+     * `generatorComprehension` -> `es7.comprehensions`
+     * `arrowFunctions` -> `es6.arrowFunctions`
+     * `classes` -> `es6.classes`
+     * `objectSpread` -> `es7.objectSpread`
+     * `exponentiationOperator` -> `es7.exponentiationOperator`
+     * `spread` -> `es6.spread`
+     * `templateLiterals` -> `es6.templateLiterals`
+     * `propertyMethodAssignment` -> `es6.properties.shorthand`
+     * `computedPropertyNames` -> `es6.properties.computed`
+     * `defaultParameters` -> `es6.parameters.default`
+     * `restParameters` -> `es6.parameters.rest`
+     * `destructuring` -> `es6.destructuring`
+     * `forOf` -> `es6.forOf`
+     * `unicodeRegex` -> `es6.unicodeRegex`
+     * `abstractReferences` -> `es7.abstractReferences`
+     * `constants` -> `es6.constants`
+     * `letScoping` -> `es6.blockScoping`
+     * `blockScopingTDZ` -> `es6.blockScopingTDZ`
+     * `generators` -> `regenerator`
+     * `protoToAssign` -> `spec.protoToAssign`
+     * `typeofSymbol` -> `spec.typeofSymbol`
+     * `coreAliasing` -> `selfContained`
+     * `undefinedToVoid` -> `spec.undefinedToVoid`
+     * `undeclaredVariableCheck` -> `validation.undeclaredVariableCheck`
+     * `specPropertyLiterals` -> `minification.propertyLiterals`
+     * `specMemberExpressionLiterals` -> `minification.memberExpressionLiterals`
+
+## 2.13.7
+
+ * **Bug Fix**
+  * Don't realias variables that are already declared in optional `coreAliasing` transformer.
+
+## 2.13.6
+
+ * **Bug Fix**
+  * Add `NewExpression` as a valid parent for parentheses insertion for `ConditionalExpression`.
+
+## 2.13.5
+
+ * **Bug Fix**
+  * Allow rest parameters to be destructuring patterns.
+ * **Internal**
+  * Upgrade `kexec` to `1.1.0`.
+
+## 2.13.4
+
+ * **Bug Fix**
+  * Fix ordering of destructuring and default params.
+  * Fix loop body scope.
+  * Fix `for...of` transformation not retaining it's scope.
+  * Add destructuring assignment support to scope tracking.
+ * **Polish**
+  * More reliable newlines for pretty printing variable declarations.
+
+## 2.13.3
+
+ * **Internal**
+  * Add `coverage` and `vendor` to npmignore.
+
+## 2.13.2
+
+ * **Bug Fix**
+  * Fix `super` inside of nested functions.
+ * **Internal**
+  * Move let scoping TDZ into a separate transformer until it's more solid.
+  * Use `process.stdin.write` instead of `console.log` in `bin` to avoid sprintfification.
+
+## 2.13.1
+
+ * **New Feature**
+  * Temporal dead zone for block binding.
+
+## 2.13.0
+
+ * **New Feature**
+  * Block scoped functions.
+  * Add `--loose all` option.
+  * Add playground mallet operator thanks to [@jridgewell](https://github.com/jridgewell).
+ * **Bug Fix**
+  * Rewrote large parts of the let scoping transformer. Now passes all known tests.
+ * **Internal**
+  * Even more optimisations thanks to the awesome [@gaearon](https://github.com/gaearon).
+  * Upgrade `acorn-6to5`.
+    * Fixes exponentation operator thanks to [@charliesome](https://github.com/charliesome).
+    * Fix flow optional parameters with types.
+  * Upgrade `chokidar` to `0.12.6`.
+  * Upgrade `commander` to `2.6.0`.
+  * Upgrade `core-js` to `0.4.5`.
+  * Upgrade `estraverse` to `1.9.1`.
+  * Upgrade `jshint` to `2.5.11`.
+  * Upgrade `regenerator` to `0.8.9`.
+  * Upgrade `regexpu` to `1.0.0`.
+  * Upgrade `source-map` to `0.1.43`.
+  * Upgrade `source-map-support` to `0.2.9`.
+  * Upgrade `browserify` to `8.1.1`.
+  * Upgrade `chai` to `1.10.0`.
+  * Upgrade `istanbul` to `0.3.5`.
+  * Upgrade `mocha` to `2.1.0`.
+  * Upgrade `uglify-js` to `2.4.16`.
+
+## 2.12.6
+
+ * **Bug Fix**
+  * Add missing flow type traversal keys.
+
+## 2.12.5
+
+ * **Internal**
+  * Fix incorrect `for...in` loop still causing `ember-script` issues.
+
+## 2.12.4
+
+ * **Polish**
+  * Rest parameters now allocate the array before populating.
+ * **Internal**
+  * `for...in` loops have been changed to optimised `for` loops - better performance and no enumeration of protoype keys.
+  * Parts of the code generator have now been optimised thanks to [gaearon](https://github.com/gaearon).
+
+## 2.12.3
+
+ * **Spec Compliancy**
+  * Optional `typeof` transformer checks for `undefined` before passing it to the helper.
+  * Class methods are now named.
+
+## 2.12.2
+
+ * **Internal**
+  * Exclude nodes in function parameters and catch clauses from `isReferenced` check.
+
+## 2.12.1
+
+ * **Internal**
+  * Add `.jsx` to list of allowed extensions.
+
+## 2.12.0
+
+ * **Bug Fix**
+  * Support non-string JSX literals.
+ * **New Feature**
+  * Loose mode for some transformers that enables non-spec behaviour.
+ * **Internal**
+  * Uglify `--mangle sort` has been added to the build script, cutting minified scripts in half.
+
+## 2.11.4
+
+ * **Internal**
+  * Make all dependency versions fixed.
+
+## 2.11.3
+
+ * **Bug Fix**
+  * Allow a string to be passed as the `optional` option.
+
+## 2.11.2
+
+ * **Bug Fix**
+  * Support esprima-style catch clause handlers.
+ * **Polish**
+  * Don't print a stacktrace for syntax errors in the CLI.
+
+## 2.11.1
+
+ * **Bug Fix**
+  * Remove stray `console.log` outputting debug code.
+  * Remove `Dict` from `coreAliasing`.
+
+## 2.11.0
+
+ * **Bug Fix**
+  * Fix unnecessary IIFE in default parameters on method calls.
+  * Add support for supers inside of closures.
+ * **New Feature**
+  * Add `--keep-module-id-extensions`/`keepModuleIdExtensions` option to keep extensions in module ids.
+ * **Polish**
+  * Special case single argument spread properties in `super` inside classes.
+  * Don't use a variable declaration for class declaration IFFE.
+  * Rename `inherits` helper parameters.
+  * `coreAliasing` transformer now aliases `Promise`, `Set`, `Map` and more. Thanks [@AluisioASG](https://github.com/AluisioASG).
+
+## 2.10.1
+
+ * **Internal**
+  * Upgrade `core-js` to `0.4.4`.
+ * **New Feature**
+  * Added `--include-regenerator` option to CLI and `includeRegenerator` option to API that includes the regenerator runtime if necessary.
+
+## 2.10.0
+
+ * **New Feature**
+  * Add `classesFastSuper` optional transformer that doesn't support parent getters and prototype changing.
+  * Add `forOfFast` transformer that speeds up `for...of` on arrays but produces more code.
+  * Add `--react-compat` to `bin/6to5`.
+ * **Spec Compliancy**
+  * Disallow setters without a single parameter.
+  * Add `configurable` and `writable` to defined properties.
+  * Use define instead of assignment for class methods.
+ * **Polish**
+  * Fix bin name in `6to5-node --help`.
+  * Fix shorthand `--whitelist` name in `bin/6to5`.
+ * **Internal**
+  * Hot code optimisation of traversal etc thanks to [gaearon](https://github.com/gaearon).
+
+## 2.9.4
+
+ * **Bug Fix**
+  * Support `UpdateExpression`s as `MemberExpression` objects.
+
+## 2.9.3
+
+ * **Bug Fix**
+  * Remove `exportsWildcard` helper in favor of `defaults`.
+
+## 2.9.2
+
+ * **Bug Fix**
+  * Pass `exports` to `exportWildcard` helper to allow for use inside the optional runtime.
+
+## 2.9.1
+
+ * **Bug Fix**
+  * Fix runtime generator breaking the helper inclusion loop.
+
+## 2.9.0
+
+ * **Internal**
+  * Upgrade `acorn-6to5`.
+    * Now supports destructuring shorthand properties.
+
+## 2.8.1
+
+ * **Bug Fix**
+  * Fix computed accessors on object literals.
+
+## 2.8.0
+
+ * **New Feature**
+  * Add `commonStrict`, `amdStrict` and `umdStrict` module formatters that remove `module.exports` interop assignment.
+  * Add `--indent` option to the 6to5 CLI.
+
+## 2.7.4
+
+ * **Polish**
+  * Inherit assignments from their declaration in destructuring.
+  * Properly align multi-declarator variable declarations.
+
+## 2.7.3
+
+ * **Polish**
+  * Indent and add newlines to `React.createElement` calls in `react` transformer.
+  * Remove `Object.assign` calls and replace it with an `extends` helper.
+
+## 2.7.1
+
+ * **New Feature**
+  * Expose `version` on browser and node API.
+ * **Internal**
+  * Upgrade `core-js` to 0.4.1
+
+## 2.7.0
+
+ * **Spec Compliancy**
+  * Disallow reassignments of imports.
+ * **New Feature**
+  * `reactCompat` option to enable pre-v0.12 react components.
+
+## 2.6.3
+
+ * **Bug Fix**
+  * Fix 2.6.0 regression caused by faulty export default from a source handling.
+
+## 2.6.2
+
+ * **Bug Fix**
+  * Fix rest parameter keys when on functions with params.
+
 ## 2.6.1
 
  * **Bug Fix**

CONTRIBUTING.md

@@ -1,6 +1,20 @@
 # Contributing
 
-Before contributing, please read the [code of conduct](https://github.com/6to5/6to5/blob/master/CODE_OF_CONDUCT.md).
+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).
+
+## 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.

Makefile

@@ -1,17 +1,19 @@
 BROWSERIFY_CMD = node_modules/browserify/bin/cmd.js
 ISTANBUL_CMD = node_modules/istanbul/lib/cli.js cover
 UGLIFY_CMD = node_modules/uglify-js/bin/uglifyjs
+#UGLIFY_CMD = node_modules/uglify-js/bin/uglifyjs --mangle sort
 JSHINT_CMD = node_modules/jshint/bin/jshint
 MOCHA_CMD = node_modules/mocha/bin/_mocha
+JSCS_CMD = node_modules/jscs/bin/jscs
 
 export NODE_ENV = test
 
-.PHONY: clean test test-cov test-clean lint test-travis test-spec test-browser publish bench build bootstrap
+.PHONY: clean test test-cov test-clean lint test-travis test-simple test-all test-browser publish build bootstrap publish-core publish-runtime
 
 build:
 	mkdir -p dist
 
-	node bin/cache-templates
+	node tools/cache-templates
 
 	node $(BROWSERIFY_CMD) -e lib/6to5/polyfill.js >dist/polyfill.js
 	node $(UGLIFY_CMD) dist/polyfill.js >dist/polyfill.min.js
@@ -19,20 +21,14 @@ build:
 	node $(BROWSERIFY_CMD) lib/6to5/browser.js -s to5 >dist/6to5.js
 	node $(UGLIFY_CMD) dist/6to5.js >dist/6to5.min.js
 
-	node bin/6to5-runtime >dist/runtime.js
-	node $(UGLIFY_CMD) dist/runtime.js >dist/runtime.min.js
-
 	rm -rf templates.json
 
 clean:
 	rm -rf coverage templates.json test/tmp dist
 
-bench:
-	npm install es6-transpiler traceur esnext es6now jstransform
-	node node_modules/matcha/bin/_matcha
-
 lint:
-	$(JSHINT_CMD) --reporter node_modules/jshint-stylish/stylish.js lib bin benchmark/index.js
+	$(JSHINT_CMD) --reporter node_modules/jshint-stylish/stylish.js lib bin
+	$(JSCS_CMD) lib bin
 
 test-clean:
 	rm -rf test/tmp
@@ -41,21 +37,30 @@ test: lint
 	$(MOCHA_CMD)
 	make test-clean
 
+test-simple:
+	# excludes test262
+	export SIMPLE_6TO5_TESTS=1; \
+	make test
+
+test-all:
+	# includes traceur, esnext, regenerator
+	export ALL_6TO5_TESTS=1; \
+	make test
+
 test-cov:
 	rm -rf coverage
+	export SIMPLE_6TO5_TESTS=1; \
 	node $(ISTANBUL_CMD) $(MOCHA_CMD) --
 
-test-spec:
-	node $(ISTANBUL_CMD) $(MOCHA_CMD) -- --reporter spec
-
-test-travis: test-spec
+test-travis: bootstrap
+	node $(ISTANBUL_CMD) $(MOCHA_CMD) --
 	if test -n "$$CODECLIMATE_REPO_TOKEN"; then codeclimate < coverage/lcov.info; fi
 
 test-browser:
 	mkdir -p dist
 
-	node bin/cache-templates
-	node bin/cache-tests
+	node tools/cache-templates
+	node tools/cache-tests
 	node $(BROWSERIFY_CMD) -e test/_browser.js >dist/6to5-test.js
 	rm -rf templates.json tests.json
 
@@ -66,21 +71,40 @@ publish:
 
 	make test
 
+	read -p "Version: " version; \
+	npm version $$version --message "v%s"
+
 	make build
 	cp dist/6to5.min.js browser.js
 	cp dist/polyfill.min.js browser-polyfill.js
-	cp dist/runtime.min.js runtime.js
 
-	node bin/cache-templates
+	node tools/cache-templates
 	test -f templates.json
 
-	read -p "Version: "  version; \
-  npm version $$version --message "v%s"
 	npm publish
 
 	git push --follow-tags
 
-	rm -rf templates.json browser.js runtime.js browser-polyfill.js
+	make publish-core
+	make publish-runtime
+
+	rm -rf templates.json browser.js browser-polyfill.js
+
+publish-runtime:
+	cd packages; \
+	node build-runtime.js; \
+	cd 6to5-runtime; \
+	npm publish
+
+publish-core:
+	tools/generate-core-package-json >package2.json
+	mv package.json .package.json
+	mv package2.json package.json
+
+	npm publish
+
+	rm -rf package.json
+	mv .package.json package.json
 
 bootstrap:
 	npm install

NOTES.md

@@ -1,8 +1,3 @@
 # Notes
 
- * Wildcard exports/imports wont normalise if `export default` is a non-object.
-
-## 3.0.0 breaking changes
-
- * Remove `allowImportExportEverywhere` option from acorn.
- * Remove this shorthand from playground.
+ * Wildcard exports/imports wont normalise if `export default` is a non-object. See [#224](https://github.com/6to5/6to5/issues/224).

benchmark/fixtures/all.js

@@ -1,99 +0,0 @@
-var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-var obj = {};
-var foo = "foo";
-var bar = "bar";
-
-// constants
-const MULTIPLIER = 5;
-
-// classes
-class Foo {
-  constructor() {
-    this.foo = "bar";
-  }
-}
-
-class Bar extends Foo {
-  constructor() {
-    super();
-  }
-
-  // default parameters
-  go(foo = "bar", bar = "foo") {
-
-  }
-
-  // not supported by jstransform
-  //get foo() {
-  //  return this._foo;
-  //}
-  //set foo(val) {
-  //  this._foo = val + " foo!";
-  //}
-}
-
-// arrow functions
-arr.map(x => x * x);
-
-// block binding
-for (let key in arr) {
-  let val = arr[key];
-  console.log(key, val);
-}
-
-// computed property names
-obj = {
-  ["foo" + bar]: "foobar"
-};
-
-// destructuring
-var [a, [b], c, d] = ["hello", [", ", "junk"], ["world"]];
-console.log(a + b + c);
-
-// array comprehension
-// [for (i of [1, 2, 3]) i * i]; // not supported by es6now
-
-// for-of
-for (var i of [1, 2, 3]) {
-  console.log(i * i);
-}
-
-// property method assignment
-obj = {
-  foo() {
-    return "foobar";
-  },
-
-  get bar() {
-    return this._bar;
-  },
-
-  set bar(val) {
-    this._bar = val;
-  }
-};
-
-// property name shorthand
-function f(x, y) {
-  return { x, y };
-}
-
-// rest parameters
-function printList(name, ...items) {
-  console.log("list %s has the following items", name);
-  items.forEach(function (item) {
-    console.log(item);
-  });
-}
-
-// spread
-function add(x, y) {
-  return x + y;
-}
-var numbers = [5, 10];
-add(...numbers);
-
-// template literals
-var x = 5;
-var y = 10;
-console.log(`${x} + ${y} = ${x + y}`);

benchmark/index.js

@@ -1,168 +0,0 @@
-Error.stackTraceLimit = Infinity;
-
-var jsTrans = require("jstransform");
-var traceur = require("traceur");
-//var es6tr   = require("es6-transpiler");
-var es6now  = require("es6now");
-//var esnext  = require("esnext");
-var to5     = require("../lib/6to5");
-
-//var uglify  = require("uglify-js");
-var matcha  = require("matcha");
-var path    = require("path");
-var fs      = require("fs");
-var _       = require("lodash");
-
-var readResolve = function (filename) {
-  try {
-    filename = require.resolve(filename);
-  } catch (err) {
-    return null;
-  }
-  return fs.readFileSync(filename, "utf8");
-};
-
-var getVersion = function (name) {
-  return require(name + "/package.json").version;
-};
-
-var jsTransVisitors = [];
-
-_.each([
-  "arrow-function-visitors", "class-visitors", "destructuring-visitors",
-  "object-concise-method-visitors", "object-short-notation-visitors",
-  "rest-param-visitors", "template-visitors"
-], function (name) {
-  var mod = require("jstransform/visitors/es6-" + name);
-  jsTransVisitors = jsTransVisitors.concat(mod.visitorList);
-});
-
-
-var compilers = {
-  "6to5": {
-    version: getVersion(".."),
-    compile: function (code, filename) {
-      return to5.transform(code, { filename: filename }).code;
-    }
-  },
-
-  traceur: {
-    runtime: readResolve("traceur/bin/traceur-runtime.js"),
-    compile: function (code) {
-      return traceur.compile(code, {
-        modules: "commonjs",
-        experimental: true
-      });
-    }
-  },
-
-  /*esnext: {
-    runtime: readResolve("esnext/node_modules/regenerator/runtime.js") || readResolve("regenerator/runtime.js"),
-    compile: function (code) {
-      return esnext.compile(code).code;
-    }
-  },*/
-
-  es6now: {
-    runtime: readResolve("es6now/runtime/ES6.js"),
-    compile: function (code) {
-      return es6now.translate(code);
-    }
-  },
-
-  /*"es6-transpiler": {
-    compile: function (code) {
-      var result = es6tr.run({ src: code });
-      if (result.errors.length) throw new Error(result.join("; "));
-      return result.src;
-    }
-  },*/
-
-  jstransform: {
-    compile: function (code) {
-      return jsTrans.transform(jsTransVisitors, code).code;
-    }
-  }
-};
-
-// versions
-
-//var uglifyTitle = "uglify v" + getVersion("uglify-js");
-
-_.each(compilers, function (compiler, name) {
-  compiler.title = name + " v" + (compiler.version || getVersion(name));
-});
-
-//
-
-var sizeBenchmark = function (code, loc, name, compiler) {
-  var log = function (output, title) {
-    title = [compiler.title].concat(title || []).join(" + ");
-
-    var text;
-    var color;
-    if (output.stack) {
-      text = "error";
-      color = "red";
-    } else {
-      var kilo  = (output.length / 1024).toFixed(2);
-      text = kilo + "KB";
-      color = "cyan";
-    }
-
-    text = matcha.utils.color(matcha.utils.padBefore(text, 22), color);
-
-    console.log(text, matcha.utils.color("» " + title, "gray"));
-
-    if (output.stack) {
-      console.error(output.stack);
-    }
-  };
-
-  var go = function (getOutput, title) {
-    var code;
-    try {
-      code = getOutput();
-    } catch (err) {
-      log(err, title);
-      return;
-    }
-
-    log(code, title);
-  };
-
-  var output;
-  go(function () {
-    return output = compiler.compile(code, loc);
-  });
-  if (!output) return;
-
-  //go(function () {
-  //  return uglify.minify(output, { fromString: true }).code;
-  //}, uglifyTitle);
-};
-
-//
-
-_.each(fs.readdirSync(__dirname + "/fixtures"), function (name) {
-  var alias = path.basename(name, path.extname(name));
-
-  suite(alias, function () {
-    set("delay", 0);
-
-    var loc  = __dirname + "/fixtures/" + name;
-    var code = fs.readFileSync(loc, "utf8");
-
-    before(function () {
-      _.each(compilers, function (compiler, name) {
-        sizeBenchmark(code, loc, name, compiler);
-      });
-    });
-
-    _.each(compilers, function (compiler) {
-      bench(compiler.title, function () {
-        compiler.compile(code, loc);
-      });
-    });
-  });
-});

bin/6to5-runtime

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

bin/6to5/dir.js

@@ -1,9 +1,9 @@
-var chokidar = require("chokidar");
-var mkdirp   = require("mkdirp");
-var path     = require("path");
-var util     = require("./util");
-var fs       = require("fs");
-var _        = require("lodash");
+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) {
@@ -15,16 +15,13 @@ module.exports = function (commander, filenames, opts) {
 
     var data = util.compile(src, { sourceMapName: dest });
 
-    var up = path.normalize(dest + "/..");
-    mkdirp.sync(up);
-
     if (commander.sourceMaps) {
       var mapLoc = dest + ".map";
       data.code = util.addSourceMappingUrl(data.code, mapLoc);
-      fs.writeFileSync(mapLoc, JSON.stringify(data.map));
+      outputFileSync(mapLoc, JSON.stringify(data.map));
     }
 
-    fs.writeFileSync(dest, data.code);
+    outputFileSync(dest, data.code);
 
     console.log(src + " -> " + dest);
   };
@@ -54,7 +51,7 @@ module.exports = function (commander, filenames, opts) {
         ignoreInitial: true
       });
 
-      _.each(["add", "change", "unlink"], function (type) {
+      _.each(["add", "change"], function (type) {
         watcher.on(type, function (filename) {
           // chop off the dirname plus the path separator
           var relative = filename.slice(dirname.length + 1);

bin/6to5/file.js

@@ -28,7 +28,7 @@ module.exports = function (commander, filenames) {
         map.setSourceContent(filename, result.actual);
 
         consumer.eachMapping(function (mapping) {
-          map._mappings.push({
+          map._mappings.add({
             generatedLine: mapping.generatedLine + offset,
             generatedColumn: mapping.generatedColumn,
             originalLine: mapping.originalLine,
@@ -63,7 +63,7 @@ module.exports = function (commander, filenames) {
 
       fs.writeFileSync(commander.outFile, result.code);
     } else {
-      console.log(result.code);
+      process.stdout.write(result.code + "\n");
     }
   };
 
@@ -77,7 +77,7 @@ module.exports = function (commander, filenames) {
       if (chunk !== null) code += chunk;
     });
 
-    process.stdin.on("end", function() {
+    process.stdin.on("end", function () {
       results.push(util.transform(commander.filename, code));
       output();
     });
@@ -117,7 +117,7 @@ module.exports = function (commander, filenames) {
         persistent: true,
         ignoreInitial: true
       }).on("all", function (type, filename) {
-        if (type === "add" || type === "change" || type === "unlink" ) {
+        if (type === "add" || type === "change") {
           console.log(type, filename);
           walk();
         }

bin/6to5/index.js

@@ -10,32 +10,30 @@ commander.option("-t, --source-maps-inline", "Append sourceMappingURL comment to
 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("-w, --whitelist [whitelist]", "Whitelist of transformers to ONLY use", util.list);
+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("-a, --amd-module-ids", "Insert module id in AMD modules", false); // todo: remove in 3.0.0
 commander.option("-m, --module-ids", "Insert module id in modules", false);
+commander.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.on("--help", function(){
+commander.on("--help", function () {
   var outKeys = function (title, obj) {
     console.log("  " + title + ":");
     console.log();
 
-    var hasOptional = true;
-
     _.each(_.keys(obj).sort(), function (key) {
       if (key[0] === "_") return;
 
       if (obj[key].optional) {
-        hasOptional = true;
         key = "[" + key + "]";
       }
 
@@ -98,17 +96,19 @@ if (errors.length) {
 //
 
 exports.opts = {
-  sourceMapName: commander.outFile,
-  experimental:  commander.experimental,
-  playground:    commander.playground,
-  moduleIds:     commander.amdModuleIds || commander.moduleIds,
-  blacklist:     commander.blacklist,
-  whitelist:     commander.whitelist,
-  sourceMap:     commander.sourceMaps || commander.sourceMapsInline,
-  optional:      commander.optional,
-  comments:      !commander.removeComments,
-  runtime:       commander.runtime,
-  modules:       commander.modules
+  keepModuleIdExtensions: commander.keepModuleIdExtensions,
+  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,
+  modules:                commander.modules,
+  loose:                  commander.loose
 };
 
 var fn;

bin/6to5/util.js

@@ -20,7 +20,17 @@ exports.transform = function (filename, code, opts) {
   opts = _.extend(opts || {}, index.opts);
   opts.filename = filename;
 
-  var result = to5.transform(code, opts);
+  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;

bin/_6to5-node

@@ -1,38 +1,39 @@
 #!/usr/bin/env node
 
-var roadrunner = require("roadrunner");
-var commander  = require("commander");
-var Module     = require("module");
-var path       = require("path");
-var repl       = require("repl");
-var to5        = require("../lib/6to5");
-var util       = require("../lib/6to5/util");
-var vm         = require("vm");
-var _          = require("lodash");
+var commander = require("commander");
+var Module    = require("module");
+var path      = require("path");
+var repl      = require("repl");
+var to5       = require("../lib/6to5");
+var util      = require("../lib/6to5/util");
+var vm        = require("vm");
+var _         = require("lodash");
 
-commander.option("-e, --eval [script]", "Evaluate script");
-commander.option("-p, --print", "Evaluate script and print result");
-commander.option("-i, --ignore [regex]", "Ignore all files that match this regex when using the require hook");
-commander.option("-x, --extensions [extensions]", "List of extensions to hook into [.es6,.js]");
-commander.option("-r, --experimental", "Enable experimental support for proposed ES7 features");
-commander.option("-g, --playground", "Enable playground support");
-commander.option("-c, --cache", "Cache compiled files and require paths");
+var 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);
 
 var pkg = require("../package.json");
-commander.version(pkg.version);
-commander.usage("[options] [ -e script | script.js ] [arguments]");
-commander.parse(process.argv);
-
-if (commander.cache) roadrunner.load();
+program.version(pkg.version);
+program.usage("[options] [ -e script | script.js ] [arguments]");
+program.parse(process.argv);
 
 //
 
 to5.register({
-  experimental: commander.experimental,
-  extensions:   commander.extensions,
-  playground:   commander.playground,
-  ignore:       commander.ignore,
-  cache:        commander.cache && roadrunner.get("6to5")
+  experimental: program.experimental,
+  extensions:   program.extensions,
+  playground:   program.playground,
+  blacklist:    program.blacklist,
+  whitelist:    program.whitelist,
+  ignore:       program.ignore
 });
 
 //
@@ -40,18 +41,22 @@ to5.register({
 var _eval = function (code, filename) {
   code = to5.transform(code, {
     filename: filename,
-    blacklist: ["useStrict"],
-    experimental: commander.experimental,
-    playground: commander.playground
+    blacklist: ["useStrict"].concat(program.blacklist || []),
+    whitelist: program.whitelist,
+    experimental: program.experimental,
+    playground: program.playground
   }).code;
   return vm.runInThisContext(code, filename);
 };
 
-if (commander.eval) {
-  var result = _eval(commander.eval, "eval");
-  if (commander.print) console.log(result);
+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 (commander.args.length) {
+  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);
 
@@ -77,8 +82,6 @@ if (commander.eval) {
   }
 }
 
-if (commander.cache) roadrunner.save();
-
 function replStart() {
   repl.start({
     prompt: "> ",
@@ -94,8 +97,8 @@ function replEval(code, context, filename, callback) {
   var result;
 
   try {
-    if (/^\((.*?)\n\)$/.test(code)) {
-      code = code.slice(1, -2); // remove "(" and "\n)"
+    if (code[0] === "(" && code[code.length - 1] === ")") {
+      code = code.slice(1, -1); // remove "(" and ")"
     }
 
     result = _eval(code, filename);

doc/caveats.md

@@ -1,89 +0,0 @@
----
-layout: docs
-title: Caveats
-description: Just some things to keep in mind when using 6to5.
-permalink: /docs/caveats/
-redirect_from: /caveats.html
----
-
-## Polyfills
-
-In order for certain features to work they require certain polyfills. You can
-satisfy **all** 6to5 feature requirements by using the included
-[polyfill](polyfill.md).
-
-You may alternatively selectively include what you need:
-
-| Feature                     | Requirements                                                                                                           |
-| --------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
-| Abstract References         | [experimental](experimental.md), `Symbol`                                                                              |
-| Array destructuring         | `Array.from`                                                                                                           |
-| Async functions, Generators | [experimental](experimental.md), [regenerator runtime](https://github.com/facebook/regenerator/blob/master/runtime.js) |
-| Comprehensions              | [experimental](experimental.md), `Array.from`                                                                          |
-| For Of                      | `Symbol`, `prototype[Symbol.iterator]`                                                                                 |
-| Modules                     | `Object.assign`*                                                                                                       |
-| Object spread/rest          | [experimental](experimental.md), `Object.assign`                                                                       |
-| Spread                      | `Array.from`                                                                                                           |
-
-*Only required for exporting a non-function `default` with additional `export`s.
-
-## ES5
-
-Since 6to5 assumes that your code will be ran in an ES5 environment it uses ES5
-functions. So if you're using an environment that has limited or no support for
-ES5 such as lower versions of IE then using the
-[es5-shim](https://github.com/es-shims/es5-shim) along with the
-[6to5 polyfill](polyfill.md) will add support for these methods.
-
-## Internet Explorer
-
-### Classes (10 and below)
-
-If you're inheriting from a class then static properties are inherited from it
-via [\_\_proto\_\_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/proto),
-this is widely supported but you may run into problems with much older browsers.
-
-**NOTE:** `__proto__` is not supported on IE <= 10 so static properties
-**will not** be inherited.
-
-You can use the `protoToAssign` optional transformer that will transform all
-`__proto__` assignments to a method that will shallowly copy it over all
-properties.
-
-```javascript
-require("6to5").transform("code", { optional: ["protoToAssign"] });
-```
-
-```sh
-$ 6to5 --optional protoToAssign script.js
-```
-
-This means that the following **will** work:
-
-```javascript
-var foo = { a: 1 };
-var bar = { b: 2 };
-bar.__proto__ = foo;
-bar.a; // 1
-bar.b; // 2
-```
-
-however the following **will not**:
-
-```javascript
-var foo = { a: 1 };
-var bar = { b: 2 };
-bar.__proto__ = foo;
-bar.a; // 1
-foo.a = 2;
-bar.a; // 1 - should be 2 but remember that nothing is bound and it's a straight copy
-```
-
-### Getters/setters (8 and below)
-
-In IE8 `Object.defineProperty` can only be used on DOM objects. This is
-unfortunate as it's required to set getters and setters. Due to this if
-you plan on supporting IE8 or below then the user of getters and setters
-isn't recommended.
-
-**Reference**: [MDN](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty#Internet_Explorer_8_specific_notes).

doc/compare.md

@@ -1,143 +0,0 @@
----
-layout: docs
-title: Compare
-description: Differences between 6to5 and other ES6 transpilers.
-permalink: /docs/compare/
-redirect_from: /differences.html
----
-
-## Differences
-
-### Readable code
-
-The fundamental concept behind 6to5 is that the generated code must be close as
-possible to the original, retaining all the same formatting and readability.
-
-Many other transpilers are just concerned with making the code work while 6to5
-is concerned with making sure it works **and** is readable at the same time.
-
-For example, given the following array comprehension:
-
-```js
-var seattlers = [for (c of customers) if (c.city == "Seattle") { name: c.name, age: c.age }];
-```
-
-is generated to the following with 6to5:
-
-```js
-var seattlers = Array.from(customers).filter(function (c) {
-  return c.city == "Seattle";
-}).map(function (c) {
-  return {
-    name: c.name,
-    age: c.age
-  };
-});
-```
-
-The following is what Traceur generates:
-
-```js
-var seattlers = (function() {
-  var c;
-  var $__20 = 0,
-      $__21 = [];
-  for (var $__22 = customers[$traceurRuntime.toProperty(Symbol.iterator)](),
-      $__23; !($__23 = $__22.next()).done; ) {
-    c = $__23.value;
-    if (c.city == "Seattle")
-      $traceurRuntime.setProperty($__21, $__20++, {
-        name: c.name,
-        age: c.age
-      });
-  }
-  return $__21;
-}());
-```
-
-As you can tell, it's not very pretty. Instead of mapping directly to a runtime,
-like other transpilers, 6to5 maps directly to the equivalent ES5.
-
-Sometimes there are little inline functions that 6to5 needs. These are
-placed at the top of your file much like coffee-script does. If these
-bother you then you can use the [optional runtime](optional-runtime.md).
-We promise that these inline functions will never be significant and will
-always be used as little as possible.
-
-### Static analysis
-
-6to5 uses a lot of static analysis to simplify code as much as possible.
-Not many other transpilers do this, and those that do don't do it nearly
-as much as 6to5. This process is pretty intensive but it leads to higher
-quality code.
-
-### Spec compliancy
-
-6to5 prides itself on
-[spec compliancy](https://kangax.github.io/compat-table/es6/). We have
-excellent support for edgecases, something that many other transpilers
-suffer from, including Traceur. When you use 6to5 you can be confident
-that when you turn it off and use your code in a full ES6 environment
-**it'll just work**.
-
-## Comparison to other transpilers
-
-### Features
-
-|                              | 6to5 | Traceur | es6-transpiler | es6now | jstransform |
-| ---------------------------- | ---- | ------- | -------------- | ------ | ----------- |
-| Source maps                  | ✓    | ✓       | ✓              |        | ✓           |
-| No compiler global pollution | ✓    |         | ✓              |        | ✓           |
-| Optional runtime             | ✓    |         | ✓              |        | ✓           |
-| Browser compiler             | ✓    | ✓       |                |        |             |
-
-### Language Support
-
-|                              | 6to5 | Traceur | es6-transpiler | es6now | jstransform |
-| ---------------------------- | ---- | ------- | -------------- | ------ | ----------- |
-| Abstract references          | ✓    |         |                |        |             |
-| Array comprehension          | ✓    | ✓       | ✓              |        |             |
-| Arrow functions              | ✓    | ✓       | ✓              | ✓      | ✓           |
-| Async functions              | ✓    | ✓       |                |        |             |
-| Async generator functions    | ✓    | ✓       |                |        |             |
-| Classes                      | ✓    | ✓       | ✓              | ✓      | ✓           |
-| Computed property names      | ✓    | ✓       | ✓              | ✓      |             |
-| Constants                    | ✓    | ✓       | ✓              |        |             |
-| Default parameters           | ✓    | ✓       | ✓              | ✓      |             |
-| Destructuring                | ✓    | ✓       | ✓              | ✓      | ✓           |
-| Exponentiation operator      | ✓    | ✓       |                |        |             |
-| Flow types                   | ✓    |         |                |        | ✓           |
-| For-of                       | ✓    | ✓       | ✓              | ✓      |             |
-| Generators                   | ✓    | ✓       |                |        |             |
-| Generator comprehension      | ✓    | ✓       |                |        |             |
-| JSX                          | ✓    |         |                |        |             |
-| Let scoping                  | ✓    | ✓       | ✓              |        |             |
-| Modules                      | ✓    | ✓       |                | ✓      |             |
-| Object rest/spread           | ✓    |         |                |        | ✓           |
-| Property method assignment   | ✓    | ✓       | ✓              | ✓      | ✓           |
-| Property name shorthand      | ✓    | ✓       | ✓              | ✓      | ✓           |
-| Rest parameters              | ✓    | ✓       | ✓              | ✓      | ✓           |
-| React                        | ✓    |         |                |        |             |
-| Spread                       | ✓    | ✓       | ✓              | ✓      |             |
-| Template literals            | ✓    | ✓       | ✓              | ✓      | ✓           |
-| Unicode regex                | ✓    | ✓       | ✓              |        |             |
-
-### [Traceur](https://github.com/google/traceur-compiler)
-
-Traceur requires quite a bulky runtime (~75KB) and produces quite verbose code.
-While this can be trimmed down by selectively building the runtime, it's an
-unnecessary step when a large runtime can be eliminated entirely.
-
-### [es6now](https://github.com/zenparsing/es6now)
-
-es6now doesn't output sourcemaps. This is cited as a positive as line-to-line
-mapping is the goal. This however obviously doesn't retain column mapping
-resulting in the output code not being very pleasant.
-
-### [es6-transpiler](https://github.com/termi/es6-transpiler)
-
-The es6-transpiler compiler requires shims to operate which pollutes the global
-scope resulting in possible collisions.
-
-es6-transpiler maps line-by-line, just like es6now, this results in the same
-issues such as lack of column information and unpleasant code output.

doc/index.md

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

doc/setup.md

@@ -1,708 +0,0 @@
----
-layout: docs
-title: Setup
-description: Guides on how to setup 6to5 in whatever environment you might be working in.
-permalink: /docs/setup/
-redirect_from: /plugins.html
----
-
-<blockquote class="to5-callout to5-callout-info">
-  <h4>Find your guide</h4>
-  <p>
-    It doesn't matter if you're using Node.js or Rails, Gulp or Grunt, there's likely a guide on
-    this page to help guide you. Go ahead and <span class="label label-info">&#8984; + F</span>
-    whatever you're looking for. If it doesn't happen to be on this page you might want to stop by
-    our <a href="https://gitter.im/6to5/6to5">support chat</a>.
-  </p>
-</blockquote>
-
-## Node.js
-
-### CLI
-
-**Install**
-
-```sh
-$ npm install --global 6to5
-```
-
-**Usage**
-
-```sh
-$ 6to5 script.js
-```
-
-<blockquote class="to5-callout to5-callout-info">
-  <p>
-    For full documentation on the 6to5 CLI see the
-    <a href="/docs/usage/cli/">usage docs</a>.
-  </p>
-</blockquote>
-
-### Require Hook
-
-**Install**
-
-```sh
-$ npm install 6to5
-```
-
-**Usage**
-
-All subsequent files required by node with the extensions `.es6` and `.js` will
-be transformed by 6to5. The polyfill specified in [Polyfill](polyfill.md) is
-also required.
-
-```javascript
-require('6to5/register');
-```
-
-<blockquote class="to5-callout to5-callout-info">
-  <p>
-    For full documentation on the 6to5 require hook see the
-    <a href="/docs/usage/require/">usage docs</a>.
-  </p>
-</blockquote>
-
-## Rails
-
-### Sprockets
-
-<blockquote class="to5-callout to5-callout-info">
-  <p>
-    See <strong>sprockets-es6</strong>'s
-    <a href="https://github.com/josh/sprockets-es6">repo</a> for more info. If
-    you find any bugs please
-    <a href="https://github.com/josh/sprockets-es6/issues">report them</a>.
-  </p>
-  <p>
-    <em>Issues with the output should be reported on the 6to5
-    <a href="https://github.com/6to5/6to5/issues">issue tracker</a></em>.
-  </p>
-</blockquote>
-
-**Install**
-
-```sh
-$ gem install sprockets-es6
-```
-
-**Usage**
-
-```rb
-# Gemfile
-gem 'sprockets'
-gem 'sprockets-es6'
-```
-
-```rb
-require 'sprockets/es6'
-```
-
-## Build Systems
-
-### Brocolli
-
-<blockquote class="to5-callout to5-callout-info">
-  <p>
-    See <strong>broccoli-6to5-transpiler</strong>'s
-    <a href="https://github.com/6to5/broccoli-6to5-transpiler">repo</a> for more
-    info. If you find any bugs please
-    <a href="https://github.com/6to5/broccoli-6to5-transpiler/issues">report
-    them</a>.
-  </p>
-  <p>
-    <em>Issues with the output should be reported on the 6to5
-    <a href="https://github.com/6to5/6to5/issues">issue tracker</a></em>.
-  </p>
-</blockquote>
-
-**Install**
-
-```sh
-$ npm install --save-dev broccoli-6to5-transpiler
-```
-
-**Usage**
-
-```js
-var to5Transpiler = require('broccoli-6to5-transpiler');
-var scriptTree = to5Transpiler(inputTree, options);
-```
-
-<blockquote class="to5-callout to5-callout-warning">
-  <h4>Source maps</h4>
-  <p>
-    Currently this plugin only support inline source maps. If you need separate
-    source map feature, we welcome you to submit a pull request.
-  </p>
-</blockquote>
-
-### Browserify
-
-<blockquote class="to5-callout to5-callout-info">
-  <p>
-    See <strong>6to5ify</strong>'s
-    <a href="https://github.com/6to5/6to5ify">repo</a> for more info. If you
-    find any bugs please
-    <a href="https://github.com/6to5/6to5ify/issues">report them</a>.
-  </p>
-  <p>
-    <em>Issues with the output should be reported on the 6to5
-    <a href="https://github.com/6to5/6to5/issues">issue tracker</a></em>.
-  </p>
-</blockquote>
-
-**Install**
-
-```sh
-$ npm install --save-dev 6to5ify
-```
-
-**Usage via CLI**
-
-```sh
-$ browserify script.js -t 6to5ify --outfile bundle.js
-```
-
-**Usage via Node.js**
-
-```js
-browserify({ debug: true })
-  .transform(to5ify);
-```
-
-Or a more complete example:
-
-```js
-var fs = require('fs');
-var browserify = require('browserify');
-var to5ify = require('6to5ify');
-
-browserify({ debug: true })
-  .transform(to5ify)
-  .require('./script.js', { entry: true })
-  .bundle()
-  .on('error', function (err) { console.log('Error: ' + err.message); })
-  .pipe(fs.createWriteStream("bundle.js"));
-```
-**Passing Options**
-
-```sh
-$ browserify -d -e script.js -t [ 6to5ify --blacklist generators ]
-```
-
-```js
-browserify().transform(to5ify.configure({
-  blacklist: ['generators']
-}))
-```
-
-<blockquote class="to5-callout to5-callout-info">
-  <h4>More info</h4>
-  <p>
-    For more information see the
-    <a href="https://github.com/6to5/6to5ify">6to5ify README</a>
-  </p>
-</blockquote>
-
-### Brunch
-
-<blockquote class="to5-callout to5-callout-info">
-  <p>
-    See <strong>6to5-brunch</strong>'s
-    <a href="https://github.com/6to5/6to5-brunch">repo</a> for more info. If you
-    find any bugs please
-    <a href="https://github.com/6to5/6to5-brunch/issues">report them</a>.
-  </p>
-  <p>
-    <em>Issues with the output should be reported on the 6to5
-    <a href="https://github.com/6to5/6to5/issues">issue tracker</a></em>.
-  </p>
-</blockquote>
-
-**Install**
-
-```sh
-$ npm install --save-dev 6to5-brunch
-```
-
-**Configuring**
-
-Set 6to5 options in your brunch config (such as `brunch-config.coffee`) except
-for `filename` and `sourceMap` which are handled internally.
-
-```coffee
-plugins:
-  ES6to5:
-    whitelist: ['arrowFunctions']
-    format:
-      semicolons: false
-```
-
-### Duo
-
-<blockquote class="to5-callout to5-callout-info">
-  <p>
-    See <strong>duo-6to5</strong>'s
-    <a href="https://github.com/6to5/duo-6to5">repo</a> for more info. If you
-    find any bugs please
-    <a href="https://github.com/6to5/duo-6to5/issues">report them</a>.
-  </p>
-  <p>
-    <em>Issues with the output should be reported on the 6to5
-    <a href="https://github.com/6to5/6to5/issues">issue tracker</a></em>.
-  </p>
-</blockquote>
-
-**Install**
-
-```sh
-$ npm install --save-dev duo-6to5
-```
-
-**Usage via CLI**
-
-```sh
-$ duo --use duo-6to5
-```
-
-**Usage via Node.js**
-
-```js
-Duo(root)
-  .entry(entry)
-  .use(to5)
-  .run(fn);
-```
-
-### Gobble
-
-<blockquote class="to5-callout to5-callout-info">
-  <p>
-    See <strong>gobble-6to5</strong>'s
-    <a href="https://github.com/6to5/gobble-6to5">repo</a> for more info. If you
-    find any bugs please
-    <a href="https://github.com/6to5/gobble-6to5/issues">report them</a>.
-  </p>
-  <p>
-    <em>Issues with the output should be reported on the 6to5
-    <a href="https://github.com/6to5/6to5/issues">issue tracker</a></em>.
-  </p>
-</blockquote>
-
-**Install**
-
-```sh
-$ npm install --save-dev gobble-6to5
-```
-
-**Usage**
-
-The `options` argument, if specified, is passed to 6to5.
-
-```
-var gobble = require('gobble');
-module.exports = gobble('src').transform('6to5', options);
-```
-
-**Source maps**
-
-Sourcemaps are created by default (all the relevant information is filled in by
-Gobble, you don't need to specify `sourceMapName` options etc). If you don't
-want that, pass `sourceMap: false`.
-
-### Grunt
-
-<blockquote class="to5-callout to5-callout-info">
-  <p>
-    See <strong>grunt-6to5</strong>'s
-    <a href="https://github.com/6to5/grunt-6to5">repo</a> for more info. If you
-    find any bugs please
-    <a href="https://github.com/6to5/grunt-6to5/issues">report them</a>.
-  </p>
-  <p>
-    <em>Issues with the output should be reported on the 6to5
-    <a href="https://github.com/6to5/6to5/issues">issue tracker</a></em>.
-  </p>
-</blockquote>
-
-**Install**
-
-```sh
-$ npm install --save-dev grunt-6to5
-```
-
-**Usage**
-
-```js
-require('load-grunt-tasks')(grunt); // npm install --save-dev load-grunt-tasks
-
-grunt.initConfig({
-  '6to5': {
-    options: {
-      sourceMap: true
-    },
-    dist: {
-      files: {
-        'dist/app.js': 'src/app.js'
-      }
-    }
-  }
-});
-
-grunt.registerTask('default', ['6to5']);
-```
-
-### Gulp
-
-<blockquote class="to5-callout to5-callout-info">
-  <p>
-    See <strong>gulp-6to5</strong>'s
-    <a href="https://github.com/6to5/gulp-6to5">repo</a> for more info. If you
-    find any bugs please
-    <a href="https://github.com/6to5/gulp-6to5/issues">report them</a>.
-  </p>
-  <p>
-    <em>Issues with the output should be reported on the 6to5
-    <a href="https://github.com/6to5/6to5/issues">issue tracker</a></em>.
-  </p>
-</blockquote>
-
-**Install**
-
-```sh
-$ npm install --save-dev gulp-6to5
-```
-
-**Usage**
-
-```js
-var gulp = require('gulp');
-var to5 = require('gulp-6to5');
-
-gulp.task('default', function () {
-  return gulp.src('src/app.js')
-    .pipe(to5())
-    .pipe(gulp.dest('dist'));
-});
-```
-
-**Source maps**
-
-Use [gulp-sourcemaps](https://github.com/floridoo/gulp-sourcemaps) like this:
-
-```js
-var gulp = require('gulp');
-var sourcemaps = require('gulp-sourcemaps');
-var to5 = require('gulp-6to5');
-var concat = require('gulp-concat');
-
-gulp.task('default', function () {
-  return gulp.src('src/**/*.js')
-    .pipe(sourcemaps.init())
-    .pipe(to5())
-    .pipe(concat('all.js'))
-    .pipe(sourcemaps.write('.'))
-    .pipe(gulp.dest('dist'));
-});
-```
-
-### Webpack
-
-<blockquote class="to5-callout to5-callout-info">
-  <p>
-    See <strong>6to5-loader</strong>'s
-    <a href="https://github.com/6to5/6to5-loader">repo</a> for more info. If you
-    find any bugs please
-    <a href="https://github.com/6to5/6to5-loader/issues">report them</a>.
-  </p>
-  <p>
-    <em>Issues with the output should be reported on the 6to5
-    <a href="https://github.com/6to5/6to5/issues">issue tracker</a></em>.
-  </p>
-</blockquote>
-
-**Install**
-
-```sh
-$ npm install --save-dev 6to5-loader
-```
-
-**Usage via loader**
-
-```js
-import Animal from '6to5!./Animal.js';
-
-class Person extends Animal {
-  constructor(arg='default') {
-    this.eat = 'Happy Meal';
-  }
-}
-
-export default Person;
-```
-```js
-var Person = require('6to5!./Person.js').default;
-new Person();
-```
-
-**Usage via config**
-
-```js
-module: {
-  loaders: [
-    { test: /\.js$/, exclude: /node_modules/, loader: '6to5-loader'}
-  ]
-}
-```
-
-and then import normally:
-
-```js
-import Person from './Person.js';
-```
-
-<blockquote class="to5-callout to5-callout-warning">
-  <h4>Troubleshooting</h4>
-  <p>
-    For additional information on how to troubleshoot **6to5-loader** please
-    see the
-    <a href="https://github.com/6to5/6to5-loader#troubleshooting">README</a>.
-  </p>
-</blockquote>
-
-## Misc
-
-### Connect
-
-<blockquote class="to5-callout to5-callout-info">
-  <p>
-    See <strong>6to5-connect</strong>'s
-    <a href="https://github.com/6to5/6to5-connect">repo</a> for more info. If
-    you find any bugs please
-    <a href="https://github.com/6to5/6to5-connect/issues">report them</a>.
-  </p>
-  <p>
-    <em>Issues with the output should be reported on the 6to5
-    <a href="https://github.com/6to5/6to5/issues">issue tracker</a></em>.
-  </p>
-</blockquote>
-
-**Install**
-
-```js
-$ npm install 6to5-connect
-```
-
-**Usage**
-
-```js
-var to5Middleware = require('6to5-connect');
-
-app.use(to5Middleware({
-  options: {
-    // options to use when transforming files
-  },
-  src: 'assets',
-  dest: 'cache'
-}));
-
-app.use(connect.static('cache'));
-```
-
-### Jade
-
-<blockquote class="to5-callout to5-callout-info">
-  <p>
-    See <strong>jade-6to5</strong>'s
-    <a href="https://github.com/6to5/jade-6to5">repo</a> for more info. If you
-    find any bugs please
-    <a href="https://github.com/6to5/jade-6to5/issues">report them</a>.
-  </p>
-  <p>
-    <em>Issues with the output should be reported on the 6to5
-    <a href="https://github.com/6to5/6to5/issues">issue tracker</a></em>.
-  </p>
-</blockquote>
-
-**Install**
-
-```js
-$ npm install jade-6to5
-```
-
-**Usage**
-
-```js
-var jade = require('jade');
-var to5 = require('jade-6to5');
-
-jade.filters.to5 = to5({});
-```
-
-OR
-
-```js
-var jade = require('jade');
-var to5 = require('jade-6to5');
-
-jade = to5({}, jade);
-```
-
-Now you can use ES6 in your jade templates as following.
-
-```jade
-script
-  :to5
-    console.log('Hello World !!!');
-    class Person {
-      constructor(name) {
-        this.name = name;
-      }
-      sayName(){
-        console.log(`Hello, my name is ${this.name}`);
-      }
-    }
-    var person = new Person('Apoxx');
-    person.sayName();
-```
-
-### Jest
-
-<blockquote class="to5-callout to5-callout-info">
-  <p>
-    See <strong>6to5-jest</strong>'s
-    <a href="https://github.com/6to5/6to5-jest">repo</a> for more info. If you
-    find any bugs please
-    <a href="https://github.com/6to5/6to5-jest/issues">report them</a>.
-  </p>
-  <p>
-    <em>Issues with the output should be reported on the 6to5
-    <a href="https://github.com/6to5/6to5/issues">issue tracker</a></em>.
-  </p>
-</blockquote>
-
-**Install**
-
-```sh
-$ npm install --save-dev 6to5-jest
-```
-
-**Usage**
-
-In your `package.json` file please make the following changes:
-
-```
-{
-  "dependencies": {
-    "6to5-jest": "*",
-    "jest": "*"
-  },
-  "scripts": {
-    "test": "jest"
-  },
-  "jest": {
-    "scriptPreprocessor": "<rootDir>/node_modules/6to5-jest",
-    "testFileExtensions": ["es6", "js"],
-    "moduleFileExtensions": ["js", "json", "es6"]
-  }
-}
-```
-
-### Karma
-
-<blockquote class="to5-callout to5-callout-info">
-  <p>
-    See <strong>karma-6to5-preprocessor</strong>'s
-    <a href="https://github.com/6to5/karma-6to5-preprocessor">repo</a> for more
-    info. If you find any bugs please
-    <a href="https://github.com/6to5/karma-6to5-preprocessor/issues">report them</a>.
-  </p>
-  <p>
-    <em>Issues with the output should be reported on the 6to5
-    <a href="https://github.com/6to5/6to5/issues">issue tracker</a></em>.
-  </p>
-</blockquote>
-
-**Install**
-
-```js
-npm install --save-dev karma-6to5-preprocessor
-```
-
-**Usage**
-
-See 6to5 options for more details.
-
-Given `options` properties are passed to 6to5 with no change except:
-
-- `filename`
-- `sourceMapName`
-- `sourceFileName`
-
-Because they should differ from file to file, corresponding configuration
-functions are available.
-
-For example, inline sourcemap configuration would look like the following.
-
-```js
-module.exports = function(config) {
-  config.set({
-    files: [
-      'src/**/*.js',
-      'test/**/*.js'
-    ],
-    preprocessors: {
-      'src/**/*.js': ['6to5'],
-      'test/**/*.js': ['6to5']
-    },
-    '6to5Preprocessor': {
-      options: {
-        sourceMap: 'inline'
-      },
-      filename: function(file) {
-        return file.originalPath.replace(/\.js$/, '.es5.js');
-      },
-      sourceFileName: function(file) {
-        return file.originalPath;
-      }
-    }
-  });
-};
-```
-
-### Mocha
-
-<blockquote class="to5-callout to5-callout-info">
-  <p>
-    See <strong>6to5-mocha</strong>'s
-    <a href="https://github.com/6to5/6to5-mocha">repo</a> for more info. If you
-    find any bugs please
-    <a href="https://github.com/6to5/6to5-mocha/issues">report them</a>.
-  </p>
-  <p>
-    <em>Issues with the output should be reported on the 6to5
-    <a href="https://github.com/6to5/6to5/issues">issue tracker</a></em>.
-  </p>
-</blockquote>
-
-**Install**
-
-```sh
-$ npm install --save-dev 6to5
-```
-
-**Usage**
-
-```js
-{
-  "scripts": {
-    "test": "mocha --require 6to5/register"
-  },
-  "devDependencies": {
-    "6to5": "*",
-    "mocha": "*"
-  }
-}
-```

doc/tour.md

@@ -1,771 +0,0 @@
----
-layout: docs
-title: Tour
-description: A detailed overview of ECMAScript 6 features.
-permalink: /docs/tour/
-redirect_from: /features.html
----
-
-<blockquote class="to5-callout to5-callout-info">
-  <h4>es6features</h4>
-  <p>
-    This document is taken from Luke Hoban's excellent
-    <a href="http://git.io/es6features">es6features</a> repo. Go give it a star
-    on GitHub!
-  </p>
-</blockquote>
-
-<blockquote class="to5-callout to5-callout-info">
-  <h4>REPL</h4>
-  <p>
-    Be sure to try these features out in the online
-    <a href="repl.html">REPL</a>.
-  </p>
-</blockquote>
-
-## Introduction
-
-> ECMAScript 6 is the upcoming version of the ECMAScript standard.  This
-standard is targeting ratification in June 2015.  ES6 is a significant update to
-the language, and the first update to the language since ES5 was standardized in
-2009. Implementation of these features in major JavaScript engines is
-[underway now](http://kangax.github.io/es5-compat-table/es6/).
-
-See the [draft ES6 standard](https://people.mozilla.org/~jorendorff/es6-draft.html)
-for full specification of the ECMAScript 6 language.
-
-## ECMAScript 6 Features
-
-### Arrows
-
-Arrows are a function shorthand using the `=>` syntax.  They are syntactically
-similar to the related feature in C#, Java 8 and CoffeeScript.  They support
-both expression and statement bodies.  Unlike functions, arrows share the same
-lexical `this` as their surrounding code.
-
-```js
-// Expression bodies
-var odds = evens.map(v => v + 1);
-var nums = evens.map((v, i) => v + i);
-
-// Statement bodies
-nums.forEach(v => {
-  if (v % 5 === 0)
-    fives.push(v);
-});
-
-// Lexical this
-var bob = {
-  _name: "Bob",
-  _friends: [],
-  printFriends() {
-    this._friends.forEach(f =>
-      console.log(this._name + " knows " + f));
-  }
-}
-```
-
-### Classes
-
-ES6 classes are a simple sugar over the prototype-based OO pattern.  Having a
-single convenient declarative form makes class patterns easier to use, and
-encourages interoperability.  Classes support prototype-based inheritance, super
-calls, instance and static methods and constructors.
-
-```js
-class SkinnedMesh extends THREE.Mesh {
-  constructor(geometry, materials) {
-    super(geometry, materials);
-
-    this.idMatrix = SkinnedMesh.defaultMatrix();
-    this.bones = [];
-    this.boneMatrices = [];
-    //...
-  }
-  update(camera) {
-    //...
-    super.update();
-  }
-  static defaultMatrix() {
-    return new THREE.Matrix4();
-  }
-}
-```
-
-### Enhanced Object Literals
-
-Object literals are extended to support setting the prototype at construction,
-shorthand for `foo: foo` assignments, defining methods and making super calls.
-Together, these also bring object literals and class declarations closer
-together, and let object-based design benefit from some of the same
-conveniences.
-
-```js
-var obj = {
-    // __proto__
-    __proto__: theProtoObj,
-    // Shorthand for ‘handler: handler’
-    handler,
-    // Methods
-    toString() {
-     // Super calls
-     return "d " + super.toString();
-    },
-    // Computed (dynamic) property names
-    [ 'prop_' + (() => 42)() ]: 42
-};
-```
-
-<blockquote class="to5-callout to5-callout-warning">
-  <p>
-    <code>__proto__</code> support comes from the JavaScript engine running
-    your program. Although most support the now standard property,
-    <a href="http://kangax.github.io/compat-table/es6/#__proto___in_object_literals">some do not</a>.
-  </p>
-</blockquote>
-
-### Template Strings
-
-Template strings provide syntactic sugar for constructing strings. This is
-similar to string interpolation features in Perl, Python and more. Optionally, a
-tag can be added to allow the string construction to be customized, avoiding
-injection attacks or constructing higher level data structures from string
-contents.
-
-```js
-// Basic literal string creation
-`In JavaScript '\n' is a line-feed.`
-
-// Multiline strings
-`In JavaScript this is
- not legal.`
-
-// Construct a DOM query
-var name = "Bob", time = "today";
-`Hello ${name}, how are you ${time}?`
-
-// Construct an HTTP request prefix is used to interpret the replacements and construction
-GET`http://foo.org/bar?a=${a}&b=${b}
-    Content-Type: application/json
-    X-Credentials: ${credentials}
-    { "foo": ${foo},
-      "bar": ${bar}}`(myOnReadyStateChangeHandler);
-```
-
-### Destructuring
-
-Destructuring allows binding using pattern matching, with support for matching
-arrays and objects.  Destructuring is fail-soft, similar to standard object
-lookup `foo["bar"]`, producing `undefined` values when not found.
-
-```js
-// list matching
-var [a, , b] = [1,2,3];
-
-// object matching
-var { op: a, lhs: { op: b }, rhs: c }
-       = getASTNode()
-
-// object matching shorthand
-// binds `op`, `lhs` and `rhs` in scope
-var {op, lhs, rhs} = getASTNode()
-
-// Can be used in parameter position
-function g({name: x}) {
-  console.log(x);
-}
-g({name: 5})
-
-// Fail-soft destructuring
-var [a] = [];
-a === undefined;
-
-// Fail-soft destructuring with defaults
-var [a = 1] = [];
-a === 1;
-```
-
-### Default + Rest + Spread
-
-Callee-evaluated default parameter values. Turn an array into consecutive
-arguments in a function call. Bind trailing parameters to an array. Rest
-replaces the need for `arguments` and addresses common cases more directly.
-
-```js
-function f(x, y=12) {
-  // y is 12 if not passed (or passed as undefined)
-  return x + y;
-}
-f(3) == 15
-```
-```js
-function f(x, ...y) {
-  // y is an Array
-  return x * y.length;
-}
-f(3, "hello", true) == 6
-```
-```js
-function f(x, y, z) {
-  return x + y + z;
-}
-// Pass each elem of array as argument
-f(...[1,2,3]) == 6
-```
-
-### Let + Const
-
-Block-scoped binding constructs. `let` is the new `var`. `const` is
-single-assignment. Static restrictions prevent use before assignment.
-
-
-```js
-function f() {
-  {
-    let x;
-    {
-      // okay, block scoped name
-      const x = "sneaky";
-      // error, const
-      x = "foo";
-    }
-    // error, already declared in block
-    let x = "inner";
-  }
-}
-```
-
-### Iterators + For..Of
-
-Iterator objects enable custom iteration like CLR IEnumerable or Java
-Iteratable. Generalize `for..in` to custom iterator-based iteration with
-`for..of`. Don’t require realizing an array, enabling lazy design patterns like
-LINQ.
-
-```js
-let fibonacci = {
-  [Symbol.iterator]() {
-    let pre = 0, cur = 1;
-    return {
-      next() {
-        [pre, cur] = [cur, pre + cur];
-        return { done: false, value: cur }
-      }
-    }
-  }
-}
-
-for (var n of fibonacci) {
-  // truncate the sequence at 1000
-  if (n > 1000)
-    break;
-  print(n);
-}
-```
-
-Iteration is based on these duck-typed interfaces (using
-[TypeScript](http://typescriptlang.org) type syntax for exposition only):
-
-```ts
-interface IteratorResult {
-  done: boolean;
-  value: any;
-}
-interface Iterator {
-  next(): IteratorResult;
-}
-interface Iterable {
-  [Symbol.iterator](): Iterator
-}
-```
-
-### Generators
-
-Generators simplify iterator-authoring using `function*` and `yield`. A function
-declared as function* returns a Generator instance. Generators are subtypes of
-iterators which include additional `next` and `throw`. These enable values to
-flow back into the generator, so `yield` is an expression form which returns a
-value (or throws).
-
-Note: Can also be used to enable ‘await’-like async programming, see also ES7
-`await` proposal.
-
-```js
-var fibonacci = {
-  [Symbol.iterator]: function*() {
-    var pre = 0, cur = 1;
-    for (;;) {
-      var temp = pre;
-      pre = cur;
-      cur += temp;
-      yield cur;
-    }
-  }
-}
-
-for (var n of fibonacci) {
-  // truncate the sequence at 1000
-  if (n > 1000)
-    break;
-  print(n);
-}
-```
-
-The generator interface is (using [TypeScript](http://typescriptlang.org) type
-syntax for exposition only):
-
-```ts
-interface Generator extends Iterator {
-    next(value?: any): IteratorResult;
-    throw(exception: any);
-}
-```
-
-### Comprehensions
-
-Array and generator comprehensions provide simple declarative list processing
-similar as used in many functional programming patterns.
-
-```js
-// Array comprehensions
-var results = [
-  for(c of customers)
-    if (c.city == "Seattle")
-      { name: c.name, age: c.age }
-]
-
-// Generator comprehensions
-var results = (
-  for(c of customers)
-    if (c.city == "Seattle")
-      { name: c.name, age: c.age }
-)
-```
-
-### Unicode
-
-Non-breaking additions to support full Unicode, including new unicode literal
-form in strings and new RegExp `u` mode to handle code points, as well as new
-APIs to process strings at the 21bit code points level.  These additions support
-building global apps in JavaScript.
-
-```js
-// same as ES5.1
-"𠮷".length == 2
-
-// new RegExp behaviour, opt-in ‘u’
-"𠮷".match(/./u)[0].length == 2
-
-// new form
-"\u{20BB7}"=="𠮷" == "\uD842\uDFB7"
-
-// new String ops
-"𠮷".codePointAt(0) == 0x20BB7
-
-// for-of iterates code points
-for(var c of "𠮷") {
-  console.log(c);
-}
-```
-
-### Modules
-
-Language-level support for modules for component definition. Codifies patterns
-from popular JavaScript module loaders (AMD, CommonJS). Runtime behaviour
-defined by a host-defined default loader. Implicitly async model – no code
-executes until requested modules are available and processed.
-
-```js
-// lib/math.js
-export function sum(x, y) {
-  return x + y;
-}
-export var pi = 3.141593;
-```
-```js
-// app.js
-module math from "lib/math";
-alert("2π = " + math.sum(math.pi, math.pi));
-```
-```js
-// otherApp.js
-import {sum, pi} from "lib/math";
-alert("2π = " + sum(pi, pi));
-```
-
-Some additional features include `export default` and `export *`:
-
-```js
-// lib/mathplusplus.js
-export * from "lib/math";
-export var e = 2.71828182846;
-export default function(x) {
-    return Math.exp(x);
-}
-```
-```js
-// app.js
-module math from "lib/mathplusplus";
-import exp from "lib/mathplusplus";
-alert("2π = " + exp(math.pi, math.e));
-```
-
-<blockquote class="to5-callout to5-callout-info">
-  <h4>Module Formatters</h4>
-  <p>
-    6to5 can transpile ES6 Modules to several different formats including
-    Common.js, AMD, System, and UMD. You can even create your own. For more
-    details see the <a href="modules.html">modules docs</a>.
-  </p>
-</blockquote>
-
-### Module Loaders
-
-Module loaders support:
-- Dynamic loading
-- State isolation
-- Global namespace isolation
-- Compilation hooks
-- Nested virtualization
-
-The default module loader can be configured, and new loaders can be constructed
-to evaluated and load code in isolated or constrained contexts.
-
-```js
-// Dynamic loading – ‘System’ is default loader
-System.import('lib/math').then(function(m) {
-  alert("2π = " + m.sum(m.pi, m.pi));
-});
-
-// Create execution sandboxes – new Loaders
-var loader = new Loader({
-  global: fixup(window) // replace ‘console.log’
-});
-loader.eval("console.log('hello world!');");
-
-// Directly manipulate module cache
-System.get('jquery');
-System.set('jquery', Module({$: $})); // WARNING: not yet finalized
-```
-
-<blockquote class="to5-callout to5-callout-warning">
-  <h4>Additional polyfill needed</h4>
-  <p>
-    Since 6to5 defaults to using common.js modules, it does not include the
-    polyfill for the module loader api. Get it
-    <a href="https://github.com/ModuleLoader/es6-module-loader">here</a>.
-  </p>
-</blockquote>
-
-<blockquote class="to5-callout to5-callout-info">
-  <h4>Using Module Loader</h4>
-  <p>
-    In order to use this, you'll need to tell 6to5 to use the
-    <code>system</code> module formatter. Also be sure to check out
-    <a href="https://github.com/systemjs/systemjs">System.js</a>
-  </p>
-</blockquote>
-
-
-### Map + Set + WeakMap + WeakSet
-
-Efficient data structures for common algorithms.  WeakMaps provides leak-free
-object-key’d side tables.
-
-```js
-// Sets
-var s = new Set();
-s.add("hello").add("goodbye").add("hello");
-s.size === 2;
-s.has("hello") === true;
-
-// Maps
-var m = new Map();
-m.set("hello", 42);
-m.set(s, 34);
-m.get(s) == 34;
-
-// Weak Maps
-var wm = new WeakMap();
-wm.set(s, { extra: 42 });
-wm.size === undefined
-
-// Weak Sets
-var ws = new WeakSet();
-ws.add({ data: 42 });
-// Because the added object has no other references, it will not be held in the set
-```
-
-<blockquote class="to5-callout to5-callout-info">
-  <h4>Support via polyfill</h4>
-  <p>
-    In order to support Promises you must include the 6to5 Polyfill.
-  </p>
-</blockquote>
-
-### Proxies
-
-Proxies enable creation of objects with the full range of behaviors available to
-host objects.  Can be used for interception, object virtualization,
-logging/profiling, etc.
-
-```js
-// Proxying a normal object
-var target = {};
-var handler = {
-  get: function (receiver, name) {
-    return `Hello, ${name}!`;
-  }
-};
-
-var p = new Proxy(target, handler);
-p.world === 'Hello, world!';
-```
-
-```js
-// Proxying a function object
-var target = function () { return 'I am the target'; };
-var handler = {
-  apply: function (receiver, ...args) {
-    return 'I am the proxy';
-  }
-};
-
-var p = new Proxy(target, handler);
-p() === 'I am the proxy';
-```
-
-There are traps available for all of the runtime-level meta-operations:
-
-```js
-var handler =
-{
-  get:...,
-  set:...,
-  has:...,
-  deleteProperty:...,
-  apply:...,
-  construct:...,
-  getOwnPropertyDescriptor:...,
-  defineProperty:...,
-  getPrototypeOf:...,
-  setPrototypeOf:...,
-  enumerate:...,
-  ownKeys:...,
-  preventExtensions:...,
-  isExtensible:...
-}
-```
-
-<blockquote class="to5-callout to5-callout-danger">
-  <h4>Unsupported feature</h4>
-  <p>
-    Due to the limitations of ES5, Proxies cannot be transpiled or polyfilled.
-    See support from various
-    <a href="http://kangax.github.io/compat-table/es6/#Proxy">JavaScript
-    engines</a>.
-  </p>
-</blockquote>
-
-### Symbols
-
-Symbols enable access control for object state. Symbols allow properties to be
-keyed by either `string` (as in ES5) or `symbol`. Symbols are a new primitive
-type. Optional `name` parameter used in debugging - but is not part of identity.
-Symbols are unique (like gensym), but not private since they are exposed via
-reflection features like `Object.getOwnPropertySymbols`.
-
-```js
-(function() {
-
-  // module scoped symbol
-  var key = Symbol("key");
-
-  function MyClass(privateData) {
-    this[key] = privateData;
-  }
-
-  MyClass.prototype = {
-    doStuff: function() {
-      ... this[key] ...
-    }
-  };
-
-})();
-
-var c = new MyClass("hello")
-c["key"] === undefined
-```
-
-<blockquote class="to5-callout to5-callout-info">
-  <h4>Support via polyfill</h4>
-  <p>
-    In order to support Promises you must include the 6to5 Polyfill.
-  </p>
-</blockquote>
-
-### Subclassable Built-ins
-In ES6, built-ins like `Array`, `Date` and DOM `Element`s can be subclassed.
-
-Object construction for a function named `Ctor` now uses two-phases (both
-virtually dispatched):
-
-- Call `Ctor[@@create]` to allocate the object, installing any special behavior
-- Invoke constructor on new instance to initialize
-
-The known `@@create` symbol is available via `Symbol.create`. Built-ins now
-expose their `@@create` explicitly.
-
-```js
-// Pseudo-code of Array
-class Array {
-    constructor(...args) { /* ... */ }
-    static [Symbol.create]() {
-        // Install special [[DefineOwnProperty]]
-        // to magically update 'length'
-    }
-}
-
-// User code of Array subclass
-class MyArray extends Array {
-    constructor(...args) { super(...args); }
-}
-
-// Two-phase 'new':
-// 1) Call @@create to allocate object
-// 2) Invoke constructor on new instance
-var arr = new MyArray();
-arr[1] = 12;
-arr.length == 2
-```
-
-### Math + Number + String + Object APIs
-
-Many new library additions, including core Math libraries, Array conversion
-helpers, and Object.assign for copying.
-
-```js
-Number.EPSILON
-Number.isInteger(Infinity) // false
-Number.isNaN("NaN") // false
-
-Math.acosh(3) // 1.762747174039086
-Math.hypot(3, 4) // 5
-Math.imul(Math.pow(2, 32) - 1, Math.pow(2, 32) - 2) // 2
-
-"abcde".contains("cd") // true
-"abc".repeat(3) // "abcabcabc"
-
-Array.from(document.querySelectorAll('*')) // Returns a real Array
-Array.of(1, 2, 3) // Similar to new Array(...), but without special one-arg behavior
-[0, 0, 0].fill(7, 1) // [0,7,7]
-[1,2,3].findIndex(x => x == 2) // 1
-["a", "b", "c"].entries() // iterator [0, "a"], [1,"b"], [2,"c"]
-["a", "b", "c"].keys() // iterator 0, 1, 2
-["a", "b", "c"].values() // iterator "a", "b", "c"
-
-Object.assign(Point, { origin: new Point(0,0) })
-```
-
-<blockquote class="to5-callout to5-callout-warning">
-  <h4>Limited support from polyfill</h4>
-  <p>
-    Most of these APIs are supported by the 6to5 Polyfill. However, certain
-    features are omitted for various reasons (ie.
-    <code>String.prototype.normalize</code> needs a lot of additional code to
-    support). You can find more polyfills
-    <a href="https://github.com/addyosmani/es6-tools#polyfills">here</a>.
-  </p>
-</blockquote>
-
-### Binary and Octal Literals
-Two new numeric literal forms are added for binary (`b`) and octal (`o`).
-
-```js
-0b111110111 === 503 // true
-0o767 === 503 // true
-```
-
-<blockquote class="to5-callout to5-callout-warning">
-  <h4>Only supports literal form</h4>
-  <p>
-    6to5 is only able to transform <code>0o767</code> and not
-    <code>Number('0o767')</code>.
-  </p>
-</blockquote>
-
-
-### Promises
-
-Promises are a library for asynchronous programming. Promises are a first class
-representation of a value that may be made available in the future. Promises are
-used in many existing JavaScript libraries.
-
-```js
-function timeout(duration = 0) {
-    return new Promise((resolve, reject) => {
-        setTimeout(resolve, duration);
-    })
-}
-
-var p = timeout(1000).then(() => {
-    return timeout(2000);
-}).then(() => {
-    throw new Error("hmm");
-}).catch(err => {
-    return Promise.all([timeout(100), timeout(200)]);
-})
-```
-
-<blockquote class="to5-callout to5-callout-info">
-  <h4>Support via polyfill</h4>
-  <p>
-    In order to support Promises you must include the 6to5 Polyfill.
-  </p>
-</blockquote>
-
-### Reflect API
-
-Full reflection API exposing the runtime-level meta-operations on objects. This
-is effectively the inverse of the Proxy API, and allows making calls
-corresponding to the same meta-operations as the proxy traps. Especially useful
-for implementing proxies.
-
-```js
-// No sample yet
-```
-
-<blockquote class="to5-callout to5-callout-danger">
-  <h4>Limited support from polyfill</h4>
-  <p>
-    Core.js only currently supports <code>Reflect.ownKeys</code>, if you would
-    like a much more complete Reflect API, include another polyfill such as
-    <a href="https://github.com/tvcutsem/harmony-reflect">Harmony Reflect</a>.
-  </p>
-</blockquote>
-
-### Tail Calls
-
-Calls in tail-position are guaranteed to not grow the stack unboundedly. Makes
-recursive algorithms safe in the face of unbounded inputs.
-
-```js
-function factorial(n, acc = 1) {
-    'use strict';
-    if (n <= 1) return acc;
-    return factorial(n - 1, n * acc);
-}
-
-// Stack overflow in most implementations today,
-// but safe on arbitrary inputs in eS6
-factorial(100000)
-```
-
-<blockquote class="to5-callout to5-callout-danger">
-  <h4>Unsupported feature</h4>
-  <p>
-    Due to high complexity of transpiling Tail Calls, 6to5 does not currently
-    have them implemented. See
-    <a href="https://github.com/6to5/6to5/issues/256">#256</a>.
-  </p>
-</blockquote>

doc/usage/api.md

@@ -1,59 +0,0 @@
----
-layout: docs
-title: API
-description: How to use the Node.js API.
-permalink: /docs/usage/api/
----
-
-
-```javascript
-var to5 = require('6to5');
-```
-
-## to5.transform
-
-Transforms the passed in `code`.
-
-```
-to5.transform(code, [options])
-```
-
-**Example**
-
-```js
-var result = to5.transform('code();', options);
-result.code;
-result.map;
-result.ast;
-```
-
-## to5.transformFile
-
-Asynchronously transforms the entire contents of a file.
-
-```js
-to5.transformFile(filename, [options], callback)
-```
-
-**Example**
-
-```js
-to5.transformFile('filename.js', options, function (err, result) {
-  result.code;
-});
-```
-
-## to5.transformFileSync
-
-Synchronous version of `to5.transformFile`. Returns the transformed contents of
-the `filename`.
-
-```js
-to5.transformFileSync(filename, [options])
-```
-
-**Example**
-
-```js
-to5.transformFileSync('filename.js', options).code;
-```

doc/usage/browser.md

@@ -1,59 +0,0 @@
----
-layout: docs
-title: Browser
-description: How to transpile in the browser.
-permalink: /docs/usage/browser/
-redirect_from: /browser.html
----
-
-<p class="lead">
-  A browser version of 6to5 is available from `browser.js` inside the 6to5
-  directory in an npm release.
-</p>
-
-<blockquote class="to5-callout to5-callout-warning">
-  <h4>Not intended for serious use</h4>
-  <p>
-    Compiling in the browser has a fairly limited use case, so if you are
-    working on a production site you should be precompiling your scripts
-    server-side. See <a href="../setup/#build-systems">setup build systems</a>
-    for more information.
-  </p>
-</blockquote>
-
-## Script tags
-
-When the `browser.js` file is included all scripts with the type
-`text/ecmascript-6` and `text/6to5` are automatically compiled and ran.
-
-```html
-<script src="node_modules/6to5/browser.js"></script>
-<script type="text/6to5">
-class Test {
-  test() {
-    return 'test';
-  }
-}
-
-var test = new Test;
-test.test(); // "test"
-</script>
-```
-
-## API
-
-Programmatically transpile and execute strings of ES6 code.
-
-See [options](#options) for additional documentation.
-
-### `to5.transform(code, [opts])`
-
-```js
-to5.transform('class Test {}').code;
-```
-
-### `to5.run(code, [opts])`
-
-````js
-to5.run('class Test {}');
-````

doc/usage/cli.md

@@ -1,99 +0,0 @@
----
-layout: docs
-title: CLI
-description: How to use the CLI tools.
-permalink: /docs/usage/cli/
-redirect_from: /usage.html
----
-
-<p class="lead">
-  6to5 comes with a built-in CLI which can be used to compile files from the
-  command line.
-</p>
-
-## Install
-
-Using [npm](https://www.npmjs.com/) you can install 6to5 globally, making it
-available from the command line.
-
-```sh
-$ npm install --global 6to5
-```
-
-## 6to5
-
-#### Compile Files
-
-Compile the file `script.js` and **output to stdout**.
-
-```sh
-$ 6to5 script.js
-# output...
-```
-
-If you would like to **output to a file** you may use `--out-file` or `-o`.
-
-```sh
-$ 6to5 script.js --out-file script-compiled.js
-```
-
-### Compile with Source Maps
-
-If you would then like to add a **source map file** you can use
-`--source-maps` or `-s`. [Learn more about source maps](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/).
-
-```sh
-$ 6to5 script.js --out-file script-compiled.js --source-maps
-```
-
-If you would rather have **inline source maps**, you may use
-`--source-maps-inline` or `-t`.
-
-```sh
-$ 6to5 script.js --out-file script-compiled.js --source-maps-inline
-```
-
-### Compile Directories
-
-Compile the entire `src` directory and output it to the `lib` directory.
-
-```sh
-$ 6to5 src --out-dir lib
-```
-
-Compile the entire `src` directory and output it to the one concatenated file.
-
-```sh
-$ 6to5 src --out-file script-compiled.js
-```
-
-### Piping Files
-
-Pipe a file in via stdin and output it to `script-compiled.js`
-
-```sh
-$ 6to5 --out-file script-compiled.js < script.js
-```
-
-## 6to5-node
-
-6to5 comes with a second CLI which works exactly the same as Node.js's CLI, only
-it will compile ES6 code before running it.
-
-Launch a REPL (Read-Eval-Print-Loop).
-
-```sh
-$ 6to5-node
-```
-
-Evaluate code.
-
-```sh
-$ 6to5-node -e "class Test { }"
-```
-
-Compile and run `test.js`.
-
-```sh
-$ 6to5-node test
-```

doc/usage/experimental.md

@@ -1,28 +0,0 @@
----
-layout: docs
-title: Experimental
-description: How to use experimental ES7 features.
-permalink: /docs/usage/experimental/
-redirect_from: /experimental.html
----
-
-> 6to5 also has experimental support for ES7 proposals.
-
-<blockquote class="to5-callout to5-callout-danger">
-  <h4>Subject to change</h4>
-  <p>
-    These proposals are subject to change so <strong><em>use with extreme
-    caution</em></strong>. 6to5 may update without warning in order to track spec
-    changes. Please do not use them in production applications.
-  </p>
-</blockquote>
-
-#### Usage
-
-```js
-$ 6to5 --experimental
-```
-
-```js
-to5.transform('code', { experimental: true });
-```

doc/usage/jsx.md

@@ -1,22 +0,0 @@
----
-layout: docs
-title: JSX
-description: How to use JSX.
-permalink: /docs/usage/jsx/
----
-
-<p class="lead">
-  6to5 has built-in support for React v0.12. Tags are automatically transformed
-  to their equivalent <code>React.createElement(...)</code> and
-  <code>displayName</code> is automatically inferred and added to all
-  <code>React.createClass</code> calls.
-</p>
-
-## Blacklist
-
-To disable this behaviour add react to your blacklist:
-
-````js
-to5.transform("code", { blacklist: ["react"] });
-$ 6to5 --blacklist react
-```

doc/usage/modules.md

@@ -1,260 +0,0 @@
----
-layout: docs
-title: Modules
-description: How to use module formatters.
-permalink: /docs/usage/modules/
-redirect_from: /modules.html
----
-
-<p class="lead">
-  6to5 has the ability to transpile ES6 modules to the module system of your
-  choice. You can even easily create your own.
-</p>
-
-## Usage
-
-```sh
-$ 6to5 --modules common script.js
-```
-
-```js
-to5.transform('import "foo";', { modules: "common" });
-```
-
-## Formats
-
-### Common (Default)
-
-**Usage**
-
-```sh
-$ 6to5 --modules common
-```
-
-**Example**
-
-```js
-export default test;
-
-export {test};
-export var test = 5;
-
-import "foo";
-
-import foo from "foo";
-import * as foo from "foo";
-
-import {bar} from "foo";
-import {foo as bar} from "foo";
-```
-
-```js
-"use strict";
-
-var _interopRequire = function (obj) {
-  return obj && (obj["default"] || obj);
-};
-
-exports = module.exports = test;
-
-exports.test = test;
-var test = exports.test = 5;
-
-require("foo");
-
-var foo = _interopRequire(require("foo"));
-
-var foo = require("foo");
-
-var bar = require("foo").bar;
-var bar = require("foo").foo;
-```
-
-### AMD
-
-**Usage**
-
-```sh
-$ 6to5 --modules amd
-```
-
-**Example**
-
-```js
-import foo from "foo";
-
-export function bar() {
-  return foo("foobar");
-}
-```
-
-```js
-define(["exports", "foo"], function (exports, _foo) {
-  "use strict";
-
-  var _interopRequire = function (obj) {
-    return obj && (obj["default"] || obj);
-  };
-
-  exports.bar = bar;
-  var foo = _interopRequire(_foo);
-
-  function bar() {
-    return foo("foobar");
-  }
-});
-```
-
-You can optionally specify to include the module id (using the `--amd-module-id`
-argument):
-
-```js
-define("filename", ["exports", "foo"], function (exports, _foo) {})
-```
-
-### System
-
-**Usage**
-
-```sh
-$ 6to5 --modules system
-```
-
-**Example**
-
-```js
-import foo from "foo";
-
-export function bar() {
-  return foo("foobar");
-}
-```
-
-```js
-System.register("bar", ["foo"], function (_export) {
-  "use strict";
-
-  var __moduleName = "bar";
-
-  var foo;
-  function bar() {
-    return foo("foobar");
-  }
-  return {
-    setters: [function (m) {
-      foo = m.default;
-    }],
-    execute: function () {
-      _export("bar", bar);
-    }
-  };
-});
-```
-
-### UMD
-
-**Usage**
-
-```sh
-$ 6to5 --modules umd
-```
-
-**Example**
-
-```js
-import foo from "foo";
-
-export function bar() {
-  return foo("foobar");
-}
-```
-
-```js
-(function (factory) {
-  if (typeof define === "function" && define.amd) {
-    define(["exports", "foo"], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require("foo"));
-  }
-})(function (exports, _foo) {
-  "use strict";
-
-  var _interopRequire = function (obj) {
-    return obj && (obj["default"] || obj);
-  };
-
-  exports.bar = bar;
-  var foo = _interopRequire(_foo);
-
-  function bar() {
-    return foo("foobar");
-  }
-});
-```
-
-### Ignore
-
-**Usage**
-
-```sh
-$ 6to5 --modules ignore
-```
-
-**Example**
-
-```js
-import foo from "foo";
-
-export function bar() {
-  return foo("foobar");
-}
-```
-
-```js
-function bar() {
-  return foo("foobar");
-}
-```
-
-### Custom
-
-You can alternatively specify module names instead of one of the built-in types.
-
-**Usage**
-
-```js
-$ 6to5 --modules custom-module-formatter
-```
-
-**Example**
-
-**`node_modules/custom-module-formatter/index.js`**
-
-```js
-module.exports = ModuleFormatter;
-
-function ModuleFormatter() {}
-
-ModuleFormatter.prototype.transform = function (ast) {
-  // this is ran after all transformers have had their turn at modifying the ast
-  // feel free to modify this however
-};
-
-ModuleFormatter.prototype.importDeclaration = function (node, nodes) {
-  // node is an ImportDeclaration
-};
-
-ModuleFormatter.prototype.importSpecifier = function (specifier, node, nodes) {
-  // specifier is an ImportSpecifier
-  // node is an ImportDeclaration
-};
-
-ModuleFormatter.prototype.exportDeclaration = function (node, nodes) {
-  // node is an ExportDeclaration
-};
-
-ModuleFormatter.prototype.exportSpecifier = function (specifier, node, nodes) {
-  // specifier is an ExportSpecifier
-  // node is an ExportDeclaration
-};
-```

doc/usage/options.md

@@ -1,35 +0,0 @@
----
-layout: docs
-title: Options
-description: Options for 6to5 transpiling.
-permalink: /docs/usage/options/
----
-
-## Usage
-
-```js
-to5.transform(code, options);
-```
-
-```sh
-$ 6to5 --name=value
-```
-
-## Options
-
-| Option             | Default              | Description                     |
-| ------------------ | -------------------- | ------------------------------- |
-| `filename`         | `"unknown"`          | Filename for use in errors etc. |
-| `fileNameRelative` | `(filename)`         | Filename relative to `sourceRoot`. |
-| `blacklist`        | `[]`                 | Array of transformers to **exclude**. Run `6to5 --help` to see a full list of transformers. |
-| `whitelist`        | `[]`                 | Array of transformers to **only** use. Run `6to5 --help` to see a full list of transformers. |
-| `modules`          | `"common"`           | Which module formatter to use. Run `6to5 --help` to see a full list of module formatters. |
-| `sourceMap`        | `false`              | If truthy, adds a `map` property to returned output. If set to `"inline"`, a comment with a sourceMappingURL directive is added to the bottom of the returned code. |
-| `sourceMapName`    | `(filenameRelative)` | Set `file` on returned source map. |
-| `sourceFileName`   | `(filenameRelative)` | Set `sources[0]` on returned source map. |
-| `sourceRoot`       | `(moduleRoot)`       | The root from which all sources are relative. |
-| `moduleRoot`       | `(sourceRoot)`       | Optional prefix for the AMD module formatter that will be prepend to the filename on module definitions. |
-| `amdModuleIds`     | `false`              | If truthy, insert an explicit id for each defined AMD module. By default, AMD modules are anonymous. |
-| `runtime`          | `false`              | Optionally replace all 6to5 helper declarations with a referenece to this variable. If set to `true` then the default namespace is used `to5Runtime`. |
-| `comments`         | `true`               | Output comments in generated output. |
-| `experimental`     | `false`              | Enable support for experimental ES7 features. |

doc/usage/playground.md

@@ -1,173 +0,0 @@
----
-layout: docs
-title: Playground
-description: How to use the playground.
-permalink: /docs/usage/playground/
-redirect_from: /playground.html
----
-
-> Playground is a proving ground for language ideas.
-
-<blockquote class="to5-callout to5-callout-danger">
-  <h4>Unofficial</h4>
-  <p>
-    These features are in no way endorsed by Ecma International and are not a
-    part of any ECMAScript standard, nor are they necessarily on track to become
-    part of any standard. <strong><em>Use with extreme caution</em></strong>.
-  </p>
-</blockquote>
-
-<blockquote class="to5-callout to5-callout-info">
-  <h4>Proposal Authors</h4>
-  <p>
-    If you are actively working on an
-    <a href="https://github.com/tc39/ecma262">ECMAScript proposal</a>, this is a
-    good place to get your ideas implemented with so that they may be tested
-    with all of the latest language and API features.
-  </p>
-  <p>
-    Please feel free to <a href="https://github.com/6to5/6to5/issues/new">open
-    an issue</a> on the 6to5 repository with your WIP spec, and we can discuss
-    getting it implemented. Be sure to include as much information as possible.
-  </p>
-</blockquote>
-
-## Usage
-
-```js
-$ 6to5 --playground
-```
-
-```js
-to5.transform('code', { playground: true });
-```
-
-<blockquote class="to5-callout to5-callout-info">
-  <h4>Enables experimental</h4>
-  <p>
-    Enabling playground also enables experimental support.
-  </p>
-</blockquote>
-
-## Features
-
-### Memoization assignment operator
-
-The memoization assignment operator allows you to lazily set an object property.
-It checks whether there's a property defined on the object and if there isn't
-then the right hand value is set.
-
-This means that `obj.x` in the following `var x = { x: undefined }; obj.x ?= 2;``
-will still be `undefined` because it's already been defined on the object.
-
-**Uses**
-
-```js
-var obj = {};
-obj.x ?= 2;
-obj.x; // 2
-
-obj = { x: 1 };
-obj.x ?= 2;
-obj.x; // 1
-
-obj = { x: undefined }
-obj.x ?= 2;
-obj.x; // undefined
-```
-
-**Example**
-
-```js
-var obj = {};
-obj.x ?= 2;
-```
-
-is equivalent to
-
-```js
-var obj = {};
-if (!Object.prototype.hasOwnProperty.call(obj, 'x')) obj.x = 2;
-```
-
-### Method binding
-
-```javascript
-var fn = obj#method;
-var fn = obj#method("foob");
-```
-
-is equivalent to
-
-```javascript
-var fn = obj.method.bind(obj);
-var fn = obj.method.bind(obj, "foob");
-```
-
-### Method binding function shorthand
-
-```javascript
-["foo", "bar"].map(#toUpperCase); // ["FOO", "BAR"]
-[1.1234, 23.53245, 3].map(#toFixed(2)); // ["1.12", "23.53", "3.00"]
-```
-
-equivalent to
-
-```javascript
-["foo", "bar"].map(function (val) { return val.toUpperCase(); });
-[1.1234, 23.53245, 3].map(function (val) { return val.toFixed(2); });
-```
-
-### Object getter memoization
-
-```js
-var foo = {
-  memo bar() {
-    return complex();
-  }
-};
-
-class Foo {
-  memo bar() {
-    return complex();
-  }
-}
-```
-
-is equivalent to
-
-```js
-var foo = {
-  get bar() {
-    return Object.defineProperty(this, "bar", {
-      value: complex(),
-      enumerable: true,
-      configurable: true,
-      writable: true
-    }).bar;
-  }
-};
-
-class Foo {
-  get bar() {
-    return Object.defineProperty(this, "bar", {
-      value: complex(),
-      enumerable: true,
-      configurable: true,
-      writable: true
-    }).bar;
-  }
-}
-```
-
-### This shorthand
-
-```js
-@foo
-```
-
-is equivalent to
-
-```
-this.foo
-```

doc/usage/polyfill.md

@@ -1,56 +0,0 @@
----
-layout: docs
-title: Polyfill
-description: How to use the Polyfill.
-permalink: /docs/usage/polyfill/
----
-
-<p class="lead">
-  6to5 includes a polyfill that includes a custom
-  <a href="https://github.com/facebook/regenerator/blob/master/runtime.js">regenerator runtime</a>
-  and <a href="https://github.com/zloirock/core-js">core.js</a>.
-</p>
-
-This will emulate a full ES6 environment. This polyfill is automatically loaded
-when using `6to5-node` and `6to5/register`.
-
-## Usage in Node/Browserify
-
-You need to include the polyfill require at the top the **entry point** to
-your application.
-
-```js
-require('6to5/polyfill');
-```
-
-Fortunately, this is automatically loaded when using:
-
-```js
-require('6to5/register');
-```
-
-## Usage in Browser
-
-Available from the `browser-polyfill.js` file within the 6to5 directory of an
-npm release. This needs to be included **before** all your compiled 6to5 code.
-You can either prepend it to your compiled code or include it in a `<script>`
-before it.
-
-**NOTE:** Do not `require` this via browserify etc, use `6to5/polyfill`.
-
-<blockquote class="to5-callout to5-callout-warning">
-<h4>Polyfills are not perfect</h4>
-<p>
-Due to limitations in various ES5 environments not every polyfill will work
-in every environment.
-</p>
-</blockquote>
-
-<blockquote class="to5-callout to5-callout-warning">
-<h4>Certain polyfills not included</h4>
-<p>
-Certain polyfills are too large/complex for their implemented features to
-justify including them for all builds. You may have to include additional
-polyfills for a subset of ES6 features.
-</p>
-</blockquote>

doc/usage/require.md

@@ -1,55 +0,0 @@
----
-layout: docs
-title: Require Hook
-description: How to use the require hook.
-permalink: /docs/usage/require/
----
-
-## Install
-
-```sh
-$ npm install 6to5
-```
-
-## Usage
-
-```js
-require('6to5/register');
-```
-
-All subsequent files required by node with the extensions `.es6`, `.es`, and
-`.js` will be transformed by 6to5. The polyfill specified in Polyfill is also
-required.
-
-**NOTE:** By default all requires to `node_modules` will be ignored. You can
-override this by passing an ignore regex via:
-
-```js
-require('6to5/register')({
-  // This will override `node_modules` ignoring - you can alternatively pass
-  // a regex
-  ignore: false
-});
-```
-
-## Register Options
-
-```javascript
-require('6to5/register')({
-  // Optional ignore regex - if any filenames **do** match this regex then they
-  // aren't compiled
-  ignore: /regex/,
-
-  // Optional only regex - if any filenames **don't** match this regex then they
-  // aren't compiled
-  only: /my_es6_folder/,
-
-  // See options above for usage
-  whitelist: [],
-  blacklist: [],
-
-  // This will remove the currently hooked extensions of .es6 and .js so you'll
-  // have to add them back if you want them to be used again.
-  extensions: ['.js', '.es6']
-});
-```

doc/usage/runtime.md

@@ -1,56 +0,0 @@
----
-layout: docs
-title: Optional Runtime
-description: How to use the optional runtime.
-permalink: /docs/usage/runtime/
----
-
-## Details
-
-6to5 has a few helper functions that'll be placed at the top of the generated
-code if needed so it's not inlined multiple times throughout that file. This may
-become an issue if you have multiple files, especially when you're sending them
-to the browser. gzip alleviates most of this concern but it's still not ideal.
-
-You can tell 6to5 to not place any declarations at the top of your files and
-instead just point them to a reference contained within the runtime.
-
-## Usage
-
-```js
-$ 6to5 --runtime
-```
-
-```js
-to5.transform('code', { runtime: true });
-```
-
-### Getting the runtime
-
-```sh
-$ 6to5-runtime
-```
-
-or
-
-```js
-require('6to5').runtime();
-```
-
-or from an npm release in `runtime.js` from the 6to5 directory.
-
-### Customising namespace
-
-You can also customise the runtime namespace by passing an optional namespace
-argument:
-
-```sh
-$ 6to5-runtime myCustomNamespace
-```
-
-```js
-require("6to5").runtime('myCustomNamespace');
-```
-
-See [Options - runtime](../options) for documentation on changing the reference in
-generated code.

lib/6to5/browser.js

@@ -1,5 +1,9 @@
+"use strict";
+
 var transform = module.exports = require("./transformation/transform");
 
+transform.version = require("../../package").version;
+
 transform.transform = transform;
 
 transform.run = function (code, opts) {

lib/6to5/file.js

@@ -1,21 +1,30 @@
+"use strict";
+
 module.exports = File;
 
 var SHEBANG_REGEX = /^\#\!.*/;
 
 var transform = require("./transformation/transform");
 var generate  = require("./generation/generator");
+var clone     = require("./helpers/clone");
 var Scope     = require("./traverse/scope");
 var util      = require("./util");
 var t         = require("./types");
 var _         = require("lodash");
 
 function File(opts) {
-  this.dynamicImports   = [];
   this.dynamicImportIds = {};
+  this.dynamicImported  = [];
+  this.dynamicImports   = [];
+
+  this.dynamicData      = {};
+  this.data             = {};
+
+  this.lastStatements   = [];
   this.opts             = File.normaliseOptions(opts);
-  this.transformers     = this.getTransformers();
-  this.uids             = {};
   this.ast              = {};
+
+  this.buildTransformers();
 }
 
 File.helpers = [
@@ -24,6 +33,7 @@ File.helpers = [
   "prototype-properties",
   "apply-constructor",
   "tagged-template-literal",
+  "tagged-template-literal-loose",
   "interop-require",
   "to-array",
   "sliced-to-array",
@@ -35,32 +45,65 @@ File.helpers = [
   "async-to-generator",
   "interop-require-wildcard",
   "typeof",
-  "exports-wildcard"
+  "extends",
+  "get"
 ];
 
-File.excludeHelpersFromRuntime = [
-  "async-to-generator",
-  "typeof"
+File.validOptions = [
+  "filename",
+  "filenameRelative",
+  "blacklist",
+  "whitelist",
+  "loose",
+  "optional",
+  "modules",
+  "sourceMap",
+  "sourceMapName",
+  "sourceFileName",
+  "sourceRoot",
+  "moduleRoot",
+  "moduleIds",
+  "comments",
+  "reactCompat",
+  "keepModuleIdExtensions",
+  "code",
+  "ast",
+  "format",
+  "playground",
+  "experimental",
+
+  // these are used by plugins
+  "ignore",
+  "only",
+  "extensions"
 ];
 
 File.normaliseOptions = function (opts) {
-  opts = _.cloneDeep(opts || {});
+  opts = clone(opts);
+
+  for (var key in opts) {
+    if (File.validOptions.indexOf(key) < 0) {
+      throw new ReferenceError("Unknown option: " + key);
+    }
+  }
 
   _.defaults(opts, {
-    experimental: false,
-    playground:   false,
-    whitespace:   true,
-    moduleIds:    opts.amdModuleIds || false,
-    blacklist:    [],
-    whitelist:    [],
-    sourceMap:    false,
-    optional:     [],
-    comments:     true,
-    filename:     "unknown",
-    modules:      "common",
-    runtime:      false,
-    code:         true,
-    ast:          true
+    keepModuleIdExtensions: false,
+    experimental:           false,
+    reactCompat:            false,
+    playground:             false,
+    whitespace:             true,
+    moduleIds:              false,
+    blacklist:              [],
+    whitelist:              [],
+    sourceMap:              false,
+    optional:               [],
+    comments:               true,
+    filename:               "unknown",
+    modules:                "common",
+    loose:                  [],
+    code:                   true,
+    ast:                    true
   });
 
   // normalise windows path separators to unix
@@ -68,6 +111,12 @@ File.normaliseOptions = function (opts) {
 
   opts.blacklist = util.arrayify(opts.blacklist);
   opts.whitelist = util.arrayify(opts.whitelist);
+  opts.optional  = util.arrayify(opts.optional);
+  opts.loose     = util.arrayify(opts.loose);
+
+  if (_.contains(opts.loose, "all")) {
+    opts.loose = Object.keys(transform.transformers);
+  }
 
   _.defaults(opts, {
     moduleRoot: opts.sourceRoot
@@ -86,32 +135,37 @@ File.normaliseOptions = function (opts) {
     sourceMapName:  opts.filenameRelative
   });
 
-  if (opts.runtime === true) {
-    opts.runtime = "to5Runtime";
-  }
-
   if (opts.playground) {
     opts.experimental = true;
   }
 
-  transform._ensureTransformerNames("blacklist", opts.blacklist);
-  transform._ensureTransformerNames("whitelist", opts.whitelist);
-  transform._ensureTransformerNames("optional", opts.optional);
+  opts.blacklist = transform._ensureTransformerNames("blacklist", opts.blacklist);
+  opts.whitelist = transform._ensureTransformerNames("whitelist", opts.whitelist);
+  opts.optional = transform._ensureTransformerNames("optional", opts.optional);
+  opts.loose = transform._ensureTransformerNames("loose", opts.loose);
 
   return opts;
 };
 
-File.prototype.getTransformers = function () {
+File.prototype.isLoose = function (key) {
+  return _.contains(this.opts.loose, key);
+};
+
+File.prototype.buildTransformers = function () {
   var file = this;
-  var transformers = [];
-  var secondPassTransformers = [];
 
-  _.each(transform.transformers, function (transformer) {
-    if (transformer.canRun(file)) {
-      transformers.push(transformer);
+  var transformers = {};
 
+  var secondaryStack = [];
+  var stack = [];
+
+  _.each(transform.transformers, function (transformer, key) {
+    var pass = transformers[key] = transformer.buildPass(file);
+
+    if (pass.canRun(file)) {
+      stack.push(pass);
       if (transformer.secondPass) {
-        secondPassTransformers.push(transformer);
+        secondaryStack.push(pass);
       }
 
       if (transformer.manipulateOptions) {
@@ -120,7 +174,8 @@ File.prototype.getTransformers = function () {
     }
   });
 
-  return transformers.concat(secondPassTransformers);
+  this.transformerStack = stack.concat(secondaryStack);
+  this.transformers = transformers;
 };
 
 File.prototype.toArray = function (node, i) {
@@ -166,6 +221,26 @@ File.prototype.parseShebang = function (code) {
   return code;
 };
 
+File.prototype.set = function (key, val) {
+  return this.data[key] = val;
+};
+
+File.prototype.setDynamic = function (key, fn) {
+  this.dynamicData[key] = fn;
+};
+
+File.prototype.get = function (key) {
+  var data = this.data[key];
+  if (data) {
+    return data;
+  } else {
+    var dynamic = this.dynamicData[key];
+    if (dynamic) {
+      return this.set(key, dynamic());
+    }
+  }
+};
+
 File.prototype.addImport = function (source, name) {
   name = name || source;
   var id = this.dynamicImportIds[name];
@@ -176,12 +251,18 @@ File.prototype.addImport = function (source, name) {
     var specifiers = [t.importSpecifier(t.identifier("default"), id)];
     var declar = t.importDeclaration(specifiers, t.literal(source));
     declar._blockHoist = 3;
-    this.dynamicImports.push(declar);
+    this.dynamicImported.push(declar);
+
+    this.moduleFormatter.importSpecifier(specifiers[0], declar, this.dynamicImports);
   }
 
   return id;
 };
 
+File.prototype.isConsequenceExpressionStatement = function (node) {
+  return t.isExpressionStatement(node) && this.lastStatements.indexOf(node) >= 0;
+};
+
 File.prototype.addHelper = function (name) {
   if (!_.contains(File.helpers, name)) {
     throw new ReferenceError("unknown declaration " + name);
@@ -192,22 +273,21 @@ File.prototype.addHelper = function (name) {
   var declar = program._declarations && program._declarations[name];
   if (declar) return declar.id;
 
-  var ref;
-  var runtimeNamespace = this.opts.runtime;
-  if (runtimeNamespace && !_.contains(File.excludeHelpersFromRuntime, name)) {
+  var runtime = this.get("runtimeIdentifier");
+  if (runtime) {
     name = t.identifier(t.toIdentifier(name));
-    return t.memberExpression(t.identifier(runtimeNamespace), name);
+    return t.memberExpression(runtime, name);
   } else {
-    ref = util.template(name);
+    var ref = util.template(name);
+    ref._compact = true;
+    var uid = this.generateUidIdentifier(name);
+    this.scope.push({
+      key: name,
+      id: uid,
+      init: ref
+    });
+    return uid;
   }
-
-  var uid = this.generateUidIdentifier(name);
-  this.scope.push({
-    key: name,
-    id: uid,
-    init: ref
-  });
-  return uid;
 };
 
 File.prototype.errorWithNode = function (node, msg, Error) {
@@ -230,7 +310,11 @@ File.prototype.parse = function (code) {
 
   code = this.addCode(code);
 
-  return util.parse(this.opts, code, function (tree) {
+  var opts = this.opts;
+
+  opts.allowImportExportEverywhere = this.isLoose("modules");
+
+  return util.parse(opts, code, function (tree) {
     self.transform(tree);
     return self.generate();
   });
@@ -240,19 +324,20 @@ File.prototype.transform = function (ast) {
   var self = this;
 
   this.ast = ast;
-  this.scope = new Scope(ast.program);
+  this.lastStatements = t.getLastStatements(ast.program);
+  this.scope = new Scope(ast.program, null, this);
   this.moduleFormatter = this.getModuleFormatter(this.opts.modules);
 
   var astRun = function (key) {
-    _.each(self.transformers, function (transformer) {
-      transformer.astRun(self, key);
+    _.each(self.transformerStack, function (pass) {
+      pass.astRun(key);
     });
   };
 
   astRun("enter");
 
-  _.each(this.transformers, function (transformer) {
-    transformer.transform(self);
+  _.each(this.transformerStack, function (pass) {
+    pass.transform();
   });
 
   astRun("exit");
@@ -264,6 +349,7 @@ File.prototype.generate = function () {
 
   var result = {
     code: "",
+    opts: opts,
     map: null,
     ast: null
   };
@@ -293,22 +379,23 @@ File.prototype.generateUid = function (name, scope) {
   scope = scope || this.scope;
 
   var uid;
+  var i = 0;
   do {
-    uid = this._generateUid(name);
+    uid = this._generateUid(name, i);
+    i++;
   } while (scope.has(uid));
   return uid;
 };
 
 File.prototype.generateUidIdentifier = function (name, scope) {
-  return t.identifier(this.generateUid(name, scope));
+  scope = scope || this.scope;
+  var id = t.identifier(this.generateUid(name, scope));
+  scope.add(id);
+  return id;
 };
 
-File.prototype._generateUid = function (name) {
-  var uids = this.uids;
-  var i = uids[name] || 1;
-
+File.prototype._generateUid = function (name, i) {
   var id = name;
   if (i > 1) id += i;
-  uids[name] = i + 1;
   return "_" + id;
 };

lib/6to5/generation/buffer.js

@@ -1,3 +1,5 @@
+"use strict";
+
 module.exports = Buffer;
 
 var util = require("../util");
@@ -61,39 +63,67 @@ Buffer.prototype.space = function () {
 Buffer.prototype.removeLast = function (cha) {
   if (!this.isLast(cha)) return;
 
-  this.buf = this.buf.slice(0, -1);
+  this.buf = this.buf.substr(0, this.buf.length - 1);
   this.position.unshift(cha);
 };
 
 Buffer.prototype.newline = function (i, removeLast) {
-  if (this.format.compact) return;
-
-  if (_.isBoolean(i)) {
-    removeLast = i;
-    i = null;
+  if (this.format.compact) {
+    this.space();
+    return;
   }
 
+  removeLast = removeLast || false;
+
   if (_.isNumber(i)) {
     if (this.endsWith("{\n")) i--;
     if (this.endsWith(util.repeat(i, "\n"))) return;
 
-    var self = this;
-    _.times(i, function () {
-      self.newline(null, removeLast);
-    });
+    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.buf = this.buf.replace(/\n +$/, "\n");
-
+  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
@@ -115,13 +145,18 @@ Buffer.prototype._push = function (str) {
 };
 
 Buffer.prototype.endsWith = function (str) {
-  return this.buf.slice(-str.length) === 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];
 
-  var chars = [].concat(cha);
-  return _.contains(chars, _.last(buf));
+  if (Array.isArray(cha)) {
+    return _.contains(cha, last);
+  } else {
+    return cha === last;
+  }
 };

lib/6to5/generation/generator.js

@@ -1,3 +1,5 @@
+"use strict";
+
 module.exports = function (ast, opts, code) {
   var gen = new CodeGenerator(ast, opts, code);
   return gen.generate();
@@ -5,21 +7,22 @@ module.exports = function (ast, opts, code) {
 
 module.exports.CodeGenerator = CodeGenerator;
 
-var Whitespace = require("./whitespace");
-var SourceMap  = require("./source-map");
-var Position   = require("./position");
-var Buffer     = require("./buffer");
-var util       = require("../util");
-var n          = require("./node");
-var t          = require("../types");
-var _          = require("lodash");
+var detectIndent = require("detect-indent");
+var Whitespace   = require("./whitespace");
+var SourceMap    = require("./source-map");
+var Position     = require("./position");
+var Buffer       = require("./buffer");
+var util         = require("../util");
+var n            = require("./node");
+var t            = require("../types");
+var _            = require("lodash");
 
 function CodeGenerator(ast, opts, code) {
   opts = opts || {};
 
   this.comments = ast.comments || [];
   this.tokens   = ast.tokens || [];
-  this.format   = CodeGenerator.normaliseOptions(opts);
+  this.format   = CodeGenerator.normaliseOptions(code, opts);
   this.ast      = ast;
 
   this.whitespace = new Whitespace(this.tokens, this.comments);
@@ -34,14 +37,18 @@ _.each(Buffer.prototype, function (fn, key) {
   };
 });
 
-CodeGenerator.normaliseOptions = function (opts) {
+CodeGenerator.normaliseOptions = function (code, opts) {
+  var indent = detectIndent(code);
+  var style  = indent.indent;
+  if (!style || style === " ") style = "  ";
+
   return _.merge({
     parentheses: true,
     comments: opts.comments == null || opts.comments,
     compact: false,
     indent: {
       adjustMultilineComment: true,
-      style: "  ",
+      style: style,
       base: 0
     }
   }, opts.format || {});
@@ -114,6 +121,15 @@ CodeGenerator.prototype.buildPrint = function (parent) {
 CodeGenerator.prototype.print = function (node, parent, opts) {
   if (!node) return "";
 
+  if (parent && parent._compact) {
+    node._compact = true;
+  }
+
+  var oldCompact = this.format.compact;
+  if (node._compact) {
+    this.format.compact = true;
+  }
+
   var self = this;
 
   opts = opts || {};
@@ -125,7 +141,7 @@ CodeGenerator.prototype.print = function (node, parent, opts) {
 
     var lines = 0;
 
-    if (node.start != null) {
+    if (node.start != null && !node._ignoreUserWhitespace) {
       // user node
       if (leading) {
         lines = self.whitespace.getNewlinesBefore(node);
@@ -178,6 +194,8 @@ CodeGenerator.prototype.print = function (node, parent, opts) {
   } else {
     throw new ReferenceError("unknown node of type " + JSON.stringify(node.type) + " with constructor " + JSON.stringify(node && node.constructor.name));
   }
+
+  this.format.compact = oldCompact;
 };
 
 CodeGenerator.prototype.printJoin = function (print, nodes, opts) {

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

@@ -1,3 +1,5 @@
+"use strict";
+
 exports.File = function (node, print) {
   print(node.program);
 };

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

@@ -1,3 +1,5 @@
+"use strict";
+
 exports.ClassExpression =
 exports.ClassDeclaration = function (node, print) {
   this.push("class");

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

@@ -1,3 +1,5 @@
+"use strict";
+
 exports.ComprehensionBlock = function (node, print) {
   this.keyword("for");
   this.push("(");

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

@@ -1,3 +1,5 @@
+"use strict";
+
 var util = require("../../util");
 var t    = require("../../types");
 var _    = require("lodash");
@@ -57,8 +59,28 @@ exports.ThisExpression = function () {
 
 exports.CallExpression = function (node, print) {
   print(node.callee);
+
   this.push("(");
-  print.join(node.arguments, { separator: ", " });
+
+  var separator = ",";
+
+  if (node._prettyCall) {
+    separator += "\n";
+    this.newline();
+    this.indent();
+  } else {
+    separator += " ";
+  }
+
+  print.join(node.arguments, {
+    separator: separator
+  });
+
+  if (node._prettyCall) {
+    this.newline();
+    this.dedent();
+  }
+
   this.push(")");
 };
 
@@ -90,7 +112,9 @@ exports.LogicalExpression =
 exports.AssignmentPattern =
 exports.AssignmentExpression = function (node, print) {
   print(node.left);
-  this.push(" " + node.operator + " ");
+  this.space();
+  this.push(node.operator);
+  this.space();
   print(node.right);
 };
 

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

@@ -1,3 +1,35 @@
-exports.ClassProperty = function () {
-  throw new Error("not implemented");
+"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.VoidTypeAnnotation = function () {
+  // todo: implement these once we have a `--keep-types` option
 };

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

@@ -1,7 +1,9 @@
+"use strict";
+
 var t = require("../../types");
 var _ = require("lodash");
 
-exports.XJSAttribute = function (node, print) {
+exports.JSXAttribute = function (node, print) {
   print(node.name);
   if (node.value) {
     this.push("=");
@@ -9,35 +11,35 @@ exports.XJSAttribute = function (node, print) {
   }
 };
 
-exports.XJSIdentifier = function (node) {
+exports.JSXIdentifier = function (node) {
   this.push(node.name);
 };
 
-exports.XJSNamespacedName = function (node, print) {
+exports.JSXNamespacedName = function (node, print) {
   print(node.namespace);
   this.push(":");
   print(node.name);
 };
 
-exports.XJSMemberExpression = function (node, print) {
+exports.JSXMemberExpression = function (node, print) {
   print(node.object);
   this.push(".");
   print(node.property);
 };
 
-exports.XJSSpreadAttribute = function (node, print) {
+exports.JSXSpreadAttribute = function (node, print) {
   this.push("{...");
   print(node.argument);
   this.push("}");
 };
 
-exports.XJSExpressionContainer = function (node, print) {
+exports.JSXExpressionContainer = function (node, print) {
   this.push("{");
   print(node.expression);
   this.push("}");
 };
 
-exports.XJSElement = function (node, print) {
+exports.JSXElement = function (node, print) {
   var self = this;
 
   var open = node.openingElement;
@@ -57,22 +59,22 @@ exports.XJSElement = function (node, print) {
   print(node.closingElement);
 };
 
-exports.XJSOpeningElement = function (node, print) {
+exports.JSXOpeningElement = function (node, print) {
   this.push("<");
   print(node.name);
   if (node.attributes.length > 0) {
-    this.space();
+    this.push(" ");
     print.join(node.attributes, { separator: " " });
   }
   this.push(node.selfClosing ? " />" : ">");
 };
 
-exports.XJSClosingElement = function (node, print) {
+exports.JSXClosingElement = function (node, print) {
   this.push("</");
   print(node.name);
   this.push(">");
 };
 
-exports.XJSEmptyExpression = function () {
+exports.JSXEmptyExpression = function () {
 
 };

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

@@ -1,30 +1,14 @@
+"use strict";
+
 var t = require("../../types");
 
 exports._params = function (node, print) {
-  var self = this;
-
   this.push("(");
 
   print.join(node.params, {
-    separator: ", ",
-    iterator: function (param, i) {
-      var def = node.defaults && node.defaults[i];
-      if (def) {
-        self.push(" = ");
-        print(def);
-      }
-    }
+    separator: ", "
   });
 
-  if (node.rest) {
-    if (node.params.length) {
-      this.push(", ");
-    }
-
-    this.push("...");
-    print(node.rest);
-  }
-
   this.push(")");
 };
 
@@ -52,7 +36,7 @@ exports._method = function (node, print) {
   }
 
   this._params(value, print);
-  this.space();
+  this.push(" ");
   print(value.body);
 };
 
@@ -61,8 +45,11 @@ exports.FunctionExpression = function (node, print) {
   if (node.async) this.push("async ");
   this.push("function");
   if (node.generator) this.push("*");
-  this.space();
-  if (node.id) print(node.id);
+  this.push(" ");
+  if (node.id) {
+    this.space();
+    print(node.id);
+  }
   this._params(node, print);
   this.space();
   print(node.body);
@@ -71,7 +58,7 @@ exports.FunctionExpression = function (node, print) {
 exports.ArrowFunctionExpression = function (node, print) {
   if (node.async) this.push("async ");
 
-  if (node.params.length === 1 && !node.defaults.length && !node.rest && t.isIdentifier(node.params[0])) {
+  if (node.params.length === 1 && t.isIdentifier(node.params[0])) {
     print(node.params[0]);
   } else {
     this._params(node, print);

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

@@ -1,9 +1,11 @@
+"use strict";
+
 var t = require("../../types");
 var _ = require("lodash");
 
 exports.ImportSpecifier = function (node, print) {
-  if (node.id && node.id.name === "default") {
-    print(node.name);
+  if (t.isSpecifierDefault(node)) {
+    print(t.getSpecifierName(node));
   } else {
     return exports.ExportSpecifier.apply(this, arguments);
   }
@@ -69,7 +71,7 @@ exports.ImportDeclaration = function (node, print) {
         self.push(", ");
       }
 
-      var isDefault = spec.id && spec.id.name === "default";
+      var isDefault = t.isSpecifierDefault(spec);
 
       if (!isDefault && spec.type !== "ImportBatchSpecifier" && !foundImportSpecifier) {
         foundImportSpecifier = true;

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

@@ -1,3 +1,5 @@
+"use strict";
+
 var _ = require("lodash");
 
 _.each(["BindMemberExpression", "BindFunctionExpression"], function (type) {

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

@@ -1,4 +1,7 @@
-var t = require("../../types");
+"use strict";
+
+var util = require("../../util");
+var t    = require("../../types");
 
 exports.WithStatement = function (node, print) {
   this.keyword("with");
@@ -12,12 +15,13 @@ exports.IfStatement = function (node, print) {
   this.keyword("if");
   this.push("(");
   print(node.test);
-  this.push(") ");
+  this.push(")");
+  this.space();
 
   print.indentOnComments(node.consequent);
 
   if (node.alternate) {
-    if (this.isLast("}")) this.space();
+    if (this.isLast("}")) this.push(" ");
     this.keyword("else");
     print.indentOnComments(node.alternate);
   }
@@ -31,13 +35,13 @@ exports.ForStatement = function (node, print) {
   this.push(";");
 
   if (node.test) {
-    this.space();
+    this.push(" ");
     print(node.test);
   }
   this.push(";");
 
   if (node.update) {
-    this.space();
+    this.push(" ");
     print(node.update);
   }
 
@@ -84,7 +88,7 @@ var buildLabelStatement = function (prefix, key) {
 
     var label = node[key || "label"];
     if (label) {
-      this.space();
+      this.push(" ");
       print(label);
     }
 
@@ -106,7 +110,16 @@ exports.TryStatement = function (node, print) {
   this.keyword("try");
   print(node.block);
   this.space();
-  print(node.handler);
+
+  // 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 ");
@@ -132,7 +145,9 @@ exports.SwitchStatement = function (node, print) {
   this.keyword("switch");
   this.push("(");
   print(node.discriminant);
-  this.push(") {");
+  this.push(")");
+  this.space();
+  this.push("{");
   print.sequence(node.cases, { indent: true });
   this.push("}");
 };
@@ -157,7 +172,25 @@ exports.DebuggerStatement = function () {
 exports.VariableDeclaration = function (node, print, parent) {
   this.push(node.kind + " ");
 
-  print.join(node.declarations, { separator: ", " });
+  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.join(node.declarations, { separator: sep });
 
   if (!t.isFor(parent)) {
     this.semicolon();
@@ -173,7 +206,9 @@ exports.PrivateDeclaration = function (node, print) {
 exports.VariableDeclarator = function (node, print) {
   if (node.init) {
     print(node.id);
-    this.push(" = ");
+    this.space();
+    this.push("=");
+    this.space();
     print(node.init);
   } else {
     print(node.id);

lib/6to5/generation/generators/template-literals.js

@@ -1,3 +1,5 @@
+"use strict";
+
 var _ = require("lodash");
 
 exports.TaggedTemplateExpression = function (node, print) {

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

@@ -1,9 +1,12 @@
+"use strict";
+
 var _ = require("lodash");
 
 exports.Identifier = function (node) {
   this.push(node.name);
 };
 
+exports.RestElement =
 exports.SpreadElement =
 exports.SpreadProperty = function (node, print) {
   this.push("...");

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

@@ -1,3 +1,5 @@
+"use strict";
+
 module.exports = Node;
 
 var whitespace = require("./whitespace");
@@ -6,14 +8,19 @@ var t          = require("../../types");
 var _          = require("lodash");
 
 var find = function (obj, node, parent) {
+  if (!obj) return;
   var result;
 
-  _.each(obj, function (fn, type) {
-    if (t["is" + type](node)) {
+  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) return false;
+      if (result != null) break;
     }
-  });
+  }
 
   return result;
 };
@@ -23,13 +30,11 @@ function Node(node, parent) {
   this.node   = node;
 }
 
-Node.prototype.isUserWhitespacable = function () {
-  return t.isUserWhitespacable(this.node);
+Node.isUserWhitespacable = function (node) {
+  return t.isUserWhitespacable(node);
 };
 
-Node.prototype.needsWhitespace = function (type) {
-  var parent = this.parent;
-  var node   = this.node;
+Node.needsWhitespace = function (node, parent, type) {
   if (!node) return 0;
 
   if (t.isExpressionStatement(node)) {
@@ -46,18 +51,15 @@ Node.prototype.needsWhitespace = function (type) {
   return lines || 0;
 };
 
-Node.prototype.needsWhitespaceBefore = function () {
-  return this.needsWhitespace("before");
+Node.needsWhitespaceBefore = function (node, parent) {
+  return Node.needsWhitespace(node, parent, "before");
 };
 
-Node.prototype.needsWhitespaceAfter = function () {
-  return this.needsWhitespace("after");
+Node.needsWhitespaceAfter = function (node, parent) {
+  return Node.needsWhitespace(node, parent, "after");
 };
 
-Node.prototype.needsParens = function () {
-  var parent = this.parent;
-  var node   = this.node;
-
+Node.needsParens = function (node, parent) {
   if (!parent) return false;
 
   if (t.isNewExpression(parent) && parent.callee === node) {
@@ -72,10 +74,7 @@ Node.prototype.needsParens = function () {
   return find(parens, node, parent);
 };
 
-Node.prototype.needsParensNoLineTerminator = function () {
-  var parent = this.parent;
-  var node   = this.node;
-
+Node.needsParensNoLineTerminator = function (node, parent) {
   if (!parent) return false;
 
   // no comments
@@ -95,11 +94,18 @@ Node.prototype.needsParensNoLineTerminator = function () {
   return false;
 };
 
-_.each(Node.prototype, function (fn, key) {
-  Node[key] = function (node, parent) {
-    var n = new Node(node, parent);
+_.each(Node, function (fn, key) {
+  Node.prototype[key] = function () {
+    // Avoid leaking arguments to prevent deoptimization
+    var args = new Array(arguments.length + 2);
 
-    var args = _.toArray(arguments).slice(2);
-    return n[key].apply(n, args);
+    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);
   };
 });

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

@@ -1,3 +1,5 @@
+"use strict";
+
 var t = require("../../types");
 var _ = require("lodash");
 
@@ -21,6 +23,13 @@ _.each([
   });
 });
 
+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" });
@@ -142,8 +151,10 @@ exports.ConditionalExpression = function (node, parent) {
     return true;
   }
 
-  if (t.isCallExpression(parent) && parent.callee === node) {
-    return true;
+  if (t.isCallExpression(parent) || t.isNewExpression(parent)) {
+    if (parent.callee === node) {
+      return true;
+    }
   }
 
   if (t.isConditionalExpression(parent) && parent.test === node) {

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

@@ -1,3 +1,5 @@
+"use strict";
+
 var _ = require("lodash");
 var t = require("../../types");
 
@@ -62,11 +64,15 @@ _.each({
   CallExpression: { after: 1 },
   Literal: { after: 1 }
 }, function (amounts, type) {
-  if (_.isNumber(amounts)) amounts = { after: amounts, before: amounts };
+  if (_.isNumber(amounts)) {
+    amounts = { after: amounts, before: amounts };
+  }
 
-  _.each(amounts, function (amount, key) {
-    exports[key].nodes[type] = function () {
-      return amount;
-    };
+  _.each([type].concat(t.FLIPPED_ALIAS_KEYS[type] || []), function (type) {
+    _.each(amounts, function (amount, key) {
+      exports[key].nodes[type] = function () {
+        return amount;
+      };
+    });
   });
 });

lib/6to5/generation/position.js

@@ -1,6 +1,6 @@
-module.exports = Position;
+"use strict";
 
-var _ = require("lodash");
+module.exports = Position;
 
 function Position() {
   this.line = 1;
@@ -8,26 +8,22 @@ function Position() {
 }
 
 Position.prototype.push = function (str) {
-  var self = this;
-
-  _.each(str, function (cha) {
-    if (cha === "\n") {
-      self.line++;
-      self.column = 0;
+  for (var i = 0; i < str.length; i++) {
+    if (str[i] === "\n") {
+      this.line++;
+      this.column = 0;
     } else {
-      self.column++;
+      this.column++;
     }
-  });
+  }
 };
 
 Position.prototype.unshift = function (str) {
-  var self = this;
-
-  _.each(str, function (cha) {
-    if (cha === "\n") {
-      self.line--;
+  for (var i = 0; i < str.length; i++) {
+    if (str[i] === "\n") {
+      this.line--;
     } else {
-      self.column--;
+      this.column--;
     }
-  });
+  }
 };

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

@@ -1,3 +1,5 @@
+"use strict";
+
 module.exports = SourceMap;
 
 var sourceMap = require("source-map");

lib/6to5/generation/whitespace.js

@@ -1,25 +1,62 @@
+"use strict";
+
 module.exports = Whitespace;
 
-var _ = require("lodash");
+var _    = require("lodash");
+
+/**
+ * Returns `i`th number from `base`, continuing from 0 when `max` is reached.
+ * Useful for shifting `for` loop by a fixed number but going over all items.
+ *
+ * @param {Number} i Current index in the loop
+ * @param {Number} base Start index for which to return 0
+ * @param {Number} max Array length
+ * @returns {Number} shiftedIndex
+ */
+function getLookupIndex(i, base, max) {
+  i += base;
+
+  if (i >= max)
+    i -= max;
+
+  return i;
+}
 
 function Whitespace(tokens, comments) {
   this.tokens = _.sortBy(tokens.concat(comments), "start");
-  this.used   = [];
+  this.used   = {};
+
+  // Profiling this code shows that while generator passes over it, indexes
+  // returned by `getNewlinesBefore` and `getNewlinesAfter` are always increasing.
+
+  // We use this implementation detail for an optimization: instead of always
+  // starting to look from `this.tokens[0]`, we will start `for` loops from the
+  // previous successful match. We will enumerate all tokens—but the common
+  // case will be much faster.
+
+  this._lastFoundIndex = 0;
 }
 
 Whitespace.prototype.getNewlinesBefore = function (node) {
   var startToken;
   var endToken;
   var tokens = this.tokens;
+  var token;
+
+  for (var j = 0; j < tokens.length; j++) {
+    // optimize for forward traversal by shifting for loop index
+    var i = getLookupIndex(j, this._lastFoundIndex, this.tokens.length);
+    token = tokens[i];
 
-  _.each(tokens, function (token, i) {
     // this is the token this node starts with
     if (node.start === token.start) {
       startToken = tokens[i - 1];
       endToken = token;
-      return false;
+
+      this._lastFoundIndex = i;
+      break;
     }
-  });
+  }
 
   return this.getNewlinesBetween(startToken, endToken);
 };
@@ -28,32 +65,44 @@ Whitespace.prototype.getNewlinesAfter = function (node) {
   var startToken;
   var endToken;
   var tokens = this.tokens;
+  var token;
+
+  for (var j = 0; j < tokens.length; j++) {
+    // optimize for forward traversal by shifting for loop index
+    var i = getLookupIndex(j, this._lastFoundIndex, this.tokens.length);
+    token = tokens[i];
 
-  _.each(tokens, function (token, i) {
     // this is the token this node ends with
     if (node.end === token.end) {
       startToken = token;
       endToken = tokens[i + 1];
-      return false;
+
+      this._lastFoundIndex = i;
+      break;
     }
-  });
+  }
 
   if (endToken.type.type === "eof") {
     return 1;
   } else {
-    return this.getNewlinesBetween(startToken, endToken);
+    var lines = this.getNewlinesBetween(startToken, endToken);
+    if (node.type === "Line" && !lines) {
+      // line comment
+      return 1;
+    } else {
+      return lines;
+    }
   }
 };
 
 Whitespace.prototype.getNewlinesBetween = function (startToken, endToken) {
   var start = startToken ? startToken.loc.end.line : 1;
   var end   = endToken.loc.start.line;
-
   var lines = 0;
 
   for (var line = start; line < end; line++) {
-    if (!_.contains(this.used, line)) {
-      this.used.push(line);
+    if (typeof this.used[line] === "undefined") {
+      this.used[line] = true;
       lines++;
     }
   }

lib/6to5/helpers/clone.js

@@ -0,0 +1,12 @@
+"use strict";
+
+module.exports = function cloneDeep(obj) {
+  var obj2 = {};
+  if (!obj) return obj2;
+
+  for (var key in obj) {
+    obj2[key] = obj[key];
+  }
+
+  return obj2;
+};

lib/6to5/helpers/code-frame.js

@@ -0,0 +1,79 @@
+// syntax highlighting based on https://github.com/dominictarr/ansi-highlight by the fantastic Dominic Tarr
+
+var supportsColor = require("supports-color");
+var tokenize      = require("js-tokenizer");
+var chalk         = require("chalk");
+var util          = require("../util");
+
+var defs = {
+  string1:  "red",
+  string2:  "red",
+  punct:    ["white", "bold"],
+  curly:    "green",
+  parens:   ["blue", "bold"],
+  square:   ["yellow"],
+  name:     "white",
+  keyword:  ["cyan"],
+  number:   "magenta",
+  regexp:   "magenta",
+  comment1: "grey",
+  comment2: "grey"
+};
+
+var highlight = function (text) {
+  var colorize = function (str, col) {
+    if (!col) return str;
+
+    if (Array.isArray(col)) {
+      col.forEach(function (col) {
+        str = chalk[col](str);
+      });
+    } else {
+      str = chalk[col](str);
+    }
+    return str;
+  };
+
+  return tokenize(text, true).map(function (str) {
+    var type = tokenize.type(str);
+    return colorize(str, defs[type]);
+  }).join("");
+};
+
+module.exports = function (lines, lineNumber, colNumber) {
+  colNumber = Math.max(colNumber, 0);
+
+  if (supportsColor) {
+    lines = highlight(lines);
+  }
+
+  lines = lines.split("\n");
+
+  var start = Math.max(lineNumber - 3, 0);
+  var end   = Math.min(lines.length, lineNumber + 3);
+  var width = (end + "").length;
+
+  if (!lineNumber && !colNumber) {
+    start = 0;
+    end = lines.length;
+  }
+
+  return "\n" + lines.slice(start, end).map(function (line, i) {
+    var curr = i + start + 1;
+
+    var gutter = curr === lineNumber ? "> " : "  ";
+
+    var sep = curr + util.repeat(width + 1);
+    gutter += sep + "| ";
+
+    var str = gutter + line;
+
+    if (colNumber && curr === lineNumber) {
+      str += "\n";
+      str += util.repeat(gutter.length - 2);
+      str += "|" + util.repeat(colNumber) + "^";
+    }
+
+    return str;
+  }).join("\n");
+};

lib/6to5/helpers/object.js

@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = function () {
+  return Object.create(null);
+};

lib/6to5/helpers/to-fast-properties.js

@@ -0,0 +1,17 @@
+"use strict";
+
+/**
+ * A trick from Bluebird to force V8 to use fast properties for an object.
+ * Read more: http://stackoverflow.com/questions/24987896/
+ *
+ * Use %HasFastProperties(obj) and --allow-natives-syntax to check whether
+ * a particular object already has fast properties.
+ */
+
+module.exports = function toFastProperties(obj) {
+  /*jshint -W027*/
+  function f() {}
+  f.prototype = obj;
+  return f;
+  eval(obj);
+};

lib/6to5/index.js

@@ -1,11 +1,13 @@
+"use strict";
+
 var transform = require("./transformation/transform");
 var util      = require("./util");
 var fs        = require("fs");
 var _         = require("lodash");
 
-exports.types = require("./types");
+exports.version = require("../../package").version;
 
-exports.runtime = require("./runtime-generator");
+exports.types = require("./types");
 
 exports.register = function (opts) {
   var register = require("./register");

lib/6to5/patch.js

@@ -1,22 +1,31 @@
+"use strict";
+
 var t = require("./types");
 var _ = require("lodash");
 
+require("./types/node");
+
 // estraverse
 
 var estraverse = require("estraverse");
 _.extend(estraverse.VisitorKeys, t.VISITOR_KEYS);
 
-// regenerator/recast/ast-types
+// regenerator-6to5/ast-types
 
 var types = require("ast-types");
 var def   = types.Type.def;
 var or    = types.Type.or;
 
+def("File")
+  .bases("Node")
+  .build("program")
+  .field("program", def("Program"));
+
 def("AssignmentPattern")
-    .bases("Pattern")
-    .build("left", "right")
-    .field("left", def("Pattern"))
-    .field("right", def("Expression"));
+  .bases("Pattern")
+  .build("left", "right")
+  .field("left", def("Pattern"))
+  .field("right", def("Expression"));
 
 // Acorn - Same as ImportNamespaceSpecifier but `id` is `name`
 def("ImportBatchSpecifier")
@@ -24,6 +33,11 @@ def("ImportBatchSpecifier")
   .build("name")
   .field("name", def("Identifier"));
 
+def("RestElement")
+  .bases("Node")
+  .build("argument")
+  .field("argument", def("Pattern"));
+
 // Abstract references
 def("VirtualPropertyExpression")
   .bases("Expression")

lib/6to5/polyfill.js

@@ -1,2 +1,9 @@
+"use strict";
+
+if (global._6to5Polyfill) {
+  throw new Error("only one instance of 6to5/polyfill is allowed");
+}
+global._6to5Polyfill = true;
+
 require("core-js/shim");
-require("regenerator/runtime");
+require("regenerator-6to5/runtime");

lib/6to5/register-browser.js

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

lib/6to5/register-cache.js

@@ -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 () {
+  if (!fs.existsSync(FILENAME)) return;
+
+  try {
+    data = JSON.parse(fs.readFileSync(FILENAME));
+  } catch (err) {
+    return;
+  }
+
+  process.on("exit", exports.save);
+
+  var sigint = function () {
+    process.removeListener("SIGINT", sigint);
+    exports.save();
+    process.kill(process.pid, "SIGINT");
+  };
+
+  process.on("SIGINT", sigint);
+};
+
+exports.get = function () {
+  return data;
+};

lib/6to5/register.js

@@ -1,7 +1,9 @@
+"use strict";
+
 require("./polyfill");
 
 var sourceMapSupport = require("source-map-support");
-var roadrunner       = require("roadrunner");
+var registerCache    = require("./register-cache");
 var util             = require("./util");
 var to5              = require("./index");
 var fs               = require("fs");
@@ -23,46 +25,8 @@ sourceMapSupport.install({
 
 //
 
-var blacklist  = [];
-
-var blacklistTest = function (transformer, code) {
-  try {
-    if (_.isFunction(code)) {
-      code();
-    } else {
-      new Function(code);
-    }
-    blacklist.push(transformer);
-  } catch (err) {
-    if (err.name !== "SyntaxError") throw err;
-  }
-};
-
-blacklistTest("arrayComprehension", "var foo = [for (foo of bar) foo * foo];");
-blacklistTest("generatorComprehension", "var foo = (for (foo of bar) foo * foo)");
-blacklistTest("arrowFunctions", "var foo = x => x * x;");
-blacklistTest("classes", "class Foo {}");
-blacklistTest("computedPropertyNames", "var foo = { [foo]: bar };");
-blacklistTest("constants", function () {
-  try {
-    new Function("const foo = 'foo';\nfoo = 'wow';");
-  } catch (err) {
-    return; // constants are supported
-  }
-  throw new SyntaxError;
-});
-blacklistTest("defaultParamaters", "var foo = function (bar = 0) {};");
-blacklistTest("destructuring", "var { x, y } = { x: 0, y: 0 };");
-blacklistTest("forOf", "for (var foo of bar) {}");
-blacklistTest("generators", "function* foo() {}\nasync function bar() {}"); // generators/async functions delegated to same transformer
-blacklistTest("letScoping", "let foo = 0;");
-blacklistTest("modules", 'import foo from "from";');
-blacklistTest("propertyMethodAssignment", "{ get foo() {} }");
-blacklistTest("propertyNameShorthand", "var foo = { x, y };");
-blacklistTest("restParameters", "function foo(...bar) {}");
-blacklistTest("spread", "foo(...bar);");
-blacklistTest("templateLiterals", "var foo = `foo`;");
-blacklistTest("unicodeRegex", function () { new RegExp("foo", "u"); });
+registerCache.load();
+var cache = registerCache.get();
 
 //
 
@@ -70,7 +34,6 @@ var transformOpts = {};
 var ignoreRegex   = /node_modules/;
 var onlyRegex;
 var whitelist     = [];
-var cache;
 var exts          = {};
 var maps          = {};
 var old           = require.extensions[".js"];
@@ -95,7 +58,6 @@ var loader = function (m, filename) {
 
   result = result || to5.transformFileSync(filename, _.extend({
     whitelist: whitelist,
-    blacklist: blacklist,
     sourceMap: true,
     ast:       false
   }, transformOpts));
@@ -123,26 +85,23 @@ var hookExtensions = function (_exts) {
   });
 };
 
-hookExtensions([".es6", ".es", ".js"]);
+hookExtensions(util.canCompile.EXTENSIONS);
 
 module.exports = function (opts) {
   // normalise options
   opts = opts || {};
-  if (_.isRegExp(opts)) opts = { ignore: opts };
-  if (opts.ignoreRegex != null) opts.ignore = opts.ignoreRegex;
 
   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) cache = opts.cache;
   if (opts.cache === false) cache = null;
-  if (opts.cache === true) {
-    roadrunner.load();
-    roadrunner.setup();
-    cache = roadrunner.get("6to5");
-  }
+
+  delete opts.extensions;
+  delete opts.ignore;
+  delete opts.cache;
+  delete opts.only;
 
   _.extend(transformOpts, opts);
 };

lib/6to5/runtime-generator.js

@@ -1,33 +0,0 @@
-var generator = require("./generation/generator");
-var util      = require("./util");
-var File      = require("./file");
-var t         = require("./types");
-var _         = require("lodash");
-
-module.exports = function (namespace) {
-  namespace = t.identifier(t.toIdentifier(namespace || "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([]))
-    )
-  ]));
-
-  _.each(File.helpers, function (name) {
-    if (_.contains(File.excludeHelpersFromRuntime, name)) {
-      return false;
-    }
-
-    var key = t.identifier(t.toIdentifier(name));
-    body.push(t.expressionStatement(
-      t.assignmentExpression("=", t.memberExpression(namespace, key), util.template(name))
-    ));
-  });
-
-  return generator(tree).code;
-};

lib/6to5/transformation/helpers/build-binary-assignment-operator-transformer.js

@@ -0,0 +1,46 @@
+"use strict";
+
+var explode = require("./explode-assignable-expression");
+var t       = require("../../types");
+
+module.exports = function (exports, opts) {
+  var isAssignment = function (node) {
+    return node.operator === opts.operator + "=";
+  };
+
+  var buildAssignment = function (left, right) {
+    return t.assignmentExpression("=", left, right);
+  };
+
+  exports.ExpressionStatement = function (node, parent, scope, context, file) {
+    // hit the `AssignmentExpression` one below
+    if (file.isConsequenceExpressionStatement(node)) return;
+
+    var expr = node.expression;
+    if (!isAssignment(expr)) return;
+
+    var nodes    = [];
+    var exploded = explode(expr.left, nodes, file, scope, true);
+
+    nodes.push(t.expressionStatement(
+      buildAssignment(exploded.ref, opts.build(exploded.uid, expr.right))
+    ));
+
+    return nodes;
+  };
+
+  exports.AssignmentExpression = function (node, parent, scope, context, file) {
+    if (!isAssignment(node)) return;
+
+    var nodes    = [];
+    var exploded = explode(node.left, nodes, file, scope);
+    nodes.push(buildAssignment(exploded.ref, opts.build(exploded.uid, node.right)));
+
+    return t.toSequenceExpression(nodes, scope);
+  };
+
+  exports.BinaryExpression = function (node) {
+    if (node.operator !== opts.operator) return;
+    return opts.build(node.left, node.right);
+  };
+};

lib/6to5/transformation/helpers/build-comprehension.js

@@ -0,0 +1,25 @@
+"use strict";
+
+var t = require("../../types");
+
+module.exports = function build(node, buildBody) {
+  var self = node.blocks.shift();
+  if (!self) return;
+
+  var child = build(node, buildBody);
+  if (!child) {
+    // last item
+    child = buildBody();
+
+    // add a filter as this is our final stop
+    if (node.filter) {
+      child = t.ifStatement(node.filter, t.blockStatement([child]));
+    }
+  }
+
+  return t.forOfStatement(
+    t.variableDeclaration("let", [t.variableDeclarator(self.left)]),
+    self.right,
+    t.blockStatement([child])
+  );
+};

lib/6to5/transformation/helpers/build-conditional-assignment-operator-transformer.js

@@ -0,0 +1,47 @@
+"use strict";
+
+var explode = require("./explode-assignable-expression");
+var t       = require("../../types");
+
+module.exports = function (exports, opts) {
+  var buildAssignment = function (left, right) {
+    return t.assignmentExpression("=", left, right);
+  };
+
+  exports.ExpressionStatement = function (node, parent, scope, context, file) {
+    // hit the `AssignmentExpression` one below
+    if (file.isConsequenceExpressionStatement(node)) return;
+
+    var expr = node.expression;
+    if (!opts.is(expr, file)) return;
+
+    var nodes = [];
+
+    var exploded = explode(expr.left, nodes, file, scope);
+
+    nodes.push(t.ifStatement(
+      opts.build(exploded.uid, file),
+      t.expressionStatement(buildAssignment(exploded.ref, expr.right))
+    ));
+
+    return nodes;
+  };
+
+  exports.AssignmentExpression = function (node, parent, scope, context, file) {
+    if (!opts.is(node, file)) return;
+
+    var nodes    = [];
+    var exploded = explode(node.left, nodes, file, scope);
+
+    nodes.push(t.logicalExpression(
+      "&&",
+      opts.build(exploded.uid, file),
+      buildAssignment(exploded.ref, node.right)
+    ));
+
+    // todo: duplicate expression node
+    nodes.push(exploded.ref);
+
+    return t.toSequenceExpression(nodes, scope);
+  };
+};

lib/6to5/transformation/helpers/explode-assignable-expression.js

@@ -0,0 +1,73 @@
+"use strict";
+
+var t = require("../../types");
+
+var getObjRef = function (node, nodes, file, scope) {
+  var ref;
+  if (t.isIdentifier(node)) {
+    if (scope.has(node.name, true)) {
+      // this variable is declared in scope so we can be 100% sure
+      // that evaluating it multiple times wont trigger a getter
+      // or something else
+      return node;
+    } else {
+      // could possibly trigger a getter so we need to only evaluate
+      // it once
+      ref = node;
+    }
+  } else if (t.isMemberExpression(node)) {
+    ref = node.object;
+
+    if (t.isIdentifier(ref) && scope.has(ref.name)) {
+      // the object reference that we need to save is locally declared
+      // so as per the previous comment we can be 100% sure evaluating
+      // it multiple times will be safe
+      return ref;
+    }
+  } else {
+    throw new Error("We can't explode this node type " + node.type);
+  }
+
+  var temp = scope.generateUidBasedOnNode(ref);
+  nodes.push(t.variableDeclaration("var", [
+    t.variableDeclarator(temp, ref)
+  ]));
+  return temp;
+};
+
+var getPropRef = function (node, nodes, file, scope) {
+  var prop = node.property;
+  var key = t.toComputedKey(node, prop);
+  if (t.isLiteral(key)) return key;
+
+  var temp = scope.generateUidBasedOnNode(prop);
+  nodes.push(t.variableDeclaration("var", [
+    t.variableDeclarator(temp, prop)
+  ]));
+  return temp;
+};
+
+module.exports = function (node, nodes, file, scope, allowedSingleIdent) {
+  var obj;
+  if (t.isIdentifier(node) && allowedSingleIdent) {
+    obj = node;
+  } else {
+    obj = getObjRef(node, nodes, file, scope);
+  }
+
+  var ref, uid;
+
+  if (t.isIdentifier(node)) {
+    ref = node;
+    uid = obj;
+  } else {
+    var prop = getPropRef(node, nodes, file, scope);
+    var computed = node.computed || t.isLiteral(prop);
+    uid = ref = t.memberExpression(obj, prop, computed);
+  }
+
+  return {
+    uid: uid,
+    ref: ref
+  };
+};

lib/6to5/transformation/helpers/name-method.js

@@ -0,0 +1,51 @@
+"use strict";
+
+var traverse = require("../../traverse");
+var util     = require("../../util");
+var t        = require("../../types");
+
+var visitor = {
+  enter: function (node, parent, scope, context, state) {
+    // check if this node is an identifier that matches the same as our function id
+    if (!t.isIdentifier(node, { name: state.id })) return;
+
+    // check if this node is the one referenced
+    if (!t.isReferenced(node, parent)) return;
+
+    // check that we don't have a local variable declared as that removes the need
+    // for the wrapper
+    var localDeclar = scope.get(state.id, true);
+    if (localDeclar !== state.outerDeclar) return;
+
+    state.selfReference = true;
+    context.stop();
+  }
+};
+
+exports.property = function (node, file, scope) {
+  var key = t.toComputedKey(node, node.key);
+  if (!t.isLiteral(key)) return node; // we can't set a function id with this
+
+  var id = t.toIdentifier(key.value);
+  key = t.identifier(id);
+
+  var state = {
+    id: id,
+    selfReference: false,
+    outerDeclar: scope.get(id, true),
+  };
+
+  traverse(node, visitor, scope, state);
+
+  if (state.selfReference) {
+    // todo: support generators
+    node.value = util.template("property-method-assignment-wrapper", {
+      FUNCTION: node.value,
+      FUNCTION_ID: key,
+      FUNCTION_KEY: scope.generateUidIdentifier(id),
+      WRAPPER_KEY: scope.generateUidIdentifier(id + "Wrapper")
+    });
+  } else {
+    node.value.id = key;
+  }
+};

lib/6to5/transformation/helpers/remap-async-to-generator.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var traverse = require("../../traverse");
+var t        = require("../../types");
+
+var visitor = {
+  enter: function (node, parent, scope, context) {
+    if (t.isFunction(node)) context.skip();
+
+    if (t.isAwaitExpression(node)) {
+      node.type = "YieldExpression";
+    }
+  }
+};
+
+module.exports = function (node, callId, scope) {
+  node.async = false;
+  node.generator = true;
+
+  traverse(node, visitor, scope);
+
+  var call = t.callExpression(callId, [node]);
+  var id = node.id;
+  delete node.id;
+
+  if (t.isFunctionDeclaration(node)) {
+    var declar = t.variableDeclaration("let", [
+      t.variableDeclarator(id, call)
+    ]);
+    declar._blockHoist = true;
+    return declar;
+  } else {
+    return call;
+  }
+};

lib/6to5/transformation/helpers/replace-supers.js

@@ -0,0 +1,251 @@
+"use strict";
+
+module.exports = ReplaceSupers;
+
+var traverse = require("../../traverse");
+var t        = require("../../types");
+
+/**
+ * Description
+ *
+ * @param {Object} opts
+ */
+
+function ReplaceSupers(opts) {
+  this.topLevelThisReference = null;
+  this.methodNode            = opts.methodNode;
+  this.className             = opts.className;
+  this.superName             = opts.superName;
+  this.isLoose               = opts.isLoose;
+  this.scope                 = opts.scope;
+  this.file                  = opts.file;
+}
+
+/**
+ * Gets a node representing the super class value of the named property.
+ *
+ * @example
+ *
+ *   _get(Object.getPrototypeOf(CLASS.prototype), "METHOD", this)
+ *
+ * @param {Node} property
+ * @param {boolean} isStatic
+ * @param {boolean} isComputed
+ *
+ * @returns {Node}
+ */
+
+ReplaceSupers.prototype.superProperty = function (property, isStatic, isComputed, thisExpression) {
+  return t.callExpression(
+    this.file.addHelper("get"),
+    [
+      t.callExpression(
+        t.memberExpression(t.identifier("Object"), t.identifier("getPrototypeOf")),
+        [
+          isStatic ? this.className : t.memberExpression(this.className, t.identifier("prototype"))
+        ]
+      ),
+      isComputed ? property : t.literal(property.name),
+      thisExpression
+    ]
+  );
+};
+
+/**
+ * Description
+ *
+ * @param {Object} node
+ * @param {Object} id
+ * @param {Object} parent
+ * @returns {Object}
+ */
+
+ReplaceSupers.prototype.looseSuperProperty = function (methodNode, id, parent) {
+  var methodName = methodNode.key;
+  var superName  = this.superName || t.identifier("Function");
+
+  if (parent.property === id) {
+    return;
+  } else if (t.isCallExpression(parent, { callee: id })) {
+    // super(); -> ClassName.prototype.MethodName.call(this);
+    parent.arguments.unshift(t.thisExpression());
+
+    if (methodName.name === "constructor") {
+      // constructor() { super(); }
+      return t.memberExpression(superName, t.identifier("call"));
+    } else {
+      id = superName;
+
+      // foo() { super(); }
+      if (!methodNode.static) {
+        id = t.memberExpression(id, t.identifier("prototype"));
+      }
+
+      id = t.memberExpression(id, methodName, methodNode.computed);
+      return t.memberExpression(id, t.identifier("call"));
+    }
+  } else if (t.isMemberExpression(parent) && !methodNode.static) {
+    // super.test -> ClassName.prototype.test
+    return t.memberExpression(superName, t.identifier("prototype"));
+  } else {
+    return superName;
+  }
+};
+
+/**
+ * Description
+ */
+
+ReplaceSupers.prototype.replace = function () {
+  this.traverseLevel(this.methodNode.value, true);
+};
+
+var visitor = {
+  enter: function (node, parent, scope, context, state) {
+    var topLevel = state.topLevel;
+    var self = state.self;
+
+    if (t.isFunction(node) && !t.isArrowFunctionExpression(node)) {
+      // we need to call traverseLevel again so we're context aware
+      self.traverseLevel(node, false);
+      return context.skip();
+    }
+
+    if (t.isProperty(node, { method: true }) || t.isMethodDefinition(node)) {
+      // break on object methods
+      return context.skip();
+    }
+
+    var getThisReference = topLevel ?
+      // top level so `this` is the instance
+      t.thisExpression :
+      // not in the top level so we need to create a reference
+      self.getThisReference;
+
+    var callback = self.specHandle;
+    if (self.isLoose) callback = self.looseHandle;
+    return callback.call(self, getThisReference, node, parent);
+  }
+};
+
+/**
+ * Description
+ *
+ * @param {Object} node
+ * @param {Boolean} topLevel
+ */
+
+ReplaceSupers.prototype.traverseLevel = function (node, topLevel) {
+  var state = { self: this, topLevel: topLevel };
+  traverse(node, visitor, this.scope, state);
+};
+
+/**
+ * Description
+ */
+
+ReplaceSupers.prototype.getThisReference = function () {
+  if (this.topLevelThisReference) {
+    return this.topLevelThisReference;
+  } else {
+    var ref = this.topLevelThisReference = this.file.generateUidIdentifier("this");
+    this.methodNode.value.body.body.unshift(t.variableDeclaration("var", [
+      t.variableDeclarator(this.topLevelThisReference, t.thisExpression())
+    ]));
+    return ref;
+  }
+};
+
+/**
+ * Description
+ *
+ * @param {Function} getThisReference
+ * @param {Object} node
+ * @param {Object} parent
+ */
+
+ReplaceSupers.prototype.looseHandle = function (getThisReference, node, parent) {
+  if (t.isIdentifier(node, { name: "super" })) {
+    return this.looseSuperProperty(this.methodNode, node, parent);
+  } else if (t.isCallExpression(node)) {
+    var callee = node.callee;
+    if (!t.isMemberExpression(callee)) return;
+    if (callee.object.name !== "super") return;
+
+    // super.test(); -> ClassName.prototype.MethodName.call(this);
+    t.appendToMemberExpression(callee, t.identifier("call"));
+    node.arguments.unshift(getThisReference());
+  }
+};
+
+/**
+ * Description
+ *
+ * @param {Function} getThisReference
+ * @param {Object} node
+ * @param {Object} parent
+ */
+
+ReplaceSupers.prototype.specHandle = function (getThisReference, node, parent) {
+  var methodNode = this.methodNode;
+  var property;
+  var computed;
+  var args;
+
+  if (t.isIdentifier(node, { name: "super" })) {
+    if (!(t.isMemberExpression(parent) && !parent.computed && parent.property === node)) {
+      throw this.file.errorWithNode(node, "illegal use of bare super");
+    }
+  } else if (t.isCallExpression(node)) {
+    var callee = node.callee;
+    if (t.isIdentifier(callee, { name: "super" })) {
+      // super(); -> _get(Object.getPrototypeOf(ClassName), "MethodName", this).call(this);
+      property = methodNode.key;
+      computed = methodNode.computed;
+      args = node.arguments;
+
+      // bare `super` call is illegal inside non-constructors
+      //  - https://esdiscuss.org/topic/super-call-in-methods
+      //  - https://twitter.com/wycats/status/544553184396836864
+      if (methodNode.key.name !== "constructor") {
+        var methodName = methodNode.key.name || "METHOD_NAME";
+        throw this.file.errorWithNode(node, "Direct super call is illegal in non-constructor, use super." + methodName + "() instead");
+      }
+    } else {
+      if (!t.isMemberExpression(callee)) return;
+      if (callee.object.name !== "super") return;
+
+      // super.test(); -> _get(Object.getPrototypeOf(ClassName.prototype), "test", this).call(this);
+      property = callee.property;
+      computed = callee.computed;
+      args = node.arguments;
+    }
+  } else if (t.isMemberExpression(node)) {
+    if (!t.isIdentifier(node.object, { name: "super" })) return;
+
+    // super.name; -> _get(Object.getPrototypeOf(ClassName.prototype), "name", this);
+    property = node.property;
+    computed = node.computed;
+  }
+
+  if (!property) return;
+
+  var thisReference = getThisReference();
+  var superProperty = this.superProperty(property, methodNode.static, computed, thisReference);
+  if (args) {
+    if (args.length === 1 && t.isSpreadElement(args[0])) {
+      // super(...arguments);
+      return t.callExpression(
+        t.memberExpression(superProperty, t.identifier("apply")),
+        [thisReference, args[0].argument]
+      );
+    } else {
+      return t.callExpression(
+        t.memberExpression(superProperty, t.identifier("call")),
+        [thisReference].concat(args)
+      );
+    }
+  } else {
+    return superProperty;
+  }
+};

lib/6to5/transformation/helpers/use-strict.js

@@ -1,13 +1,15 @@
+"use strict";
+
 var t = require("../../types");
 
-exports._has = function (node) {
+exports.has = function (node) {
   var first = node.body[0];
   return t.isExpressionStatement(first) && t.isLiteral(first.expression, { value: "use strict" });
 };
 
-exports._wrap = function (node, callback) {
+exports.wrap = function (node, callback) {
   var useStrictNode;
-  if (exports._has(node)) {
+  if (exports.has(node)) {
     useStrictNode = node.body.shift();
   }
 
@@ -17,11 +19,3 @@ exports._wrap = function (node, callback) {
     node.body.unshift(useStrictNode);
   }
 };
-
-exports.ast = {
-  exit: function (ast) {
-    if (!exports._has(ast.program)) {
-      ast.program.body.unshift(t.expressionStatement(t.literal("use strict")));
-    }
-  }
-};

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

@@ -1,30 +1,135 @@
+"use strict";
+
 module.exports = DefaultFormatter;
 
 var traverse = require("../../traverse");
+var object   = require("../../helpers/object");
 var util     = require("../../util");
 var t        = require("../../types");
 var _        = require("lodash");
 
 function DefaultFormatter(file) {
   this.file = file;
+  this.ids  = object();
+
+  this.hasNonDefaultExports = false;
+
+  this.hasLocalExports = false;
+  this.hasLocalImports = false;
+
+  this.localImportOccurences = object();
+  this.localExports = object();
+  this.localImports = object();
+
+  this.getLocalExports();
+  this.getLocalImports();
 
-  this.localExports = this.getLocalExports();
   this.remapAssignments();
 }
 
-DefaultFormatter.prototype.getLocalExports = function () {
-  var localExports = {};
+DefaultFormatter.prototype.doDefaultExportInterop = function (node) {
+  return node.default && !this.noInteropRequire && !this.hasNonDefaultExports;
+};
 
-  traverse(this.file.ast, {
-    enter: function (node) {
-      var declar = node && node.declaration;
-      if (t.isExportDeclaration(node) && declar && t.isStatement(declar)) {
-        _.extend(localExports, t.getIds(declar, true));
+DefaultFormatter.prototype.bumpImportOccurences = function (node) {
+  var source = node.source.value;
+  var occurs = this.localImportOccurences;
+  occurs[source] = occurs[source] || 0;
+  occurs[source] += node.specifiers.length;
+};
+
+var exportsVisitor = {
+  enter: function (node, parent, scope, context, formatter) {
+    var declar = node && node.declaration;
+    if (t.isExportDeclaration(node)) {
+      formatter.hasLocalImports = true;
+
+      if (declar && t.isStatement(declar)) {
+        _.extend(formatter.localExports, t.getIds(declar, true));
+      }
+
+      if (!node.default) {
+        formatter.hasNonDefaultExports = true;
+      }
+
+      if (node.source) {
+        formatter.bumpImportOccurences(node);
       }
     }
-  });
+  }
+};
 
-  return localExports;
+DefaultFormatter.prototype.getLocalExports = function () {
+  traverse(this.file.ast, exportsVisitor, this.file.scope, this);
+};
+
+var importsVisitor = {
+  enter: function (node, parent, scope, context, formatter) {
+    if (t.isImportDeclaration(node)) {
+      formatter.hasLocalImports = true;
+      _.extend(formatter.localImports, t.getIds(node, true));
+      formatter.bumpImportOccurences(node);
+    }
+  }
+};
+
+DefaultFormatter.prototype.getLocalImports = function () {
+  traverse(this.file.ast, importsVisitor, this.file.scope, this);
+};
+
+var remapVisitor = {
+  enter: function (node, parent, scope, context, formatter) {
+    if (t.isUpdateExpression(node) && formatter.isLocalReference(node.argument, scope)) {
+      context.skip();
+
+      // expand to long file assignment expression
+      var assign = t.assignmentExpression(node.operator[0] + "=", node.argument, t.literal(1));
+
+      // remap this assignment expression
+      var remapped = formatter.remapExportAssignment(assign);
+
+      // we don't need to change the result
+      if (t.isExpressionStatement(parent) || node.prefix) {
+        return remapped;
+      }
+
+      var nodes = [];
+      nodes.push(remapped);
+
+      var operator;
+      if (node.operator === "--") {
+        operator = "+";
+      } else { // "++"
+        operator = "-";
+      }
+      nodes.push(t.binaryExpression(operator, node.argument, t.literal(1)));
+
+      return t.sequenceExpression(nodes);
+    }
+
+    if (t.isAssignmentExpression(node) && formatter.isLocalReference(node.left, scope)) {
+      context.skip();
+      return formatter.remapExportAssignment(node);
+    }
+  }
+};
+
+DefaultFormatter.prototype.remapAssignments = function () {
+  if (this.hasLocalImports) {
+    traverse(this.file.ast, remapVisitor, this.file.scope, this);
+  }
+};
+
+DefaultFormatter.prototype.isLocalReference = function (node) {
+  var localImports = this.localImports;
+  return t.isIdentifier(node) && localImports[node.name] && localImports[node.name] !== node;
+};
+
+DefaultFormatter.prototype.checkLocalReference = function (node) {
+  var file = this.file;
+  if (this.isLocalReference(node)) {
+    throw file.errorWithNode(node, "Illegal assignment of module import");
+  }
 };
 
 DefaultFormatter.prototype.remapExportAssignment = function (node) {
@@ -39,51 +144,10 @@ DefaultFormatter.prototype.remapExportAssignment = function (node) {
   );
 };
 
-DefaultFormatter.prototype.remapAssignments = function () {
+DefaultFormatter.prototype.isLocalReference = function (node, scope) {
   var localExports = this.localExports;
-  var self = this;
-
-  var isLocalReference = function (node, scope) {
-    var name = node.name;
-    return t.isIdentifier(node) && localExports[name] && localExports[name] === scope.get(name, true);
-  };
-
-  traverse(this.file.ast, {
-    enter: function (node, parent, scope) {
-      if (t.isUpdateExpression(node) && isLocalReference(node.argument, scope)) {
-        this.skip();
-
-        // expand to long file assignment expression
-        var assign = t.assignmentExpression(node.operator[0] + "=", node.argument, t.literal(1));
-
-        // remap this assignment expression
-        var remapped = self.remapExportAssignment(assign);
-
-        // we don't need to change the result
-        if (t.isExpressionStatement(parent) || node.prefix) {
-          return remapped;
-        }
-
-        var nodes = [];
-        nodes.push(remapped);
-
-        var operator;
-        if (node.operator === "--") {
-          operator = "+";
-        } else { // "++"
-          operator = "-";
-        }
-        nodes.push(t.binaryExpression(operator, node.argument, t.literal(1)));
-
-        return t.sequenceExpression(nodes);
-      }
-
-      if (t.isAssignmentExpression(node) && isLocalReference(node.left, scope)) {
-        this.skip();
-        return self.remapExportAssignment(node);
-      }
-    }
-  });
+  var name = node.name;
+  return t.isIdentifier(node) && localExports[name] && localExports[name] === scope.get(name, true);
 };
 
 DefaultFormatter.prototype.getModuleName = function () {
@@ -105,11 +169,16 @@ DefaultFormatter.prototype.getModuleName = function () {
     filenameRelative = filenameRelative.replace(sourceRootRegEx, "");
   }
 
-  // remove extension
-  filenameRelative = filenameRelative.replace(/\.(.*?)$/, "");
+  if (!opts.keepModuleIdExtensions) {
+    // remove extension
+    filenameRelative = filenameRelative.replace(/\.(.*?)$/, "");
+  }
 
   moduleName += filenameRelative;
 
+  // normalise path separators
+  moduleName = moduleName.replace(/\\/g, "/");
+
   return moduleName;
 };
 
@@ -132,24 +201,37 @@ DefaultFormatter.prototype._hoistExport = function (declar, assign, priority) {
   return assign;
 };
 
-DefaultFormatter.prototype._exportSpecifier = function (getRef, specifier, node, nodes) {
+DefaultFormatter.prototype.getExternalReference = function (node, nodes) {
+  var ids = this.ids;
+  var id = node.source.value;
+
+  if (ids[id]) {
+    return ids[id];
+  } else {
+    return this.ids[id] = this._getExternalReference(node, nodes);
+  }
+};
+
+DefaultFormatter.prototype.exportSpecifier = function (specifier, node, nodes) {
   var inherits = false;
   if (node.specifiers.length === 1) inherits = node;
 
   if (node.source) {
+    var ref = this.getExternalReference(node, nodes);
+
     if (t.isExportBatchSpecifier(specifier)) {
       // export * from "foo";
-      nodes.push(this._exportsWildcard(getRef(), node));
+      nodes.push(this.buildExportsWildcard(ref, node));
     } else {
-      var ref;
-      if (t.isSpecifierDefault(specifier.id) || this.noInteropRequire) {
-        ref = t.memberExpression(getRef(), specifier.id);
+      if (t.isSpecifierDefault(specifier) && !this.noInteropRequire) {
+        // importing a default so we need to normalise it
+        ref = t.callExpression(this.file.addHelper("interop-require"), [ref]);
       } else {
-        ref = t.callExpression(this.file.addHelper("interop-require"), [getRef()]);
+        ref = t.memberExpression(ref, t.getSpecifierId(specifier));
       }
 
       // export { foo } from "test";
-      nodes.push(this._exportsAssign(
+      nodes.push(this.buildExportsAssignment(
         t.getSpecifierName(specifier),
         ref,
         node
@@ -157,17 +239,18 @@ DefaultFormatter.prototype._exportSpecifier = function (getRef, specifier, node,
     }
   } else {
     // export { foo };
-    nodes.push(this._exportsAssign(t.getSpecifierName(specifier), specifier.id, node));
+    nodes.push(this.buildExportsAssignment(t.getSpecifierName(specifier), specifier.id, node));
   }
 };
 
-DefaultFormatter.prototype._exportsWildcard = function (objectIdentifier) {
-  return t.expressionStatement(t.callExpression(this.file.addHelper("exports-wildcard"), [
+DefaultFormatter.prototype.buildExportsWildcard = function (objectIdentifier) {
+  return t.expressionStatement(t.callExpression(this.file.addHelper("defaults"), [
+    t.identifier("exports"),
     t.callExpression(this.file.addHelper("interop-require-wildcard"), [objectIdentifier])
   ]));
 };
 
-DefaultFormatter.prototype._exportsAssign = function (id, init) {
+DefaultFormatter.prototype.buildExportsAssignment = function (id, init) {
   return util.template("exports-assign", {
     VALUE: init,
     KEY:   id
@@ -186,13 +269,13 @@ DefaultFormatter.prototype.exportDeclaration = function (node, nodes) {
   var assign;
 
   if (t.isVariableDeclaration(declar)) {
-    for (var i in declar.declarations) {
+    for (var i = 0; i < declar.declarations.length; i++) {
       var decl = declar.declarations[i];
 
-      decl.init = this._exportsAssign(decl.id, decl.init, node).expression;
+      decl.init = this.buildExportsAssignment(decl.id, decl.init, node).expression;
 
       var newDeclar = t.variableDeclaration(declar.kind, [decl]);
-      if (i === "0") t.inherits(newDeclar, declar);
+      if (i === 0) t.inherits(newDeclar, declar);
       nodes.push(newDeclar);
     }
   } else {
@@ -203,7 +286,7 @@ DefaultFormatter.prototype.exportDeclaration = function (node, nodes) {
       nodes.push(declar);
     }
 
-    assign = this._exportsAssign(id, ref, node);
+    assign = this.buildExportsAssignment(id, ref, node);
 
     nodes.push(assign);
 

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

@@ -0,0 +1,14 @@
+"use strict";
+
+var util = require("../../util");
+
+module.exports = function (Parent) {
+  var Constructor = function () {
+    this.noInteropRequire = true;
+    Parent.apply(this, arguments);
+  };
+
+  util.inherits(Constructor, Parent);
+
+  return Constructor;
+};

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

@@ -0,0 +1,3 @@
+"use strict";
+
+module.exports = require("./_strict")(require("./amd"));

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

@@ -1,13 +1,15 @@
+"use strict";
+
 module.exports = AMDFormatter;
 
 var DefaultFormatter = require("./_default");
+var CommonFormatter  = require("./common");
 var util             = require("../../util");
 var t                = require("../../types");
 var _                = require("lodash");
 
 function AMDFormatter() {
-  DefaultFormatter.apply(this, arguments);
-  this.ids  = {};
+  CommonFormatter.apply(this, arguments);
 }
 
 util.inherits(AMDFormatter, DefaultFormatter);
@@ -30,12 +32,15 @@ AMDFormatter.prototype.transform = function (ast) {
 
   // build an array of module names
 
-  var names = [t.literal("exports")].concat(this.buildDependencyLiterals());
+  var names = [t.literal("exports")];
+  if (this.passModuleArg) names.push(t.literal("module"));
+  names = names.concat(this.buildDependencyLiterals());
   names = t.arrayExpression(names);
 
   // build up define container
 
   var params = _.values(this.ids);
+  if (this.passModuleArg) params.unshift(t.identifier("module"));
   params.unshift(t.identifier("exports"));
 
   var container = t.functionExpression(null, params, t.blockStatement(body));
@@ -62,33 +67,30 @@ AMDFormatter.prototype.getModuleName = function () {
   }
 };
 
-AMDFormatter.prototype._push = function (node) {
-  var id  = node.source.value;
-  var ids = this.ids;
-
-  if (ids[id]) {
-    return ids[id];
-  } else {
-    return this.ids[id] = this.file.generateUidIdentifier(id);
-  }
+AMDFormatter.prototype._getExternalReference = function (node) {
+  return this.file.generateUidIdentifier(node.source.value);
 };
 
 AMDFormatter.prototype.importDeclaration = function (node) {
-  this._push(node);
+  this.getExternalReference(node);
 };
 
 AMDFormatter.prototype.importSpecifier = function (specifier, node, nodes) {
   var key = t.getSpecifierName(specifier);
-  var ref = this._push(node);
+  var ref = this.getExternalReference(node);
 
-  if (t.isImportBatchSpecifier(specifier)) {
+  if (_.contains(this.file.dynamicImported, node)) {
+    // Prevent unnecessary renaming of dynamic imports.
+    this.ids[node.source.value] = key;
+    return;
+  } else if (t.isImportBatchSpecifier(specifier)) {
     // import * as bar from "foo";
   } else if (t.isSpecifierDefault(specifier) && !this.noInteropRequire) {
     // import foo from "foo";
     ref = t.callExpression(this.file.addHelper("interop-require"), [ref]);
   } else {
     // import {foo} from "foo";
-    ref = t.memberExpression(ref, specifier.id, false);
+    ref = t.memberExpression(ref, t.getSpecifierId(specifier), false);
   }
 
   nodes.push(t.variableDeclaration("var", [
@@ -96,9 +98,10 @@ AMDFormatter.prototype.importSpecifier = function (specifier, node, nodes) {
   ]));
 };
 
-AMDFormatter.prototype.exportSpecifier = function (specifier, node, nodes) {
-  var self = this;
-  return this._exportSpecifier(function () {
-    return self._push(node);
-  }, specifier, node, nodes);
+AMDFormatter.prototype.exportDeclaration = function (node) {
+  if (this.doDefaultExportInterop(node)) {
+    this.passModuleArg = true;
+  }
+
+  CommonFormatter.prototype.exportDeclaration.apply(this, arguments);
 };

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

@@ -0,0 +1,3 @@
+"use strict";
+
+module.exports = require("./_strict")(require("./common"));

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

@@ -1,20 +1,18 @@
+"use strict";
+
 module.exports = CommonJSFormatter;
 
 var DefaultFormatter = require("./_default");
-var traverse         = require("../../traverse");
 var util             = require("../../util");
 var t                = require("../../types");
+var _                = require("lodash");
 
 function CommonJSFormatter(file) {
   DefaultFormatter.apply(this, arguments);
 
-  var hasNonDefaultExports = false;
-  traverse(file.ast, {
-    enter: function (node) {
-      if (t.isExportDeclaration(node) && !node.default) hasNonDefaultExports = true;
-    }
-  });
-  this.hasNonDefaultExports = hasNonDefaultExports;
+  if (this.hasNonDefaultExports) {
+    file.ast.program.body.push(util.template("exports-module-declaration", true));
+  }
 }
 
 util.inherits(CommonJSFormatter, DefaultFormatter);
@@ -22,15 +20,14 @@ util.inherits(CommonJSFormatter, DefaultFormatter);
 CommonJSFormatter.prototype.importSpecifier = function (specifier, node, nodes) {
   var variableName = t.getSpecifierName(specifier);
 
+  var ref = this.getExternalReference(node, nodes);
+
   // import foo from "foo";
   if (t.isSpecifierDefault(specifier)) {
-    nodes.push(t.variableDeclaration("var", [
-      t.variableDeclarator(variableName,
-        t.callExpression(this.file.addHelper("interop-require"), [util.template("require", {
-          MODULE_NAME: node.source
-        })])
-      )
-    ]));
+    if (!_.contains(this.file.dynamicImported, node)) {
+      ref = t.callExpression(this.file.addHelper("interop-require"), [ref]);
+    }
+    nodes.push(t.variableDeclaration("var", [t.variableDeclarator(variableName, ref)]));
   } else {
     if (specifier.type === "ImportBatchSpecifier") {
       // import * as bar from "foo";
@@ -38,17 +35,18 @@ CommonJSFormatter.prototype.importSpecifier = function (specifier, node, nodes)
         t.variableDeclarator(
           variableName,
           t.callExpression(this.file.addHelper("interop-require-wildcard"), [
-            t.callExpression(t.identifier("require"), [node.source])
+            ref
           ])
         )
       ]));
     } else {
-      // import foo from "foo";
-      nodes.push(util.template("require-assign-key", {
-        VARIABLE_NAME: variableName,
-        MODULE_NAME:   node.source,
-        KEY:           specifier.id
-      }));
+      // import { foo } from "foo";
+      nodes.push(t.variableDeclaration("var", [
+        t.variableDeclarator(
+          variableName,
+          t.memberExpression(ref, t.getSpecifierId(specifier))
+        )
+      ]));
     }
   }
 };
@@ -61,43 +59,35 @@ CommonJSFormatter.prototype.importDeclaration = function (node, nodes) {
 };
 
 CommonJSFormatter.prototype.exportDeclaration = function (node, nodes) {
-  if (node.default) {
+  if (this.doDefaultExportInterop(node)) {
     var declar = node.declaration;
-    var assign;
+    var assign = util.template("exports-default-assign", {
+      VALUE: this._pushStatement(declar, nodes)
+    }, true);
 
-    // module.exports = VALUE;
-    var templateName = "exports-default-module";
-
-    // exports = module.exports = VALUE;
-    if (this.hasNonDefaultExports) templateName = "exports-default-module-override";
-
-    if (t.isFunctionDeclaration(declar) || !this.hasNonDefaultExports) {
-      assign = util.template(templateName, {
-        VALUE: this._pushStatement(declar, nodes)
-      }, true);
-
-      // hoist to the top if this default is a function
-      nodes.push(this._hoistExport(declar, assign, 3));
-      return;
-    } else {
-      // this export isn't a function so we can't hoist it to the top so we need to set it
-      // at the very end of the file with something like:
-      //
-      //   module.exports = Object.assign(exports["default"], exports)
-      //
-
-      assign = util.template("common-export-default-assign", true);
-      assign._blockHoist = 0;
-
-      nodes.push(assign);
+    if (t.isFunctionDeclaration(declar)) {
+      // we can hoist this assignment to the top of the file
+      assign._blockHoist = 3;
     }
+
+    nodes.push(assign);
+    return;
   }
 
   DefaultFormatter.prototype.exportDeclaration.apply(this, arguments);
 };
 
-CommonJSFormatter.prototype.exportSpecifier = function (specifier, node, nodes) {
-  this._exportSpecifier(function () {
-    return t.callExpression(t.identifier("require"), [node.source]);
-  }, specifier, node, nodes);
+CommonJSFormatter.prototype._getExternalReference = function (node, nodes) {
+  var source = node.source.value;
+  var call = t.callExpression(t.identifier("require"), [node.source]);
+
+  if (this.localImportOccurences[source] > 1) {
+    var uid = this.file.generateUidIdentifier(source);
+    nodes.push(t.variableDeclaration("var", [
+      t.variableDeclarator(uid, call)
+    ]));
+    return uid;
+  } else {
+    return call;
+  }
 };

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

@@ -1,3 +1,5 @@
+"use strict";
+
 module.exports = IgnoreFormatter;
 
 var t = require("../../types");

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

@@ -0,0 +1,10 @@
+module.exports = {
+  commonStrict: require("./common-strict"),
+  amdStrict:    require("./amd-strict"),
+  umdStrict:    require("./umd-strict"),
+  common:       require("./common"),
+  system:       require("./system"),
+  ignore:       require("./ignore"),
+  amd:          require("./amd"),
+  umd:          require("./umd")
+};

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

@@ -1,17 +1,20 @@
+"use strict";
+
 module.exports = SystemFormatter;
 
-var AMDFormatter = require("./amd");
-var useStrict    = require("../transformers/use-strict");
-var traverse     = require("../../traverse");
-var util         = require("../../util");
-var t            = require("../../types");
-var _            = require("lodash");
+var DefaultFormatter = require("./_default");
+var AMDFormatter     = require("./amd");
+var useStrict        = require("../helpers/use-strict");
+var traverse         = require("../../traverse");
+var util             = require("../../util");
+var t                = require("../../types");
+var _                = require("lodash");
 
 function SystemFormatter(file) {
-  this.exportIdentifier  = file.generateUidIdentifier("export");
+  this.exportIdentifier = file.generateUidIdentifier("export");
   this.noInteropRequire = true;
 
-  AMDFormatter.apply(this, arguments);
+  DefaultFormatter.apply(this, arguments);
 }
 
 util.inherits(SystemFormatter, AMDFormatter);
@@ -21,7 +24,7 @@ SystemFormatter.prototype._addImportSource = function (node, exportNode) {
   return node;
 };
 
-SystemFormatter.prototype._exportsWildcard = function (objectIdentifier, node) {
+SystemFormatter.prototype.buildExportsWildcard = function (objectIdentifier, node) {
   var leftIdentifier = this.file.generateUidIdentifier("key");
   var valIdentifier  = t.memberExpression(objectIdentifier, leftIdentifier, true);
 
@@ -38,7 +41,7 @@ SystemFormatter.prototype._exportsWildcard = function (objectIdentifier, node) {
   return this._addImportSource(t.forInStatement(left, right, block), node);
 };
 
-SystemFormatter.prototype._exportsAssign = function (id, init, node) {
+SystemFormatter.prototype.buildExportsAssignment = function (id, init, node) {
   var call = this.buildExportCall(t.literal(id.name), init, true);
   return this._addImportSource(call, node);
 };
@@ -61,31 +64,95 @@ SystemFormatter.prototype.importSpecifier = function (specifier, node, nodes) {
   this._addImportSource(_.last(nodes), node);
 };
 
+var runnerSettersVisitor = {
+  enter: function (node, parent, scope, context, state) {
+    if (node._importSource === state.source) {
+      if (t.isVariableDeclaration(node)) {
+        _.each(node.declarations, function (declar) {
+          state.hoistDeclarators.push(t.variableDeclarator(declar.id));
+          state.nodes.push(t.expressionStatement(
+            t.assignmentExpression("=", declar.id, declar.init)
+          ));
+        });
+      } else {
+        state.nodes.push(node);
+      }
+
+      context.remove();
+    }
+  }
+};
+
 SystemFormatter.prototype.buildRunnerSetters = function (block, hoistDeclarators) {
+  var scope = this.file.scope;
+
   return t.arrayExpression(_.map(this.ids, function (uid, source) {
-    var nodes = [];
+    var state = {
+      source:           source,
+      nodes:            [],
+      hoistDeclarators: hoistDeclarators
+    };
 
-    traverse(block, {
-      enter: function (node) {
-        if (node._importSource === source) {
-          if (t.isVariableDeclaration(node)) {
-            _.each(node.declarations, function (declar) {
-              hoistDeclarators.push(t.variableDeclarator(declar.id));
-              nodes.push(t.expressionStatement(
-                t.assignmentExpression("=", declar.id, declar.init)
-              ));
-            });
-          } else {
-            nodes.push(node);
-          }
+    traverse(block, runnerSettersVisitor, scope, state);
 
-          this.remove();
+    return t.functionExpression(null, [uid], t.blockStatement(state.nodes));
+  }));
+};
+
+var hoistVariablesVisitor = {
+  enter: function (node, parent, scope, context, hoistDeclarators) {
+    if (t.isFunction(node)) {
+      // nothing inside is accessible
+      return context.skip();
+    }
+
+    if (t.isVariableDeclaration(node)) {
+      if (node.kind !== "var" && !t.isProgram(parent)) { // let, const
+        // can't be accessed
+        return;
+      }
+
+      // ignore block hoisted nodes as these can be left in
+      if (node._blockHoist) return;
+
+      var nodes = [];
+
+      for (var i = 0; i < node.declarations.length; i++) {
+        var declar = node.declarations[i];
+        hoistDeclarators.push(t.variableDeclarator(declar.id));
+        if (declar.init) {
+          // no initializer so we can just hoist it as-is
+          var assign = t.expressionStatement(t.assignmentExpression("=", declar.id, declar.init));
+          nodes.push(assign);
         }
       }
-    });
 
-    return t.functionExpression(null, [uid], t.blockStatement(nodes));
-  }));
+      // for (var i in test)
+      // for (var i = 0;;)
+      if (t.isFor(parent)) {
+        if (parent.left === node) {
+          return node.declarations[0].id;
+        }
+
+        if (parent.init === node) {
+          return t.toSequenceExpression(nodes, scope);
+        }
+      }
+
+      return nodes;
+    }
+  }
+};
+
+var hoistFunctionsVisitor = {
+  enter: function (node, parent, scope, context, handlerBody) {
+    if (t.isFunction(node)) context.skip();
+
+    if (t.isFunctionDeclaration(node) || node._blockHoist) {
+      handlerBody.push(node);
+      context.remove();
+    }
+  }
 };
 
 SystemFormatter.prototype.transform = function (ast) {
@@ -111,46 +178,8 @@ SystemFormatter.prototype.transform = function (ast) {
   var returnStatement = handlerBody.pop();
 
   // hoist up all variable declarations
-  traverse(block, {
-    enter: function (node, parent, scope) {
-      if (t.isFunction(node)) {
-        // nothing inside is accessible
-        return this.skip();
-      }
+  traverse(block, hoistVariablesVisitor, this.file.scope, hoistDeclarators);
 
-      if (t.isVariableDeclaration(node)) {
-        if (node.kind !== "var" && !t.isProgram(parent)) { // let, const
-          // can't be accessed
-          return;
-        }
-
-        var nodes = [];
-
-        _.each(node.declarations, function (declar) {
-          hoistDeclarators.push(t.variableDeclarator(declar.id));
-          if (declar.init) {
-            // no initializer so we can just hoist it as-is
-            var assign = t.expressionStatement(t.assignmentExpression("=", declar.id, declar.init));
-            nodes.push(assign);
-          }
-        });
-
-        // for (var i in test)
-        // for (var i = 0;;)
-        if (t.isFor(parent)) {
-          if (parent.left === node) {
-            return node.declarations[0].id;
-          }
-
-          if (parent.init === node) {
-            return t.toSequenceExpression(nodes, scope);
-          }
-        }
-
-        return nodes;
-      }
-    }
-  });
   if (hoistDeclarators.length) {
     var hoistDeclar = t.variableDeclaration("var", hoistDeclarators);
     hoistDeclar._blockHoist = true;
@@ -158,20 +187,11 @@ SystemFormatter.prototype.transform = function (ast) {
   }
 
   // hoist up function declarations for circular references
-  traverse(block, {
-    enter: function (node) {
-      if (t.isFunction(node)) this.skip();
-
-      if (t.isFunctionDeclaration(node) || node._blockHoist) {
-        handlerBody.push(node);
-        this.remove();
-      }
-    }
-  });
+  traverse(block, hoistFunctionsVisitor, this.file.scope, handlerBody);
 
   handlerBody.push(returnStatement);
 
-  if (useStrict._has(block)) {
+  if (useStrict.has(block)) {
     handlerBody.unshift(block.body.shift());
   }
 

lib/6to5/transformation/modules/umd-strict

@@ -0,0 +1,3 @@
+"use strict";
+
+module.exports = require("./_strict")(require("./umd"));

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

@@ -1,3 +1,5 @@
+"use strict";
+
 module.exports = UMDFormatter;
 
 var AMDFormatter = require("./amd");
@@ -25,22 +27,44 @@ UMDFormatter.prototype.transform = function (ast) {
   // factory
 
   var ids  = _.values(this.ids);
-  var args = [t.identifier("exports")].concat(ids);
+  var args = [t.identifier("exports")];
+  if (this.passModuleArg) args.push(t.identifier("module"));
+  args = args.concat(ids);
 
   var factory = t.functionExpression(null, args, t.blockStatement(body));
 
-  // runner
+  // amd
+
+  var defineArgs = [t.literal("exports")];
+  if (this.passModuleArg) defineArgs.push(t.literal("module"));
+  defineArgs = defineArgs.concat(names);
+  defineArgs = [t.arrayExpression(defineArgs)];
+
+  // common
+
+  var testExports = util.template("test-exports");
+  var testModule  = util.template("test-module");
+  var commonTests = this.passModuleArg ? t.logicalExpression("&&", testExports, testModule) : testExports;
+
+  var commonArgs = [t.identifier("exports")];
+  if (this.passModuleArg) commonArgs.push(t.identifier("module"));
+  commonArgs = commonArgs.concat(names.map(function (name) {
+    return t.callExpression(t.identifier("require"), [name]);
+  }));
+
+  // globals
+
+  //var umdArgs = [];
+
+  //
 
-  var defineArgs = [t.arrayExpression([t.literal("exports")].concat(names))];
   var moduleName = this.getModuleName();
   if (moduleName) defineArgs.unshift(t.literal(moduleName));
 
   var runner = util.template("umd-runner-body", {
     AMD_ARGUMENTS: defineArgs,
-
-    COMMON_ARGUMENTS: names.map(function (name) {
-      return t.callExpression(t.identifier("require"), [name]);
-    })
+    COMMON_TEST: commonTests,
+    COMMON_ARGUMENTS: commonArgs
   });
 
   //

lib/6to5/transformation/templates/array-comprehension-for-each.js

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

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

@@ -3,35 +3,26 @@
     var gen = fn.apply(this, arguments);
 
     return new Promise(function (resolve, reject) {
-      function step(getNext) {
-        var next;
+      var callNext = step.bind(gen.next);
+      var callThrow = step.bind(gen.throw);
 
+      function step(arg) {
         try {
-          next = getNext();
-        } catch(e) {
-          reject(e);
+          var info = this(arg);
+          var value = info.value;
+        } catch (error) {
+          reject(error);
           return;
         }
 
-        if (next.done) {
-          resolve(next.value);
-          return;
+        if (info.done) {
+          resolve(value);
+        } else {
+          Promise.resolve(value).then(callNext, callThrow);
         }
-
-        Promise.resolve(next.value).then(function (v) {
-          step(function () {
-            return gen.next(v);
-          });
-        }, function (e) {
-          step(function () {
-            return gen["throw"](e);
-          });
-        });
       }
 
-      step(function () {
-        return gen.next();
-      });
+      callNext();
     });
-  }
+  };
 })

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

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

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+exports.__esModule = true;

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

@@ -1,7 +0,0 @@
-(function (obj) {
-  for (var i in obj) {
-    if (exports[i] !== undefined) {
-      exports[i] = obj[i];
-    }
-  }
-})

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

@@ -0,0 +1,11 @@
+(function (target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i];
+    for (var key in source) {
+      if (Object.prototype.hasOwnProperty.call(source, key)) {
+        target[key] = source[key];
+      }
+    }
+  }
+  return target;
+})

lib/6to5/transformation/templates/for-of-loose.js

@@ -0,0 +1,13 @@
+for (var LOOP_OBJECT = OBJECT,
+         IS_ARRAY = Array.isArray(LOOP_OBJECT),
+         INDEX = 0,
+         LOOP_OBJECT = IS_ARRAY ? LOOP_OBJECT : LOOP_OBJECT[Symbol.iterator]();;) {
+  if (IS_ARRAY) {
+    if (INDEX >= LOOP_OBJECT.length) break;
+    ID = LOOP_OBJECT[INDEX++];
+  } else {
+    INDEX = LOOP_OBJECT.next();
+    if (INDEX.done) break;
+    ID = INDEX.value;
+  }
+}

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

@@ -0,0 +1,23 @@
+(function get(object, property, receiver) {
+  var desc = Object.getOwnPropertyDescriptor(object, property);
+
+  if (desc === undefined) {
+    var parent = Object.getPrototypeOf(object);
+
+    if (parent === null) {
+      return undefined;
+    } else {
+      return get(parent, property, receiver);
+    }
+  } else if ("value" in desc && desc.writable) {
+    return desc.value;
+  } else {
+    var getter = desc.get;
+
+    if (getter === undefined) {
+      return undefined;
+    }
+
+    return getter.call(receiver);
+  }
+});

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

@@ -1,14 +1,14 @@
-(function (child, parent) {
-  if (typeof parent !== "function" && parent !== null) {
-    throw new TypeError("Super expression must either be null or a function, not " + typeof parent);
+(function (subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
   }
-  child.prototype = Object.create(parent && parent.prototype, {
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
     constructor: {
-      value: child,
+      value: subClass,
       enumerable: false,
       writable: true,
       configurable: true
     }
   });
-  if (parent) child.__proto__ = parent;
+  if (superClass) subClass.__proto__ = superClass;
 })