v5.1.9

This reverts commit dd84b554e6.

.babelrc

@@ -0,0 +1,6 @@
+{
+  "experimental": true,
+  "playground": true,
+  "loose": true,
+  "blacklist": ["es6.tailCall"]
+}

.editorconfig

@@ -4,8 +4,8 @@ root = true
 insert_final_newline = true
 charset = utf-8
 trim_trailing_whitespace = true
-insert_final_newline = true
+end_of_line = lf
 
-[*.js]
+[*.{js,json}]
 indent_style = space
 indent_size = 2

.eslintignore

@@ -0,0 +1 @@
+src/babel/transformation/templates

.eslintrc

@@ -0,0 +1,22 @@
+{
+  "parser": "babel-eslint",
+  "rules": {
+    "strict": 0,
+    "no-underscore-dangle": 0,
+    "no-unused-vars": 0,
+    "curly": 0,
+    "no-multi-spaces": 0,
+    "key-spacing": 0,
+    "no-return-assign": 0,
+    "consistent-return": 0,
+    "no-shadow": 0,
+    "no-comma-dangle": 0,
+    "no-use-before-define": 0,
+    "no-empty": 0,
+    "new-parens": 0,
+    "no-cond-assign": 0
+  },
+  "env": {
+    "node": true
+  }
+}

.gitignore

@@ -1,9 +1,17 @@
 .DS_Store
 node_modules
-test/tmp
+test/core/tmp
 *.log
 *.cache
 /templates.json
+/tests.json
 /browser.js
+/browser-polyfill.js
+/runtime.js
 coverage
 dist
+.package.json
+packages/babel-runtime/core-js
+packages/babel-runtime/helpers/*.js
+packages/babel-runtime/regenerator/*.js
+lib

.gitmodules

@@ -0,0 +1,12 @@
+[submodule "vendor/traceur"]
+	path = vendor/traceur
+	url = https://github.com/google/traceur-compiler
+[submodule "vendor/regenerator"]
+	path = vendor/regenerator
+	url = https://github.com/babel/regenerator-babel
+[submodule "vendor/test262"]
+	path = vendor/test262
+	url = https://github.com/tc39/test262
+[submodule "vendor/compat-table"]
+	path = vendor/compat-table
+	url = https://github.com/kangax/compat-table

.istanbul.yml

@@ -0,0 +1,2 @@
+instrumentation:
+  root: lib

.jshintignore

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

.jshintrc

@@ -1,28 +0,0 @@
-{
-  "esnext": true,
-  "indent": 2,
-  "freeze": true,
-  "camelcase": true,
-  "unused": true,
-  "eqnull": true,
-  "proto": true,
-  "newcap": true,
-  "supernew": true,
-  "noyield": true,
-  "evil": true,
-  "node": true,
-  "boss": true,
-  "expr": true,
-  "undef": true,
-  "loopfunc": true,
-  "white": true,
-  "maxparams": 5,
-  "maxdepth": 4,
-
-  "globals": {
-    "suite": true,
-    "set": true,
-    "before": true,
-    "bench": true
-  }
-}

.npmignore

@@ -1,10 +1,15 @@
-node_modules
 *.log
 *.cache
-lib/6to5/templates
-test
-benchmark
-Makefile
 .*
-dist
-!README.md
+/lib/babel/transformation/templates
+/test
+/benchmark
+/Makefile
+/dist
+/tests.json
+/CHANGELOG.md
+/.package.json
+/coverage
+/vendor
+/packages
+/src

.travis.yml

@@ -1,16 +1,19 @@
+sudo: false
 language: node_js
+cache:
+  directories:
+    - node_modules
 node_js:
-  - "0.10"
-  - "0.11"
-
-branches:
-  except:
-   - experimental
+  - "0.12"
+  - "iojs"
 
 before_script: "npm install -g codeclimate-test-reporter"
 script: "make test-travis"
 
-addons:
-  code_climate:
-    repo_token:
-      secure: "PfP9sDUJzSznDb+ZEPO2cignXabSTXJxEVm5ESRPgEcFr+/4b0pt3hI8R9b+9mLtBEwtw3DLUq48MOeqEKnq29csQmpjPVcN6gT4uR2DdNa1JpVgDuwxT05NB3fBea9U2reM73iV8ylCgPHExr2uGR9/87JzR2beY/56EUL5NjY="
+notifications:
+  webhooks:
+    urls:
+      - https://webhooks.gitter.im/e/acf1870e9d223c65e8d5
+    on_success: always
+    on_failure: always
+    on_start: false

CHANGELOG.md

@@ -0,0 +1,495 @@
+# Changelog
+
+> **Tags:**
+> - [New Feature]
+> - [Bug Fix]
+> - [Spec Compliancy]
+> - [Breaking Change]
+> - [Documentation]
+> - [Internal]
+> - [Polish]
+
+_Note: Gaps between patch versions are faulty/broken releases._
+
+See [CHANGELOG - 6to5](CHANGELOG-6to5.md) for the pre-4.0.0 version changelog.
+
+## 5.1.9
+
+ * **Bug Fix**
+  * Fix class property initializers with `undefined` values not being correctly writable.
+  * Fix self inferring generators incorrectly causing a stack error.
+ * **Internal**
+  * Upgrade to latest `acorn`.
+ * **Polish**
+  * Make invalid LHS pattern error messages nicer.
+
+## 5.1.8
+
+ * **Bug Fix**
+  * Only make parenthesized object pattern LHS illegal.
+
+## 5.1.7
+
+ * **Internal**
+  * Add `parse` node API.
+
+## 5.1.6
+
+ * **Bug Fix**
+  * Fix `runtime` built-in catchall not properly checking for local variables.
+
+## 5.1.5
+
+ * **Internal**
+  * Bump `core-js` version.
+
+## 5.1.4
+
+ * **Polish**
+  * Add missing `Reflect` methods to runtime transformer.
+
+## 5.1.3
+
+ * **Internal**
+  * Switch entirely to vanilla regenerator.
+  * Clean up and make the parsing of decorators stateless.
+ * **Bug Fix**
+  * Don't do TCO on generators and async functions.
+  * Add missing `core-js` runtime definitions.
+
+## 5.1.2
+
+ * **Bug Fix**
+  * Add `getIterator` and `isIterable` to `babel-runtime` build script.
+
+## 5.1.1
+
+ * **Bug Fix**
+  * Add missing runtime symbol definitions.
+
+## 5.1.0
+
+ * **Bug Fix**
+  * Fix super reference when using decorators.
+  * Don't do array unpack optimisation when member expressions are present.
+  * Add missing descriptors for undecorated class properties.
+  * Don't consider `arguments` and `eval` valid function names when doing function name inferrence.
+  * Fix scope tracking of constants in loop heads.
+  * Parse `AwaitExpression` as a unary instead of an assignment.
+  * Fix regex evaluation when attempting static evaluation.
+  * Don't emit tokens when doing a lookahead.
+  * Add missing `test` declaration to `utility.deadCodeElimination` transformer.
+ * **Internal**
+  * Upgrade `regenerator` to the latest and use my branch with the hope of eventually switching to vanilla regenerator.
+  * Add support for the replacement of for loop `init`s with statements.
+  * Upgrade dependencies.
+ * **Polish**
+  * When adding the scope IIFE when using default parameters, don't shadow the function expression, just `apply` `this` and `arguments` if necessary.
+  * Use path basename as non-default import fallback.
+ * **New Feature**
+  * Add [trailing function comma proposal](https://github.com/jeffmo/es-trailing-function-commas). Thanks [@AluisioASG](https://github.com/AluisioASG)!
+  * Add support for object literal decorators.
+  * Make core-js modular when using the `runtime` transformer.
+
+## 5.0.12
+
+ * **Bug Fix**
+  * Fix incorrect remapping of module references inside of a function id redirection container.
+
+## 5.0.11
+
+ * **Bug Fix**
+  * Fix new `for...of` loops not properly inheriting their original loop.
+ * **Internal**
+  * Disable scope instance cache.
+ * **Polish**
+  * Allow comments in `.babelrc` JSON.
+
+## 5.0.9
+
+ * **Polish**
+  * Use `moduleId` for UMD global name if available.
+ * **Bug Fix**
+  * Fix UMD global `module` variable shadowing the `amd`/`common` `module` variable.
+  * Fix Flow param type annotation regression.
+  * Fix function name collision `toString` wrapper. Thanks [@alawatthe](https://github.com/alawatthe)!
+
+## 5.0.8
+
+ * **Bug Fix**
+  * Fix falsy static class properties not being writable.
+  * Fix block scoping collisions not properly detecting modules and function clashes.
+  * Skip `this` before `super` for derived constructors on functions.
+
+## 5.0.7
+
+ * **New Feature**
+  * Add `--ignore` and `--only` support to the CLI.
+ * **Bug Fix**
+  * Remove `HOMEPATH` environment variable from home resolution in `babel/register` cache.
+ * **Internal**
+  * Disable WIP path resolution introducing infinite recursion in some code examples.
+ * **Polish**
+  * Add live binding to CommonJS default imports.
+
+## 5.0.6
+
+ * **Bug Fix**
+  * Fix mangling of import references that collide with properties on `Object.prototype`.
+  * Fix duplicate declarations incorrectly being reported for `var`.
+
+## 5.0.5
+
+ * **Internal**
+  * Upgrade `core-js`.
+ * **Bug Fix**
+  * Fix arrays not being supported in `util.list`.
+
+## 5.0.4
+
+ * **Polish**
+  * Check for top level `breakConfig` in `resolveRc`.
+
+## 5.0.3
+
+ * **Bug Fix**
+  * Make relative location absolute before calling `resolveRc`.
+ * **Internal**
+  * Switch to global UID registry.
+  * Add `breakConfig` option to prevent Babel from erroring when hitting that option.
+
+## 5.0.1
+
+ * **Bug Fix**
+  * Fix duplicate declaration regression.
+  * Fix not being able to call non-writable methods.
+
+## 5.0.0
+
+ * **New Feature**
+  * Decorators based on [@wycat's](https://github.com/wycats) [stage 1 proposal](https://github.com/wycats/javascript-decorators).
+  * Class property initializers based on [@jeffmo's](https://github.com/jeffmo) [stage 0 proposal](https://gist.github.com/jeffmo/054df782c05639da2adb).
+  * Export extensions based on [@leebyron's](https://github.com/leebyron) [stage 1 proposal](https://github.com/leebyron/ecmascript-more-export-from).
+  * UMD module formatter now supports globals.
+  * Add `es3.runtime`, `optimisation.react.inlineElements` and `optimisation.react.constantElements` transformers.
+  * Add stage option that replaces the experimental one.
+  * Allow ES7 transformer to be enabled via `optional` instead of only via `stage`.
+  * Infer string quotes to use in the code generator.
+  * Consider `export { foo as default  };` to be the same as `export default foo;`.
+  * Add `nonStandard` option that can be set to `false` to remove parser support for JSX and Flow.
+  * Add `jsxPragma` option.
+  * Automatically generate CLI options based on internal API options.
+  * Add support for `.babelrc` on absolute paths.
+  * Plugin API!
+ * **Internal**
+  * Export `options` in browser API.
+  * Rewritten parser.
+  * Don't block hoist when runtime transformer is enabled in system module formatter.
+  * Rewritten the internal traversal and node replacement API to use "paths" that abstracts out node relationships.
+ * **Polish**
+  * JSX output is now more inline with the official JSX transformer.
+  * Hoist block scoping IIFE - this improves memory usage and performance.
+  * Better IIFE detection - references are now checked to see if they're referencing the binding we're searching for.
+  * Check for import reassignments in constants transformer.
+  * Make method definitions with expression bodies illegal.
+  * Save register cache on tick instead of `SIGINT`.
+  * Enable strict mode on babel-node eval flag.
+ * **Bug Fixes**
+  * Add support for live bindings. This change also increases the reliablity of export specifier renaming.
+  * Add support for super update and non equals assignment expressions.
+  * Rename shadow constructor binding in classes.
+  * Seed next iteration bindings with previous fresh bindings when reassinging loop block scoped variables.
+  * Fix new expression spread referencing the wrong constructor.
+  * Call `resolveModuleSource` on dynamic imports.
+  * Added `param` to list of duplicate declaration kinds.
+ * **Breaking Changes**
+  * The Babel playground has been removed.
+  * ES7 Abstract References have been removed.
+  * Experimental option has been removed in favor of a stage option.
+  * Rename `returnUsedHelpers` to `metadataUsedHelpers`.
+
+## 4.7.16
+
+ * **Bug Fix**
+  * Fix constructor spreading of typed arrays.
+  * Fix break/continue/return aliasing of non-loops in block scoping transformer.
+
+## 4.7.15
+
+ * **Bug Fix**
+  * Fix constructor spreading of collections.
+
+## 4.7.14
+
+ * **Bug Fix**
+  * Fix constructor spreading of `Promise`.
+ * **Internal**
+  * Deprecate remaining playground transformers and abstract references.
+
+## 4.7.13
+
+ * **Bug Fix**
+  * Handle comments on use strict directives.
+  * Fix assignment patterns with a left side pattern.
+ * **Polish**
+  * Special case `this` when doing expression memoisation.
+
+## 4.7.12
+
+ * **Bug Fix**
+  * Deprecate `playground.methodBinding`.
+
+## 4.7.11
+
+ * **Bug Fix**
+  * Fix unicode regexes stripping their unicode flag before being passed on two `regexpu`.
+
+## 4.7.10
+
+ * **Internal**
+  * Deprecate `playground.methodBinding` and `playground.objectGetterMemoization`.
+ * **Bug Fix**
+  * Fix `inputSourceMap` option. Thanks [@Rich-Harris](https://github.com/Rich-Harris)!
+
+## 4.7.9
+
+ * **Polish**
+  * Allow `inputSourceMap` to be set to `false` to skip the source map inference.
+  * Infer computed literal property names.
+ * **Bug Fix**
+  * Fix nested labeled for-ofs.
+  * Fix block scoping `break` colliding with the parent switch case.
+ * **Internal**
+  * Upgrade `acorn-babel`.
+
+## 4.7.8
+
+ * **Bug Fix**
+  * Fix computed classes not properly setting symbols.
+
+## 4.7.7
+
+ * **Bug Fix**
+  * Fix `types` API exposure.
+
+## 4.7.6
+
+ * **Bug Fix**
+  * Fix non-Identifier/Literal computed class methods.
+ * **Polish**
+  * Add a fallback if `stack` on an error is unconfigurable.
+  * Hoist `esModule` module declarations to the top of the file to handle circular dependencies better.
+
+## 4.7.5
+
+ * **Bug Fix**
+  * Don't remap` break`s to call the iterator return.
+ * **Polish**
+  * Use a different helper for computed classes for much nicer output. Also fixes a bug in symbols being non-enumerable so they wouldn't be set on the class.
+
+## 4.7.4
+
+ * **Bug Fix**
+  * Rewrite named function expressions in optional async function transformers.
+  * Hoist directives.
+  * Remove `Number` from the list of valid `runtime` constructors.
+ * **Internal**
+  * `spec.typeofSymbol` transformer has been renamed to `es6.symbols`.
+
+## 4.7.2
+
+ * **New Feature**
+  * `"both"` option for `sourceMap`.
+  * Add output types to external helpers. Thanks [@neVERberleRfellerER](https://github.com/neVERberleRfellerER)!
+ * **Bug Fix**
+  * Fix node duplication sometimes resulting in a recursion error.
+  * Ignore `break`s within cases inside `for...of`.
+ * **Polish**
+  * Split up variable declarations and export declarations to allow easier transformation.
+
+## 4.7.0
+
+ * **Bug Fix**
+  * Add `alternate` to list of `STATEMENT_OR_BLOCK` keys.
+  * Add support for module specifiers to `t.isReferenced`.
+ * **New Feature**
+  * Add `inputSourceMap` option.
+ * **Polish**
+  * Throw an error on different `babel` and `babel-runtime` versions.
+  * Replicate module environment for `babel-node` eval.
+  * Clean up classes output.
+ * **Spec Compliancy**
+  * Make it illegal to use a rest parameter on a setter.
+
+## 4.6.6
+
+ * **Bug Fix**
+  * Fix incorrect method call in `utility.deadCodeElimination` transformer.
+  * Fix `es6.blockScopingTDZ` transformer duplicating binding nodes.
+
+## 4.6.5
+
+ * **Internal**
+  * `useStrict` transformer has been renamed to `strict`.
+
+## 4.6.4
+
+ * **Bug Fix**
+  * Fix `ForOfStatement` not proplery inheriting labels.
+  * When in closure mode in block scoping transformer, properly check for variable shadowing.
+ * **New Feature**
+  * New `utility.inlineEnvironmentVariables` and `utility.inlineExpression` transformers.
+
+## 4.6.3
+
+ * **Bug Fix**
+  * Fix `arguments` being incorrectly aliased in arrow function rest parameter optimisation.
+  * Make deoptimisation trigger safer.
+ * **New Feature**
+  * Flow types are now retained when blacklisting the `flow` transformer.
+
+## 4.6.1
+
+ * **Bug Fix**
+  * Fix generators in template directory being transformed.
+  * Fix exposure of `util` for plugins.
+
+## 4.6.0
+
+ * **New Feature**
+  * Desugar sticky regexes to a new constructor expression so it can be handled by a polyfill.
+ * **Spec Compliancy**
+  * `for...of` now outputs in a lengthy `try...catch` this is to ensure spec compliancy in regards to iterator returns and abrupt completions. See [google/traceur-compiler#1773](https://github.com/google/traceur-compiler/issues/1773) and [babel/babel/#838](https://github.com/babel/babel/issues/838) for more information.
+ * **Polish**
+  * Rest parameters that are only refered to via number properties on member expressions are desugared into a direct `arguments` reference. Thanks [@neVERberleRfellerER](https://github.com/neVERberleRfellerER)!
+  * `$ babel` no longer exits on syntax errors.
+ * **Internal**
+  * Upgrade `browserify`.
+  * Upgrade `source-map`.
+  * Publicly expose more internals.
+
+## 4.5.5
+
+ * **Polish**
+  * Delete old extensions when overriding them in `babel/register`.
+
+## 4.5.3
+
+ * **Bug Fix**
+  * Fix whitelisting logic for helper build script.
+
+## 4.5.2
+
+ * **New Feature**
+  * `returnUsedHelpers` option and add whitelist to `buildHelpers`.
+ * **Bug Fix**
+  * Fix function arity on self referencing inferred named functions.
+ * **Internal**
+  * Bump `acorn-babel`.
+  * Start converting source to ES6...
+
+## 4.5.1
+
+**Babel now compiles itself!**
+
+![holy shit](http://gifsec.com/wp-content/uploads/GIF/2014/03/OMG-GIF_2.gif)
+
+## 4.5.0
+
+ * **New Feature**
+  * Add `.babelrc` support.
+ * **Bug Fix**
+  * Move use strict directives to the module formatter bodies.
+ * **Internal**
+  * Make default `bin/babel` behaviour to ignore non-compilable files and add a `--copy-files` flag to revert to the old behaviour.
+
+## 4.4.6
+
+ * **Bug Fix**
+  * Fix extending a class expression with no methods/only constructor. Thanks [@neVERberleRfellerER](https://github.com/neVERberleRfellerER)!
+  * Allow `MemberExpression` as a valid `left` of `ForOfStatement`.
+ * **Polish**
+  * Throw an error when people try and transpile code with the `@jsx React.DOM` pragma as it conflicts with the custom jsx constructo method detection.
+  * Crawl all comments for `@jsx` pragma.
+ * **Internal**
+  * Upgrade `chalk`.
+  * Upgrade `core-js`.
+
+## 4.4.5
+
+ * **Internal**
+  * Remove function self reference optimisation.
+
+## 4.4.4
+
+ * **Bug Fix**
+  * Handle inferred function ids to be reassigned and deopt to a slower but working equivalent.
+  * Don't unpack array patterns that have more elements than their right hand array expression.
+ * **Polish**
+  * Improve syntax highlighting in the code frame. Thanks [@lydell](https://github.com/lydell)!
+ * **Internal**
+  * Upgrade `acorn-babel`.
+
+## 4.4.3
+
+ * **Bug Fix**
+  * Fix `for...of` iterator break returns being duplicated.
+  * Only call `return` on the iterator if it exists.
+ * **Internal**
+  * Rename `selfContained` transformer to `runtime`.
+
+## 4.4.2
+
+ * **New Feature**
+  * Add `moduleId` option for specifying a custom module id.
+
+## 4.4.0
+
+ * **New Feature**
+  * `/*** @jsx NAMESPACE **/` comments are now honored by the `react` transformer.
+  * `getModuleName` option.
+  * Infer function expression names. Thanks [@RReverser](https://github.com/RReverser)!
+ * **Bug Fix**
+  * Add proper control flow for tail recursion optimisation.
+ * **Internal**
+  * Remove useless `format` options and move the `format.compact` option to `format`.
+ * **Polish**
+  * Newline handling of the code generator has been heavily improved.
+  * Code generator now deopts whitespace if the input size is >100KB.
+
+## 4.3.0
+
+ * **Breaking Change**
+  * Remove `commonStandard` module formatter and make it the default behaviour of all the strict module formatters.
+
+## 4.2.1
+
+ * **Polish**
+  * Add auxiliary comment to let scoping closure flow control.
+
+## 4.2.0
+
+ * **Polish**
+  * Use an assignment instead of a define for `__esModule` in loose mode.
+ * **Internal**
+  * Add error for `eval();` usage and enable strict mode for parsing.
+
+## 4.1.0
+
+ * **New Feature**
+  * Add `BABEL_CACHE_PATH` and `BABEL_DISABLE_CACHE` environment variables.
+ * **Internal**
+  * Replace many internal util functions with modules. Thanks [@sindresorhus](https://github.com/sindresorhus)!
+
+## 4.0.2
+
+ * **Bug Fix**
+  * Fix generators not properly propagating their internal declarations.
+ * **Polish**
+  * Update setter param length error message.
+  * Use ranges on dependencies.
+
+## 4.0.0
+
+ * 6to5 is now known as Babel.
+ * Global helpers/runtime has now been given the more descriptive name of "external helpers".

CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

CONTRIBUTING.md

@@ -0,0 +1,77 @@
+# Contributing
+
+Contributions are always welcome, no matter how large or small. Before
+contributing, please read the
+[code of conduct](https://github.com/babel/babel/blob/master/CODE_OF_CONDUCT.md).
+
+## Developing
+
+#### Setup
+
+```sh
+$ git clone https://github.com/babel/babel
+$ cd babel
+$ make bootstrap
+```
+
+Then you need to run:
+
+```sh
+$ make watch-core
+```
+
+This will compile Babel and then sit in the background and on file modification
+recompile the necessary files.
+
+#### Running tests
+
+You can run tests via:
+
+```sh
+$ make test
+```
+
+This is mostly overkill and you can limit the tests to a select few by directly
+running them with `mocha`:
+
+```sh
+$ mocha test/core/transformation.js
+```
+
+Use mocha's `--grep` option to run a subset of tests by name:
+
+```sh
+$ mocha test/core/transformation.js --grep es7
+```
+
+#### Workflow
+
+* Fork the repository
+* Clone your fork and change directory to it (`git clone git@github.com:yourUserName/babel.git && cd babel`)
+* 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**
+   * Max of five arguments for functions
+   * Max depth of four nested blocks
+   * 2-spaced soft tabs
+ * **Naming**
+   * CamelCase all class names
+   * camelBack all variable names
+ * **Spacing**
+   * Spaces after all keywords
+   * Spaces before all left curly braces
+ * **Comments**
+   * Use JSDoc-style comments for methods
+   * Single-line comments for ambiguous code
+ * **Quotes**
+   * Always use double quotes
+   * Only use single quotes when the string contains a double quote
+ * **Declaration**
+   * No unused variables
+   * No pollution of global variables and prototypes

FEATURES.md

@@ -1,162 +0,0 @@
-# Features
-
-## Array comprehension
-
-```javascript
-[for (i of [1, 2, 3]) i * i]; // [1, 4, 9]
-```
-
-## Arrow functions
-
-```javascript
-arr.map(x => x * x);
-```
-
-## Let scoping
-
-```javascript
-for (let i in arr) {
-  let v = arr[i];
-}
-```
-
-## Classes
-
-```javascript
-class Foo extends Bar {
-  constructor() { }
-
-  foo() { }
-
-  get bar() { }
-
-  set bar() { }
-}
-```
-
-## Computed property names
-
-```javascript
-var foo = "foo";
-var bar = "bar";
-var obj = {
-  ["foo" + bar]: "heh",
-  ["bar" + foo]: "noo",
-  foo: "foo",
-  bar: "bar"
-};
-```
-
-## Constants
-
-```javascript
-const MULTIPLIER = 5;
-console.log(2 * MULTIPLIER);
-
-MULTIPLIER = 6; // error
-var MULTIPLIER; // error
-```
-
-## Default parameters
-
-```javascript
-function foo(bar = "foo") {
-  return bar + "bar";
-}
-```
-
-## Destructuring
-
-```javascript
-var [a, [b], c, d] = ["hello", [", ", "junk"], ["world"]];
-console.log(a + b + c); // hello, world
-```
-
-## For-of
-
-```javascript
-for (var i of [1, 2, 3]) {
-  console.log(i * i);
-}
-```
-
-## Generators
-
-```javascript
-```
-
-## Modules
-
-```javascript
-```
-
-## Numeric literals
-
-```javascript
-0b111110111 === 503; // true
-0o767 === 503; // true
-```
-
-## Property method assignment
-
-```javascript
-var obj = {
-  foo() {
-    return "foobar";
-  },
-
-  get bar() {
-    return this._bar;
-  },
-
-  set bar(val) {
-    this._bar = val;
-  }
-};
-```
-
-## Property name shorthand
-
-```javascript
-function f(x, y) {
-  return { x, y };
-}
-```
-
-## Rest parameters
-
-```javascript
-function printList(name, ...items) {
-  console.log("list %s has the following items", name);
-  items.forEach(function (item) {
-    console.log(item);
-  });
-}
-```
-
-## Spread
-
-```javascript
-function add(x, y) {
-  return x + y;
-}
-
-var numbers = [5, 10];
-add(...numbers); // 15
-```
-
-## Template literals
-
-```javascript
-var x = 5;
-var y = 10;
-console.log(`${x} + ${y} = ${x + y}`); // "5 + 10 = 15"
-```
-
-## Unicode regex
-
-```javascript
-var string = 'foo💩bar';
-var match = string.match(/foo(.)bar/u);
-console.log(match[1]);
-```

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2014 Sebastian McKenzie
+Copyright (c) 2014-2015 Sebastian McKenzie <sebmck@gmail.com>
 
 MIT License
 

MODULES.md

@@ -1,145 +0,0 @@
-# Modules
-
-## Usage
-
-### CLI
-
-    $ 6to5 --modules common script.js
-
-### Node
-
-```javascript
-var to5 = require("6to5");
-to5.transform('import "foo";', { modules: "common" });
-```
-
-## Formats
-
-### Common (Default)
-
-**In**
-
-```javascript
-import "foo";
-
-import foo from "foo";
-import * as foo from "foo";
-
-import {bar} from "foo";
-import {foo as bar} from "foo";
-
-export {test};
-export var test = 5;
-
-export default test;
-```
-
-**Out**
-
-```javascript
-require("foo");
-
-var foo = require("foo").default;
-var foo = require("foo");
-
-var bar = require("foo").bar;
-var bar = require("foo").foo;
-
-exports.test = test;
-var test = 5; exports.test = test;
-
-exports.default = test;
-```
-
-### AMD
-
-**In**
-
-```javascript
-import foo from "foo";
-
-export function bar() {
-  return foo("foobar");
-}
-```
-
-**Out**
-
-```javascript
-define(["exports", "foo"], function (exports, _foo) {
-  exports.bar = bar;
-
-  var foo = _foo.default;
-
-  function bar() {
-    return foo("foobar");
-  }
-});
-```
-
-### UMD
-
-**In**
-
-```javascript
-import foo from "foo";
-
-export function bar() {
-  return foo("foobar");
-}
-```
-
-**Out**
-
-```javascript
-(function (factory) {
-  if (typeof define === "function" && define.amd) {
-    define(["exports", "foo"], factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, require("foo"));
-  }
-})(function (exports) {
-  exports.bar = bar;
-
-  var foo = _foo.default;
-
-  function bar() {
-    return foo("foobar");
-  }
-});
-```
-
-## Custom
-
-You can alternatively specify module names instead of one of the built-in types.
-
-```javascript
-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.import = function (node, nodes) {
-  // node is an ImportDeclaration
-};
-
-ModuleFormatter.prototype.importSpecifier = function (specifier, node, nodes) {
-  // specifier is an ImportSpecifier
-  // node is an ImportDeclaration
-};
-
-ModuleFormatter.prototype.export = function (node, nodes) {
-  // node is an ExportDeclaration
-};
-
-ModuleFormatter.prototype.exportSpecifier = function (specifier, node, nodes) {
-  // specifier is an ExportSpecifier
-  // node is an ExportDeclaration
-};
-```

Makefile

@@ -1,60 +1,118 @@
+MAKEFLAGS = -j1
+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
+BABEL_CMD = node_modules/babel/bin/babel
 
 export NODE_ENV = test
 
-.PHONY: clean test test-cov test-travis test-browser publish bench build
+.PHONY: clean test test-cov test-clean test-travis test-simple test-all test-browser test-parser publish build bootstrap publish-core publish-runtime build-core watch-core build-core-test
 
-clean:
-	rm -rf coverage templates.json test/tmp dist
+build-core:
+	node $(BABEL_CMD) src --out-dir lib --copy-files
 
-bench:
-	npm install es6-transpiler traceur esnext es6now jstransform
-	node node_modules/matcha/bin/_matcha
+build-core-test:
+	node $(BABEL_CMD) src --out-dir lib --copy-files --auxiliary-comment "istanbul ignore next"
 
-test:
-	$(JSHINT_CMD) lib bin benchmark/index.js
-	$(MOCHA_CMD)
-
-test-cov:
-	rm -rf coverage
-	node $(ISTANBUL_CMD) $(MOCHA_CMD) --
-
-test-travis:
-	node $(ISTANBUL_CMD) $(MOCHA_CMD) -- --reporter spec
-	if test -n "$$CODECLIMATE_REPO_TOKEN"; then codeclimate < coverage/lcov.info; fi
-
-test-browser:
-	make build
-	node bin/generate-browser-test >dist/6to5-test.js
-	test -n "`which open`" && open test/browser.html
+watch-core:
+	node $(BABEL_CMD) src --out-dir lib --watch --copy-files
 
 build:
 	mkdir -p dist
+	make build-core
 
-	node bin/cache-templates
+	node tools/cache-templates
 
-	browserify lib/6to5/browser.js -s to5 >dist/6to5.js
-	uglifyjs dist/6to5.js >dist/6to5.min.js
+	node $(BROWSERIFY_CMD) -e lib/babel/polyfill.js >dist/polyfill.js
+	node $(UGLIFY_CMD) dist/polyfill.js >dist/polyfill.min.js
+
+	node $(BROWSERIFY_CMD) lib/babel/api/browser.js -s babel >dist/babel.js
+	node $(UGLIFY_CMD) dist/babel.js >dist/babel.min.js
+
+	node packages/babel-cli/bin/babel-external-helpers >dist/external-helpers.js
+	node $(UGLIFY_CMD) dist/external-helpers.js >dist/external-helpers.min.js
 
 	rm -rf templates.json
 
+clean:
+	rm -rf coverage templates.json test/tmp dist lib
+
+test-clean:
+	rm -rf test/tmp
+
+test: test-parser
+	node $(MOCHA_CMD) test/core
+	make test-clean
+
+test-all:
+	export ALL_BABEL_TESTS=1; \
+	make test
+
+test-cov:
+	rm -rf coverage
+	make build-core-test
+	node $(ISTANBUL_CMD) $(MOCHA_CMD) -- test/core
+
+test-parser:
+	node test/acorn/run.js
+
+test-travis: bootstrap build test
+
+test-browser:
+	mkdir -p dist
+
+	node tools/cache-templates
+	node tools/build-tests
+	node $(BROWSERIFY_CMD) -e test/core/_browser.js >dist/babel-test.js
+	rm -rf templates.json tests.json
+
+	test -n "`which open`" && open test/browser.html
+
 publish:
 	git pull --rebase
 
 	make test
 
-	make build
-	cp dist/6to5.js browser.js
+	read -p "Version: " version; \
+	npm version $$version --message "v%s"
 
-	node bin/cache-templates
+	make build
+	cp dist/babel.min.js browser.js
+	cp dist/polyfill.min.js browser-polyfill.js
+	cp dist/external-helpers.min.js external-helpers.js
+
+	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
+	make publish-cli
+	make publish-runtime
+
+	rm -rf templates.json browser.js browser-polyfill.js external-helpers.js
+
+publish-runtime:
+	cd packages; \
+	node build-runtime.js; \
+	cd babel-runtime; \
+	npm publish
+
+publish-cli:
+	cd packages; \
+	node build-cli.js; \
+	cd babel-cli; \
+	npm publish
+
+bootstrap:
+	npm list --global --depth 1 babel >/dev/null 2>&1 && npm uninstall -g babel || true
+	npm install
+	npm link
+	cd packages/babel-cli && npm install && npm link && npm link babel-core
+	git submodule update --init
+	cd vendor/regenerator && npm install
+	cd vendor/compat-table && npm install object-assign

README.md

@@ -1,419 +1,17 @@
 <p align="center">
-  <img alt="6to5" src="http://i.imgur.com/hVl9KRw.png">
+  <a href="https://babeljs.io/">
+    <img alt="babel" src="https://raw.githubusercontent.com/babel/logo/master/logo.png" width="546">
+  </a>
 </p>
 
 <p align="center">
-  <a href="https://travis-ci.org/sebmck/6to5">
-    <img alt="Travis Status" src="http://img.shields.io/travis/sebmck/6to5.svg?branch=master&amp;style=flat&amp;label=travis">
-  </a>
-
-  <a href="https://codeclimate.com/github/sebmck/6to5">
-    <img alt="Code Climate Score" src="http://img.shields.io/codeclimate/github/sebmck/6to5.svg?style=flat">
-  </a>
-
-  <a href="https://codeclimate.com/github/sebmck/6to5">
-    <img alt="Coverage" src="http://img.shields.io/codeclimate/coverage/github/sebmck/6to5.svg?style=flat">
-  </a>
-
-  <a href="https://david-dm.org/sebmck/6to5">
-    <img alt="Dependency Status" src="http://img.shields.io/david/sebmck/6to5.svg?style=flat">
-  </a>
+  <strong>Babel</strong> is a compiler for writing next generation JavaScript.
 </p>
 
-**6to5** turns ES6 code into vanilla ES5, so you can use ES6 features **today.**
+<p align="center">
+  For questions and support please visit the <a href="https://gitter.im/babel/babel">gitter room</a> or <a href="http://stackoverflow.com/questions/tagged/babeljs">StackOverflow</a>. The Babel issue tracker is <strong>exclusively</strong> for bug reports and feature requests.
+</p>
 
- - **Readable** - formatting is retained if possible so your generated code is as similar as possible.
- - **Extensible** - with a large range of [plugins](#plugins) and **browser support**.
- - **Lossless** - **source map support** so you can debug your compiled code with ease.
- - **Compact** - maps directly to the equivalent ES5 with **no runtime**[\*](#generators).
-
-## Installation
-
-It's as easy as:
-
-    $ npm install -g 6to5
-
-## Table of Contents
-
-- [Features](#features)
-- [Usage](#usage)
-  - [Plugins](#plugins)
-  - [CLI](#cli)
-  - [Node](#node-1)
-  - [Browser](#browser)
-- [Modules](#modules)
-- [Caveats](#caveats)
-- [Differences](#differences)
-
-## [Features](FEATURES.md)
-
- - [Array comprehension](FEATURES.md#array-comprehension)
- - [Arrow functions](FEATURES.md#arrow-functions)
- - [Classes](FEATURES.md#classes)
- - [Computed property names](FEATURES.md#computed-property-names)
- - [Constants](FEATURES.md#constants)
- - [Default parameters](FEATURES.md#default-parameters)
- - [Destructuring](FEATURES.md#destructuring)
- - [For-of](FEATURES.md#for-of)
- - [Generators](FEATURES.md#generators) via [regenerator](https://github.com/facebook/regenerator)
- - [Let scoping](FEATURES.md#let-scoping)
- - [Modules](FEATURES.md#modules)
- - [Numeric literals](FEATURES.md#numeric-literals)
- - [Property method assignment](FEATURES.md#property-method-assignment)
- - [Property name shorthand](FEATURES.md#property-name-shorthand)
- - [Rest parameters](FEATURES.md#rest-parameters)
- - [Spread](FEATURES.md#spread)
- - [Template literals](FEATURES.md#template-literals)
- - [Unicode regex](FEATURES.md#unicode-regex)
-
-## Usage
-
-### Plugins
-
- - [Broccoli](https://github.com/very-geek/broccoli-6to5-transpiler)
- - [Browserify](https://github.com/sebmck/6to5-browserify)
- - [Brunch](https://github.com/es128/6to5-brunch)
- - [Connect](https://github.com/sebmck/6to5-connect)
- - [Gulp](https://github.com/sindresorhus/gulp-6to5)
- - [Grunt](https://github.com/sindresorhus/grunt-6to5)
- - [Jade](https://github.com/Apoxx/jade-6to5)
- - [webpack](https://github.com/Couto/6to5-loader)
-
-### CLI
-
-Compile the file `script.js` and output it to stdout.
-
-    $ 6to5 script.js
-
-Compile the file `script.js` and output it to `script-compiled.js`.
-
-    $ 6to5 script.js --out-file script-compiled.js
-
-Compile the file `script.js` and output it to `script-compiled.js` and save a
-source map to `script-compiled.js.map`.
-
-    $ 6to5 script.js --source-maps --out-file script-compiled.js
-
-Compile the file `script.js` and output it to `script-compiled.js` with a source
-map embedded in a comment at the bottom.
-
-    $ 6to5 script.js --source-maps-inline --out-file script-compiled.js
-
-Compile the entire `src` directory and output it to the `lib` directory.
-
-    $ 6to5 src --out-dir lib
-
-Compile the entire `src` directory and output it to the one concatenated file.
-
-    $ 6to5 src --out-file script-compiled.js
-
-Pipe a file in via stdin and output it to `script-compiled.js`
-
-    $ 6to5 --out-file script-compiled.js < script.js
-
-#### Node
-
-Launch a repl.
-
-    $ 6to5-node
-
-Evaluate code.
-
-    $ 6to5-node -e "class Test { }"
-
-Compile and run `test.js`.
-
-    $ 6to5-node test
-
-### Node
-
-```javascript
-var to5 = require("6to5");
-
-var result = to5.transform("code();", options);
-result.code;
-result.map;
-result.ast;
-
-to5.transformFileSync("filename.js", options).code;
-
-to5.transformFile("filename.js", options, function (err, result) {
-
-});
-```
-
-##### Options
-
-```javascript
-{
-  // Filename for use in errors etc.
-  // Default: "unknown"
-  filename: "filename",
-
-  // List of transformers to EXCLUDE.
-  // Run `6to5 --help` to see a full list of transformers.
-  blacklist: [],
-
-  // List of transformers to ONLY use.
-  // Run `6to5 --help` to see a full list of transformers.
-  whitelist: [],
-
-  // Module formatter to use
-  // Run `6to5 --help` to see a full list of module formatters.
-  // Default: "common"
-  modules: "common",
-
-  // 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.
-  // Default: false
-  sourceMap: true,
-
-  // Set `file` on returned source map.
-  // Default: `filename` option.
-  sourceMapName: "filename",
-
-  // Set `sources[0]` on returned source map.
-  // Default: `filename` option.
-  sourceFileName: "filename"
-}
-```
-
-#### Require hook
-
-All subsequent files required by node with the extensions `.es6` and `.js` will
-be transformed by 6to5. The polyfill specified in [Polyfill](#polyfill) is also
-required.
-
-```javascript
-require("6to5/register");
-```
-
-**NOTE:** By default all requires to `node_modules` will be ignored. You can
-override this by passing an ignore regex via options.
-
-```javascript
-require("6to5/register")({
-  // This will override `node_modules` ignoring - you can alternatively pass
-  // a regex
-  ignore: false
-});
-```
-
-##### 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"]
-});
-```
-
-### Browser
-
-You can build a browser version of the compiler by running the following in the
-6to5 directory:
-
-    $ make build
-
-This will output the files `dist/6to5.js` and `dist/6to5.min.js`.
-
-Just include one of those in the browser and access the transform method via the
-global `to5`.
-
-```javascript
-to5("class Test {}").code;
-```
-
-#### Test
-
-To test 6to5 in your browser run:
-
-    $ make test-browser
-
-And open `test/browser.html` in your browser if it doesn't open automatically.
-
-## [Modules](MODULES.md)
-
-See [Modules - Common](MODULES.md#common-default) for documentation on the
-default module formatting.
-
-Alternatively see [Modules](MODULES.md) for all other supported module formatting types.
-
-## Caveats
-
-### Polyfill
-
-6to5 does not include a runtime nor polyfill and it's up to the developer to
-include one in compiled browser code.
-
-#### Node
-
-A polyfill is included with the 6to5 module that can be included in node like
-so:
-
-```javascript
-require("6to5/polyfill");
-```
-
-This is simply a wrapper around the
-[regenerator runtime](https://github.com/facebook/regenerator/blob/master/runtime.js) and the
-[es6-shim](https://github.com/paulmillr/es6-shim) and
-[es6-symbol](https://github.com/medikoo/es6-symbol) polyfills.
-
-#### Browser
-
-If you're planning on using 6to5 output in the browser then it's up to you
-to include polyfills. [es6-symbol](https://github.com/medikoo/es6-symbol#browser)
-and [es6-shim](https://raw.githubusercontent.com/paulmillr/es6-shim/master/es6-shim.js)
-fill the vast majority of polyfill concerns.
-
-### For-of
-
-A polyfill is required for for-of functionality that implements `Symbol` and
-adds `prototype[Symbol.iterator]` behaviour to built-ins. Using the polyfills
-specified in [polyfill](#polyfill) suffices.
-
-### Classes
-
-Built-in classes such as `Date`, `Array` and `DOM` cannot be subclassed due to
-limitations in ES5 implementations.
-
-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 <= 9 so static properties
-**will not** be inherited. A possible workaround is to use `super();`:
-
-```javascript
-class Foo {
-  static foo() {
-
-  }
-}
-
-class Bar extends Foo {
-  static foo() {
-    super();
-  }
-}
-```
-
-### Generators
-
-The [regenerator runtime](https://github.com/facebook/regenerator/blob/master/runtime.js)
-and an [ES6 polyfill](#polyfill) are required in order for generators to work.
-
-## Differences
-
-### Philosophy
-
-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:
-
-```javascript
-var seattlers = [for (c of customers) if (c.city == "Seattle") { name: c.name, age: c.age }];
-```
-
-is generated to the following with 6to5:
-
-```javascript
-var seattlers = customers.filter(function (c) {
-  return c.city == "Seattle";
-}).map(function (c) {
-  return {
-    name: c.name,
-    age: c.age
-  };
-});
-```
-
-The following is what Traceur generates:
-
-```javascript
-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, unreadable even. Instead of mapping
-directly to a runtime, like other transpilers, 6to5 maps directly to the
-equivalent ES5.
-
-I'm not saying 6to5 is for everyone or even suited for everything. Traceur is
-better suited if you'd like a full ES6 environment with polyfills and all.
-
-### Comparison to other transpilers
-
-|                              | 6to5 | Traceur | esnext | es6now | es6-transpiler | jstransform |
-| ---------------------------- | ---- | ------- | ------ | ------ | -------------- | ----------- |
-| No runtime                   | ✓    |         |        |        | ✓              | ✓           |
-| Source maps                  | ✓    | ✓       | ✓      |        | ✓              | ✓           |
-| No compiler global pollution | ✓    |         | ✓      |        | ✓              | ✓           |
-| Arrow functions              | ✓    | ✓       | ✓      | ✓      | ✓              | ✓           |
-| Classes                      | ✓    | ✓       | ✓      | ✓      | ✓              | ✓           |
-| Computed property names      | ✓    | ✓       | ✓      | ✓      | ✓              |             |
-| Constants                    | ✓    | ✓       |        |        | ✓              |             |
-| Default parameters           | ✓    | ✓       | ✓      | ✓      | ✓              |             |
-| Destructuring                | ✓    | ✓       | ✓      | ✓      | ✓              | ✓           |
-| For-of                       | ✓    | ✓       | ✓      | ✓      | ✓              |             |
-| Generators                   | ✓    | ✓       | ✓      |        |                |             |
-| Let scoping                  | ✓    | ✓       |        |        | ✓              |             |
-| Modules                      | ✓    | ✓       |        | ✓      |                |             |
-| Property method assignment   | ✓    | ✓       | ✓      | ✓      | ✓              | ✓           |
-| Property name shorthand      | ✓    | ✓       | ✓      | ✓      | ✓              | ✓           |
-| Rest parameters              | ✓    | ✓       | ✓      | ✓      | ✓              | ✓           |
-| 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
-unneccesary step when a 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.
+<p align="center">
+  For documentation and website issues please visit the <a href="https://github.com/babel/babel.github.io">babel.github.io</a> repo.
+</p>

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-node

@@ -1,83 +0,0 @@
-#!/usr/bin/env node
-
-var commander = require("commander");
-var util      = require("../lib/6to5/util");
-var path      = require("path");
-var repl      = require("repl");
-var to5       = require("../lib/6to5");
-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]", util.list);
-
-var pkg = require("../package.json");
-commander.version(pkg.version);
-commander.usage("[options] [ -e script | script.js ] [arguments]");
-commander.parse(process.argv);
-
-//
-
-var registerOpts = {};
-
-if (commander.ignore) {
-  registerOpts.ignoreRegex = new RegExp(commander.ignore);
-}
-
-if (commander.extensions && commander.extensions.length) {
-  registerOpts.extensions = commander.extensions
-}
-
-to5.register(registerOpts);
-
-//
-
-var _eval = function (code, filename) {
-  code = to5.transform(code, { filename: filename }).code;
-  return vm.runInThisContext(code, filename);
-};
-
-if (commander.eval) {
-  var result = _eval(commander.eval, "eval");
-  if (commander.print) console.log(result);
-} else {
-  var filenames = commander.args;
-
-  if (filenames.length) {
-    _.each(filenames, function (filename) {
-      if (!util.isAbsolute(filename)) {
-        filename = path.join(process.cwd(), filename);
-      }
-
-      require(require.resolve(filename));
-    });
-  } else {
-    replStart();
-  }
-}
-
-function replStart() {
-  repl.start({
-    prompt: "> ",
-    input: process.stdin,
-    output: process.stdout,
-    eval: replEval,
-    useGlobal: true
-  });
-}
-
-function replEval(code, context, filename, callback) {
-  var err;
-  var result;
-
-  try {
-    code = code.slice(1, -2); // remove "(" and "\n)"
-    result = _eval(code, filename);
-  } catch (e) {
-    err = e;
-  }
-
-  callback(err, result);
-}

bin/6to5/dir.js

@@ -1,66 +0,0 @@
-var chokidar = require("chokidar");
-var mkdirp   = require("mkdirp");
-var path     = require("path");
-var util     = require("./util");
-var fs       = require("fs");
-var _        = require("lodash");
-
-module.exports = function (commander, filenames, opts) {
-  if (commander.sourceMapsInline) {
-    opts.sourceMap = "inline";
-  }
-
-  var write = function (src, relative) {
-    var dest = path.join(commander.outDir, relative);
-
-    var data = util.compile(src, { sourceMapName: dest });
-
-    var up = path.normalize(dest + "/..");
-    mkdirp.sync(up);
-
-    if (commander.sourceMaps) {
-      fs.writeFileSync(dest + ".map", JSON.stringify(data.map));
-    }
-
-    fs.writeFileSync(dest, data.code);
-
-    console.log(src + " -> " + dest);
-  };
-
-  var handle = function (filename) {
-    if (!fs.existsSync(filename)) return;
-
-    var stat = fs.statSync(filename);
-
-    if (stat.isDirectory(filename)) {
-      var dirname = filename;
-
-      _.each(util.readdirFilter(dirname), function (filename) {
-        write(path.join(dirname, filename), filename);
-      });
-    } else {
-      write(filename, filename);
-    }
-  };
-
-  _.each(filenames, handle);
-
-  if (commander.watch) {
-    _.each(filenames, function (dirname) {
-      var watcher = chokidar.watch(dirname, {
-        persistent: true,
-        ignoreInitial: true
-      });
-
-      _.each(["add", "change", "unlink"], function (type) {
-        watcher.on(type, function (filename) {
-          // chop off the dirname plus the path separator
-          var relative = filename.slice(dirname.length + 1);
-
-          console.log(type, filename);
-          write(filename, relative);
-        });
-      });
-    });
-  }
-};

bin/6to5/util.js

@@ -1,25 +0,0 @@
-var readdir = require("fs-readdir-recursive");
-var index   = require("./index");
-var util    = require("../../lib/6to5/util");
-var to5     = require("../../lib/6to5");
-var fs      = require("fs");
-var _       = require("lodash");
-
-exports.readdirFilter = function (filename) {
-  return readdir(filename).filter(util.canCompile);
-};
-
-exports.transform = function (filename, code, opts) {
-  opts = _.extend(opts || {}, index.opts);
-  opts.filename = filename;
-
-  var result = to5.transform(code, opts);
-  result.filename = filename;
-  result.actual = code;
-  return result;
-};
-
-exports.compile = function (filename, opts) {
-  var code = fs.readFileSync(filename, "utf8");
-  return exports.transform(filename, code, opts);
-};

bin/generate-browser-test

@@ -1,6 +0,0 @@
-#!/usr/bin/env node
-
-var helper = require("../test/_helper");
-var util   = require("../lib/6to5/util");
-
-console.log("(" + helper.run + ")(" + JSON.stringify(helper.getTests()) + ", to5, proclaim)");

lib/6to5/browser.js

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

lib/6to5/file.js

@@ -1,150 +0,0 @@
-module.exports = File;
-
-var SHEBANG_REGEX = /^\#\!.*/;
-
-var transform = require("./transform");
-var recast    = require("acorn-recast");
-var util      = require("./util");
-var b         = require("acorn-ast-types").builders;
-var _         = require("lodash");
-
-function File(opts) {
-  this.opts            = File.normaliseOptions(opts);
-  this.moduleFormatter = this.getModuleFormatter(opts.modules);
-
-  this.declarations = {};
-  this.uids         = {};
-  this.ast          = {};
-}
-
-File.normaliseOptions = function (opts) {
-  opts = opts || {};
-
-  _.defaults(opts, {
-    blacklist: [],
-    whitelist: [],
-    sourceMap: false,
-    filename:  "unknown",
-    modules:   "common"
-  });
-
-  _.defaults(opts, {
-    sourceFileName: opts.filename,
-    sourceMapName:  opts.filename
-  });
-
-  transform._ensureTransformerNames("blacklist", opts.blacklist);
-  transform._ensureTransformerNames("whitelist", opts.whitelist);
-
-  return opts;
-};
-
-File.prototype.getModuleFormatter = function (type) {
-  var ModuleLoader = transform.moduleFormatters[type];
-
-  if (!ModuleLoader) {
-    var loc = util.resolve(type);
-    if (loc) ModuleLoader = require(loc);
-  }
-
-  if (!ModuleLoader) {
-    throw new ReferenceError("unknown module formatter type " + type);
-  }
-
-  return new ModuleLoader(this);
-};
-
-File.prototype.parseShebang = function (code) {
-  var shebangMatch = code.match(SHEBANG_REGEX);
-  if (shebangMatch) {
-    this.shebang = shebangMatch[0];
-
-    // remove shebang
-    code = code.replace(SHEBANG_REGEX, "");
-  }
-
-  return code;
-};
-
-File.prototype.addDeclaration = function (name) {
-  var declar = this.declarations[name];
-  if (declar) return declar.uid;
-
-  var uid = b.identifier(this.generateUid(name));
-  this.declarations[name] = {
-    uid: uid,
-    node: util.template(name)
-  };
-  return uid;
-};
-
-File.prototype.parse = function (code) {
-  var self = this;
-
-  code = this.parseShebang(code);
-
-  return util.parse(this.opts, code, function (tree) {
-    self.transform(tree);
-    return self.generate();
-  });
-};
-
-File.prototype.transform = function (ast) {
-  this.ast = ast;
-
-  var self = this;
-
-  _.each(transform.transformers, function (transformer) {
-    transformer.transform(self);
-  });
-};
-
-File.prototype.generate = function () {
-  var opts = this.opts;
-  var ast  = this.ast;
-
-  var printOpts = { tabWidth: 2 };
-
-  if (opts.sourceMap) {
-    printOpts.sourceMapName = opts.sourceMapName;
-  }
-
-  var result = recast.print(ast, printOpts);
-  var code   = result.code;
-
-  if (this.shebang) {
-    // add back shebang
-    code = this.shebang + code;
-  }
-
-  if (opts.sourceMap === "inline") {
-    code += "\n" + util.sourceMapToComment(result.map);
-  }
-
-  return {
-    code: code,
-    map:  result.map || null,
-    ast:  ast
-  };
-};
-
-File.prototype.generateUid = function (name) {
-  // replace all non-valid identifiers with dashes
-  name = name.replace(/[^a-zA-Z0-9]/g, "-");
-
-  // remove all dashes and numbers from start of name
-  name = name.replace(/^[-0-9]+/, "");
-
-  // camel case
-  name = name.replace(/[-_\s]+(.)?/g, function (match, c) {
-    return c ? c.toUpperCase() : "";
-  });
-
-  var uids = this.uids;
-  var i = uids[name] || 1;
-
-  var id = name;
-  if (i > 1) id += i;
-  uids[name] = i + 1;
-  return "_" + id;
-};

lib/6to5/index.js

@@ -1,46 +0,0 @@
-var transform = require("./transform");
-var fs        = require("fs");
-var _         = require("lodash");
-
-exports.util = require("./util");
-
-exports.register = function (opts) {
-  var register = require("./register");
-  if (opts != null) register(opts);
-  return register;
-};
-
-exports.polyfill = function () {
-  require("./polyfill");
-};
-
-exports.transform = transform;
-
-exports.transformFile = function (filename, opts, callback) {
-  if (_.isFunction(opts)) {
-    callback = opts;
-    opts = {};
-  }
-
-  opts.filename = filename;
-
-  fs.readFile(filename, function (err, code) {
-    if (err) return callback(err);
-
-    var result;
-
-    try {
-      result = transform(code, opts);
-    } catch (err) {
-      return callback(err);
-    }
-
-    callback(null, result);
-  });
-};
-
-exports.transformFileSync = function (filename, opts) {
-  opts = opts || {};
-  opts.filename = filename;
-  return transform(fs.readFileSync(filename), opts);
-};

lib/6to5/modules/amd.js

@@ -1,82 +0,0 @@
-module.exports = AMDFormatter;
-
-var CommonJSFormatter = require("./common");
-var util              = require("../util");
-var b                 = require("acorn-ast-types").builders;
-var _                 = require("lodash");
-
-function AMDFormatter(file) {
-  this.file = file;
-  this.ids  = {};
-}
-
-util.inherits(AMDFormatter, CommonJSFormatter);
-
-AMDFormatter.prototype.transform = function (ast) {
-  var program = ast.program;
-  var body    = program.body;
-
-  // build an array of module names
-
-  var names = [b.literal("exports")];
-  _.each(this.ids, function (id, name) {
-    names.push(b.literal(name));
-  });
-  names = b.arrayExpression(names);
-
-  // build up define container
-
-  var params = _.values(this.ids);
-  params.unshift(b.identifier("exports"));
-
-  var container = b.functionExpression(null, params, b.blockStatement(body));
-  var call = b.callExpression(b.identifier("define"), [names, container]);
-
-  program.body = [b.expressionStatement(call)];
-};
-
-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] = b.identifier(this.file.generateUid(id));
-  }
-};
-
-AMDFormatter.prototype.import = function (node) {
-  this._push(node);
-};
-
-AMDFormatter.prototype.importSpecifier = function (specifier, node, nodes) {
-  var key = util.getSpecifierName(specifier);
-  var id  = specifier.id;
-
-  // import foo from "foo";
-  if (specifier.default) {
-    id = b.identifier("default");
-  }
-
-  var ref;
-
-  if (specifier.type === "ImportBatchSpecifier") {
-    // import * as bar from "foo";
-    ref = this._push(node);
-  } else {
-    // import foo from "foo";
-    ref = b.memberExpression(this._push(node), id, false);
-  }
-
-  nodes.push(b.variableDeclaration("var", [
-    b.variableDeclarator(key, ref)
-  ]));
-};
-
-AMDFormatter.prototype.exportSpecifier = function (specifier, node, nodes) {
-  var self = this;
-  return this._exportSpecifier(function () {
-    return self._push(node);
-  }, specifier, node, nodes);
-};

lib/6to5/modules/common.js

@@ -1,97 +0,0 @@
-module.exports = CommonJSFormatter;
-
-var util = require("../util");
-var b    = require("acorn-ast-types").builders;
-
-function CommonJSFormatter(file) {
-  this.file = file;
-}
-
-CommonJSFormatter.prototype.import = function (node, nodes) {
-  // import "foo";
-  nodes.push(util.template("require", {
-    MODULE_NAME: node.source.raw
-  }, true));
-};
-
-CommonJSFormatter.prototype.importSpecifier = function (specifier, node, nodes) {
-  var variableName = util.getSpecifierName(specifier);
-
-  // import foo from "foo";
-  if (specifier.default) {
-    specifier.id = b.identifier("default");
-  }
-
-  var templateName = "require-assign";
-
-  // import * as bar from "foo";
-  if (specifier.type !== "ImportBatchSpecifier") templateName += "-key";
-
-  nodes.push(util.template(templateName, {
-    VARIABLE_NAME: variableName,
-    MODULE_NAME:   node.source.raw,
-    KEY:           specifier.id
-  }));
-};
-
-CommonJSFormatter.prototype.export = function (node, nodes) {
-  var declar = node.declaration;
-
-  if (node.default) {
-    util.ensureExpressionType(declar);
-
-    nodes.push(util.template("exports-default", {
-      VALUE: declar
-    }, true));
-  } else {
-    var id = declar.id;
-    if (declar.type === "VariableDeclaration") {
-      id = declar.declarations[0].id;
-    }
-
-    var assign = util.template("exports-assign", {
-      VALUE: id,
-      KEY:   id
-    }, true);
-
-    nodes.push(declar);
-
-    if (declar.type === "FunctionDeclaration") {
-      assign._blockHoist = true;
-    }
-
-    nodes.push(assign);
-  }
-};
-
-CommonJSFormatter.prototype._exportSpecifier = function (getRef, specifier, node, nodes) {
-  var variableName = util.getSpecifierName(specifier);
-
-  if (node.source) {
-    if (specifier.type === "ExportBatchSpecifier") {
-      // export * from "foo";
-      nodes.push(util.template("exports-wildcard", {
-        OBJECT: getRef()
-      }, true));
-    } else {
-      // export { foo } from "test";
-      nodes.push(util.template("exports-assign-key", {
-        VARIABLE_NAME: variableName.name,
-        OBJECT:        getRef(),
-        KEY:           specifier.id
-      }, true));
-    }
-  } else {
-    // export { foo };
-    nodes.push(util.template("exports-assign", {
-      VALUE: specifier.id,
-      KEY:   variableName
-    }, true));
-  }
-};
-
-CommonJSFormatter.prototype.exportSpecifier = function (specifier, node, nodes) {
-  return this._exportSpecifier(function () {
-    return b.callExpression(b.identifier("require"), [node.source]);
-  }, specifier, node, nodes);
-};

lib/6to5/modules/umd.js

@@ -1,47 +0,0 @@
-module.exports = UMDFormatter;
-
-var AMDFormatter = require("./amd");
-var util         = require("../util");
-var b            = require("acorn-ast-types").builders;
-var _            = require("lodash");
-
-function UMDFormatter(file) {
-  this.file = file;
-  this.ids  = {};
-}
-
-util.inherits(UMDFormatter, AMDFormatter);
-
-UMDFormatter.prototype.transform = function (ast) {
-  var program = ast.program;
-  var body    = program.body;
-
-  // build an array of module names
-
-  var names = [];
-  _.each(this.ids, function (id, name) {
-    names.push(b.literal(name));
-  });
-
-  // factory
-
-  var ids  = _.values(this.ids);
-  var args = [b.identifier("exports")].concat(ids);
-
-  var factory = b.functionExpression(null, args, b.blockStatement(body));
-
-  // runner
-
-  var runner = util.template("umd-runner-body", {
-    AMD_ARGUMENTS: b.arrayExpression([b.literal("exports")].concat(names)),
-
-    COMMON_ARGUMENTS: names.map(function (name) {
-      return b.callExpression(b.identifier("require"), [name]);
-    })
-  });
-
-  //
-
-  var call = b.callExpression(runner, [factory]);
-  program.body = [b.expressionStatement(call)];
-};

lib/6to5/polyfill.js

@@ -1,3 +0,0 @@
-require("es6-symbol/implement");
-require("es6-shim");
-require("regenerator/runtime");

lib/6to5/register.js

@@ -1,109 +0,0 @@
-require("./polyfill");
-
-var sourceMapSupport = require("source-map-support");
-var to5              = require("./index");
-var _                = require("lodash");
-
-sourceMapSupport.install({
-  retrieveSourceMap: function (source) {
-    var map = maps[source];
-    if (map) {
-      return {
-        url: null,
-        map: map
-      };
-    } else {
-      return null;
-    }
-  }
-});
-
-//
-
-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("arrowFunctions", "var foo = x => x * x;");
-blacklistTest("classes", "class Foo {}");
-blacklistTest("computedPropertyNames", "var foo = { [foo]: bar };");
-//blacklistTest("constants", "const foo = 0;");
-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() {}");
-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", "`foo`");
-blacklistTest("unicodeRegex", function () { new RegExp("foo", "u"); });
-
-//
-
-var ignoreRegex = /node_modules/;
-var onlyRegex;
-var whitelist   = [];
-var exts        = {};
-var maps        = {};
-var old         = require.extensions[".js"];
-
-var loader = function (m, filename) {
-  if ((ignoreRegex && ignoreRegex.test(filename)) || (onlyRegex && !onlyRegex.test(filename))) {
-    return old.apply(this, arguments);
-  }
-
-  var result = to5.transformFileSync(filename, {
-    whitelist: whitelist,
-    blacklist: blacklist,
-    sourceMap: true
-  });
-
-  maps[filename] = result.map;
-
-  m._compile(result.code, filename);
-};
-
-var hookExtensions = function (_exts) {
-  _.each(exts, function (old, ext) {
-    require.extensions[ext] = old;
-  });
-
-  exts = {};
-
-  _.each(_exts, function (ext) {
-    exts[ext] = require.extensions[ext];
-    require.extensions[ext] = loader;
-  });
-};
-
-hookExtensions([".es6", ".js"]);
-
-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 = opts.only;
-  if (opts.ignore != null) ignoreRegex = opts.ignore;
-
-  if (opts.extensions) hookExtensions(opts.extensions);
-
-  if (opts.blacklist) blacklist = opts.blacklist;
-  if (opts.whitelist) whitelist = opts.whitelist;
-};

lib/6to5/templates/arguments-slice-assign-arg.js

@@ -1 +0,0 @@
-var VARIABLE_NAME = SLICE_KEY.call(arguments, SLICE_ARG);

lib/6to5/templates/arguments-slice-assign.js

@@ -1 +0,0 @@
-var VARIABLE_NAME = SLICE_KEY.call(arguments);

lib/6to5/templates/arguments-slice.js

@@ -1 +0,0 @@
-SLICE_KEY.call(arguments);

lib/6to5/templates/array-comprehension-filter.js

@@ -1,5 +0,0 @@
-ARRAY.filter(function (KEY) {
-  return FILTER;
-}).map(function (KEY) {
-  return STATEMENT;
-});

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

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

lib/6to5/templates/array-comprehension-map.js

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

lib/6to5/templates/class-props.js

@@ -1,4 +0,0 @@
-(function (child, staticProps, instanceProps) {
-  if (staticProps) Object.defineProperties(child, staticProps);
-  if (instanceProps) Object.defineProperties(child.prototype, instanceProps);
-})

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

@@ -1,2 +0,0 @@
-SUPER_NAME.apply(this, arguments);
-

lib/6to5/templates/class.js

@@ -1,7 +0,0 @@
-(function () {
-  var CLASS_NAME = function () {
-
-  };
-
-  return CLASS_NAME;
-})()

lib/6to5/templates/exports-assign-key.js

@@ -1 +0,0 @@
-exports.VARIABLE_NAME = OBJECT.KEY;

lib/6to5/templates/exports-default.js

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

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

@@ -1,5 +0,0 @@
-(function (obj) {
-  for (var i in obj) {
-    exports[i] = obj[i];
-  }
-})(OBJECT);

lib/6to5/templates/extends.js

@@ -1,11 +0,0 @@
-(function (child, parent) {
-  child.prototype = Object.create(parent.prototype, {
-    constructor: {
-      value: child,
-      enumerable: false,
-      writable: true,
-      configurable: true
-    }
-  });
-  child.__proto__ = parent;
-})

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

@@ -1,3 +0,0 @@
-for (var ITERATOR_KEY = OBJECT[Symbol.iterator](), STEP_KEY; !(STEP_KEY = ITERATOR_KEY.next()).done; ) {
-
-}

lib/6to5/templates/function-return-obj.js

@@ -1,3 +0,0 @@
-(function (KEY) {
-  return KEY;
-})(OBJECT)

lib/6to5/templates/if-undefined-set-to.js

@@ -1 +0,0 @@
-if (VARIABLE === undefined) VARIABLE = DEFAULT;

lib/6to5/templates/object-define-properties-closure.js

@@ -1,4 +0,0 @@
-(function (KEY) {
-  CONTENT;
-  return KEY;
-})(OBJECT);

lib/6to5/templates/object-define-properties.js

@@ -1 +0,0 @@
-Object.defineProperties(OBJECT, PROPS);

lib/6to5/templates/require-assign.js

@@ -1 +0,0 @@
-var VARIABLE_NAME = require(MODULE_NAME);

lib/6to5/templates/umd-runner-body.js

@@ -1,7 +0,0 @@
-(function (factory) {
-  if (typeof define === "function" && define.amd) {
-    define(AMD_ARGUMENTS, factory);
-  } else if (typeof exports !== "undefined") {
-    factory(exports, COMMON_ARGUMENTS);
-  }
-});

lib/6to5/transform.js

@@ -1,120 +0,0 @@
-module.exports = transform;
-
-var Transformer = require("./transformer");
-var sourceMap   = require("source-map");
-var recast      = require("acorn-recast");
-var File        = require("./file");
-var util        = require("./util");
-var _           = require("lodash");
-
-function transform(code, opts) {
-  opts = opts || {};
-  code = (code || "") + "";
-
-  var file = new File(opts);
-  return file.parse(code);
-}
-
-transform.test = function (task, assert) {
-  var actual = task.actual;
-  var expect = task.expect;
-  var opts   = task.options;
-  var exec   = task.exec;
-
-  var getOpts = function (filename) {
-    return _.merge({ filename: filename }, opts);
-  };
-
-  var execCode = exec.code.trim();
-  var result;
-
-  if (execCode) {
-    result = transform(execCode, getOpts(exec.filename));
-    execCode = result.code;
-
-    require("./polyfill");
-    var fn = new Function("assert", execCode);
-    fn(assert);
-  } else {
-    var actualCode = actual.code.trim();
-    var expectCode = expect.code.trim();
-
-    var printOpts = { tabWidth: 2 };
-
-    result     = transform(actualCode, getOpts(actual.filename));
-    actualCode = recast.prettyPrint(result.ast, printOpts).code;
-
-    var expectAst    = util.parse(expect, expectCode);
-    var expectResult = recast.prettyPrint(expectAst, printOpts);
-    expectCode       = expectResult.code;
-
-    assert.equal(actualCode, expectCode);
-  }
-
-  if (task.sourceMap) {
-    assert.deepEqual(task.sourceMap, result.map);
-  }
-
-  if (task.sourceMappings) {
-    var consumer = new sourceMap.SourceMapConsumer(result.map);
-
-    _.each(task.sourceMappings, function (mapping, i) {
-      var generated = mapping.generated;
-      var original  = mapping.original;
-
-      var pos = consumer.originalPositionFor(generated);
-      var msg = "source mapping " + i + " - generated: " + generated.line + ":" + generated.column;
-      assert.equal(pos.line + ":" + pos.column, original.line + ":" + original.column, msg);
-    });
-  }
-};
-
-transform._ensureTransformerNames = function (type, keys) {
-  _.each(keys, function (key) {
-    if (!_.has(transform.transformers, key)) {
-      throw new ReferenceError("unknown transformer " + key + " specified in " + type);
-    }
-  });
-};
-
-transform.transformers = {
-  modules:                  require("./transformers/modules"),
-  computedPropertyNames:    require("./transformers/computed-property-names"),
-  propertyNameShorthand:    require("./transformers/property-name-shorthand"),
-  constants:                require("./transformers/constants"),
-  arrayComprehension:       require("./transformers/array-comprehension"),
-  arrowFunctions:           require("./transformers/arrow-functions"),
-  classes:                  require("./transformers/classes"),
-  spread:                   require("./transformers/spread"),
-  templateLiterals:         require("./transformers/template-literals"),
-  propertyMethodAssignment: require("./transformers/property-method-assignment"),
-  defaultParameters:        require("./transformers/default-parameters"),
-  letScoping:               require("./transformers/let-scoping"),
-  restParameters:           require("./transformers/rest-parameters"),
-  destructuring:            require("./transformers/destructuring"),
-  forOf:                    require("./transformers/for-of"),
-  unicodeRegex:             require("./transformers/unicode-regex"),
-  generators:               require("./transformers/generators"),
-  numericLiterals:          require("./transformers/numeric-literals"),
-
-  react:                    require("./transformers/react"),
-  jsx:                      require("./transformers/jsx"),
-
-  _aliasFunctions:          require("./transformers/_alias-functions"),
-  _blockHoist:              require("./transformers/_block-hoist"),
-  _declarations:            require("./transformers/_declarations"),
-
-  useStrict:                require("./transformers/use-strict"),
-
-  _moduleFormatter:         require("./transformers/_module-formatter")
-};
-
-transform.moduleFormatters = {
-  common: require("./modules/common"),
-  amd:    require("./modules/amd"),
-  umd:    require("./modules/umd")
-};
-
-_.each(transform.transformers, function (transformer, key) {
-  transform.transformers[key] = new Transformer(key, transformer);
-});

lib/6to5/transformer.js

@@ -1,76 +0,0 @@
-module.exports = Transformer;
-
-var traverse = require("./traverse");
-var _        = require("lodash");
-
-function Transformer(key, transformer) {
-  this.transformer = Transformer.normalise(transformer);
-  this.key         = key;
-}
-
-Transformer.normalise = function (transformer) {
-  if (_.isFunction(transformer)) {
-    transformer = { ast: transformer };
-  }
-
-  _.each(transformer, function (fns, type) {
-    if (_.isFunction(fns)) fns = { enter: fns };
-    transformer[type] = fns;
-  });
-
-  return transformer;
-};
-
-Transformer.prototype.transform = function (file) {
-  if (!this.canRun(file)) return;
-
-  var transformer = this.transformer;
-  var ast         = file.ast;
-
-  if (transformer.ast && transformer.ast.enter) {
-    transformer.ast.enter(ast, file);
-  }
-
-  var build = function (exit) {
-    return function (node, parent) {
-      // add any node type aliases that exist
-      var types = [node.type].concat(traverse.aliases[node.type] || []);
-
-      var fns = transformer.all;
-
-      _.each(types, function (type) {
-        fns = transformer[type] || fns;
-      });
-
-      // this transformer cannot deal with this node type
-      if (!fns) return;
-
-      var fn = fns.enter;
-      if (exit) fn = fns.exit;
-      if (!fn) return;
-
-      return fn(node, parent, file);
-    };
-  };
-
-  traverse(ast, {
-    enter: build(),
-    exit:  build(true)
-  });
-
-  if (transformer.ast && transformer.ast.exit) {
-    transformer.ast.exit(ast, file);
-  }
-};
-
-Transformer.prototype.canRun = function (file) {
-  var opts = file.opts;
-
-  var blacklist = opts.blacklist;
-  if (blacklist.length && _.contains(blacklist, this.key)) return false;
-
-  var whitelist = opts.whitelist;
-  if (whitelist.length && !_.contains(whitelist, this.key)) return false;
-
-  return true;
-};

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

@@ -1,86 +0,0 @@
-var traverse = require("../traverse");
-var util     = require("../util");
-var b        = require("acorn-ast-types").builders;
-
-var go = function (getBody, node, file) {
-  var argumentsId;
-  var thisId;
-
-  var getArgumentsId = function () {
-    return argumentsId = argumentsId || b.identifier(file.generateUid("arguments"));
-  };
-
-  var getThisId = function () {
-    return thisId = thisId || b.identifier(file.generateUid("this"));
-  };
-
-  // traverse the function and find all alias functions so we can alias
-  // arguments and this if necessary
-  traverse(node, function (node) {
-    var _aliasFunction = node._aliasFunction;
-    if (!_aliasFunction) {
-      if (traverse.isFunction(node)) {
-        // stop traversal of this node as it'll be hit again by this transformer
-        return false;
-      } else {
-        return;
-      }
-    }
-
-    // traverse all child nodes of this function and find arguments and this
-    traverse(node, function (node, parent) {
-      if (_aliasFunction === "arrows") {
-        if (traverse.isFunction(node) && node._aliasFunction !== "arrows") {
-          return false;
-        }
-      }
-
-      if (node._ignoreAliasFunctions) return;
-
-      var getId;
-
-      if (node.type === "Identifier" && node.name === "arguments") {
-        getId = getArgumentsId;
-      } else if (node.type === "ThisExpression") {
-        getId = getThisId;
-      } else {
-        return;
-      }
-
-      if (util.isReferenced(node, parent)) return getId();
-    });
-
-    return false;
-  });
-
-  var body;
-
-  var pushDeclaration = function (id, init) {
-    body = body || getBody();
-    body.unshift(b.variableDeclaration("var", [
-      b.variableDeclarator(id, init)
-    ]));
-  };
-
-  if (argumentsId) {
-    pushDeclaration(argumentsId, b.identifier("arguments"));
-  }
-
-  if (thisId) {
-    pushDeclaration(thisId, b.identifier("this"));
-  }
-};
-
-exports.Program = function (node, parent, file) {
-  go(function () {
-    return node.body;
-  }, node, file);
-};
-
-exports.FunctionDeclaration =
-exports.FunctionExpression = function (node, parent, file) {
-  go(function () {
-    util.ensureBlock(node);
-    return node.body.body;
-  }, node, file);
-};

lib/6to5/transformers/_block-hoist.js

@@ -1,17 +0,0 @@
-exports.BlockStatement =
-exports.Program = {
-  exit: function (node) {
-    var unshift = [];
-
-    node.body = node.body.filter(function (bodyNode) {
-      if (bodyNode._blockHoist) {
-        unshift.push(bodyNode);
-        return false;
-      } else {
-        return true;
-      }
-    });
-
-    node.body = unshift.concat(node.body);
-  }
-};

lib/6to5/transformers/_declarations.js

@@ -1,12 +0,0 @@
-var b = require("acorn-ast-types").builders;
-var _ = require("lodash");
-
-module.exports = function (ast, file) {
-  var body = ast.program.body;
-
-  _.each(file.declarations, function (declar) {
-    body.unshift(b.variableDeclaration("var", [
-      b.variableDeclarator(declar.uid, declar.node)
-    ]));
-  });
-};

lib/6to5/transformers/_module-formatter.js

@@ -1,11 +0,0 @@
-var transform = require("../transform");
-
-exports.ast = {
-  exit: function (ast, file) {
-    if (!transform.transformers.modules.canRun(file)) return;
-
-    if (file.moduleFormatter.transform) {
-      file.moduleFormatter.transform(ast);
-    }
-  }
-};

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

@@ -1,75 +0,0 @@
-var util = require("../util");
-var b    = require("acorn-ast-types").builders;
-
-var single = function (node) {
-  var block = node.blocks[0];
-
-  var templateName = "array-comprehension-map";
-  if (node.filter) templateName = "array-comprehension-filter";
-
-  var result = util.template(templateName, {
-    STATEMENT: node.body,
-    FILTER:    node.filter,
-    ARRAY:     block.right,
-    KEY:       block.left
-  });
-  result._aliasFunction = true;
-  return result;
-};
-
-var multiple = function (node, file) {
-  var uid = file.generateUid("arr");
-
-  var container = util.template("array-comprehension-container", {
-    KEY: uid
-  });
-  container._aliasFunction = true;
-
-  var block = container.callee.body;
-  var body  = block.body;
-
-  var returnStatement = body.pop();
-
-  var build = function () {
-    var self = node.blocks.shift();
-    if (!self) return;
-
-    var child = build();
-    if (!child) {
-      // last item
-
-      child = util.template("array-push", {
-        STATEMENT: node.body,
-        KEY:       uid
-      }, true);
-
-      // add a filter as this is our final stop
-      if (node.filter) {
-        child = b.ifStatement(node.filter, b.blockStatement([child]));
-      }
-    }
-
-    var container2 = util.template("array-comprehension-for-each", {
-      ARRAY: self.right,
-      KEY:   self.left
-    }, true);
-
-    // set function body
-    container2.expression.arguments[0].body.body = [child];
-
-    return container2;
-  };
-
-  body.push(build());
-  body.push(returnStatement);
-
-  return container;
-};
-
-exports.ComprehensionExpression = function (node, parent, file) {
-  if (node.blocks.length === 1) {
-    return single(node);
-  } else {
-    return multiple(node, file);
-  }
-};

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

@@ -1,11 +0,0 @@
-var util = require("../util");
-
-exports.ArrowFunctionExpression = function (node) {
-  util.ensureBlock(node);
-
-  node._aliasFunction = "arrows";
-  node.expression = false;
-  node.type = "FunctionExpression";
-
-  return node;
-};

lib/6to5/transformers/classes.js

@@ -1,185 +0,0 @@
-var traverse = require("../traverse");
-var util     = require("../util");
-var b        = require("acorn-ast-types").builders;
-var _        = require("lodash");
-
-exports.ClassDeclaration = function (node, parent, file) {
-  return b.variableDeclaration("var", [
-    b.variableDeclarator(node.id, buildClass(node, file))
-  ]);
-};
-
-exports.ClassExpression = function (node, parent, file) {
-  return buildClass(node, file);
-};
-
-var getMemberExpressionObject = function (node) {
-  while (node.type === "MemberExpression") {
-    node = node.object;
-  }
-  return node;
-};
-
-var buildClass = function (node, file) {
-  var superName = node.superClass;
-  var className = node.id || b.identifier(file.generateUid("class"));
-
-  var superClassArgument = node.superClass;
-  var superClassCallee   = node.superClass;
-
-  if (superName) {
-    if (superName.type === "MemberExpression") {
-      superClassArgument = superClassCallee = getMemberExpressionObject(superName);
-    } else if (superName.type !== "Identifier") {
-      superClassArgument = superName;
-      superClassCallee = superName = b.identifier(file.generateUid("ref"));
-    }
-  }
-
-  var container = util.template("class", {
-    CLASS_NAME: className
-  });
-
-  var block     = container.callee.body;
-  var body      = block.body;
-
-  if (node.id) {
-    body[0].declarations[0].init.id = className;
-  }
-
-  var returnStatement = body.pop();
-
-  if (superName) {
-    body.push(b.expressionStatement(b.callExpression(file.addDeclaration("extends"), [className, superName])));
-
-    container.arguments.push(superClassArgument);
-    container.callee.params.push(superClassCallee);
-  }
-
-  buildClassBody(file, body, className, superName, node);
-
-  body.push(returnStatement);
-
-  return container;
-};
-
-var buildClassBody = function (file, body, className, superName, node) {
-  var instanceMutatorMap = {};
-  var staticMutatorMap   = {};
-  var hasConstructor     = false;
-
-  var construct = body[0].declarations[0].init;
-  var classBody = node.body.body;
-
-  _.each(classBody, function (node) {
-    var methodName = node.key.name;
-    var method     = node.value;
-
-    replaceInstanceSuperReferences(superName, method, node, methodName);
-
-    if (methodName === "constructor") {
-      if (node.kind === "") {
-        hasConstructor = true;
-        addConstructor(construct, method);
-      } else {
-        throw util.errorWithNode(node, "unknown kind for constructor method");
-      }
-    } else {
-      var mutatorMap = instanceMutatorMap;
-      if (node.static) mutatorMap = staticMutatorMap;
-
-      var kind = node.kind;
-
-      if (kind === "") {
-        kind = "value";
-        util.pushMutatorMap(mutatorMap, methodName, "writable", b.identifier("true"));
-      }
-
-      util.pushMutatorMap(mutatorMap, methodName, kind, node);
-    }
-  });
-
-  if (!hasConstructor && superName) {
-    construct.body.body.push(util.template("class-super-constructor-call", {
-      SUPER_NAME: superName
-    }, true));
-  }
-
-  var instanceProps;
-  var staticProps;
-
-  if (!_.isEmpty(instanceMutatorMap)) {
-    var protoId = util.template("prototype-identifier", {
-      CLASS_NAME: className
-    });
-
-    instanceProps = util.buildDefineProperties(instanceMutatorMap, protoId);
-  }
-
-  if (!_.isEmpty(staticMutatorMap)) {
-    staticProps = util.buildDefineProperties(staticMutatorMap, className);
-  }
-
-  if (instanceProps || staticProps) {
-    instanceProps = instanceProps || b.literal(null);
-    staticProps = staticProps || b.literal(null);
-
-    body.push(b.expressionStatement(
-      b.callExpression(file.addDeclaration("class-props"), [className, staticProps, instanceProps])
-    ));
-  }
-};
-
-var superIdentifier = function (superName, methodNode, methodName, node, parent) {
-  if (parent.property === node) {
-    return;
-  } else if (parent.type === "CallExpression" && parent.callee === node) {
-    // super(); -> ClassName.prototype.MethodName.call(this);
-    parent.arguments.unshift(b.thisExpression());
-
-    if (methodName === "constructor") {
-      // constructor() { super(); }
-      return b.memberExpression(superName, b.identifier("call"), false);
-    } else {
-      node = superName;
-
-      // foo() { super(); }
-      if (!methodNode.static) {
-        node = b.memberExpression(node, b.identifier("prototype"), false);
-      }
-
-      node = b.memberExpression(node, b.identifier(methodName), false);
-      return b.memberExpression(node, b.identifier("call"), false);
-    }
-  } else if (parent.type === "MemberExpression" && !methodNode.static) {
-    // super.test -> ClassName.prototype.test
-    return b.memberExpression(superName, b.identifier("prototype"), false);
-  } else {
-    return superName;
-  }
-};
-
-var replaceInstanceSuperReferences = function (superName, method, methodNode, methodName) {
-  superName = superName || b.identifier("Function");
-
-  traverse(method, function (node, parent) {
-    if (node.type === "Identifier" && node.name === "super") {
-      return superIdentifier(superName, methodNode, methodName, node, parent);
-    } else if (node.type === "CallExpression") {
-      var callee = node.callee;
-      if (callee.type !== "MemberExpression") return;
-      if (callee.object.name !== "super") return;
-
-      //  super.test(); -> ClassName.prototype.MethodName.call(this);
-      callee.property.name = callee.property.name + ".call";
-      node.arguments.unshift(b.thisExpression());
-    }
-  });
-};
-
-var addConstructor = function (construct, method) {
-  construct.defaults = method.defaults;
-  construct.params   = method.params;
-  construct.body     = method.body;
-  construct.rest     = method.rest;
-};

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

@@ -1,47 +0,0 @@
-var util = require("../util");
-var b    = require("acorn-ast-types").builders;
-var _    = require("lodash");
-
-exports.ObjectExpression = function (node, parent, file) {
-  var hasComputed = false;
-
-  var computed = [];
-
-  node.properties = node.properties.filter(function (prop) {
-    if (prop.computed) {
-      hasComputed = true;
-      computed.unshift(prop);
-      return false;
-    } else {
-      return true;
-    }
-  });
-
-  if (!hasComputed) return;
-
-  var objId = util.getUid(parent, file);
-
-  var container = util.template("function-return-obj", {
-    KEY: objId,
-    OBJECT: node
-  });
-
-  var containerCallee = container.callee;
-  var containerBody = containerCallee.body.body;
-
-  containerCallee._aliasFunction = "arrows";
-
-  _.each(computed, function (prop) {
-    containerBody.unshift(
-      b.expressionStatement(
-        b.assignmentExpression(
-          "=",
-          b.memberExpression(objId, prop.key, true),
-          prop.value
-        )
-      )
-    );
-  });
-
-  return container;
-};

lib/6to5/transformers/constants.js

@@ -1,45 +0,0 @@
-var traverse = require("../traverse");
-var util     = require("../util");
-var _        = require("lodash");
-
-exports.Program =
-exports.BlockStatement =
-exports.ForInStatement =
-exports.ForOfStatement =
-exports.ForStatement = function (node) {
-  var constants = [];
-
-  var check = function (node, name) {
-    if (constants.indexOf(name) >= 0) {
-      throw util.errorWithNode(node, name + " is read-only");
-    }
-  };
-
-  _.each(node.body, function (child) {
-    if (child && child.type === "VariableDeclaration" && child.kind === "const") {
-      _.each(child.declarations, function (declar) {
-        _.each(util.getIds(declar.id), function (name) {
-          check(declar, name);
-          constants.push(name);
-        });
-
-        declar._ignoreConstant = true;
-      });
-      child.kind = "let";
-    }
-  });
-
-  if (!constants.length) return;
-
-  traverse(node, function (child) {
-    if (child._ignoreConstant) return;
-
-    if (child.type === "VariableDeclarator" ||
-        child.type === "FunctionDeclaration" ||
-        child.type === "ClassDeclaration") {
-      check(child, child.id.name);
-    } else if (child.type === "AssignmentExpression") {
-      check(child, child.left.name);
-    }
-  });
-};

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

@@ -1,20 +0,0 @@
-var util = require("../util");
-var _    = require("lodash");
-
-exports.Function = function (node) {
-  if (!node.defaults.length) return;
-  util.ensureBlock(node);
-
-  _.each(node.defaults, function (def, i) {
-    if (!def) return;
-
-    var param = node.params[i];
-
-    node.body.body.unshift(util.template("if-undefined-set-to", {
-      VARIABLE: param,
-      DEFAULT: def
-    }, true));
-  });
-
-  node.defaults = [];
-};

lib/6to5/transformers/destructuring.js

@@ -1,169 +0,0 @@
-var traverse = require("../traverse");
-var util     = require("../util");
-var b        = require("acorn-ast-types").builders;
-var _        = require("lodash");
-
-var buildVariableAssign = function (kind, id, init) {
-  if (kind === false) {
-    return b.expressionStatement(b.assignmentExpression("=", id, init));
-  } else {
-    return b.variableDeclaration(kind, [
-      b.variableDeclarator(id, init)
-    ]);
-  }
-};
-
-var push = function (kind, nodes, elem, parentId) {
-  if (elem.type === "ObjectPattern") {
-    pushObjectPattern(kind, nodes, elem, parentId);
-  } else if (elem.type === "ArrayPattern") {
-    pushArrayPattern(kind, nodes, elem, parentId);
-  } else if (elem.type === "MemberExpression") {
-    nodes.push(buildVariableAssign(false, elem, parentId));
-  } else {
-    nodes.push(buildVariableAssign(kind, elem, parentId));
-  }
-};
-
-var pushObjectPattern = function (kind, nodes, pattern, parentId) {
-  _.each(pattern.properties, function (prop) {
-    var pattern2   = prop.value;
-    var patternId2 = b.memberExpression(parentId, prop.key, false);
-
-    if (traverse.isPattern(pattern2)) {
-      push(kind, nodes, pattern2, patternId2);
-    } else {
-      nodes.push(buildVariableAssign(kind, pattern2, patternId2));
-    }
-  });
-};
-
-var pushArrayPattern = function (kind, nodes, pattern, parentId) {
-  _.each(pattern.elements, function (elem, i) {
-    if (!elem) return;
-
-    var newPatternId = b.memberExpression(parentId, b.literal(i), true);
-    push(kind, nodes, elem, newPatternId);
-  });
-};
-
-var pushPattern = function (kind, nodes, pattern, parentId, file) {
-  if (parentId.type !== "MemberExpression" && parentId.type !== "Identifier") {
-    var key = b.identifier(file.generateUid("ref"));
-
-    nodes.push(b.variableDeclaration("var", [
-      b.variableDeclarator(key, parentId)
-    ]));
-
-    parentId = key;
-  }
-
-  push(kind, nodes, pattern, parentId);
-};
-
-exports.ForInStatement =
-exports.ForOfStatement = function (node, parent, file) {
-  var declar = node.left;
-  if (declar.type !== "VariableDeclaration") return;
-
-  var pattern = declar.declarations[0].id;
-  if (!traverse.isPattern(pattern)) return;
-
-  var key = b.identifier(file.generateUid("ref"));
-  node.left = b.variableDeclaration(declar.kind, [
-    b.variableDeclarator(key, null)
-  ]);
-
-  var nodes = [];
-
-  push(declar.kind, nodes, pattern, key);
-
-  util.ensureBlock(node);
-
-  var block = node.body;
-  block.body = nodes.concat(block.body);
-};
-
-exports.Function = function (node, parent, file) {
-  var nodes = [];
-
-  var hasDestructuring = false;
-
-  node.params = node.params.map(function (pattern) {
-    if (!traverse.isPattern(pattern)) return pattern;
-
-    hasDestructuring = true;
-    var parentId = b.identifier(file.generateUid("ref"));
-    pushPattern("var", nodes, pattern, parentId, file);
-    return parentId;
-  });
-
-  if (!hasDestructuring) return;
-
-  util.ensureBlock(node);
-
-  var block = node.body;
-  block.body = nodes.concat(block.body);
-};
-
-exports.ExpressionStatement = function (node, parent, file) {
-  var expr = node.expression;
-  if (expr.type !== "AssignmentExpression") return;
-
-  if (!traverse.isPattern(expr.left)) return;
-
-  var nodes = [];
-
-  var ref = b.identifier(file.generateUid("ref"));
-  nodes.push(b.variableDeclaration("var", [
-    b.variableDeclarator(ref, expr.right)
-  ]));
-
-  push(false, nodes, expr.left, ref);
-
-  return nodes;
-};
-
-exports.VariableDeclaration = function (node, parent, file) {
-  if (parent.type === "ForInStatement") return;
-
-  var nodes = [];
-
-  var hasPattern = false;
-  _.each(node.declarations, function (declar) {
-    if (traverse.isPattern(declar.id)) {
-      hasPattern = true;
-      return false;
-    }
-  });
-  if (!hasPattern) return;
-
-  _.each(node.declarations, function (declar) {
-    var patternId = declar.init;
-    var pattern   = declar.id;
-    if (traverse.isPattern(pattern) && patternId) {
-      pushPattern(node.kind, nodes, pattern, patternId, file);
-    } else {
-      nodes.push(buildVariableAssign(node.kind, declar.id, declar.init));
-    }
-  });
-
-  if (parent.type !== "Program" && parent.type !== "BlockStatement") {
-    var declar;
-
-    _.each(nodes, function (node) {
-      declar = declar || b.variableDeclaration(node.kind, []);
-
-      if (node.type !== "VariableDeclaration" && declar.kind !== node.kind) {
-        throw util.errorWithNode(node, "Cannot use this node within the current parent");
-      }
-
-      declar.declarations = declar.declarations.concat(node.declarations);
-    });
-
-    return declar;
-  }
-
-  return nodes;
-};
-

lib/6to5/transformers/for-of.js

@@ -1,34 +0,0 @@
-var util = require("../util");
-var b    = require("acorn-ast-types").builders;
-
-exports.ForOfStatement = function (node, parent, file) {
-  var left = node.left;
-  var declar;
-
-  var stepKey = b.identifier(file.generateUid("step"));
-  var stepValueId = b.memberExpression(stepKey, b.identifier("value"), false);
-
-  if (left.type === "Identifier") {
-    declar = b.expressionStatement(b.assignmentExpression("=", left, stepValueId));
-  } else if (left.type === "VariableDeclaration") {
-    declar = b.variableDeclaration(left.kind, [
-      b.variableDeclarator(left.declarations[0].id, stepValueId)
-    ]);
-  } else {
-    return;
-  }
-
-  var node2 = util.template("for-of", {
-    ITERATOR_KEY: file.generateUid("iterator"),
-    STEP_KEY:     stepKey,
-    OBJECT:       node.right
-  });
-
-  util.ensureBlock(node);
-
-  var block = node2.body;
-  block.body.push(declar);
-  block.body = block.body.concat(node.body.body);
-
-  return node2;
-};

lib/6to5/transformers/generators.js

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

lib/6to5/transformers/jsx/index.js

@@ -1,97 +0,0 @@
-// Based upon the excellent jsx-transpiler by Ingvar Stepanyan (RReverser)
-// https://github.com/RReverser/jsx-transpiler
-
-var esutils = require("esutils");
-var b       = require("acorn-ast-types").builders;
-var _       = require("lodash");
-
-var JSX_ANNOTATION_REGEX = /^\*\s*@jsx\s+([^\s]+)/;
-var KNOWN_TAGS           = require("./known-tags");
-
-exports.Program = function (node, parent, file) {
-  var jsx = "React.DOM";
-
-  // looking for namespace annotation
-  _.each(node.comments, function (comment) {
-    if (!comment.possiblyLeading) return;
-
-    var matches = JSX_ANNOTATION_REGEX.exec(comment.value);
-    if (matches) jsx = matches[1];
-  });
-
-  // prebuilding AST node
-  file.jsx = jsx.split(".").map(b.identifier).reduce(function (object, property) {
-    return b.memberExpression(object, property, false);
-  });
-};
-
-exports.XJSIdentifier = function (node) {
-  if (esutils.keyword.isIdentifierName(node.name)) {
-    node.type = "Identifier";
-  } else {
-    return b.literal(node.name);
-  }
-};
-
-exports.XJSNamespacedName = function () {
-  throw new Error("Namespace tags are not supported. ReactJSX is not XML.");
-};
-
-exports.XJSMemberExpression = {
-  exit: function (node) {
-    node.computed = node.property.type === "Literal";
-    node.type = "MemberExpression";
-  }
-};
-
-exports.XJSEmptyExpression = function (node) {
-  node.value = null;
-  node.type = "Literal";
-};
-
-exports.XJSExpressionContainer = function (node) {
-  return node.expression;
-};
-
-exports.XJSAttribute = {
-  exit: function (node) {
-    var value = node.value || b.literal(true);
-    var propNode = b.property("init", node.name, value);
-    propNode.loc = node.loc;
-    return propNode;
-  }
-};
-
-exports.XJSOpeningElement = {
-  exit: function (node, parent, file) {
-    var tagExpr = node.name;
-
-    if (_.contains(KNOWN_TAGS, tagExpr.name)) {
-      tagExpr = b.memberExpression(file.jsx, tagExpr, false);
-    }
-
-    var props = node.attributes;
-    if (props.length) {
-      props = b.objectExpression(props);
-    } else {
-      props = b.literal(null);
-    }
-
-    return b.callExpression(tagExpr, [props]);
-  }
-};
-
-exports.XJSElement = {
-  exit: function (node) {
-    var callExpr = node.openingElement;
-    var children = node.children;
-
-    _.each(children, function (child) {
-      delete child.raw;
-      callExpr.arguments.push(child);
-    });
-
-    callExpr.loc = node.loc;
-    return callExpr;
-  }
-};

lib/6to5/transformers/jsx/known-tags.json

@@ -1,132 +0,0 @@
-[
-  "a",
-  "abbr",
-  "address",
-  "applet",
-  "area",
-  "article",
-  "aside",
-  "audio",
-  "b",
-  "base",
-  "bdi",
-  "bdo",
-  "big",
-  "blockquote",
-  "body",
-  "br",
-  "button",
-  "canvas",
-  "caption",
-  "circle",
-  "cite",
-  "code",
-  "col",
-  "colgroup",
-  "command",
-  "data",
-  "datalist",
-  "dd",
-  "defs",
-  "del",
-  "details",
-  "dfn",
-  "dialog",
-  "div",
-  "dl",
-  "dt",
-  "ellipse",
-  "em",
-  "embed",
-  "fieldset",
-  "figcaption",
-  "figure",
-  "footer",
-  "form",
-  "g",
-  "h1",
-  "h2",
-  "h3",
-  "h4",
-  "h5",
-  "h6",
-  "head",
-  "header",
-  "hgroup",
-  "hr",
-  "html",
-  "i",
-  "iframe",
-  "img",
-  "input",
-  "ins",
-  "kbd",
-  "keygen",
-  "label",
-  "legend",
-  "li",
-  "line",
-  "linearGradient",
-  "link",
-  "main",
-  "map",
-  "mark",
-  "marquee",
-  "menu",
-  "menuitem",
-  "meta",
-  "meter",
-  "nav",
-  "noscript",
-  "object",
-  "ol",
-  "optgroup",
-  "option",
-  "output",
-  "p",
-  "param",
-  "path",
-  "polygon",
-  "polyline",
-  "pre",
-  "progress",
-  "q",
-  "radialGradient",
-  "rect",
-  "rp",
-  "rt",
-  "ruby",
-  "s",
-  "samp",
-  "script",
-  "section",
-  "select",
-  "small",
-  "source",
-  "span",
-  "stop",
-  "strong",
-  "style",
-  "sub",
-  "summary",
-  "sup",
-  "svg",
-  "table",
-  "tbody",
-  "td",
-  "text",
-  "textarea",
-  "tfoot",
-  "th",
-  "thead",
-  "time",
-  "title",
-  "tr",
-  "track",
-  "tspan",
-  "u",
-  "ul",
-  "var",
-  "video",
-  "wbr"
-]

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

@@ -1,60 +0,0 @@
-var traverse = require("../traverse");
-var util     = require("../util");
-var b        = require("acorn-ast-types").builders;
-var _        = require("lodash");
-
-exports.VariableDeclaration = function (node, parent, file) {
-  if (node.kind !== "let") return;
-  node.kind = "var";
-
-  var ids = {};
-
-  _.each(node.declarations, function (declar) {
-    _.each(util.getIds(declar.id), function (id) {
-      ids[id] = b.identifier(file.generateUid(id));
-    });
-  });
-
-  var replaceId = function (node, parent) {
-    // not an identifier so we have no use for this node
-    if (node.type !== "Identifier") return;
-
-    // not a let reference
-    var id = ids[node.name];
-    if (!id) return;
-
-    if (util.isReferenced(node, parent)) return id;
-  };
-
-  var isProgram = parent.type === "Program";
-
-  var replace = function (node, parent) {
-    if (!isProgram && _.contains(traverse.FUNCTION_TYPES, node.type)) {
-      var letReferences = [];
-
-      traverse(node, function (node, parent) {
-        var id = replaceId(node, parent);
-        if (id && !_.contains(letReferences, id)) letReferences.push(id);
-        return id;
-      });
-
-      if (letReferences.length) {
-        if (node.type === "FunctionDeclaration") {
-          throw new Error("`FunctionDeclaration`s that use `let` and `constant` references aren't allowed outside of the root scope");
-        } else {
-          var func = b.functionExpression(null, letReferences, b.blockStatement([
-            b.returnStatement(node)
-          ]));
-          func._aliasFunction = true;
-          return b.callExpression(func, letReferences);
-        }
-      } else {
-        return false;
-      }
-    }
-
-    return replaceId(node, parent);
-  };
-
-  traverse(parent, replace);
-};

lib/6to5/transformers/modules.js

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

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

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

lib/6to5/transformers/property-method-assignment.js

@@ -1,32 +0,0 @@
-var util = require("../util");
-var _    = require("lodash");
-
-exports.Property = function (node) {
-  if (node.method) node.method = false;
-};
-
-exports.ObjectExpression = function (node, parent, file) {
-  var mutatorMap = {};
-
-  node.properties = node.properties.filter(function (prop) {
-    if (prop.kind === "get" || prop.kind === "set") {
-      util.pushMutatorMap(mutatorMap, prop.key.name, prop.kind, prop.value);
-      return false;
-    } else {
-      return true;
-    }
-  });
-
-  if (_.isEmpty(mutatorMap)) return;
-
-  var objId = util.getUid(parent, file);
-
-  return util.template("object-define-properties-closure", {
-    KEY: objId,
-    OBJECT: node,
-    CONTENT: util.template("object-define-properties", {
-      OBJECT: objId,
-      PROPS:  util.buildDefineProperties(mutatorMap)
-    })
-  });
-};

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

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

lib/6to5/transformers/react.js

@@ -1,63 +0,0 @@
-var b = require("acorn-ast-types").builders;
-var _ = require("lodash");
-
-var addDisplayName = function (id, call) {
-  if (!call || call.type !== "CallExpression") return;
-
-  var callee = call.callee;
-  if (callee.type !== "MemberExpression") return;
-
-  // not React
-  var obj = callee.object;
-  if (obj.type !== "Identifier" || obj.name !== "React") return;
-
-  // not createClass
-  var prop = callee.property;
-  if (prop.type !== "Identifier" || prop.name !== "createClass") return;
-
-  // no arguments
-  var args = call.arguments;
-  if (args.length !== 1) return;
-
-  // not an object
-  var first = args[0];
-  if (first.type !== "ObjectExpression") return;
-
-  var props = first.properties;
-  var safe = true;
-
-  _.each(props, function (prop) {
-    if (prop.key.name === "displayName") {
-      return safe = false;
-    }
-  });
-
-  if (safe) {
-    props.unshift(b.property("init", b.identifier("displayName"), b.literal(id)));
-  }
-};
-
-exports.AssignmentExpression =
-exports.Property =
-exports.VariableDeclarator = function (node) {
-  var left, right;
-
-  if (node.type === "AssignmentExpression") {
-    left = node.left;
-    right = node.right;
-  } else if (node.type === "Property") {
-    left = node.key;
-    right = node.value;
-  } else if (node.type === "VariableDeclarator") {
-    left = node.id;
-    right = node.init;
-  }
-
-  if (left && left.type === "MemberExpression") {
-    left = left.property;
-  }
-
-  if (left && left.type === "Identifier") {
-    addDisplayName(left.name, right);
-  }
-};

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

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

lib/6to5/transformers/spread.js

@@ -1,98 +0,0 @@
-var util = require("../util");
-var b    = require("acorn-ast-types").builders;
-var _    = require("lodash");
-
-var getSpreadLiteral = function (spread, file) {
-  var literal = spread.argument;
-  if (literal.type !== "ArrayExpression") {
-    literal = util.template("call", {
-      OBJECT: file.addDeclaration("slice"),
-      CONTEXT: literal
-    });
-  }
-  return literal;
-};
-
-var hasSpread = function (nodes) {
-  var has = false;
-  _.each(nodes, function (node) {
-    if (node.type === "SpreadElement") {
-      has = true;
-      return false;
-    }
-  });
-  return has;
-};
-
-var build = function (props, file) {
-  var nodes = [];
-
-  var _props = [];
-
-  var push = function () {
-    if (!_props.length) return;
-    nodes.push(b.arrayExpression(_props));
-    _props = [];
-  };
-
-  _.each(props, function (prop) {
-    if (prop.type === "SpreadElement") {
-      push();
-      nodes.push(getSpreadLiteral(prop, file));
-    } else {
-      _props.push(prop);
-    }
-  });
-
-  push();
-
-  return nodes;
-};
-
-exports.ArrayExpression = function (node, parent, file) {
-  var elements = node.elements;
-  if (!hasSpread(elements)) return;
-
-  var nodes = build(elements, file);
-  var first = nodes.shift();
-
-  if (!nodes.length) return first;
-
-  return b.callExpression(b.memberExpression(first, b.identifier("concat"), false), nodes);
-};
-
-exports.CallExpression = function (node, parent, file) {
-  var args = node.arguments;
-  if (!hasSpread(args)) return;
-
-  var contextLiteral = b.literal(null);
-
-  node.arguments = [];
-
-  var nodes = build(args, file);
-  var first = nodes.shift();
-
-  if (nodes.length) {
-    node.arguments.push(b.callExpression(b.memberExpression(first, b.identifier("concat"), false), nodes));
-  } else {
-    node.arguments.push(first);
-  }
-
-  var callee = node.callee;
-
-  if (callee.type === "MemberExpression") {
-    contextLiteral = callee.object;
-
-    if (callee.computed) {
-      callee.object = b.memberExpression(callee.object, callee.property, true);
-      callee.property = b.identifier("apply");
-      callee.computed = false;
-    } else {
-      callee.property = b.memberExpression(callee.property, b.identifier("apply"), false);
-    }
-  } else {
-    node.callee = b.memberExpression(node.callee, b.identifier("apply"), false);
-  }
-
-  node.arguments.unshift(contextLiteral);
-};

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

@@ -1,49 +0,0 @@
-var b = require("acorn-ast-types").builders;
-var _ = require("lodash");
-
-var buildBinaryExpression = function (left, right) {
-  return b.binaryExpression("+", left, right);
-};
-
-exports.TaggedTemplateExpression = function (node) {
-  var args = [];
-  var quasi = node.quasi;
-
-  var strings = quasi.quasis.map(function (elem) {
-    return b.literal(elem.value.raw);
-  });
-  args.push(b.arrayExpression(strings));
-
-  _.each(quasi.expressions, function (expr) {
-    args.push(expr);
-  });
-
-  return b.callExpression(node.tag, args);
-};
-
-exports.TemplateLiteral = function (node) {
-  var nodes = [];
-
-  _.each(node.quasis, function (elem) {
-    nodes.push(b.literal(elem.value.raw));
-
-    var expr = node.expressions.shift();
-    if (expr) nodes.push(expr);
-  });
-
-  if (nodes.length > 1) {
-    // remove redundant '' at the end of the expression
-    var last = _.last(nodes);
-    if (last.type === "Literal" && last.value === "") nodes.pop();
-
-    var root = buildBinaryExpression(nodes.shift(), nodes.shift());
-
-    _.each(nodes, function (node) {
-      root = buildBinaryExpression(root, node);
-    });
-
-    return root;
-  } else {
-    return nodes[0];
-  }
-};

lib/6to5/transformers/unicode-regex.js

@@ -1,15 +0,0 @@
-var rewritePattern = require("regexpu/rewrite-pattern");
-var b              = require("acorn-ast-types").builders;
-var _              = require("lodash");
-
-exports.Literal = function (node) {
-  var regex = node.regex;
-  if (!regex) return;
-
-  var flags = regex.flags.split("");
-  if (!_.contains(regex.flags, "u")) return;
-  _.pull(flags, "u");
-
-  var pattern = rewritePattern(regex.pattern, regex.flags);
-  return b.literal(new RegExp(pattern, flags.join("")));
-};

lib/6to5/transformers/use-strict.js

@@ -1,12 +0,0 @@
-var b = require("acorn-ast-types").builders;
-
-module.exports = function (ast) {
-  var body = ast.program.body;
-  var first = body[0];
-
-  var noStrict = !first || first.type !== "ExpressionStatement" || first.expression.type !== "Literal" || first.expression.value !== "use strict";
-
-  if (noStrict) {
-    body.unshift(b.expressionStatement(b.literal("use strict")));
-  }
-};

lib/6to5/traverse/index.js

@@ -1,127 +0,0 @@
-var VISITOR_KEYS = require("./visitor-keys");
-var _            = require("lodash");
-
-var traverse = module.exports = function (parent, callbacks, blacklistTypes) {
-  // falsy node
-  if (!parent) return;
-
-  // array of nodes
-  if (_.isArray(parent)) {
-    _.each(parent, function (node) {
-      traverse(node, callbacks, blacklistTypes);
-    });
-    return;
-  }
-
-  // unknown node type to traverse
-  var keys = VISITOR_KEYS[parent.type];
-  if (!keys) return;
-
-  // blacklist these node types from being traversed
-  blacklistTypes = blacklistTypes || [];
-
-  // normalise callbacks
-  if (_.isFunction(callbacks)) callbacks = { enter: callbacks };
-
-  _.each(keys, function (key) {
-    var nodes = parent[key];
-    if (!nodes) return;
-
-    var handle = function (obj, key) {
-      var node = obj[key];
-      if (!node) return;
-
-      // type is blacklisted
-      if (_.contains(blacklistTypes, node.type)) return;
-
-      var result;
-
-      // replace node
-      var maybeReplace = function (result) {
-        if (result != null) obj[key] = result;
-      };
-
-      // enter
-      if (callbacks.enter) {
-        result = callbacks.enter(node, parent, obj, key);
-
-        // stop iteration
-        if (result === false) return;
-
-        maybeReplace(result);
-      }
-
-      // traverse node
-      traverse(node, callbacks, blacklistTypes);
-
-      // exit
-      if (callbacks.exit) {
-        maybeReplace(callbacks.exit(node, parent, obj, key));
-      }
-    };
-
-    if (_.isArray(nodes)) {
-      _.each(nodes, function (node, i) {
-        handle(nodes, i);
-      });
-
-      // remove deleted nodes
-      parent[key] = _.flatten(parent[key]).filter(function (node) {
-        return node !== traverse.Delete;
-      });
-    } else {
-      handle(parent, key);
-
-      if (parent[key] === traverse.Delete) {
-        throw new Error("trying to delete property " + key + " from " +
-                        parent.type + " but can't because it's required");
-      }
-    }
-  });
-};
-
-traverse.FUNCTION_TYPES = ["ArrowFunctionExpression", "FunctionDeclaration", "FunctionExpression"];
-
-traverse.aliases = {
-  ArrowFunctionExpression: ["Function"],
-  FunctionDeclaration:     ["Function"],
-  FunctionExpression:      ["Function"]
-};
-
-traverse.isFunction = function (node) {
-  return _.contains(traverse.FUNCTION_TYPES, node.type);
-};
-
-traverse.isPattern = function (node) {
-  return node.type === "ArrayPattern" || node.type === "ObjectPattern";
-};
-
-traverse.Delete = {};
-
-traverse.hasType = function (tree, type, blacklistTypes) {
-  blacklistTypes = [].concat(blacklistTypes || []);
-
-  var has = false;
-
-  if (_.isArray(tree)) {
-    // array of nodes, find the first
-    return !!_.find(tree, function (node) {
-      return traverse.hasType(node, type, blacklistTypes);
-    });
-  } else {
-    // the node we're searching in is blacklisted
-    if (_.contains(blacklistTypes, tree.type)) return false;
-
-    // the type we're looking for is the same as the passed node
-    if (tree.type === type) return true;
-
-    traverse(tree, function (node) {
-      if (node.type === type) {
-        has = true;
-        return false;
-      }
-    }, blacklistTypes);
-  }
-
-  return has;
-};

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

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

lib/6to5/util.js

@@ -1,311 +0,0 @@
-var traverse = require("./traverse");
-var astTypes = require("acorn-ast-types");
-var recast   = require("acorn-recast");
-var path     = require("path");
-var util     = require("util");
-var fs       = require("fs");
-var _        = require("lodash");
-
-var n = astTypes.namedTypes;
-var b = astTypes.builders;
-
-exports.inherits = util.inherits;
-
-exports.ensureBlock = function (node) {
-  var block = node.body;
-  if (block.type === "BlockStatement") return;
-
-  if (!_.isArray(block)) {
-    if (!n.Statement.check(block)) block = b.returnStatement(block);
-    block = [block];
-  }
-
-  node.body = b.blockStatement(block);
-};
-
-exports.resolve = function (loc) {
-  try {
-    return require.resolve(loc);
-  } catch (err) {
-    return null;
-  }
-};
-
-exports.list = function (val) {
-  return val ? val.split(",") : [];
-};
-
-exports.getSpecifierName = function (specifier) {
-  return specifier.name || specifier.id;
-};
-
-exports.ensureExpressionType = function (node) {
-  node.type = {
-    FunctionDeclaration: "FunctionExpression",
-    ClassDeclaration: "ClassExpression"
-  }[node.type] || node.type;
-  return node;
-};
-
-exports.getUid = function (parent, file) {
-  var node;
-
-  if (parent.type === "AssignmentExpression") {
-    node = parent.left;
-  } else if (parent.type === "VariableDeclarator") {
-    node = parent.id;
-  }
-
-  var id = "ref";
-
-  if (node && node.type === "Identifier") {
-    id = node.name;
-  }
-
-  return b.identifier(file.generateUid(id));
-};
-
-exports.isAbsolute = function (loc) {
-  if (!loc) return false;
-  if (loc[0] === "/") return true; // unix
-  if (loc[1] === ":" && loc[2] === "\\") return true; // windows
-  return false;
-};
-
-exports.removeProperties = function (tree) {
-  var clear = function (node) {
-    delete node.tokens;
-    delete node.range;
-    delete node.loc;
-  };
-
-  clear(tree);
-  traverse(tree, clear);
-
-  return tree;
-};
-
-exports.getIds = function (node) {
-  var search = [node];
-  var ids  = [];
-
-  while (search.length) {
-    var id = search.shift();
-
-    if (id.type === "Identifier") {
-      ids.push(id.name);
-    } else if (id.type === "ArrayPattern") {
-      _.each(id.elements, function (elem) {
-        search.push(elem);
-      });
-    } else if (id.type === "ObjectPattern") {
-      _.each(id.properties, function (prop) {
-        search.push(prop.value);
-      });
-    } else {
-      throw new Error("unknown node " + id.type);
-    }
-  }
-
-  return ids;
-};
-
-exports.errorWithNode = function (node, msg) {
-  var line = node.loc.start.line;
-  var col  = node.loc.start.column;
-
-  var err = new SyntaxError("Line " + line + ": " + msg);
-  err.lineNumber = line;
-  err.column = col;
-  return err;
-};
-
-exports.canCompile = function (filename) {
-  var ext = path.extname(filename);
-  return _.contains([".js", ".es6"], ext);
-};
-
-exports.sourceMapToComment = function (map) {
-  var json = JSON.stringify(map);
-  var base64 = new Buffer(json).toString("base64");
-  return "//# sourceMappingURL=data:application/json;base64," + base64;
-};
-
-exports.pushMutatorMap = function (mutatorMap, key, kind, method) {
-  var map;
-  if (_.has(mutatorMap, key)) {
-    map = mutatorMap[key];
-  } else {
-    map = {};
-  }
-  mutatorMap[key] = map;
-
-  if (map[kind]) {
-    throw new Error("a " + kind + " already exists for this property");
-  } else {
-    map[kind] = method;
-  }
-};
-
-exports.buildDefineProperties = function (mutatorMap) {
-  var objExpr = b.objectExpression([]);
-
-  _.each(mutatorMap, function (map, key) {
-    var mapNode = b.objectExpression([]);
-
-    var propNode = b.property("init", b.identifier(key), mapNode);
-
-    _.each(map, function (node, key) {
-      node = _.clone(node);
-      if (node.type === "MethodDefinition") node = node.value;
-      mapNode.properties.push(b.property("init", b.identifier(key), node));
-    });
-
-    objExpr.properties.push(propNode);
-  });
-
-  return objExpr;
-};
-
-exports.template = function (name, nodes, keepExpression) {
-  var template = exports.templates[name];
-  if (!template) throw new ReferenceError("unknown template " + name);
-
-  template = _.cloneDeep(template);
-
-  if (!_.isEmpty(nodes)) {
-    traverse(template, function (node) {
-      if (node.type === "Identifier" && _.has(nodes, node.name)) {
-        var newNode = nodes[node.name];
-        if (_.isString(newNode)) {
-          node.name = newNode;
-        } else {
-          return newNode;
-        }
-      }
-    });
-  }
-
-  var node = template.body[0];
-
-  if (!keepExpression && node.type === "ExpressionStatement") {
-    return node.expression;
-  } else {
-    return node;
-  }
-};
-
-exports.isReferenced = function (node, parent) {
-  // we're a property key
-  if (parent.type === "Property" && parent.key === node) return false;
-
-  var isMemberExpression = parent.type === "MemberExpression";
-
-  // we're in a member expression and we're the computed property so we're referenced
-  var isComputedProperty = isMemberExpression && parent.property === node && parent.computed;
-
-  // we're in a member expression and we're the object so we're referenced
-  var isObject = isMemberExpression && parent.object === node;
-
-  // we are referenced
-  if (!isMemberExpression || isComputedProperty || isObject) return true;
-
-  return false;
-};
-
-exports.codeFrame = function (lines, lineNumber, colNumber) {
-  colNumber = Math.max(colNumber, 0);
-
-  lines = lines.split("\n");
-  var start = Math.max(lineNumber - 3, 0);
-  var end   = Math.min(lines.length, lineNumber + 3);
-  var width = (end + "").length;
-
-  return "\n" + lines.slice(start, end).map(function (line, i) {
-    var curr = i + start + 1;
-
-    var gutter = curr === lineNumber ? "> " : "  ";
-
-    var sep = curr + exports.repeat(width + 1);
-    gutter += sep + "| ";
-
-    var str = gutter + line;
-
-    if (colNumber && curr === lineNumber) {
-      str += "\n";
-      str += exports.repeat(gutter.length - 2);
-      str += "|" + exports.repeat(colNumber) + "^";
-    }
-
-    return str;
-  }).join("\n");
-};
-
-exports.repeat = function (width, cha) {
-  cha = cha || " ";
-  return new Array(width + 1).join(cha);
-};
-
-exports.parse = function (opts, code, callback) {
-  try {
-    var recastOpts = {};
-
-    if (opts.sourceMap) {
-      recastOpts.sourceFileName = opts.sourceFileName;
-      recastOpts.sourceRoot     = opts.sourceRoot;
-    }
-
-    var ast = recast.parse(code, recastOpts);
-
-    if (callback) {
-      return callback(ast);
-    } else {
-      return ast;
-    }
-  } catch (err) {
-    if (!err._6to5) {
-      err._6to5 = true;
-      var message = opts.filename + ": " + err.message;
-
-      if (err.loc) {
-        var frame = exports.codeFrame(code, err.loc.line, err.loc.column);
-        message += frame;
-      }
-
-      err.stack   = err.stack.replace(err.message, message);
-      err.message = message;
-    }
-
-    throw err;
-  }
-};
-
-exports.parseNoProperties = function (loc, code) {
-  var ast = exports.parse({ filename: loc }, code).program;
-  return exports.removeProperties(ast);
-};
-
-try {
-  exports.templates = require("../../templates.json");
-} catch (err) {
-  if (err.code !== "MODULE_NOT_FOUND") throw err;
-
-  exports.templates = {};
-
-  var templatesLoc = __dirname + "/templates";
-  if (!fs.existsSync(templatesLoc)) {
-    throw new Error("no templates directory - this is most likely the result" +
-                    " of a broken `npm publish`. Please report to " +
-                    "https://github.com/sebmck/6to5/issues");
-  }
-
-  _.each(fs.readdirSync(templatesLoc), function (name) {
-    if (name[0] === ".") return;
-
-    var key  = path.basename(name, path.extname(name));
-    var loc  = templatesLoc + "/" + name;
-    var code = fs.readFileSync(loc, "utf8");
-
-    exports.templates[key] = exports.parseNoProperties(loc, code);
-  });
-}

package.json

@@ -1,21 +1,13 @@
 {
-  "name": "6to5",
+  "name": "babel-core",
   "description": "Turn ES6 code into readable vanilla ES5 with source maps",
-  "version": "1.10.12",
+  "version": "5.1.9",
   "author": "Sebastian McKenzie <sebmck@gmail.com>",
-  "homepage": "https://github.com/sebmck/6to5",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/sebmck/6to5.git"
-  },
-  "bugs": {
-    "url": "https://github.com/sebmck/6to5/issues"
-  },
-  "preferGlobal": true,
-  "main": "lib/6to5/index.js",
-  "bin": {
-    "6to5": "./bin/6to5/index.js",
-    "6to5-node": "./bin/6to5-node"
+  "homepage": "https://babeljs.io/",
+  "repository": "babel/babel",
+  "main": "lib/babel/api/node.js",
+  "browser": {
+    "./lib/babel/api/register/node.js": "./lib/babel/api/register/browser.js"
   },
   "keywords": [
     "harmony",
@@ -27,39 +19,56 @@
     "es6",
     "transpile",
     "transpiler",
-    "6to5"
+    "6to5",
+    "babel"
   ],
   "scripts": {
     "bench": "make bench",
     "test": "make test"
   },
   "dependencies": {
-    "commander": "2.4.0",
-    "fs-readdir-recursive": "0.0.2",
-    "lodash": "2.4.1",
-    "mkdirp": "0.5.0",
-    "es6-shim": "0.18.0",
-    "es6-symbol": "0.1.1",
-    "regexpu": "0.3.0",
-    "recast": "0.8.0",
-    "source-map": "0.1.40",
-    "regenerator": "0.6.7",
-    "chokidar": "0.10.0",
-    "source-map-support": "0.2.7",
-    "esutils": "1.1.4",
-    "acorn-jsx": "https://github.com/sebmck/acorn-jsx/archive/master.tar.gz",
-    "acorn-recast": "0.8.0-4",
-    "acorn-ast-types": "0.5.3-1"
+    "ast-types": "~0.7.0",
+    "chalk": "^1.0.0",
+    "convert-source-map": "^1.0.0",
+    "core-js": "^0.8.3",
+    "debug": "^2.1.1",
+    "detect-indent": "^3.0.0",
+    "estraverse": "^3.0.0",
+    "esutils": "^2.0.0",
+    "fs-readdir-recursive": "^0.1.0",
+    "globals": "^6.4.0",
+    "is-integer": "^1.0.4",
+    "js-tokens": "1.0.0",
+    "leven": "^1.0.1",
+    "line-numbers": "0.2.0",
+    "lodash": "^3.6.0",
+    "minimatch": "^2.0.3",
+    "output-file-sync": "^1.1.0",
+    "path-is-absolute": "^1.0.0",
+    "private": "^0.1.6",
+    "regenerator": "^0.8.20",
+    "regexpu": "^1.1.2",
+    "repeating": "^1.1.2",
+    "shebang-regex": "^1.0.0",
+    "slash": "^1.0.0",
+    "source-map": "^0.4.0",
+    "source-map-support": "^0.2.10",
+    "strip-json-comments": "^1.0.2",
+    "to-fast-properties": "^1.0.0",
+    "trim-right": "^1.0.0",
+    "user-home": "^1.1.1"
   },
   "devDependencies": {
-    "istanbul": "0.3.2",
-    "matcha": "0.5.0",
-    "mocha": "1.21.5",
-    "uglify-js": "2.4.15",
-    "browserify": "6.1.0",
-    "proclaim": "2.0.0",
-    "rimraf": "2.2.8",
-    "jshint": "2.5.6",
-    "chai": "^1.9.2"
+    "babel": "4.7.13",
+    "browserify": "^9.0.8",
+    "chai": "^2.2.0",
+    "eslint": "^0.18.0",
+    "babel-eslint": "^2.0.0",
+    "esvalid": "^1.1.0",
+    "istanbul": "^0.3.5",
+    "matcha": "^0.6.0",
+    "mocha": "2.2.0",
+    "rimraf": "^2.3.2",
+    "uglify-js": "^2.4.16"
   }
 }

packages/babel-cli/README.md

@@ -0,0 +1,5 @@
+# babel-cli
+
+Babel CLI
+
+For more information please look at [babel](https://github.com/babel/babel).

packages/babel-cli/bin/_babel-node

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+
+var pathIsAbsolute = require("path-is-absolute");
+var commander      = require("commander");
+var Module         = require("module");
+var babel          = require("babel-core");
+var inspect        = require("util").inspect;
+var path           = require("path");
+var repl           = require("repl");
+var util           = require("babel-core").util;
+var vm             = require("vm");
+var _              = require("lodash");
+
+var program = new commander.Command("babel-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, --stage [stage]", "Enable support for specific ECMAScript stages");
+program.option("-w, --whitelist [whitelist]", "Whitelist of transformers to ONLY use", util.list);
+program.option("-b, --blacklist [blacklist]", "Blacklist of transformers to NOT use", util.list);
+program.option("-o, --optional [optional]", "List of optional transformers to enable", util.list);
+
+var pkg = require("../package.json");
+program.version(pkg.version);
+program.usage("[options] [ -e script | script.js ] [arguments]");
+program.parse(process.argv);
+
+//
+
+babel.register({
+  extensions:   program.extensions,
+  blacklist:    program.blacklist,
+  whitelist:    program.whitelist,
+  optional:     program.optional,
+  ignore:       program.ignore,
+  stage:        program.stage,
+});
+
+//
+
+var _eval = function (code, filename) {
+  if (!code) return undefined;
+
+  code = babel.transform(code, {
+    filename: filename,
+    blacklist: program.blacklist,
+    whitelist: program.whitelist,
+    optional: program.optional,
+    stage: program.stage
+  }).code;
+
+  return vm.runInThisContext(code, {
+    filename: filename
+  });
+};
+
+if (program.eval || program.print) {
+  var code = program.eval;
+  if (!code || code === true) code = program.print;
+
+  global.__filename = "[eval]";
+  global.__dirname = process.cwd();
+
+  var module = new Module(global.__filename);
+  module.filename = global.__filename;
+  module.paths    = Module._nodeModulePaths(global.__dirname);
+
+  global.exports = module.exports;
+  global.module  = module;
+  global.require = module.require.bind(module);
+
+  var result = _eval(code, global.__filename);
+  if (program.print) {
+    var output = _.isString(result) ? result : inspect(result);
+    process.stdout.write(output + "\n");
+  }
+} else {
+  if (program.args.length) {
+    // slice all arguments up to the first filename since they're babel args that we handle
+    var args = process.argv.slice(2);
+
+    var i = 0;
+    var ignoreNext = false;
+    _.each(args, function (arg, i2) {
+      if (ignoreNext) {
+        ignoreNext = false;
+        return;
+      }
+
+      if (arg[0] === "-") {
+        var parsedArg = program[arg.slice(2)];
+        if (parsedArg && parsedArg !== true) {
+          ignoreNext = true;
+        }
+      } else {
+        i = i2;
+        return false;
+      }
+    });
+    args = args.slice(i);
+
+    // make the filename absolute
+    var filename = args[0];
+    if (!pathIsAbsolute(filename)) args[0] = path.join(process.cwd(), filename);
+
+    // add back on node and concat the sliced args
+    process.argv = ["node"].concat(args);
+
+    Module.runMain();
+  } else {
+    replStart();
+  }
+}
+
+function replStart() {
+  repl.start({
+    prompt: "> ",
+    input: process.stdin,
+    output: process.stdout,
+    eval: replEval,
+    useGlobal: true
+  });
+}
+
+function replEval(code, context, filename, callback) {
+  var err;
+  var result;
+
+  try {
+    if (code[0] === "(" && code[code.length - 1] === ")") {
+      code = code.slice(1, -1); // remove "(" and ")"
+    }
+
+    result = _eval(code, filename);
+  } catch (e) {
+    err = e;
+  }
+
+  callback(err, result);
+}

packages/babel-cli/bin/babel-external-helpers

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+
+var commander = require("commander");
+var util      = require("babel-core").util;
+var runtime   = require("babel-core").buildExternalHelpers;
+
+commander.option("-l, --whitelist [whitelist]", "Whitelist of helpers to ONLY include", util.list);
+commander.option("-t, --output-type [type]", "Type of output (global|umd|var)", "global");
+
+commander.usage("[options]");
+commander.parse(process.argv);
+
+console.log(runtime(commander.whitelist, commander.outputType));

packages/babel-cli/bin/babel-node

@@ -0,0 +1,448 @@
+#!/usr/bin/env node
+
+/**
+ * This tiny wrapper file checks for known node flags and appends them
+ * when found, before invoking the "real" _babel-node(1) executable.
+ */
+
+var args  = [__dirname + "/_babel-node"];
+
+var babelArgs = process.argv.slice(2);
+var userArgs;
+
+// separate node arguments from script arguments
+var argSeparator = babelArgs.indexOf("--");
+if (argSeparator > -1) {
+  userArgs  = babelArgs.slice(argSeparator); // including the  --
+  babelArgs = babelArgs.slice(0, argSeparator);
+}
+
+babelArgs.forEach(function(arg){
+  var flag = arg.split("=")[0];
+
+  switch (flag) {
+    case "-d":
+      args.unshift("--debug");
+      break;
+
+    case "debug":
+    case "--debug":
+    case "--debug-brk":
+      args.unshift(arg);
+      break;
+
+    case "-gc":
+    case "--expose-gc":
+      args.unshift("--expose-gc");
+      break;
+
+    case "--use_strict":
+    case "--es_staging":
+    case "--harmony":
+    case "--harmony_shipping":
+    case "--harmony_modules":
+    case "--harmony_arrays":
+    case "--harmony_array_includes":
+    case "--harmony_regexps":
+    case "--harmony_arrow_functions":
+    case "--harmony_proxies":
+    case "--harmony_sloppy":
+    case "--harmony_unicode":
+    case "--harmony_tostring":
+    case "--harmony_numeric_literals":
+    case "--harmony_strings":
+    case "--harmony_scoping":
+    case "--harmony_classes":
+    case "--harmony_object_literals":
+    case "--harmony_templates":
+    case "--compiled_keyed_generic_loads":
+    case "--pretenuring_call_new":
+    case "--allocation_site_pretenuring":
+    case "--trace_pretenuring":
+    case "--trace_pretenuring_statistics":
+    case "--track_fields":
+    case "--track_double_fields":
+    case "--track_heap_object_fields":
+    case "--track_computed_fields":
+    case "--track_field_types":
+    case "--smi_binop":
+    case "--vector_ics":
+    case "--optimize_for_size":
+    case "--unbox_double_arrays":
+    case "--string_slices":
+    case "--crankshaft":
+    case "--hydrogen_filter":
+    case "--use_gvn":
+    case "--gvn_iterations":
+    case "--use_canonicalizing":
+    case "--use_inlining":
+    case "--use_escape_analysis":
+    case "--use_allocation_folding":
+    case "--use_local_allocation_folding":
+    case "--use_write_barrier_elimination":
+    case "--max_inlining_levels":
+    case "--max_inlined_source_size":
+    case "--max_inlined_nodes":
+    case "--max_inlined_nodes_cumulative":
+    case "--loop_invariant_code_motion":
+    case "--fast_math":
+    case "--collect_megamorphic_maps_from_stub_cache":
+    case "--hydrogen_stats":
+    case "--trace_check_elimination":
+    case "--trace_hydrogen":
+    case "--trace_hydrogen_filter":
+    case "--trace_hydrogen_stubs":
+    case "--trace_hydrogen_file":
+    case "--trace_phase":
+    case "--trace_inlining":
+    case "--trace_load_elimination":
+    case "--trace_store_elimination":
+    case "--trace_alloc":
+    case "--trace_all_uses":
+    case "--trace_range":
+    case "--trace_gvn":
+    case "--trace_representation":
+    case "--trace_removable_simulates":
+    case "--trace_escape_analysis":
+    case "--trace_allocation_folding":
+    case "--trace_track_allocation_sites":
+    case "--trace_migration":
+    case "--trace_generalization":
+    case "--stress_pointer_maps":
+    case "--stress_environments":
+    case "--deopt_every_n_times":
+    case "--deopt_every_n_garbage_collections":
+    case "--print_deopt_stress":
+    case "--trap_on_deopt":
+    case "--trap_on_stub_deopt":
+    case "--deoptimize_uncommon_cases":
+    case "--polymorphic_inlining":
+    case "--use_osr":
+    case "--array_bounds_checks_elimination":
+    case "--trace_bce":
+    case "--array_bounds_checks_hoisting":
+    case "--array_index_dehoisting":
+    case "--analyze_environment_liveness":
+    case "--load_elimination":
+    case "--check_elimination":
+    case "--store_elimination":
+    case "--dead_code_elimination":
+    case "--fold_constants":
+    case "--trace_dead_code_elimination":
+    case "--unreachable_code_elimination":
+    case "--trace_osr":
+    case "--stress_runs":
+    case "--lookup_sample_by_shared":
+    case "--cache_optimized_code":
+    case "--flush_optimized_code_cache":
+    case "--inline_construct":
+    case "--inline_arguments":
+    case "--inline_accessors":
+    case "--escape_analysis_iterations":
+    case "--optimize_for_in":
+    case "--concurrent_recompilation":
+    case "--job_based_recompilation":
+    case "--trace_concurrent_recompilation":
+    case "--concurrent_recompilation_queue_length":
+    case "--concurrent_recompilation_delay":
+    case "--block_concurrent_recompilation":
+    case "--concurrent_osr":
+    case "--omit_map_checks_for_leaf_maps":
+    case "--turbo_filter":
+    case "--trace_turbo":
+    case "--trace_turbo_graph":
+    case "--trace_turbo_cfg_file":
+    case "--trace_turbo_types":
+    case "--trace_turbo_scheduler":
+    case "--trace_turbo_reduction":
+    case "--trace_turbo_jt":
+    case "--turbo_asm":
+    case "--turbo_verify":
+    case "--turbo_stats":
+    case "--turbo_types":
+    case "--turbo_source_positions":
+    case "--context_specialization":
+    case "--turbo_deoptimization":
+    case "--turbo_inlining":
+    case "--turbo_inlining_intrinsics":
+    case "--trace_turbo_inlining":
+    case "--loop_assignment_analysis":
+    case "--turbo_profiling":
+    case "--turbo_reuse_spill_slots":
+    case "--turbo_delay_ssa_decon":
+    case "--turbo_move_optimization":
+    case "--turbo_jt":
+    case "--typed_array_max_size_in_heap":
+    case "--frame_count":
+    case "--interrupt_budget":
+    case "--type_info_threshold":
+    case "--generic_ic_threshold":
+    case "--self_opt_count":
+    case "--trace_opt_verbose":
+    case "--debug_code":
+    case "--code_comments":
+    case "--enable_sse3":
+    case "--enable_sse4_1":
+    case "--enable_sahf":
+    case "--enable_avx":
+    case "--enable_fma3":
+    case "--enable_vfp3":
+    case "--enable_armv7":
+    case "--enable_armv8":
+    case "--enable_neon":
+    case "--enable_sudiv":
+    case "--enable_mls":
+    case "--enable_movw_movt":
+    case "--enable_unaligned_accesses":
+    case "--enable_32dregs":
+    case "--enable_vldr_imm":
+    case "--force_long_branches":
+    case "--expose_natives_as":
+    case "--expose_debug_as":
+    case "--expose_free_buffer":
+    case "--expose_gc":
+    case "--expose_gc_as":
+    case "--expose_externalize_string":
+    case "--expose_trigger_failure":
+    case "--stack_trace_limit":
+    case "--builtins_in_stack_traces":
+    case "--disable_native_files":
+    case "--inline_new":
+    case "--trace_codegen":
+    case "--trace":
+    case "--mask_constants_with_cookie":
+    case "--lazy":
+    case "--trace_opt":
+    case "--trace_opt_stats":
+    case "--opt":
+    case "--always_opt":
+    case "--always_osr":
+    case "--prepare_always_opt":
+    case "--trace_deopt":
+    case "--trace_stub_failures":
+    case "--serialize_toplevel":
+    case "--serialize_inner":
+    case "--trace_serializer":
+    case "--min_preparse_length":
+    case "--max_opt_count":
+    case "--compilation_cache":
+    case "--cache_prototype_transitions":
+    case "--cpu_profiler_sampling_interval":
+    case "--trace_debug_json":
+    case "--trace_js_array_abuse":
+    case "--trace_external_array_abuse":
+    case "--trace_array_abuse":
+    case "--enable_liveedit":
+    case "--hard_abort":
+    case "--stack_size":
+    case "--max_stack_trace_source_length":
+    case "--always_inline_smi_code":
+    case "--min_semi_space_size":
+    case "--target_semi_space_size":
+    case "--max_semi_space_size":
+    case "--semi_space_growth_factor":
+    case "--experimental_new_space_growth_heuristic":
+    case "--max_old_space_size":
+    case "--initial_old_space_size":
+    case "--max_executable_size":
+    case "--gc_global":
+    case "--gc_interval":
+    case "--trace_gc":
+    case "--trace_gc_nvp":
+    case "--trace_gc_ignore_scavenger":
+    case "--trace_idle_notification":
+    case "--trace_idle_notification_verbose":
+    case "--print_cumulative_gc_stat":
+    case "--print_max_heap_committed":
+    case "--trace_gc_verbose":
+    case "--trace_fragmentation":
+    case "--collect_maps":
+    case "--weak_embedded_maps_in_optimized_code":
+    case "--weak_embedded_objects_in_optimized_code":
+    case "--flush_code":
+    case "--flush_code_incrementally":
+    case "--trace_code_flushing":
+    case "--age_code":
+    case "--incremental_marking":
+    case "--incremental_marking_steps":
+    case "--concurrent_sweeping":
+    case "--trace_incremental_marking":
+    case "--track_gc_object_stats":
+    case "--heap_profiler_trace_objects":
+    case "--use_idle_notification":
+    case "--use_ic":
+    case "--trace_ic":
+    case "--native_code_counters":
+    case "--always_compact":
+    case "--never_compact":
+    case "--compact_code_space":
+    case "--incremental_code_compaction":
+    case "--cleanup_code_caches_at_gc":
+    case "--use_marking_progress_bar":
+    case "--zap_code_space":
+    case "--random_seed":
+    case "--trace_weak_arrays":
+    case "--track_prototype_users":
+    case "--use_verbose_printer":
+    case "--allow_natives_syntax":
+    case "--trace_parse":
+    case "--trace_sim":
+    case "--debug_sim":
+    case "--check_icache":
+    case "--stop_sim_at":
+    case "--sim_stack_alignment":
+    case "--sim_stack_size":
+    case "--log_regs_modified":
+    case "--log_colour":
+    case "--ignore_asm_unimplemented_break":
+    case "--trace_sim_messages":
+    case "--stack_trace_on_illegal":
+    case "--abort_on_uncaught_exception":
+    case "--randomize_hashes":
+    case "--hash_seed":
+    case "--profile_deserialization":
+    case "--regexp_optimization":
+    case "--testing_bool_flag":
+    case "--testing_maybe_bool_flag":
+    case "--testing_int_flag":
+    case "--testing_float_flag":
+    case "--testing_string_flag":
+    case "--testing_prng_seed":
+    case "--testing_serialization_file":
+    case "--startup_blob":
+    case "--profile_hydrogen_code_stub_compilation":
+    case "--predictable":
+    case "--help":
+    case "--dump_counters":
+    case "--debugger":
+    case "--map_counters":
+    case "--js_arguments":
+    case "--gdbjit":
+    case "--gdbjit_full":
+    case "--gdbjit_dump":
+    case "--gdbjit_dump_filter":
+    case "--force_marking_deque_overflows":
+    case "--stress_compaction":
+    case "--log":
+    case "--log_all":
+    case "--log_api":
+    case "--log_code":
+    case "--log_gc":
+    case "--log_handles":
+    case "--log_snapshot_positions":
+    case "--log_suspect":
+    case "--prof":
+    case "--prof_browser_mode":
+    case "--log_regexp":
+    case "--logfile":
+    case "--logfile_per_isolate":
+    case "--ll_prof":
+    case "--perf_basic_prof":
+    case "--perf_jit_prof":
+    case "--gc_fake_mmap":
+    case "--log_internal_timer_events":
+    case "--log_timer_events":
+    case "--log_instruction_stats":
+    case "--log_instruction_file":
+    case "--log_instruction_period":
+    case "--redirect_code_traces":
+    case "--redirect_code_traces_to":
+    case "--hydrogen_track_positions":
+    case "--trace_elements_transitions":
+    case "--trace_creation_allocation_sites":
+    case "--print_code_stubs":
+    case "--test_secondary_stub_cache":
+    case "--test_primary_stub_cache":
+    case "--print_code":
+    case "--print_opt_code":
+    case "--print_unopt_code":
+    case "--print_code_verbose":
+    case "--print_builtin_code":
+    case "--sodium":
+    case "--print_all_code":
+    case "--es5_readonly":
+    case "--es52_globals":
+    case "--harmony_typeof":
+    case "--harmony_collections":
+    case "--packed_arrays":
+    case "--smi_only_arrays":
+    case "--clever_optimizations":
+    case "--use_range":
+    case "--eliminate_dead_phis":
+    case "--optimize_closures":
+    case "--loop_weight":
+    case "--opt_safe_uint32_operations":
+    case "--parallel_recompilation":
+    case "--trace_parallel_recompilation":
+    case "--parallel_recompilation_queue_length":
+    case "--experimental_profiler":
+    case "--watch_ic_patching":
+    case "--self_optimization":
+    case "--direct_self_opt":
+    case "--retry_self_opt":
+    case "--count_based_interrupts":
+    case "--interrupt_at_exit":
+    case "--weighted_back_edges":
+    case "--debug_code (generate extra code":
+    case "--enable_sse2":
+    case "--enable_cmov":
+    case "--enable_rdtsc":
+    case "--enable_vfp2":
+    case "--enable_fpu":
+    case "--stack_trace_on_abort":
+    case "--always_full_compiler":
+    case "--debugger_auto_break":
+    case "--break_on_abort":
+    case "--max_new_space_size":
+    case "--trace_external_memory":
+    case "--lazy_sweeping":
+    case "--trace_exception":
+    case "--preallocate_message_memory":
+    case "--preemption":
+    case "--extra_code":
+    case "--remote_debugger":
+    case "--debugger_agent":
+    case "--debugger_port":
+    case "--debug_compile_events":
+    case "--debug_script_collected_events":
+    case "--gdbjit":
+    case "--log_runtime":
+    case "--prof_auto":
+    case "--prof_lazy":
+    case "--sliding_state_window":
+      args.unshift(arg);
+      break;
+
+    default:
+      if (arg.indexOf("--trace") === 0) {
+        args.unshift(arg);
+      } else {
+        args.push(arg);
+      }
+      break;
+  }
+});
+
+// append arguments passed after --
+if (argSeparator > -1) {
+  args = args.concat(userArgs);
+}
+
+try {
+  var kexec = require("kexec");
+  kexec(process.argv[0], args);
+} catch (err) {
+  if (err.code !== "MODULE_NOT_FOUND") throw err;
+
+  var child_process = require("child_process");
+  var proc = child_process.spawn(process.argv[0], args, { stdio: "inherit" });
+  proc.on("exit", function (code, signal) {
+    process.on("exit", function () {
+      if (signal) {
+        process.kill(process.pid, signal);
+      } else {
+        process.exit(code);
+      }
+    })
+  });
+}

packages/babel-cli/bin/babel/dir.js

@@ -0,0 +1,78 @@
+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) {
+  var write = function (src, relative) {
+    // remove extension and then append back on .js
+    relative = relative.replace(/\.(\w*?)$/, "") + ".js";
+
+    var dest = path.join(commander.outDir, relative);
+
+    var data = util.compile(src, {
+      sourceFileName: path.relative(dest + "/..", src)
+    });
+
+    if (commander.sourceMaps && commander.sourceMaps !== "inline") {
+      var mapLoc = dest + ".map";
+      data.code = util.addSourceMappingUrl(data.code, mapLoc);
+      outputFileSync(mapLoc, JSON.stringify(data.map));
+    }
+
+    outputFileSync(dest, data.code);
+
+    console.log(src + " -> " + dest);
+  };
+
+  var handleFile = function (src, filename) {
+    if (util.shouldIgnore(src)) return;
+
+    if (util.canCompile(filename)) {
+      write(src, filename);
+    } else if (commander.copyFiles) {
+      outputFileSync(path.join(commander.outDir, filename), fs.readFileSync(src));
+    }
+  };
+
+  var handle = function (filename) {
+    if (!fs.existsSync(filename)) return;
+
+    var stat = fs.statSync(filename);
+
+    if (stat.isDirectory(filename)) {
+      var dirname = filename;
+
+      _.each(util.readdir(dirname), function (filename) {
+        var src = path.join(dirname, filename);
+        handleFile(src, filename);
+      });
+    } else {
+      write(filename, filename);
+    }
+  };
+
+  _.each(filenames, handle);
+
+  if (commander.watch) {
+    _.each(filenames, function (dirname) {
+      var watcher = chokidar.watch(dirname, {
+        persistent: true,
+        ignoreInitial: true
+      });
+
+      _.each(["add", "change"], function (type) {
+        watcher.on(type, function (filename) {
+          var relative = path.relative(dirname, filename) || filename;
+          try {
+            handleFile(filename, relative);
+          } catch (err) {
+            console.error(err.stack);
+          }
+        });
+      });
+    });
+  }
+};

packages/babel-cli/bin/babel/file.js

@@ -1,12 +1,16 @@
-var sourceMap = require("source-map");
-var chokidar  = require("chokidar");
-var util2     = require("../../lib/6to5/util");
-var path      = require("path");
-var util      = require("./util");
-var fs        = require("fs");
-var _         = require("lodash");
+var convertSourceMap = require("convert-source-map");
+var sourceMap        = require("source-map");
+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.sourceMaps === "inline") {
+    opts.sourceMaps = true;
+  }
 
-module.exports = function (commander, filenames) {
   var results = [];
 
   var buildResult = function () {
@@ -28,7 +32,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,
@@ -41,8 +45,8 @@ module.exports = function (commander, filenames) {
       }
     });
 
-    if (commander.sourceMapsInline || (!commander.outFile && commander.sourceMaps)) {
-      code += "\n" + util2.sourceMapToComment(map);
+    if (commander.sourceMaps === "inline" || (!commander.outFile && commander.sourceMaps)) {
+      code += "\n" + convertSourceMap.fromObject(map).toComment();
     }
 
     return {
@@ -55,13 +59,15 @@ module.exports = function (commander, filenames) {
     var result = buildResult();
 
     if (commander.outFile) {
-      if (commander.sourceMaps) {
-        fs.writeFileSync(commander.outFile + ".map", JSON.stringify(result.map));
+      if (commander.sourceMaps && commander.sourceMaps !== "inline") {
+        var mapLoc = commander.outFile + ".map";
+        result.code = util.addSourceMappingUrl(result.code, mapLoc);
+        fs.writeFileSync(mapLoc, JSON.stringify(result.map));
       }
 
       fs.writeFileSync(commander.outFile, result.code);
     } else {
-      console.log(result.code);
+      process.stdout.write(result.code + "\n");
     }
   };
 
@@ -75,7 +81,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();
     });
@@ -101,6 +107,8 @@ module.exports = function (commander, filenames) {
     });
 
     _.each(_filenames, function (filename) {
+      if (util.shouldIgnore(filename)) return;
+
       results.push(util.compile(filename));
     });
 
@@ -111,16 +119,18 @@ module.exports = function (commander, filenames) {
     walk();
 
     if (commander.watch) {
-      var watcher = chokidar.watch(filenames, {
+      chokidar.watch(filenames, {
         persistent: true,
         ignoreInitial: true
-      });
-
-      _.each(["add", "change", "unlink"], function (type) {
-        watcher.on(type, function (filename) {
+      }).on("all", function (type, filename) {
+        if (type === "add" || type === "change") {
           console.log(type, filename);
-          walk();
-        });
+          try {
+            walk();
+          } catch (err) {
+            console.error(err.stack);
+          }
+        }
       });
     }
   };

packages/babel-cli/bin/babel/index.js

@@ -1,29 +1,55 @@
 #!/usr/bin/env node
 
 var commander = require("commander");
-var transform = require("../../lib/6to5/transform");
-var util      = require("../../lib/6to5/util");
+var transform = require("babel-core").transform;
+var kebabCase = require("lodash/string/kebabCase");
+var options   = require("babel-core").options;
+var util      = require("babel-core").util;
+var each      = require("lodash/collection/each");
+var keys      = require("lodash/object/keys");
 var fs        = require("fs");
-var _         = require("lodash");
 
-commander.option("-t, --source-maps-inline", "Append sourceMappingURL comment to bottom of code");
-commander.option("-s, --source-maps", "Save source map alongside the compiled code");
-commander.option("-f, --filename [filename]", "Filename to use when reading from stdin - this will be used in source-maps, errors etc [stdin]", "stdin");
+each(options, function (option, key) {
+  if (option.hidden) return;
+
+  var arg = kebabCase(key);
+
+  if (option.type !== "boolean") {
+    arg += " [" + (option.type || "string") + "]";
+  }
+
+  if (option.type === "boolean" && option.default === true) {
+    arg = "no-" + arg;
+  }
+
+  arg = "--" + arg;
+
+  if (option.shorthand) {
+    arg = "-" + option.shorthand + ", " + arg;
+  }
+
+  var desc = [];
+  if (option.deprecated) desc.push("[DEPRECATED] " + option.deprecated);
+  if (option.description) desc.push(option.description);
+
+  commander.option(arg, desc.join(" "));
+})
+
 commander.option("-w, --watch", "Recompile files on changes");
-
-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("-b, --blacklist [blacklist]", "Blacklist of transformers to NOT use", util.list);
 commander.option("-o, --out-file [out]", "Compile all input files into a single file");
 commander.option("-d, --out-dir [out]", "Compile an input directory of modules into an output directory");
+commander.option("-D, --copy-files", "When compiling a directory copy over non-compilable files");
 
-commander.on("--help", function(){
+commander.on("--help", function () {
   var outKeys = function (title, obj) {
     console.log("  " + title + ":");
     console.log();
 
-    _.each(_.keys(obj).sort(), function (key) {
+    each(keys(obj).sort(), function (key) {
       if (key[0] === "_") return;
+
+      if (obj[key].optional) key = "[" + key + "]";
+
       console.log("    - " + key);
     });
 
@@ -45,7 +71,7 @@ var errors = [];
 
 var filenames = commander.args;
 
-_.each(filenames, function (filename) {
+each(filenames, function (filename) {
   if (!fs.existsSync(filename)) {
     errors.push(filename + " doesn't exist");
   }
@@ -69,12 +95,6 @@ if (commander.watch) {
   }
 }
 
-if (commander.sourceMaps) {
-  if (!commander.outFile && !commander.outDir) {
-    errors.push("--source-maps requires --out-file or --out-dir");
-  }
-}
-
 if (errors.length) {
   console.error(errors.join(". "));
   process.exit(2);
@@ -82,13 +102,14 @@ if (errors.length) {
 
 //
 
-exports.opts = {
-  sourceMapName: commander.outFile,
-  blacklist:     commander.blacklist,
-  whitelist:     commander.whitelist,
-  sourceMap:     commander.sourceMaps || commander.sourceMapsInline,
-  modules:       commander.modules
-};
+var opts = exports.opts = {};
+
+each(options, function (opt, key) {
+  opts[key] = commander[key];
+});
+
+opts.ignore = util.arrayify(opts.ignore, util.regexify);
+opts.only   = util.arrayify(opts.only, util.regexify);
 
 var fn;
 

packages/babel-cli/bin/babel/util.js

@@ -0,0 +1,42 @@
+var readdir = require("fs-readdir-recursive");
+var index   = require("./index");
+var babel   = require("babel-core");
+var util    = require("babel-core").util;
+var path    = require("path");
+var fs      = require("fs");
+var _       = require("lodash");
+
+exports.readdirFilter = function (filename) {
+  return readdir(filename).filter(function (filename) {
+    return util.canCompile(filename);
+  });
+};
+
+exports.readdir = readdir;
+
+exports.canCompile = util.canCompile;
+
+exports.shouldIgnore = function (loc) {
+  return util.shouldIgnore(loc, index.opts.ignore, index.opts.only);
+};
+
+exports.addSourceMappingUrl = function (code, loc) {
+  return code + "\n//# sourceMappingURL=" + path.basename(loc);
+};
+
+exports.transform = function (filename, code, opts) {
+  opts = _.defaults(opts || {}, index.opts);
+  opts.filename = filename;
+  opts.ignore = null;
+  opts.only = null;
+
+  var result = babel.transform(code, opts);
+  result.filename = filename;
+  result.actual = code;
+  return result;
+};
+
+exports.compile = function (filename, opts) {
+  var code = fs.readFileSync(filename, "utf8");
+  return exports.transform(filename, code, opts);
+};

packages/babel-cli/index.js

@@ -0,0 +1 @@
+module.exports = require("babel-core");

packages/babel-cli/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "babel",
+  "description": "Turn ES6 code into readable vanilla ES5 with source maps",
+  "version": "5.1.8",
+  "author": "Sebastian McKenzie <sebmck@gmail.com>",
+  "homepage": "https://babeljs.io/",
+  "repository": "babel/babel",
+  "preferGlobal": true,
+  "dependencies": {
+    "babel-core": "^5.1.8",
+    "chokidar": "^1.0.0",
+    "commander": "^2.6.0",
+    "fs-readdir-recursive": "^0.1.0",
+    "output-file-sync": "^1.1.0",
+    "lodash": "^3.2.0",
+    "convert-source-map": "^0.5.0",
+    "source-map": "^0.4.0",
+    "path-is-absolute": "^1.0.0"
+  },
+  "bin": {
+    "babel": "./bin/babel/index.js",
+    "babel-node": "./bin/babel-node",
+    "babel-external-helpers": "./bin/babel-external-helpers"
+  }
+}

packages/babel-cli/polyfill.js

@@ -0,0 +1 @@
+module.exports = require("babel-core/polyfill");

packages/babel-cli/register.js

@@ -0,0 +1 @@
+module.exports = require("babel-core/register");

packages/babel-runtime/README.md

@@ -0,0 +1,5 @@
+# babel-runtime
+
+Babel self-contained runtime
+
+For more information please look at [babel](https://github.com/babel/babel).

packages/babel-runtime/core-js.js

@@ -0,0 +1,4 @@
+module.exports = {
+  "default": require("core-js/library"),
+  __esModule: true
+};