v4.7.14

Addresses #1033.

.editorconfig

@@ -4,7 +4,6 @@ root = true
 insert_final_newline = true
 charset = utf-8
 trim_trailing_whitespace = true
-insert_final_newline = true
 end_of_line = lf
 
 [*.{js,json}]

.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

@@ -12,5 +12,6 @@ coverage
 dist
 .package.json
 packages/babel-runtime/*.js
+packages/babel-runtime/helpers/*.js
 packages/babel-runtime/regenerator/*.js
 lib

.travis.yml

@@ -1,7 +1,6 @@
 sudo: false
 language: node_js
 node_js:
-  - "0.10"
   - "0.12"
   - "iojs"
 

CHANGELOG.md

@@ -13,6 +13,160 @@ _Note: Gaps between patch versions are faulty/broken releases._
 
 See [CHANGELOG - 6to5](CHANGELOG-6to5.md) for the pre-4.0.0 version changelog.
 
+## 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**

CONTRIBUTING.md

@@ -4,10 +4,6 @@ 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).
 
-**NOTE:** Please do not send pull requests that fix linting issues. It's highly
-likely that they've already been fixed by the time it's submitted and it just
-pollutes the git tree.
-
 ## Developing
 
 #### Setup
@@ -44,15 +40,6 @@ running them with `mocha`:
 $ mocha test/transformation.js
 ```
 
-#### Linting
-
-Please follow the correct code style, this ensures that the code is consistent
-and increases maintainability.
-
-```sh
-$ make lint
-```
-
 #### Workflow
 
 * Fork the repository
@@ -66,7 +53,6 @@ $ make lint
 #### Code Standards
 
  * **General**
-   * No ES6 syntax features or methods, exclusively ES5.
    * Max of five arguments for functions
    * Max depth of four nested blocks
    * 2-spaced soft tabs

Makefile

@@ -8,11 +8,14 @@ BABEL_CMD = node_modules/babel/bin/babel
 
 export NODE_ENV = test
 
-.PHONY: clean test test-cov test-clean test-travis test-simple test-all test-browser publish build bootstrap publish-core publish-runtime build-core watch-core
+.PHONY: clean test test-cov test-clean test-travis test-simple test-all test-browser publish build bootstrap publish-core publish-runtime build-core watch-core build-core-test
 
 build-core:
 	node $(BABEL_CMD) src --out-dir lib --copy-files
 
+build-core-test:
+	node $(BABEL_CMD) src --out-dir lib --copy-files --auxiliary-comment "istanbul ignore next"
+
 watch-core:
 	node $(BABEL_CMD) src --out-dir lib --watch --copy-files
 
@@ -40,26 +43,19 @@ test-clean:
 	rm -rf test/tmp
 
 test:
-	$(MOCHA_CMD)
+	node $(MOCHA_CMD)
 	make test-clean
 
-test-simple:
-	# excludes test262
-	export SIMPLE_BABEL_TESTS=1; \
-	make test
-
 test-all:
 	export ALL_BABEL_TESTS=1; \
 	make test
 
 test-cov:
 	rm -rf coverage
-	export SIMPLE_BABEL_TESTS=1; \
+	make build-core-test
 	node $(ISTANBUL_CMD) $(MOCHA_CMD) --
 
-test-travis: bootstrap build
-	node $(ISTANBUL_CMD) $(MOCHA_CMD) --
-	if test -n "$$CODECLIMATE_REPO_TOKEN"; then codeclimate < coverage/lcov.info; fi
+test-travis: bootstrap build test
 
 test-browser:
 	mkdir -p dist

bin/_babel-node

@@ -60,7 +60,18 @@ if (program.eval || program.print) {
   var code = program.eval;
   if (!code || code === true) code = program.print;
 
-  var result = _eval(code, "eval");
+  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) console.log(result);
 } else {
   if (program.args.length) {
@@ -88,7 +99,7 @@ if (program.eval || program.print) {
     args = args.slice(i);
 
     // make the filename absolute
-    var filename = args[0]
+    var filename = args[0];
     if (!pathIsAbsolute(filename)) args[0] = path.join(process.cwd(), filename);
 
     // add back on node and concat the sliced args

bin/babel-external-helpers

@@ -1,4 +1,13 @@
 #!/usr/bin/env node
 
-var runtime = require("../lib/babel/build-external-helpers");
-console.log(runtime());
+var commander = require("commander");
+var util      = require("../lib/babel/util");
+var runtime   = require("../lib/babel/tools/build-external-helpers");
+
+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));

bin/babel-node

@@ -7,7 +7,17 @@
 
 var args  = [__dirname + "/_babel-node"];
 
-process.argv.slice(2).forEach(function(arg){
+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) {
@@ -26,16 +36,380 @@ process.argv.slice(2).forEach(function(arg){
       args.unshift("--expose-gc");
       break;
 
-    case "--gc-global":
+    case "--use_strict":
+    case "--es_staging":
     case "--harmony":
-    case "--harmony-proxies":
-    case "--harmony-collections":
-    case "--harmony-generators":
-    case "--no-deprecation":
+    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 "--throw-deprecation":
-    case "--trace-deprecation":
-    case "--use-strict":
+    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;
 
@@ -49,6 +423,11 @@ process.argv.slice(2).forEach(function(arg){
   }
 });
 
+// append arguments passed after --
+if (argSeparator > -1) {
+  args = args.concat(userArgs);
+}
+
 try {
   var kexec = require("kexec");
   kexec(process.argv[0], args);

bin/babel/dir.js

@@ -31,6 +31,14 @@ module.exports = function (commander, filenames, opts) {
     console.log(src + " -> " + dest);
   };
 
+  var handleFile = function (src, filename) {
+    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;
 
@@ -41,11 +49,7 @@ module.exports = function (commander, filenames, opts) {
 
       _.each(util.readdir(dirname), function (filename) {
         var src = path.join(dirname, filename);
-        if (util.canCompile(filename)) {
-          write(src, filename);
-        } else if (commander.copyFiles) {
-          outputFileSync(path.join(commander.outDir, filename), fs.readFileSync(src));
-        }
+        handleFile(src, filename);
       });
     } else {
       write(filename, filename);
@@ -64,7 +68,11 @@ module.exports = function (commander, filenames, opts) {
       _.each(["add", "change"], function (type) {
         watcher.on(type, function (filename) {
           var relative = path.relative(dirname, filename) || filename;
-          if (util.canCompile(filename)) write(filename, relative);
+          try {
+            handleFile(filename, relative);
+          } catch (err) {
+            console.error(err.stack);
+          }
         });
       });
     });

bin/babel/file.js

@@ -1,10 +1,10 @@
-var sourceMapToComment = require("source-map-to-comment");
-var sourceMap          = require("source-map");
-var chokidar           = require("chokidar");
-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) {
   var results = [];
@@ -42,7 +42,7 @@ module.exports = function (commander, filenames) {
     });
 
     if (commander.sourceMapsInline || (!commander.outFile && commander.sourceMaps)) {
-      code += "\n" + sourceMapToComment(map);
+      code += "\n" + convertSourceMap.fromObject(map).toComment();
     }
 
     return {
@@ -119,7 +119,11 @@ module.exports = function (commander, filenames) {
       }).on("all", function (type, filename) {
         if (type === "add" || type === "change") {
           console.log(type, filename);
-          walk();
+          try {
+            walk();
+          } catch (err) {
+            console.error(err.stack);
+          }
         }
       });
     }

bin/babel/util.js

@@ -26,17 +26,7 @@ exports.transform = function (filename, code, opts) {
   opts.filename = filename;
   resolveRc(filename, opts);
 
-  var result;
-  try {
-    result = babel.transform(code, opts);
-  } catch (e) {
-    if (e instanceof SyntaxError) {
-      console.error("SyntaxError:", e.message);
-      process.exit(1);
-    } else {
-      throw e;
-    }
-  }
+  var result = babel.transform(code, opts);
   result.filename = filename;
   result.actual = code;
   return result;

package.json

@@ -1,7 +1,7 @@
 {
   "name": "babel",
   "description": "Turn ES6 code into readable vanilla ES5 with source maps",
-  "version": "4.5.5",
+  "version": "4.7.14",
   "author": "Sebastian McKenzie <sebmck@gmail.com>",
   "homepage": "https://babeljs.io/",
   "repository": "babel/babel",
@@ -36,11 +36,12 @@
     "test": "make test"
   },
   "dependencies": {
-    "acorn-babel": "0.11.1-35",
-    "ast-types": "~0.6.1",
+    "acorn-babel": "0.11.1-38",
+    "ast-types": "~0.7.0",
     "chalk": "^1.0.0",
     "chokidar": "^0.12.6",
     "commander": "^2.6.0",
+    "convert-source-map": "^0.5.0",
     "core-js": "^0.6.1",
     "debug": "^2.1.1",
     "detect-indent": "^3.0.0",
@@ -49,27 +50,29 @@
     "fs-readdir-recursive": "^0.1.0",
     "globals": "^6.2.0",
     "is-integer": "^1.0.4",
-    "js-tokens": "0.4.1",
+    "js-tokens": "1.0.0",
     "leven": "^1.0.1",
     "line-numbers": "0.2.0",
     "lodash": "^3.2.0",
     "output-file-sync": "^1.1.0",
     "path-is-absolute": "^1.0.0",
     "private": "^0.1.6",
-    "regenerator-babel": "0.8.13-1",
-    "regexpu": "^1.1.1",
+    "regenerator-babel": "0.8.13-2",
+    "regexpu": "^1.1.2",
     "repeating": "^1.1.2",
     "shebang-regex": "^1.0.0",
     "slash": "^1.0.0",
-    "source-map": "^0.1.43",
+    "source-map": "^0.4.0",
     "source-map-support": "^0.2.9",
-    "source-map-to-comment": "^1.0.0",
+    "to-fast-properties": "^1.0.0",
     "trim-right": "^1.0.0"
   },
   "devDependencies": {
-    "babel": "4.5.1",
-    "browserify": "^8.1.3",
+    "babel": "4.6.0",
+    "browserify": "^9.0.3",
     "chai": "^2.0.0",
+    "eslint": "^0.15.1",
+    "babel-eslint": "^1.0.1",
     "esvalid": "^1.1.0",
     "istanbul": "^0.3.5",
     "matcha": "^0.6.0",

packages/babel-runtime/package.json

@@ -1,7 +1,10 @@
 {
   "name": "babel-runtime",
   "description": "babel selfContained runtime",
-  "version": "4.5.4",
+  "version": "4.7.13",
   "repository": "babel/babel",
-  "author": "Sebastian McKenzie <sebmck@gmail.com>"
+  "author": "Sebastian McKenzie <sebmck@gmail.com>",
+  "dependencies": {
+    "core-js": "^0.6.1"
+  }
 }

packages/build-runtime.js

@@ -1,11 +1,12 @@
 "use strict";
 
-var buildHelpers = require("../lib/babel/build-helpers");
-var transform    = require("../lib/babel/transformation");
-var util         = require("../lib/babel/util");
-var fs           = require("fs");
-var t            = require("../lib/babel/types");
-var _            = require("lodash");
+var transform = require("../lib/babel/transformation");
+var each      = require("lodash/collection/each");
+var File      = require("../lib/babel/transformation/file");
+var util      = require("../lib/babel/util");
+var fs        = require("fs");
+var t         = require("../lib/babel/types");
+var _         = require("lodash");
 
 var relative = function (filename) {
   return __dirname + "/babel-runtime/" + filename;
@@ -39,22 +40,26 @@ var updatePackage = function () {
 
 var selfContainify = function (code) {
   return transform(code, {
-    optional: ["selfContained"]
+    optional: ["runtime"]
   }).code;
 };
 
-var buildHelpers2 = function () {
-  var body = util.template("self-contained-helpers-head");
-  var tree = t.program(body);
-
-  buildHelpers(body, t.identifier("helpers"));
+var buildHelper = function (helperName) {
+  var tree = t.program(
+    util.template("self-contained-helpers-head", {
+      HELPER: util.template(helperName)
+    })
+  );
 
   return transform.fromAst(tree, null, {
-    optional: ["selfContained"]
+    optional: ["runtime"]
   }).code;
 };
 
-writeFile("helpers.js", buildHelpers2());
+each(File.helpers, function (helperName) {
+  writeFile("helpers/" + helperName + ".js", buildHelper(helperName));
+});
+
 writeFile("core-js.js", readFile("core-js/library", true));
 writeFile("regenerator/index.js", readFile("regenerator-babel/runtime-module", true));
 writeFile("regenerator/runtime.js", selfContainify(readFile("regenerator-babel/runtime")));

src/babel/api/browser.js

@@ -4,14 +4,12 @@ transform.version = require("../../../package").version;
 
 transform.transform = transform;
 
-transform.run = function (code, opts) {
-  opts ||= {};
+transform.run = function (code, opts = {}) {
   opts.sourceMap = "inline";
   return new Function(transform(code, opts).code)();
 };
 
-transform.load = function (url, callback, opts, hold) {
-  opts ||= {};
+transform.load = function (url, callback, opts = {}, hold) {
   opts.filename ||= url;
 
   var xhr = global.ActiveXObject ? new global.ActiveXObject("Microsoft.XMLHTTP") : new global.XMLHttpRequest();
@@ -27,7 +25,7 @@ transform.load = function (url, callback, opts, hold) {
       if (!hold) transform.run.apply(transform, param);
       if (callback) callback(param);
     } else {
-      throw new Error("Could not load " + url);
+      throw new Error(`Could not load ${url}`);
     }
   };
 

src/babel/api/node.js

@@ -1,32 +1,31 @@
-var isFunction = require("lodash/lang/isFunction");
-var transform  = require("../transformation");
-var util       = require("../util");
-var fs         = require("fs");
+import isFunction from "lodash/lang/isFunction";
+import transform from "../transformation";
+import fs from "fs";
 
-exports.version = require("../../../package").version;
+import * as util from "../util";
+export { util as _util };
+export { canCompile } from "../util";
 
-exports.buildExternalHelpers = require("../build-external-helpers");
+export { default as acorn } from "acorn-babel";
+export { default as transform } from "../transformation";
+export { default as traverse } from "../traversal";
+export { default as buildExternalHelpers } from "../tools/build-external-helpers";
+export { version } from "../../../package";
 
-exports.types = require("../types");
+import * as t from "../types";
+export { t as types };
 
-exports.register = function (opts) {
-  var register = require("./register/node");
-  if (opts != null) register(opts);
-  return register;
-};
+export function register(opts) {
+  var callback = require("./register/node");
+  if (opts != null) callback(opts);
+  return callback;
+}
 
-exports.polyfill = function () {
+export function polyfill() {
   require("../polyfill");
-};
+}
 
-exports.canCompile = util.canCompile;
-
-// do not use this - this is for use by official maintained babel plugins
-exports._util = util;
-
-exports.transform = transform;
-
-exports.transformFile = function (filename, opts, callback) {
+export function transformFile(filename, opts, callback) {
   if (isFunction(opts)) {
     callback = opts;
     opts = {};
@@ -47,10 +46,9 @@ exports.transformFile = function (filename, opts, callback) {
 
     callback(null, result);
   });
-};
+}
 
-exports.transformFileSync = function (filename, opts) {
-  opts ||= {};
+export function transformFileSync(filename, opts = {}) {
   opts.filename = filename;
   return transform(fs.readFileSync(filename), opts);
-};
+}

src/babel/api/register/browser.js

@@ -1,5 +1,5 @@
 // required to safely use babel/register within a browserify codebase
 
-module.exports = function () {};
+export default function () {};
 
-require("../../polyfill");
+import "../../polyfill";

src/babel/api/register/cache.js

@@ -1,22 +1,22 @@
-var path = require("path");
-var os   = require("os");
-var fs   = require("fs");
+import path from "path";
+import os from "os";
+import fs from "fs";
 
 var FILENAME = process.env.BABEL_CACHE_PATH || path.join(os.tmpdir(), "babel.json");
 var data = {};
 
-exports.save = function () {
+export function save() {
   fs.writeFileSync(FILENAME, JSON.stringify(data, null, "  "));
-};
+}
 
-exports.load = function () {
+export function load() {
   if (process.env.BABEL_DISABLE_CACHE) return;
 
-  process.on("exit", exports.save);
+  process.on("exit", save);
 
   var sigint = function () {
     process.removeListener("SIGINT", sigint);
-    exports.save();
+    save();
     process.kill(process.pid, "SIGINT");
   };
 
@@ -29,8 +29,8 @@ exports.load = function () {
   } catch (err) {
     return;
   }
-};
+}
 
-exports.get = function () {
+export function get() {
   return data;
-};
+}

src/babel/api/register/node.js

@@ -1,15 +1,15 @@
-require("../../polyfill");
-
-var sourceMapSupport = require("source-map-support");
-var registerCache    = require("./cache");
-var resolveRc        = require("./resolve-rc");
-var extend           = require("lodash/object/extend");
-var babel            = require("../node");
-var each             = require("lodash/collection/each");
-var util             = require("../../util");
-var fs               = require("fs");
+import "../../polyfill";
+import sourceMapSupport from "source-map-support";
+import * as registerCache from "./cache";
+import resolveRc from "./resolve-rc";
+import extend from "lodash/object/extend";
+import * as babel from "../node";
+import each from "lodash/collection/each";
+import * as util from  "../../util";
+import fs from "fs";
 
 sourceMapSupport.install({
+  handleUncaughtExceptions: false,
   retrieveSourceMap(source) {
     var map = maps && maps[source];
     if (map) {
@@ -33,7 +33,7 @@ var cache = registerCache.get();
 var transformOpts = {};
 var ignoreRegex   = /node_modules/;
 var onlyRegex;
-var exts          = {};
+var oldHandlers   = {};
 var maps          = {};
 
 var mtime = function (filename) {
@@ -46,7 +46,7 @@ var compile = function (filename) {
   var opts = extend({}, transformOpts);
   resolveRc(filename, opts);
 
-  var cacheKey = filename + ":" + JSON.stringify(opts);
+  var cacheKey = `${filename}:${JSON.stringify(opts)}:${babel.version}`;
 
   if (cache) {
     var cached = cache[cacheKey];
@@ -57,7 +57,7 @@ var compile = function (filename) {
 
   if (!result) {
     result = babel.transformFileSync(filename, extend(opts, {
-      sourceMap: true,
+      sourceMap: "both",
       ast:       false
     }));
   }
@@ -105,7 +105,7 @@ var normalLoader = function (m, filename) {
 };
 
 var registerExtension = function (ext) {
-  var old = require.extensions[ext];
+  var old = oldHandlers[ext] || oldHandlers[".js"];
 
   var loader = normalLoader;
   if (process.env.running_under_istanbul) loader = istanbulLoader; // jshint ignore:line
@@ -120,7 +120,7 @@ var registerExtension = function (ext) {
 };
 
 var hookExtensions = function (_exts) {
-  each(exts, function (old, ext) {
+  each(oldHandlers, function (old, ext) {
     if (old === undefined) {
       delete require.extensions[ext];
     } else {
@@ -128,20 +128,17 @@ var hookExtensions = function (_exts) {
     }
   });
 
-  exts = {};
+  oldHandlers = {};
 
   each(_exts, function (ext) {
-    exts[ext] = require.extensions[ext];
+    oldHandlers[ext] = require.extensions[ext];
     registerExtension(ext);
   });
 };
 
 hookExtensions(util.canCompile.EXTENSIONS);
 
-module.exports = function (opts) {
-  // normalize options
-  opts ||= {};
-
+export default function (opts = {}) {
   if (opts.only != null) onlyRegex = util.regexify(opts.only);
   if (opts.ignore != null) ignoreRegex = util.regexify(opts.ignore);
 
@@ -156,3 +153,16 @@ module.exports = function (opts) {
 
   extend(transformOpts, opts);
 };
+
+//
+
+try {
+  var runtimePackage = require("babel-runtime/package");
+  var version = require("../../package").version;
+  if (runtimePackage.version !== version) {
+    throw new ReferenceError(`The verison of babel-runtime of ${runtimePackage.runtime} that you have installed does not match the babel verison of ${version}`);
+  }
+} catch (err) {
+  if (err.code !== "MODULE_NOT_FOUND") throw err;
+}
+

src/babel/api/register/resolve-rc.js

@@ -1,6 +1,6 @@
-var merge = require("lodash/object/merge");
-var path  = require("path");
-var fs    = require("fs");
+import merge from "lodash/object/merge";
+import path from "path";
+import fs from "fs";
 
 var cache = {};
 
@@ -10,9 +10,8 @@ function exists(filename) {
   return cache[filename] = fs.existsSync(filename);
 }
 
-module.exports = function (loc, opts) {
+export default function (loc, opts = {}) {
   var rel = ".babelrc";
-  opts ||= {};
 
   function find(start, rel) {
     var file = path.join(start, rel);
@@ -24,7 +23,7 @@ module.exports = function (loc, opts) {
       try {
         json = JSON.parse(content);
       } catch (err) {
-        err.message = file + ": " + err.message;
+        err.message = `${file}: ${err.message}`;
         throw err;
       }
 

src/babel/build-external-helpers.js

@@ -1,23 +0,0 @@
-var buildHelpers = require("./build-helpers");
-var generator    = require("./generation");
-var util         = require("./util");
-var t            = require("./types");
-
-module.exports = function (whitelist) {
-  var namespace = t.identifier("babelHelpers");
-
-  var body      = [];
-  var container = t.functionExpression(null, [t.identifier("global")], t.blockStatement(body));
-  var tree      = t.program([t.expressionStatement(t.callExpression(container, [util.template("self-global")]))]);
-
-  body.push(t.variableDeclaration("var", [
-    t.variableDeclarator(
-      namespace,
-      t.assignmentExpression("=", t.memberExpression(t.identifier("global"), namespace), t.objectExpression([]))
-    )
-  ]));
-
-  buildHelpers(body, namespace, whitelist);
-
-  return generator(tree).code;
-};

src/babel/build-helpers.js

@@ -1,15 +0,0 @@
-var File = require("./transformation/file");
-var util = require("./util");
-var each = require("lodash/collection/each");
-var t    = require("./types");
-
-module.exports = function (body, namespace, whitelist = []) {
-  each(File.helpers, function (name) {
-    if (whitelist.length && whitelist.indexOf(name) == -1) return;
-
-    var key = t.identifier(t.toIdentifier(name));
-    body.push(t.expressionStatement(
-      t.assignmentExpression("=", t.memberExpression(namespace, key), util.template(name))
-    ));
-  });
-};

src/babel/detection/index.js

@@ -1,29 +0,0 @@
-module.exports = detect;
-
-var SYNTAX_KEYS = require("./syntax-keys");
-var traverse    = require("../traversal");
-var visitors    = traverse.explode(require("./visitors"));
-
-function detect(ast) {
-  var stats = {
-    syntax: {},
-    builtins: {}
-  };
-
-  var detectedSyntax = function (name) {
-    stats.syntax[name] = true;
-  };
-
-  traverse(ast, {
-    enter(node, parent) {
-      if (SYNTAX_KEYS[node.type]) {
-        detectedSyntax(SYNTAX_KEYS[node.type]);
-      }
-
-      var visitor = visitors[node.type];
-      if (visitor) visitor(node, parent, detectedSyntax);
-    }
-  });
-
-  return stats;
-}

src/babel/detection/syntax-keys.json

@@ -1,84 +0,0 @@
-{
-  "ArrowFunctionExpression":   "es6.arrowFunctions",
-
-  "AwaitExpression":           "es7.asyncFunctions",
-
-  "ClassBody":                 "es6.classes",
-  "ClassDeclaration":          "es6.classes",
-  "ClassExpression":           "es6.classes",
-  "MethodDefinition":          "es6.classes",
-
-  "ComprehensionBlock":        "es7.comprehensions",
-  "ComprehensionExpression":   "es7.comprehensions",
-
-  "ForOfStatement":            "es6.forOf",
-
-  "ExportBatchSpecifier":      "es6.modules",
-  "ExportDeclaration":         "es6.modules",
-  "ExportSpecifier":           "es6.modules",
-  "ImportBatchSpecifier":      "es6.modules",
-  "ImportDeclaration":         "es6.modules",
-  "ImportSpecifier":           "es6.modules",
-
-  "ArrayPattern":              "es6.destructuring",
-  "AssignmentPattern":         "es6.destructuring",
-  "ObjectPattern":             "es6.destructuring",
-
-  "RestElement":               "es6.parameters.rest",
-
-  "SpreadElement":             "es6.spread",
-
-  "SpreadProperty":            "es7.objectSpread",
-
-  "TaggedTemplateExpression":  "es6.templateLiterals",
-  "TemplateElement":           "es6.templateLiterals",
-  "TemplateLiteral":           "es6.templateLiterals",
-
-  "VirtualPropertyExpression": "es7.abstractReferences",
-  "PrivateDeclaration":        "es7.abstractReferences",
-
-  "YieldExpression":           "es6.generators",
-
-  "AnyTypeAnnotation":           "flow",
-  "ArrayTypeAnnotation":         "flow",
-  "BooleanTypeAnnotation":       "flow",
-  "ClassProperty":               "flow",
-  "DeclareClass":                "flow",
-  "DeclareFunction":             "flow",
-  "DeclareModule":               "flow",
-  "DeclareVariable":             "flow",
-  "FunctionTypeAnnotation":      "flow",
-  "FunctionTypeParam":           "flow",
-  "GenericTypeAnnotation":       "flow",
-  "InterfaceExtends":            "flow",
-  "InterfaceDeclaration":        "flow",
-  "IntersectionTypeAnnotation":  "flow",
-  "NullableTypeAnnotation":      "flow",
-  "NumberTypeAnnotation":        "flow",
-  "StringLiteralTypeAnnotation": "flow",
-  "StringTypeAnnotation":        "flow",
-  "TupleTypeAnnotation":         "flow",
-  "TypeofTypeAnnotation":        "flow",
-  "TypeAlias":                   "flow",
-  "TypeAnnotation":              "flow",
-  "TypeParameterDeclaration":    "flow",
-  "TypeParameterInstantiation":  "flow",
-  "ObjectTypeAnnotation":        "flow",
-  "ObjectTypeCallProperty":      "flow",
-  "ObjectTypeIndexer":           "flow",
-  "ObjectTypeProperty":          "flow",
-  "QualifiedTypeIdentifier":     "flow",
-  "UnionTypeAnnotation":         "flow",
-  "VoidTypeAnnotation":          "flow",
-
-  "JSXAttribute":              "jsx",
-  "JSXClosingElement":         "jsx",
-  "JSXElement":                "jsx",
-  "JSXEmptyExpression":        "jsx",
-  "JSXExpressionContainer":    "jsx",
-  "JSXIdentifier":             "jsx",
-  "JSXMemberExpression":       "jsx",
-  "JSXNamespacedName":         "jsx",
-  "JSXOpeningElement":         "jsx",
-  "JSXSpreadAttribute":        "jsx"
-}

src/babel/detection/visitors.js

@@ -1,54 +0,0 @@
-var t = require("../types");
-var includes = require("lodash/collection/includes");
-
-exports.AssignmentExpression = function (node, parent, detected) {
-  if (node.operator === "**=") {
-    detected("es6.exponentation");
-  }
-};
-
-exports.BinaryExpression = function (node, parent, detected) {
-  if (node.operator === "**") {
-    detected("es6.exponentation");
-  }
-};
-
-exports.VariableDeclaration = function (node, parent, detected) {
-  if (node.kind === "let" || node.kind === "const") {
-    detected("es6.blockScoping");
-  }
-
-  if (node.kind === "const") {
-    detected("es6.constants");
-  }
-};
-
-exports.Property = function (node, parent, detected) {
-  if (node.shorthand || node.method) {
-    detected("es6.properties.shorthand");
-  }
-
-  if (node.kind === "set" || node.kind === "get") {
-    detected("es5.properties.mutators");
-  }
-
-  if (node.computed) {
-    detected("es6.properties.computed");
-  }
-};
-
-exports.AssignmentPattern = function (node, parent, detected) {
-  if (t.isFunction(parent) && includes(parent.params, node)) {
-    detected("es6.parameters.default");
-  }
-};
-
-exports.Function = function (node, parent, detected) {
-  if (node.generator) {
-    detected("es6.generators");
-  }
-
-  if (node.async) {
-    detected("es7.asyncFunctions");
-  }
-};

src/babel/generation/buffer.js

@@ -1,8 +1,8 @@
-var repeating = require("repeating");
-var trimRight = require("trim-right");
-var isBoolean = require("lodash/lang/isBoolean");
-var includes  = require("lodash/collection/includes");
-var isNumber  = require("lodash/lang/isNumber");
+import repeating from "repeating";
+import trimRight from "trim-right";
+import isBoolean from "lodash/lang/isBoolean";
+import includes from "lodash/collection/includes";
+import isNumber from "lodash/lang/isNumber";
 
 export default class Buffer {
   constructor(position, format) {
@@ -140,7 +140,7 @@ export default class Buffer {
       var indent = this.getIndent();
 
       // replace all newlines with newlines with the indentation
-      str = str.replace(/\n/g, "\n" + indent);
+      str = str.replace(/\n/g, `\n${indent}`);
 
       // we've got a newline before us so prepend on the indentation
       if (this.isLast("\n")) this._push(indent);

src/babel/generation/generators/base.js

@@ -1,12 +1,12 @@
-exports.File = function (node, print) {
+export function File(node, print) {
   print(node.program);
-};
+}
 
-exports.Program = function (node, print) {
+export function Program(node, print) {
   print.sequence(node.body);
-};
+}
 
-exports.BlockStatement = function (node, print) {
+export function BlockStatement(node, print) {
   if (node.body.length === 0) {
     this.push("{}");
   } else {
@@ -16,4 +16,4 @@ exports.BlockStatement = function (node, print) {
     this.removeLast("\n");
     this.rightBrace();
   }
-};
+}

src/babel/generation/generators/classes.js

@@ -1,5 +1,4 @@
-exports.ClassExpression =
-exports.ClassDeclaration = function (node, print) {
+export function ClassDeclaration(node, print) {
   this.push("class");
 
   if (node.id) {
@@ -7,16 +6,26 @@ exports.ClassDeclaration = function (node, print) {
     print(node.id);
   }
 
+  print(node.typeParameters);
+
   if (node.superClass) {
     this.push(" extends ");
     print(node.superClass);
+    print(node.superTypeParameters);
+  }
+
+  if (node.implements) {
+    this.push(" implements ");
+    print.join(node.implements, { separator: ", " });
   }
 
   this.space();
   print(node.body);
-};
+}
 
-exports.ClassBody = function (node, print) {
+export { ClassDeclaration as ClassExpression };
+
+export function ClassBody(node, print) {
   if (node.body.length === 0) {
     this.push("{}");
   } else {
@@ -29,12 +38,12 @@ exports.ClassBody = function (node, print) {
 
     this.rightBrace();
   }
-};
+}
 
-exports.MethodDefinition = function (node, print) {
+export function MethodDefinition(node, print) {
   if (node.static) {
     this.push("static ");
   }
 
   this._method(node, print);
-};
+}

src/babel/generation/generators/comprehensions.js

@@ -1,13 +1,13 @@
-exports.ComprehensionBlock = function (node, print) {
+export function ComprehensionBlock(node, print) {
   this.keyword("for");
   this.push("(");
   print(node.left);
   this.push(" of ");
   print(node.right);
   this.push(")");
-};
+}
 
-exports.ComprehensionExpression = function (node, print) {
+export function ComprehensionExpression(node, print) {
   this.push(node.generator ? "(" : "[");
 
   print.join(node.blocks, { separator: " " });
@@ -24,4 +24,4 @@ exports.ComprehensionExpression = function (node, print) {
   print(node.body);
 
   this.push(node.generator ? ")" : "]");
-};
+}

src/babel/generation/generators/expressions.js

@@ -1,8 +1,8 @@
-var isInteger = require("is-integer");
-var isNumber  = require("lodash/lang/isNumber");
-var t         = require("../../types");
+import isInteger from "is-integer";
+import isNumber from "lodash/lang/isNumber";
+import * as t from "../../types";
 
-exports.UnaryExpression = function (node, print) {
+export function UnaryExpression(node, print) {
   var hasSpace = /[a-z]$/.test(node.operator);
   var arg = node.argument;
 
@@ -17,9 +17,9 @@ exports.UnaryExpression = function (node, print) {
   this.push(node.operator);
   if (hasSpace) this.push(" ");
   print(node.argument);
-};
+}
 
-exports.UpdateExpression = function (node, print) {
+export function UpdateExpression(node, print) {
   if (node.prefix) {
     this.push(node.operator);
     print(node.argument);
@@ -27,9 +27,9 @@ exports.UpdateExpression = function (node, print) {
     print(node.argument);
     this.push(node.operator);
   }
-};
+}
 
-exports.ConditionalExpression = function (node, print) {
+export function ConditionalExpression(node, print) {
   print(node.test);
   this.space();
   this.push("?");
@@ -39,25 +39,25 @@ exports.ConditionalExpression = function (node, print) {
   this.push(":");
   this.space();
   print(node.alternate);
-};
+}
 
-exports.NewExpression = function (node, print) {
+export function NewExpression(node, print) {
   this.push("new ");
   print(node.callee);
   this.push("(");
   print.list(node.arguments);
   this.push(")");
-};
+}
 
-exports.SequenceExpression = function (node, print) {
+export function SequenceExpression(node, print) {
   print.list(node.expressions);
-};
+}
 
-exports.ThisExpression = function () {
+export function ThisExpression() {
   this.push("this");
-};
+}
 
-exports.CallExpression = function (node, print) {
+export function CallExpression(node, print) {
   print(node.callee);
 
   this.push("(");
@@ -80,7 +80,7 @@ exports.CallExpression = function (node, print) {
   }
 
   this.push(")");
-};
+}
 
 var buildYieldAwait = function (keyword) {
   return function (node, print) {
@@ -97,33 +97,36 @@ var buildYieldAwait = function (keyword) {
   };
 };
 
-exports.YieldExpression = buildYieldAwait("yield");
-exports.AwaitExpression = buildYieldAwait("await");
+export var YieldExpression = buildYieldAwait("yield");
+export var AwaitExpression = buildYieldAwait("await");
 
-exports.EmptyStatement = function () {
+export function EmptyStatement() {
   this.semicolon();
-};
+}
 
-exports.ExpressionStatement = function (node, print) {
+export function ExpressionStatement(node, print) {
   print(node.expression);
   this.semicolon();
-};
+}
 
-exports.BinaryExpression =
-exports.LogicalExpression =
-exports.AssignmentPattern =
-exports.AssignmentExpression = function (node, print) {
+export function AssignmentExpression(node, print) {
   // todo: add cases where the spaces can be dropped when in compact mode
   print(node.left);
   this.push(" ");
   this.push(node.operator);
   this.push(" ");
   print(node.right);
+}
+
+export {
+  AssignmentExpression as BinaryExpression,
+  AssignmentExpression as LogicalExpression,
+  AssignmentExpression as AssignmentPattern
 };
 
 var SCIENTIFIC_NOTATION = /e/i;
 
-exports.MemberExpression = function (node, print) {
+export function MemberExpression(node, print) {
   var obj = node.object;
   print(obj);
 
@@ -149,4 +152,4 @@ exports.MemberExpression = function (node, print) {
     this.push(".");
     print(node.property);
   }
-};
+}

src/babel/generation/generators/flow.js

@@ -1,34 +1,226 @@
-exports.AnyTypeAnnotation =
-exports.ArrayTypeAnnotation =
-exports.BooleanTypeAnnotation =
-exports.ClassProperty =
-exports.DeclareClass =
-exports.DeclareFunction =
-exports.DeclareModule =
-exports.DeclareVariable =
-exports.FunctionTypeAnnotation =
-exports.FunctionTypeParam =
-exports.GenericTypeAnnotation =
-exports.InterfaceExtends =
-exports.InterfaceDeclaration =
-exports.IntersectionTypeAnnotation =
-exports.NullableTypeAnnotation =
-exports.NumberTypeAnnotation =
-exports.StringLiteralTypeAnnotation =
-exports.StringTypeAnnotation =
-exports.TupleTypeAnnotation =
-exports.TypeofTypeAnnotation =
-exports.TypeAlias =
-exports.TypeAnnotation =
-exports.TypeParameterDeclaration =
-exports.TypeParameterInstantiation =
-exports.ObjectTypeAnnotation =
-exports.ObjectTypeCallProperty =
-exports.ObjectTypeIndexer =
-exports.ObjectTypeProperty =
-exports.QualifiedTypeIdentifier =
-exports.UnionTypeAnnotation =
-exports.TypeCastExpression =
-exports.VoidTypeAnnotation = function () {
-  // todo: implement these once we have a `--keep-types` option
-};
+import * as t from "../../types";
+
+export function AnyTypeAnnotation() {
+  this.push("any");
+}
+
+export function ArrayTypeAnnotation(node, print) {
+  print(node.elementType);
+  this.push("[");
+  this.push("]");
+}
+
+export function BooleanTypeAnnotation(node) {
+  this.push("bool");
+}
+
+export function ClassProperty(node, print) {
+  if (node.static) this.push("static ");
+  print(node.key);
+  print(node.typeAnnotation);
+  this.semicolon();
+}
+
+export function DeclareClass(node, print) {
+  this.push("declare class ");
+  this._interfaceish(node, print);
+}
+
+export function DeclareFunction(node, print) {
+  this.push("declare function ");
+  print(node.id);
+  print(node.id.typeAnnotation.typeAnnotation);
+  this.semicolon();
+}
+
+export function DeclareModule(node, print) {
+  this.push("declare module ");
+  print(node.id);
+  this.space();
+  print(node.body);
+}
+
+export function DeclareVariable(node, print) {
+  this.push("declare var ");
+  print(node.id);
+  print(node.id.typeAnnotation);
+  this.semicolon();
+}
+
+export function FunctionTypeAnnotation(node, print, parent) {
+  print(node.typeParameters);
+  this.push("(");
+  print.list(node.params);
+
+  if (node.rest) {
+    if (node.params.length) {
+      this.push(",");
+      this.space();
+    }
+    this.push("...");
+    print(node.rest);
+  }
+
+  this.push(")");
+
+  // this node type is overloaded, not sure why but it makes it EXTREMELY annoying
+  if (parent.type === "ObjectTypeProperty" || parent.type === "ObjectTypeCallProperty" || parent.type === "DeclareFunction") {
+    this.push(":");
+  } else {
+    this.space();
+    this.push("=>");
+  }
+
+  this.space();
+  print(node.returnType);
+}
+
+export function FunctionTypeParam(node, print) {
+  print(node.name);
+  if (node.optional) this.push("?");
+  this.push(":");
+  this.space();
+  print(node.typeAnnotation);
+}
+
+export function InterfaceExtends(node, print) {
+  print(node.id);
+  print(node.typeParameters);
+}
+
+export { InterfaceExtends as ClassImplements, InterfaceExtends as GenericTypeAnnotation };
+
+export function _interfaceish(node, print) {
+  print(node.id);
+  print(node.typeParameters);
+  if (node.extends.length) {
+    this.push(" extends ");
+    print.join(node.extends, { separator: ", " });
+  }
+  this.space();
+  print(node.body);
+}
+
+export function InterfaceDeclaration(node, print) {
+  this.push("interface ");
+  this._interfaceish(node, print);
+}
+
+export function IntersectionTypeAnnotation(node, print) {
+  print.join(node.types, { separator: " & " });
+}
+
+export function NullableTypeAnnotation(node, print) {
+  this.push("?");
+  print(node.typeAnnotation);
+}
+
+export function NumberTypeAnnotation() {
+  this.push("number");
+}
+
+export function StringLiteralTypeAnnotation(node) {
+  this._stringLiteral(node.value);
+}
+
+export function StringTypeAnnotation() {
+  this.push("string");
+}
+
+export function TupleTypeAnnotation(node, print) {
+  this.push("[");
+  print.join(node.types, { separator: ", " });
+  this.push("]");
+}
+
+export function TypeofTypeAnnotation(node, print) {
+  this.push("typeof ");
+  print(node.argument);
+}
+
+export function TypeAlias(node, print) {
+  this.push("type ");
+  print(node.id);
+  print(node.typeParameters);
+  this.space();
+  this.push("=");
+  this.space();
+  print(node.right);
+  this.semicolon();
+}
+
+export function TypeAnnotation(node, print) {
+  this.push(":");
+  this.space();
+  if (node.optional) this.push("?");
+  print(node.typeAnnotation);
+}
+
+export function TypeParameterInstantiation(node, print) {
+  this.push("<");
+  print.join(node.params, { separator: ", " });
+  this.push(">");
+}
+
+export { TypeParameterInstantiation as TypeParameterDeclaration };
+
+export function ObjectTypeAnnotation(node, print) {
+  this.push("{");
+  var props = node.properties.concat(node.callProperties, node.indexers);
+  if (props.length) {
+    this.space();
+    print.list(props, { indent: true, separator: "; " });
+    this.space();
+  }
+  this.push("}");
+}
+
+export function ObjectTypeCallProperty(node, print) {
+  if (node.static) this.push("static ");
+  print(node.value);
+}
+
+export function ObjectTypeIndexer(node, print) {
+  if (node.static) this.push("static ");
+  this.push("[");
+  print(node.id);
+  this.push(":");
+  this.space();
+  print(node.key);
+  this.push("]");
+  this.push(":");
+  this.space();
+  print(node.value);
+}
+
+export function ObjectTypeProperty(node, print) {
+  if (node.static) this.push("static ");
+  print(node.key);
+  if (node.optional) this.push("?");
+  if (!t.isFunctionTypeAnnotation(node.value)) {
+    this.push(":");
+    this.space();
+  }
+  print(node.value);
+}
+
+export function QualifiedTypeIdentifier(node, print) {
+  print(node.qualification);
+  this.push(".");
+  print(node.id);
+}
+
+export function UnionTypeAnnotation(node, print) {
+  print.join(node.types, { separator: " | " });
+}
+
+export function TypeCastExpression(node, print) {
+  this.push("(");
+  print(node.expression);
+  print(node.typeAnnotation);
+  this.push(")");
+}
+
+export function VoidTypeAnnotation(node) {
+  this.push("void");
+}

src/babel/generation/generators/jsx.js

@@ -1,43 +1,43 @@
-var t    = require("../../types");
-var each = require("lodash/collection/each");
+import each from "lodash/collection/each";
+import * as t from "../../types";
 
-exports.JSXAttribute = function (node, print) {
+export function JSXAttribute(node, print) {
   print(node.name);
   if (node.value) {
     this.push("=");
     print(node.value);
   }
-};
+}
 
-exports.JSXIdentifier = function (node) {
+export function JSXIdentifier(node) {
   this.push(node.name);
-};
+}
 
-exports.JSXNamespacedName = function (node, print) {
+export function JSXNamespacedName(node, print) {
   print(node.namespace);
   this.push(":");
   print(node.name);
-};
+}
 
-exports.JSXMemberExpression = function (node, print) {
+export function JSXMemberExpression(node, print) {
   print(node.object);
   this.push(".");
   print(node.property);
-};
+}
 
-exports.JSXSpreadAttribute = function (node, print) {
+export function JSXSpreadAttribute(node, print) {
   this.push("{...");
   print(node.argument);
   this.push("}");
-};
+}
 
-exports.JSXExpressionContainer = function (node, print) {
+export function JSXExpressionContainer(node, print) {
   this.push("{");
   print(node.expression);
   this.push("}");
-};
+}
 
-exports.JSXElement = function (node, print) {
+export function JSXElement(node, print) {
   var open = node.openingElement;
   print(open);
   if (open.selfClosing) return;
@@ -53,9 +53,9 @@ exports.JSXElement = function (node, print) {
   this.dedent();
 
   print(node.closingElement);
-};
+}
 
-exports.JSXOpeningElement = function (node, print) {
+export function JSXOpeningElement(node, print) {
   this.push("<");
   print(node.name);
   if (node.attributes.length > 0) {
@@ -63,12 +63,12 @@ exports.JSXOpeningElement = function (node, print) {
     print.join(node.attributes, { separator: " " });
   }
   this.push(node.selfClosing ? " />" : ">");
-};
+}
 
-exports.JSXClosingElement = function (node, print) {
+export function JSXClosingElement(node, print) {
   this.push("</");
   print(node.name);
   this.push(">");
-};
+}
 
-exports.JSXEmptyExpression = function () {};
+export function JSXEmptyExpression() {}

src/babel/generation/generators/methods.js

@@ -1,12 +1,22 @@
-var t = require("../../types");
+import * as t from "../../types";
 
-exports._params = function (node, print) {
+export function _params(node, print) {
+  print(node.typeParameters);
   this.push("(");
-  print.list(node.params);
+  print.list(node.params, {
+    iterator: (node) =>{
+      if (node.optional) this.push("?");
+      print(node.typeAnnotation);
+    }
+  });
   this.push(")");
-};
 
-exports._method = function (node, print) {
+  if (node.returnType) {
+    print(node.returnType);
+  }
+}
+
+export function _method(node, print) {
   var value = node.value;
   var kind  = node.kind;
   var key   = node.key;
@@ -32,10 +42,9 @@ exports._method = function (node, print) {
   this._params(value, print);
   this.push(" ");
   print(value.body);
-};
+}
 
-exports.FunctionDeclaration =
-exports.FunctionExpression = function (node, print) {
+export function FunctionExpression(node, print) {
   if (node.async) this.push("async ");
   this.push("function");
   if (node.generator) this.push("*");
@@ -50,9 +59,11 @@ exports.FunctionExpression = function (node, print) {
   this._params(node, print);
   this.space();
   print(node.body);
-};
+}
 
-exports.ArrowFunctionExpression = function (node, print) {
+export { FunctionExpression as FunctionDeclaration };
+
+export function ArrowFunctionExpression(node, print) {
   if (node.async) this.push("async ");
 
   if (node.params.length === 1 && t.isIdentifier(node.params[0])) {
@@ -63,4 +74,4 @@ exports.ArrowFunctionExpression = function (node, print) {
 
   this.push(" => ");
   print(node.body);
-};
+}

src/babel/generation/generators/modules.js

@@ -1,27 +1,27 @@
-var t    = require("../../types");
-var each = require("lodash/collection/each");
+import each from "lodash/collection/each";
+import * as t from "../../types";
 
-exports.ImportSpecifier = function (node, print) {
+export function ImportSpecifier(node, print) {
   if (t.isSpecifierDefault(node)) {
     print(t.getSpecifierName(node));
   } else {
-    return exports.ExportSpecifier.apply(this, arguments);
+    return ExportSpecifier.apply(this, arguments);
   }
-};
+}
 
-exports.ExportSpecifier = function (node, print) {
+export function ExportSpecifier(node, print) {
   print(node.id);
   if (node.name) {
     this.push(" as ");
     print(node.name);
   }
-};
+}
 
-exports.ExportBatchSpecifier = function () {
+export function ExportBatchSpecifier() {
   this.push("*");
-};
+}
 
-exports.ExportDeclaration = function (node, print) {
+export function ExportDeclaration(node, print) {
   this.push("export ");
 
   var specifiers = node.specifiers;
@@ -53,9 +53,9 @@ exports.ExportDeclaration = function (node, print) {
   }
 
   this.ensureSemicolon();
-};
+}
 
-exports.ImportDeclaration = function (node, print) {
+export function ImportDeclaration(node, print) {
   this.push("import ");
 
   if (node.isType) {
@@ -90,9 +90,9 @@ exports.ImportDeclaration = function (node, print) {
 
   print(node.source);
   this.semicolon();
-};
+}
 
-exports.ImportBatchSpecifier = function (node, print) {
+export function ImportBatchSpecifier(node, print) {
   this.push("* as ");
   print(node.name);
-};
+}

src/babel/generation/generators/playground.js

@@ -1,7 +1,7 @@
-var each = require("lodash/collection/each");
+import each from "lodash/collection/each";
 
 each(["BindMemberExpression", "BindFunctionExpression"], function (type) {
   exports[type] = function () {
-    throw new ReferenceError("Trying to render non-standard playground node " + JSON.stringify(type));
+    throw new ReferenceError(`Trying to render non-standard playground node ${JSON.stringify(type)}`);
   };
 });

src/babel/generation/generators/statements.js

@@ -1,15 +1,15 @@
-var repeating = require("repeating");
-var t         = require("../../types");
+import repeating from "repeating";
+import * as t from "../../types";
 
-exports.WithStatement = function (node, print) {
+export function WithStatement(node, print) {
   this.keyword("with");
   this.push("(");
   print(node.object);
   this.push(")");
   print.block(node.body);
-};
+}
 
-exports.IfStatement = function (node, print) {
+export function IfStatement(node, print) {
   this.keyword("if");
   this.push("(");
   print(node.test);
@@ -23,9 +23,9 @@ exports.IfStatement = function (node, print) {
     this.push("else ");
     print.indentOnComments(node.alternate);
   }
-};
+}
 
-exports.ForStatement = function (node, print) {
+export function ForStatement(node, print) {
   this.keyword("for");
   this.push("(");
 
@@ -45,32 +45,32 @@ exports.ForStatement = function (node, print) {
 
   this.push(")");
   print.block(node.body);
-};
+}
 
-exports.WhileStatement = function (node, print) {
+export function WhileStatement(node, print) {
   this.keyword("while");
   this.push("(");
   print(node.test);
   this.push(")");
   print.block(node.body);
-};
+}
 
 var buildForXStatement = function (op) {
   return function (node, print) {
     this.keyword("for");
     this.push("(");
     print(node.left);
-    this.push(" " + op + " ");
+    this.push(` ${op} `);
     print(node.right);
     this.push(")");
     print.block(node.body);
   };
 };
 
-exports.ForInStatement = buildForXStatement("in");
-exports.ForOfStatement = buildForXStatement("of");
+export var ForInStatement = buildForXStatement("in");
+export var ForOfStatement = buildForXStatement("of");
 
-exports.DoWhileStatement = function (node, print) {
+export function DoWhileStatement(node, print) {
   this.keyword("do");
   print(node.body);
   this.space();
@@ -78,7 +78,7 @@ exports.DoWhileStatement = function (node, print) {
   this.push("(");
   print(node.test);
   this.push(");");
-};
+}
 
 var buildLabelStatement = function (prefix, key) {
   return function (node, print) {
@@ -94,17 +94,17 @@ var buildLabelStatement = function (prefix, key) {
   };
 };
 
-exports.ContinueStatement = buildLabelStatement("continue");
-exports.ReturnStatement   = buildLabelStatement("return", "argument");
-exports.BreakStatement    = buildLabelStatement("break");
+export var ContinueStatement = buildLabelStatement("continue");
+export var ReturnStatement   = buildLabelStatement("return", "argument");
+export var BreakStatement    = buildLabelStatement("break");
 
-exports.LabeledStatement = function (node, print) {
+export function LabeledStatement(node, print) {
   print(node.label);
   this.push(": ");
   print(node.body);
-};
+}
 
-exports.TryStatement = function (node, print) {
+export function TryStatement(node, print) {
   this.keyword("try");
   print(node.block);
   this.space();
@@ -123,23 +123,23 @@ exports.TryStatement = function (node, print) {
     this.push("finally ");
     print(node.finalizer);
   }
-};
+}
 
-exports.CatchClause = function (node, print) {
+export function CatchClause(node, print) {
   this.keyword("catch");
   this.push("(");
   print(node.param);
   this.push(") ");
   print(node.body);
-};
+}
 
-exports.ThrowStatement = function (node, print) {
+export function ThrowStatement(node, print) {
   this.push("throw ");
   print(node.argument);
   this.semicolon();
-};
+}
 
-exports.SwitchStatement = function (node, print) {
+export function SwitchStatement(node, print) {
   this.keyword("switch");
   this.push("(");
   print(node.discriminant);
@@ -155,9 +155,9 @@ exports.SwitchStatement = function (node, print) {
   });
 
   this.push("}");
-};
+}
 
-exports.SwitchCase = function (node, print) {
+export function SwitchCase(node, print) {
   if (node.test) {
     this.push("case ");
     print(node.test);
@@ -170,13 +170,13 @@ exports.SwitchCase = function (node, print) {
     this.newline();
     print.sequence(node.consequent, { indent: true });
   }
-};
+}
 
-exports.DebuggerStatement = function () {
+export function DebuggerStatement() {
   this.push("debugger;");
-};
+}
 
-exports.VariableDeclaration = function (node, print, parent) {
+export function VariableDeclaration(node, print, parent) {
   this.push(node.kind + " ");
 
   var hasInits = false;
@@ -192,7 +192,7 @@ exports.VariableDeclaration = function (node, print, parent) {
 
   var sep = ",";
   if (!this.format.compact && hasInits) {
-    sep += "\n" + repeating(" ", node.kind.length + 1);
+    sep += `\n${repeating(" ", node.kind.length + 1)}`;
   } else {
     sep += " ";
   }
@@ -202,22 +202,21 @@ exports.VariableDeclaration = function (node, print, parent) {
   if (!t.isFor(parent)) {
     this.semicolon();
   }
-};
+}
 
-exports.PrivateDeclaration = function (node, print) {
+export function PrivateDeclaration(node, print) {
   this.push("private ");
   print.join(node.declarations, { separator: ", " });
   this.semicolon();
-};
+}
 
-exports.VariableDeclarator = function (node, print) {
+export function VariableDeclarator(node, print) {
+  print(node.id);
+  print(node.id.typeAnnotation);
   if (node.init) {
-    print(node.id);
     this.space();
     this.push("=");
     this.space();
     print(node.init);
-  } else {
-    print(node.id);
   }
-};
+}

src/babel/generation/generators/template-literals.js

@@ -1,15 +1,15 @@
-var each = require("lodash/collection/each");
+import each from "lodash/collection/each";
 
-exports.TaggedTemplateExpression = function (node, print) {
+export function TaggedTemplateExpression(node, print) {
   print(node.tag);
   print(node.quasi);
-};
+}
 
-exports.TemplateElement = function (node) {
+export function TemplateElement(node) {
   this._push(node.value.raw);
-};
+}
 
-exports.TemplateLiteral = function (node, print) {
+export function TemplateLiteral(node, print) {
   this.push("`");
 
   var quasis = node.quasis;
@@ -26,4 +26,4 @@ exports.TemplateLiteral = function (node, print) {
   });
 
   this._push("`");
-};
+}

src/babel/generation/generators/types.js

@@ -1,24 +1,23 @@
-var each = require("lodash/collection/each");
+import each from "lodash/collection/each";
 
-exports.Identifier = function (node) {
+export function Identifier(node) {
   this.push(node.name);
-};
+}
 
-exports.RestElement =
-exports.SpreadElement =
-exports.SpreadProperty = function (node, print) {
+export function RestElement(node, print) {
   this.push("...");
   print(node.argument);
-};
+}
 
-exports.VirtualPropertyExpression = function (node, print) {
+export { RestElement as SpreadElement, RestElement as SpreadProperty };
+
+export function VirtualPropertyExpression(node, print) {
   print(node.object);
   this.push("::");
   print(node.property);
-};
+}
 
-exports.ObjectExpression =
-exports.ObjectPattern = function (node, print) {
+export function ObjectExpression(node, print) {
   var props = node.properties;
 
   if (props.length) {
@@ -32,9 +31,11 @@ exports.ObjectPattern = function (node, print) {
   } else {
     this.push("{}");
   }
-};
+}
 
-exports.Property = function (node, print) {
+export { ObjectExpression as ObjectPattern };
+
+export function Property(node, print) {
   if (node.method || node.kind === "get" || node.kind === "set") {
     this._method(node, print);
   } else {
@@ -51,10 +52,9 @@ exports.Property = function (node, print) {
     this.space();
     print(node.value);
   }
-};
+}
 
-exports.ArrayExpression =
-exports.ArrayPattern = function (node, print) {
+export function ArrayExpression(node, print) {
   var elems = node.elements;
   var len   = elems.length;
 
@@ -76,28 +76,34 @@ exports.ArrayPattern = function (node, print) {
   });
 
   this.push("]");
-};
+}
 
-exports.Literal = function (node) {
+export { ArrayExpression as ArrayPattern };
+
+export function Literal(node) {
   var val  = node.value;
   var type = typeof val;
 
   if (type === "string") {
-    val = JSON.stringify(val);
-
-    // escape illegal js but valid json unicode characters
-    val = val.replace(/[\u000A\u000D\u2028\u2029]/g, function (c) {
-      return "\\u" + ("0000" + c.charCodeAt(0).toString(16)).slice(-4);
-    });
-
-    this.push(val);
+    this._stringLiteral(val);
   } else if (type === "number") {
     this.push(val + "");
   } else if (type === "boolean") {
     this.push(val ? "true" : "false");
   } else if (node.regex) {
-    this.push("/" + node.regex.pattern + "/" + node.regex.flags);
+    this.push(`/${node.regex.pattern}/${node.regex.flags}`);
   } else if (val === null) {
     this.push("null");
   }
-};
+}
+
+export function _stringLiteral(val) {
+  val = JSON.stringify(val);
+
+  // escape illegal js but valid json unicode characters
+  val = val.replace(/[\u000A\u000D\u2028\u2029]/g, function (c) {
+    return "\\u" + ("0000" + c.charCodeAt(0).toString(16)).slice(-4);
+  });
+
+  this.push(val);
+}

src/babel/generation/index.js

@@ -1,14 +1,14 @@
-var detectIndent = require("detect-indent");
-var Whitespace   = require("./whitespace");
-var repeating    = require("repeating");
-var SourceMap    = require("./source-map");
-var Position     = require("./position");
-var messages     = require("../messages");
-var Buffer       = require("./buffer");
-var extend       = require("lodash/object/extend");
-var each         = require("lodash/collection/each");
-var n            = require("./node");
-var t            = require("../types");
+import detectIndent from "detect-indent";
+import Whitespace from "./whitespace";
+import repeating from "repeating";
+import SourceMap from "./source-map";
+import Position from "./position";
+import * as messages from "../messages";
+import Buffer from "./buffer";
+import extend from "lodash/object/extend";
+import each from "lodash/collection/each";
+import n from "./node";
+import * as t from "../types";
 
 class CodeGenerator {
   constructor(ast, opts, code) {
@@ -91,8 +91,7 @@ class CodeGenerator {
       return this.print(node, parent, opts);
     };
 
-    print.sequence = (nodes, opts) => {
-      opts ||= {};
+    print.sequence = (nodes, opts = {}) => {
       opts.statement = true;
       return this.printJoin(print, nodes, opts);
     };
@@ -101,8 +100,7 @@ class CodeGenerator {
       return this.printJoin(print, nodes, opts);
     };
 
-    print.list = function (items, opts) {
-      opts ||= {};
+    print.list = function (items, opts = {}) {
       opts.separator ||= ", ";
       print.join(items, opts);
     };
@@ -118,8 +116,8 @@ class CodeGenerator {
     return print;
   }
 
-  print(node, parent, opts) {
-    if (!node) return "";
+  print(node, parent, opts = {}) {
+    if (!node) return;
 
     if (parent && parent._compact) {
       node._compact = true;
@@ -130,8 +128,6 @@ class CodeGenerator {
       this.format.concise = true;
     }
 
-    opts ||= {};
-
     var newline = (leading) => {
       if (!opts.statement && !n.isUserWhitespacable(node, parent)) {
         return;
@@ -191,17 +187,15 @@ class CodeGenerator {
 
       this.printTrailingComments(node, parent);
     } else {
-      throw new ReferenceError("unknown node of type " + JSON.stringify(node.type) + " with constructor " + JSON.stringify(node && node.constructor.name));
+      throw new ReferenceError(`unknown node of type ${JSON.stringify(node.type)} with constructor ${JSON.stringify(node && node.constructor.name)}`);
     }
 
     this.format.concise = oldConcise;
   }
 
-  printJoin(print, nodes, opts) {
+  printJoin(print, nodes, opts = {}) {
     if (!nodes || !nodes.length) return;
 
-    opts ||= {};
-
     var len = nodes.length;
 
     if (opts.indent) this.indent();
@@ -244,9 +238,9 @@ class CodeGenerator {
   generateComment(comment) {
     var val = comment.value;
     if (comment.type === "Line") {
-      val = "//" + val;
+      val = `//${val}`;
     } else {
-      val = "/*" + val + "*/";
+      val = `/*${val}*/`;
     }
     return val;
   }
@@ -325,7 +319,7 @@ class CodeGenerator {
         }
 
         var indent = Math.max(this.indentSize(), column);
-        val = val.replace(/\n/g, "\n" + repeating(" ", indent));
+        val = val.replace(/\n/g, `\n${repeating(" ", indent)}`);
       }
 
       if (column === 0) {

src/babel/generation/node/index.js

@@ -1,8 +1,8 @@
-var whitespace = require("./whitespace");
-var parens     = require("./parentheses");
-var each       = require("lodash/collection/each");
-var some       = require("lodash/collection/some");
-var t          = require("../../types");
+import whitespace from "./whitespace";
+import * as parens from "./parentheses";
+import each from "lodash/collection/each";
+import some from "lodash/collection/some";
+import * as t from "../../types";
 
 var find = function (obj, node, parent) {
   if (!obj) return;

src/babel/generation/node/parentheses.js

@@ -1,5 +1,5 @@
-var t    = require("../../types");
-var each = require("lodash/collection/each");
+import each from "lodash/collection/each";
+import * as t from "../../types";
 
 var PRECEDENCE = {};
 
@@ -21,14 +21,20 @@ each([
   });
 });
 
-exports.UpdateExpression = function (node, parent) {
+export function NullableTypeAnnotation(node, parent) {
+  return t.isArrayTypeAnnotation(parent);
+}
+
+export { NullableTypeAnnotation as FunctionTypeAnnotation };
+
+export function UpdateExpression(node, parent) {
   if (t.isMemberExpression(parent) && parent.object === node) {
     // (foo++).test()
     return true;
   }
-};
+}
 
-exports.ObjectExpression = function (node, parent) {
+export function ObjectExpression(node, parent) {
   if (t.isExpressionStatement(parent)) {
     // ({ foo: "bar" });
     return true;
@@ -40,9 +46,9 @@ exports.ObjectExpression = function (node, parent) {
   }
 
   return false;
-};
+}
 
-exports.Binary = function (node, parent) {
+export function Binary(node, parent) {
   if ((t.isCallExpression(parent) || t.isNewExpression(parent)) && parent.callee === node) {
     return true;
   }
@@ -70,9 +76,9 @@ exports.Binary = function (node, parent) {
       return true;
     }
   }
-};
+}
 
-exports.BinaryExpression = function (node, parent) {
+export function BinaryExpression(node, parent) {
   if (node.operator === "in") {
     // var i = (1 in []);
     if (t.isVariableDeclarator(parent)) {
@@ -84,9 +90,9 @@ exports.BinaryExpression = function (node, parent) {
       return true;
     }
   }
-};
+}
 
-exports.SequenceExpression = function (node, parent) {
+export function SequenceExpression(node, parent) {
   if (t.isForStatement(parent)) {
     // Although parentheses wouldn't hurt around sequence
     // expressions in the head of for loops, traditional style
@@ -102,9 +108,9 @@ exports.SequenceExpression = function (node, parent) {
   // Otherwise err on the side of overparenthesization, adding
   // explicit exceptions above if this proves overzealous.
   return true;
-};
+}
 
-exports.YieldExpression = function (node, parent) {
+export function YieldExpression(node, parent) {
   return t.isBinary(parent) ||
          t.isUnaryLike(parent) ||
          t.isCallExpression(parent) ||
@@ -112,17 +118,17 @@ exports.YieldExpression = function (node, parent) {
          t.isNewExpression(parent) ||
          t.isConditionalExpression(parent) ||
          t.isYieldExpression(parent);
-};
+}
 
-exports.ClassExpression = function (node, parent) {
+export function ClassExpression(node, parent) {
   return t.isExpressionStatement(parent);
-};
+}
 
-exports.UnaryLike = function (node, parent) {
+export function UnaryLike(node, parent) {
   return t.isMemberExpression(parent) && parent.object === node;
-};
+}
 
-exports.FunctionExpression = function (node, parent) {
+export function FunctionExpression(node, parent) {
   // function () {};
   if (t.isExpressionStatement(parent)) {
     return true;
@@ -137,10 +143,9 @@ exports.FunctionExpression = function (node, parent) {
   if (t.isCallExpression(parent) && parent.callee === node) {
     return true;
   }
-};
+}
 
-exports.AssignmentExpression =
-exports.ConditionalExpression = function (node, parent) {
+export function ConditionalExpression(node, parent) {
   if (t.isUnaryLike(parent)) {
     return true;
   }
@@ -164,4 +169,6 @@ exports.ConditionalExpression = function (node, parent) {
   }
 
   return false;
-};
+}
+
+export { ConditionalExpression as AssignmentExpression };

src/babel/generation/node/whitespace.js

@@ -1,11 +1,9 @@
-var isBoolean = require("lodash/lang/isBoolean");
-var each      = require("lodash/collection/each");
-var map       = require("lodash/collection/map");
-var t         = require("../../types");
-
-var crawl = function (node, state) {
-  state ||= {};
+import isBoolean from "lodash/lang/isBoolean";
+import each from "lodash/collection/each";
+import map from "lodash/collection/map";
+import * as t from "../../types";
 
+function crawl(node, state = {}) {
   if (t.isMemberExpression(node)) {
     crawl(node.object, state);
     if (node.computed) crawl(node.property, state);
@@ -22,9 +20,9 @@ var crawl = function (node, state) {
   }
 
   return state;
-};
+}
 
-var isHelper = function (node) {
+function isHelper(node) {
   if (t.isMemberExpression(node)) {
     return isHelper(node.object) || isHelper(node.property);
   } else if (t.isIdentifier(node)) {
@@ -36,12 +34,12 @@ var isHelper = function (node) {
   } else {
     return false;
   }
-};
+}
 
-var isType = function (node) {
+function isType(node) {
   return t.isLiteral(node) || t.isObjectExpression(node) || t.isArrayExpression(node) ||
          t.isIdentifier(node) || t.isMemberExpression(node);
-};
+}
 
 exports.nodes = {
   AssignmentExpression(node) {

src/babel/generation/source-map.js

@@ -1,5 +1,5 @@
-var sourceMap = require("source-map");
-var t         = require("../types");
+import sourceMap from "source-map";
+import * as t from "../types";
 
 export default class SourceMap {
   constructor(position, opts, code) {

src/babel/generation/whitespace.js

@@ -1,4 +1,4 @@
-var sortBy = require("lodash/collection/sortBy");
+import sortBy from "lodash/collection/sortBy";
 
 /**
  * Returns `i`th number from `base`, continuing from 0 when `max` is reached.

src/babel/helpers/code-frame.js

@@ -1,23 +1,22 @@
-var lineNumbers = require("line-numbers");
-var repeating   = require("repeating");
-var jsTokens    = require("js-tokens");
-var esutils     = require("esutils");
-var chalk       = require("chalk");
-var ary         = require("lodash/function/ary");
+import lineNumbers from "line-numbers";
+import repeating from "repeating";
+import jsTokens from "js-tokens";
+import esutils from "esutils";
+import chalk from "chalk";
+import ary from "lodash/function/ary";
 
 var defs = {
-  string:      chalk.red,
-  punctuation: chalk.white.bold,
-  operator:    chalk.white.bold,
-  curly:       chalk.green,
-  parens:      chalk.blue.bold,
-  square:      chalk.yellow,
-  name:        chalk.white,
-  keyword:     chalk.cyan,
-  number:      chalk.magenta,
-  regex:       chalk.magenta,
-  comment:     chalk.grey,
-  invalid:     chalk.inverse
+  string:     chalk.red,
+  punctuator: chalk.white.bold,
+  curly:      chalk.green,
+  parens:     chalk.blue.bold,
+  square:     chalk.yellow,
+  name:       chalk.white,
+  keyword:    chalk.cyan,
+  number:     chalk.magenta,
+  regex:      chalk.magenta,
+  comment:    chalk.grey,
+  invalid:    chalk.inverse
 };
 
 var newline = /\r\n|[\n\r\u2028\u2029]/;
@@ -25,11 +24,11 @@ var newline = /\r\n|[\n\r\u2028\u2029]/;
 var highlight = function (text) {
   var tokenType = function (match) {
     var token = jsTokens.matchToToken(match);
-    if (token.type === "name" && esutils.keyword.isKeywordES6(token.value)) {
+    if (token.type === "name" && esutils.keyword.isReservedWordES6(token.value)) {
       return "keyword";
     }
 
-    if (token.type === "punctuation") {
+    if (token.type === "punctuator") {
       switch (token.value) {
         case "{":
         case "}":
@@ -56,7 +55,7 @@ var highlight = function (text) {
   });
 };
 
-module.exports = function (lines, lineNumber, colNumber) {
+export default function (lines, lineNumber, colNumber) {
   colNumber = Math.max(colNumber, 0);
 
   if (chalk.supportsColor) {
@@ -82,8 +81,7 @@ module.exports = function (lines, lineNumber, colNumber) {
         return;
       }
       if (colNumber) {
-        params.line += "\n" + params.before + repeating(" ", params.width) +
-                       params.after + repeating(" ", colNumber - 1) + "^";
+        params.line += `\n${params.before}${repeating(" ", params.width)}${params.after}${repeating(" ", colNumber - 1)}^`;
       }
       params.before = params.before.replace(/^./, ">");
     }

src/babel/helpers/normalize-ast.js

@@ -1,6 +1,6 @@
-var t = require("../types");
+import * as t from "../types";
 
-module.exports = function (ast, comments, tokens) {
+export default function (ast, comments, tokens) {
   if (ast && ast.type === "Program") {
     return t.file(ast, comments || [], tokens || []);
   } else {

src/babel/helpers/object.js

@@ -1,3 +1,3 @@
-module.exports = function () {
+export default function () {
   return Object.create(null);
 };

src/babel/helpers/parse.js

@@ -1,9 +1,9 @@
-var normalizeAst = require("./normalize-ast");
-var estraverse   = require("estraverse");
-var codeFrame    = require("./code-frame");
-var acorn        = require("acorn-babel");
+import normalizeAst from "./normalize-ast";
+import estraverse from "estraverse";
+import codeFrame from "./code-frame";
+import acorn from "acorn-babel";
 
-module.exports = function (opts, code, callback) {
+export default function (opts, code, callback) {
   try {
     var comments = [];
     var tokens   = [];
@@ -32,7 +32,7 @@ module.exports = function (opts, code, callback) {
   } catch (err) {
     if (!err._babel) {
       err._babel = true;
-      var message = opts.filename + ": " + err.message;
+      var message = `${opts.filename}: ${err.message}`;
 
       var loc = err.loc;
       if (loc) {
@@ -40,7 +40,15 @@ module.exports = function (opts, code, callback) {
         message += frame;
       }
 
-      if (err.stack) err.stack = err.stack.replace(err.message, message);
+      if (err.stack) {
+        var newStack = err.stack.replace(err.message, message);
+        try {
+          err.stack = newStack;
+        } catch (e) {
+          // `err.stack` may be a readonly property in some environments
+        }
+      }
+
       err.message = message;
     }
 

src/babel/helpers/to-fast-properties.js

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

src/babel/messages.js

@@ -1,6 +1,6 @@
-var util = require("util");
+import * as util from  "util";
 
-exports.messages = {
+export var messages = {
   tailCallReassignmentDeopt: "Function reference has been reassigned so it's probably be dereferenced so we can't optimise this with confidence",
   JSXNamespacedTags: "Namespace tags are not supported. ReactJSX is not XML.",
   classesIllegalBareSuper: "Illegal use of bare super",
@@ -10,6 +10,7 @@ exports.messages = {
   undeclaredVariable: "Reference to undeclared variable $1",
   undeclaredVariableSuggestion: "Reference to undeclared variable $1 - did you mean $2?",
   settersInvalidParamLength: "Setters must have exactly one parameter",
+  settersNoRest: "Setters aren't allowed to have a rest",
   noAssignmentsInForHead: "No assignments allowed in for-in/of head",
   expectedMemberExpressionOrIdentifier: "Expected type MemeberExpression or Identifier",
   invalidParentForThisNode: "We don't know how to handle this node within the current parent - please open an issue",
@@ -18,25 +19,23 @@ exports.messages = {
   unknownForHead: "Unknown node type $1 in ForStatement",
   didYouMean: "Did you mean $1?",
   evalInStrictMode: "eval is not allowed in strict mode",
-  codeGeneratorDeopt: "Note: The code generator has deoptimised the styling of $1 as it exceeds the max of $2."
+  codeGeneratorDeopt: "Note: The code generator has deoptimised the styling of $1 as it exceeds the max of $2.",
+  missingTemplatesDirectory: "no templates directory - this is most likely the result of a broken `npm publish`. Please report to https://github.com/babel/babel/issues",
+  unsupportedOutputType: "Unsupported output type $1"
 };
 
-exports.get = function (key) {
-  var msg = exports.messages[key];
-  if (!msg) throw new ReferenceError("Unknown message `" + key + "`");
+export function get(key: String, ...args) {
+  var msg = messages[key];
+  if (!msg) throw new ReferenceError(`Unknown message ${JSON.stringify(key)}`);
 
-  var args = [];
-  for (var i = 1; i < arguments.length; i++) {
-    args.push(arguments[i]);
-  }
-  args = exports.parseArgs(args);
+  args = parseArgs(args);
 
   return msg.replace(/\$(\d+)/g, function (str, i) {
     return args[--i];
   });
-};
+}
 
-exports.parseArgs = function (args) {
+export function parseArgs(args: Array<any>) {
   return args.map(function (val) {
     if (val != null && val.inspect) {
       return val.inspect();
@@ -48,4 +47,4 @@ exports.parseArgs = function (args) {
       }
     }
   });
-};
+}

src/babel/patch.js

@@ -1,16 +1,16 @@
-var extend = require("lodash/object/extend");
-var t      = require("./types");
+import estraverse from "estraverse";
+import extend from "lodash/object/extend";
+import types from "ast-types";
+import * as t from "./types";
 
 // estraverse
 
-var estraverse = require("estraverse");
 extend(estraverse.VisitorKeys, t.VISITOR_KEYS);
 
 // regenerator-babel/ast-types
 
-var types = require("ast-types");
-var def   = types.Type.def;
-var or    = types.Type.or;
+var def = types.Type.def;
+var or  = types.Type.or;
 
 def("File")
   .bases("Node")

src/babel/polyfill.js

@@ -3,5 +3,5 @@ if (global._babelPolyfill) {
 }
 global._babelPolyfill = true;
 
-require("core-js/shim");
-require("regenerator-babel/runtime");
+import "core-js/shim";
+import "regenerator-babel/runtime";

src/babel/tools/build-external-helpers.js

@@ -0,0 +1,86 @@
+import generator from "../generation";
+import * as messages from "../messages";
+import * as util from  "../util";
+import File from "../transformation/file";
+import each from "lodash/collection/each";
+import * as t from "../types";
+
+function buildGlobal(namespace, builder) {
+  var body      = [];
+  var container = t.functionExpression(null, [t.identifier("global")], t.blockStatement(body));
+  var tree      = t.program([t.expressionStatement(t.callExpression(container, [util.template("self-global")]))]);
+
+  body.push(t.variableDeclaration("var", [
+    t.variableDeclarator(
+      namespace,
+      t.assignmentExpression("=", t.memberExpression(t.identifier("global"), namespace), t.objectExpression([]))
+    )
+  ]));
+
+  builder(body);
+
+  return tree;
+}
+
+function buildUmd(namespace, builder) {
+  var body = [];
+  body.push(t.variableDeclaration("var", [
+    t.variableDeclarator(namespace, t.identifier("global"))
+  ]));
+
+  builder(body);
+
+  var container = util.template("umd-commonjs-strict", {
+    FACTORY_PARAMETERS: t.identifier("global"),
+    BROWSER_ARGUMENTS:  t.assignmentExpression("=", t.memberExpression(t.identifier("root"), namespace), t.objectExpression({})),
+    COMMON_ARGUMENTS:   t.identifier("exports"),
+    AMD_ARGUMENTS:      t.arrayExpression([t.literal("exports")]),
+    FACTORY_BODY:       body,
+    UMD_ROOT:           t.identifier("this")
+  });
+  return t.program([container]);
+}
+
+function buildVar(namespace, builder) {
+  var body = [];
+  body.push(t.variableDeclaration("var", [
+    t.variableDeclarator(namespace, t.objectExpression({}))
+  ]));
+  builder(body);
+  return t.program(body);
+}
+
+function buildHelpers(body, namespace, whitelist = []) {
+  each(File.helpers, function (name) {
+    if (whitelist.length && whitelist.indexOf(name) === -1) return;
+
+    var key = t.identifier(t.toIdentifier(name));
+    body.push(t.expressionStatement(
+      t.assignmentExpression("=", t.memberExpression(namespace, key), util.template(name))
+    ));
+  });
+}
+
+export default function (whitelist, outputType = "global") {
+  var namespace = t.identifier("babelHelpers");
+
+  var builder = function (body) {
+    return buildHelpers(body, namespace, whitelist);
+  };
+
+  var tree;
+
+  var build = {
+    global: buildGlobal,
+    umd:    buildUmd,
+    var:    buildVar
+  }[outputType];
+
+  if (build) {
+    tree = build(namespace, builder);
+  } else {
+    throw new Error(messages.get("unsupportedOutputType", outputType));
+  }
+
+  return generator(tree).code;
+};

src/babel/transformation/file.js

@@ -1,18 +1,20 @@
-var sourceMapToComment = require("source-map-to-comment");
-var shebangRegex       = require("shebang-regex");
-var isFunction         = require("lodash/lang/isFunction");
-var transform          = require("./index");
-var generate           = require("../generation");
-var defaults           = require("lodash/object/defaults");
-var includes           = require("lodash/collection/includes");
-var assign             = require("lodash/object/assign");
-var parse              = require("../helpers/parse");
-var Scope              = require("../traversal/scope");
-var slash              = require("slash");
-var util               = require("../util");
-var path               = require("path");
-var each               = require("lodash/collection/each");
-var t                  = require("../types");
+import convertSourceMap from "convert-source-map";
+import shebangRegex from "shebang-regex";
+import isFunction from "lodash/lang/isFunction";
+import sourceMap from "source-map";
+import transform from "./index";
+import generate from "../generation";
+import defaults from "lodash/object/defaults";
+import includes from "lodash/collection/includes";
+import assign from "lodash/object/assign";
+import Logger from "./logger";
+import parse from "../helpers/parse";
+import Scope from "../traversal/scope";
+import slash from "slash";
+import * as util from  "../util";
+import path from "path";
+import each from "lodash/collection/each";
+import * as t from "../types";
 
 var checkTransformerVisitor = {
   enter(node, parent, scope, state) {
@@ -20,12 +22,12 @@ var checkTransformerVisitor = {
   }
 };
 
-var checkNode = function (stack, node, scope) {
+function checkNode(stack, node, scope) {
   each(stack, function (pass) {
-    if (pass.shouldRun) return;
+    if (pass.shouldRun || pass.ran) return;
     pass.checkNode(node, scope);
   });
-};
+}
 
 export default class File {
   constructor(opts) {
@@ -40,6 +42,7 @@ export default class File {
 
     this.lastStatements = [];
     this.opts           = this.normalizeOptions(opts);
+    this.log            = new Logger(this);
     this.ast            = {};
 
     this.buildTransformers();
@@ -48,7 +51,8 @@ export default class File {
   static helpers = [
     "inherits",
     "defaults",
-    "prototype-properties",
+    "create-class",
+    "create-computed-class",
     "apply-constructor",
     "tagged-template-literal",
     "tagged-template-literal-loose",
@@ -77,34 +81,41 @@ export default class File {
   static validOptions = [
     "filename",
     "filenameRelative",
+
     "blacklist",
     "whitelist",
-    "loose",
     "optional",
+
+    "loose",
+    "playground",
+    "experimental",
+
     "modules",
+    "moduleIds",
+    "moduleId",
+    "resolveModuleSource",
+    "keepModuleIdExtensions",
+
+    "code",
+    "ast",
+
+    "comments",
+    "compact",
+
+    "auxiliaryComment",
+    "externalHelpers",
+    "returnUsedHelpers",
+
+    "inputSourceMap",
     "sourceMap",
     "sourceMapName",
     "sourceFileName",
     "sourceRoot",
     "moduleRoot",
-    "moduleIds",
-    "comments",
-    "reactCompat",
-    "keepModuleIdExtensions",
-    "code",
-    "ast",
-    "playground",
-    "experimental",
-    "externalHelpers",
-    "auxiliaryComment",
-    "compact",
-    "returnUsedHelpers",
-
-    "resolveModuleSource",
-    "moduleId",
 
     // legacy
     "format",
+    "reactCompat",
 
     // these are used by plugins
     "ignore",
@@ -113,12 +124,12 @@ export default class File {
     "accept"
   ];
 
-  normalizeOptions(opts) {
+  normalizeOptions(opts: Object) {
     opts = assign({}, opts);
 
     for (var key in opts) {
       if (key[0] !== "_" && File.validOptions.indexOf(key) < 0) {
-        throw new ReferenceError("Unknown option: " + key);
+        throw new ReferenceError(`Unknown option: ${key}`);
       }
     }
 
@@ -128,6 +139,7 @@ export default class File {
       returnUsedHelpers:      false,
       externalHelpers:        false,
       auxilaryComment:        "",
+      inputSourceMap:         null,
       experimental:           false,
       reactCompat:            false,
       playground:             false,
@@ -145,6 +157,10 @@ export default class File {
       ast:                    true
     });
 
+    if (opts.inputSourceMap) {
+      opts.sourceMap = true;
+    }
+
     // normalize windows path separators to unix
     opts.filename = slash(opts.filename);
     if (opts.sourceRoot) {
@@ -214,7 +230,7 @@ export default class File {
     return opts;
   };
 
-  isLoose(key) {
+  isLoose(key: string) {
     return includes(this.opts.loose, key);
   }
 
@@ -246,13 +262,7 @@ export default class File {
     this.transformers = transformers;
   }
 
-  debug(msg) {
-    var parts = this.opts.filename;
-    if (msg) parts += ": " + msg;
-    util.debug(parts);
-  }
-
-  getModuleFormatter(type) {
+  getModuleFormatter(type: string) {
     var ModuleFormatter = isFunction(type) ? type : transform.moduleFormatters[type];
 
     if (!ModuleFormatter) {
@@ -261,13 +271,27 @@ export default class File {
     }
 
     if (!ModuleFormatter) {
-      throw new ReferenceError("Unknown module formatter type " + JSON.stringify(type));
+      throw new ReferenceError(`Unknown module formatter type ${JSON.stringify(type)}`);
     }
 
     return new ModuleFormatter(this);
   }
 
-  parseShebang(code) {
+  parseInputSourceMap(code: string) {
+    var opts = this.opts;
+
+    if (opts.inputSourceMap !== false) {
+      var inputMap = convertSourceMap.fromSource(code);
+      if (inputMap) {
+        opts.inputSourceMap = inputMap.toObject();
+        code = convertSourceMap.removeComments(code);
+      }
+    }
+
+    return code;
+  }
+
+  parseShebang(code: string) {
     var shebangMatch = shebangRegex.exec(code);
 
     if (shebangMatch) {
@@ -280,15 +304,15 @@ export default class File {
     return code;
   }
 
-  set(key, val) {
+  set(key: string, val): any {
     return this.data[key] = val;
   };
 
-  setDynamic(key, fn) {
+  setDynamic(key: string, fn: Function) {
     this.dynamicData[key] = fn;
   }
 
-  get(key) {
+  get(key: string): any {
     var data = this.data[key];
     if (data) {
       return data;
@@ -300,7 +324,7 @@ export default class File {
     }
   }
 
-  addImport(source, name, noDefault) {
+  addImport(source: string, name?: string, noDefault?: boolean): Object {
     name ||= source;
     var id = this.dynamicImportIds[name];
 
@@ -314,17 +338,21 @@ export default class File {
       this.dynamicImported.push(declar);
       if (noDefault) this.dynamicImportedNoDefault.push(declar);
 
-      this.moduleFormatter.importSpecifier(specifiers[0], declar, this.dynamicImports);
+      if (this.transformers["es6.modules"].canRun()) {
+        this.moduleFormatter.importSpecifier(specifiers[0], declar, this.dynamicImports);
+      } else {
+        this.dynamicImports.push(declar);
+      }
     }
 
     return id;
   }
 
-  isConsequenceExpressionStatement(node) {
+  isConsequenceExpressionStatement(node: Object): boolean {
     return t.isExpressionStatement(node) && this.lastStatements.indexOf(node) >= 0;
   }
 
-  attachAuxiliaryComment(node) {
+  attachAuxiliaryComment(node: Object): Object {
     var comment = this.opts.auxiliaryComment;
     if (comment) {
       node.leadingComments ||= [];
@@ -336,9 +364,9 @@ export default class File {
     return node;
   }
 
-  addHelper(name) {
+  addHelper(name: string): Object {
     if (!includes(File.helpers, name)) {
-      throw new ReferenceError("Unknown helper " + name);
+      throw new ReferenceError(`Unknown helper ${name}`);
     }
 
     var program = this.ast.program;
@@ -348,10 +376,13 @@ export default class File {
 
     this.usedHelpers[name] = true;
 
+    var generator = this.get("helperGenerator");
     var runtime = this.get("helpersNamespace");
-    if (runtime) {
-      name = t.identifier(t.toIdentifier(name));
-      return t.memberExpression(runtime, name);
+    if (generator) {
+      return generator(name);
+    } else if (runtime) {
+      var id = t.identifier(t.toIdentifier(name));
+      return t.memberExpression(runtime, id);
     } else {
       var ref = util.template(name);
       ref._compact = true;
@@ -365,32 +396,27 @@ export default class File {
     }
   }
 
-  logDeopt() {
-    // todo, (node, msg)
-  }
-
-  errorWithNode(node, msg, Error) {
-    Error ||= SyntaxError;
-
+  errorWithNode(node, msg, Error = SyntaxError) {
     var loc = node.loc.start;
-    var err = new Error("Line " + loc.line + ": " + msg);
+    var err = new Error(`Line ${loc.line}: ${msg}`);
     err.loc = loc;
     return err;
   }
 
-  addCode(code) {
+  addCode(code: string) {
     code = (code || "") + "";
+    code = this.parseInputSourceMap(code);
     this.code = code;
     return this.parseShebang(code);
   }
 
-  parse(code) {
+  parse(code: string) {
     code = this.addCode(code);
 
     var opts = this.opts;
 
     opts.allowImportExportEverywhere = this.isLoose("es6.modules");
-    opts.strictMode = this.transformers.useStrict.canRun();
+    opts.strictMode = this.transformers.strict.canRun();
 
     return parse(opts, code, (tree) => {
       this.transform(tree);
@@ -399,7 +425,7 @@ export default class File {
   }
 
   transform(ast) {
-    this.debug();
+    this.log.debug();
 
     this.ast = ast;
     this.lastStatements = t.getLastStatements(ast.program);
@@ -421,7 +447,7 @@ export default class File {
     this.call("post");
   }
 
-  call(key) {
+  call(key: string) {
     var stack = this.transformerStack;
     for (var i = 0; i < stack.length; i++) {
       var transformer = stack[i].transformer;
@@ -432,6 +458,13 @@ export default class File {
   }
 
   checkNode(node, scope) {
+    if (Array.isArray(node)) {
+      for (var i = 0; i < node.length; i++) {
+        this.checkNode(node[i], scope);
+      }
+      return;
+    }
+
     var stack = this.transformerStack;
     scope ||= this.scope;
 
@@ -442,7 +475,33 @@ export default class File {
     });
   }
 
-  generate() {
+  mergeSourceMap(map: Object) {
+    var opts = this.opts;
+
+    var inputMap = opts.inputSourceMap;
+
+    if (inputMap) {
+      map.sources[0] = inputMap.file;
+
+      var inputMapConsumer = new sourceMap.SourceMapConsumer(inputMap);
+      var outputMapConsumer = new sourceMap.SourceMapConsumer(map);
+      var outputMapGenerator = sourceMap.SourceMapGenerator.fromSourceMap(outputMapConsumer);
+      outputMapGenerator.applySourceMap(inputMapConsumer);
+
+      var mergedMap = outputMapGenerator.toJSON();
+      mergedMap.sources = inputMap.sources
+      mergedMap.file = inputMap.file;
+      return mergedMap;
+    }
+
+    return map;
+  }
+
+  generate(): {
+    code: string;
+    map?: Object;
+    ast?: Object;
+  } {
     var opts = this.opts;
     var ast  = this.ast;
 
@@ -465,11 +524,16 @@ export default class File {
 
     if (this.shebang) {
       // add back shebang
-      result.code = this.shebang + "\n" + result.code;
+      result.code = `${this.shebang}\n${result.code}`;
+    }
+
+    result.map = this.mergeSourceMap(result.map);
+
+    if (opts.sourceMap === "inline" || opts.sourceMap === "both") {
+      result.code += "\n" + convertSourceMap.fromObject(result.map).toComment();
     }
 
     if (opts.sourceMap === "inline") {
-      result.code += "\n" + sourceMapToComment(result.map);
       result.map = null;
     }
 

src/babel/transformation/helpers/build-binary-assignment-operator-transformer.js

@@ -1,7 +1,7 @@
-var explode = require("./explode-assignable-expression");
-var t       = require("../../types");
+import explode from "./explode-assignable-expression";
+import * as t from "../../types";
 
-module.exports = function (exports, opts) {
+export default function (exports, opts) {
   var isAssignment = function (node) {
     return node.operator === opts.operator + "=";
   };

src/babel/transformation/helpers/build-comprehension.js

@@ -1,6 +1,6 @@
-var t = require("../../types");
+import * as t from "../../types";
 
-module.exports = function build(node, buildBody) {
+export default function build(node, buildBody) {
   var self = node.blocks.shift();
   if (!self) return;
 
@@ -20,4 +20,4 @@ module.exports = function build(node, buildBody) {
     self.right,
     t.blockStatement([child])
   );
-};
+}

src/babel/transformation/helpers/build-conditional-assignment-operator-transformer.js

@@ -1,7 +1,7 @@
-var explode = require("./explode-assignable-expression");
-var t       = require("../../types");
+import explode from "./explode-assignable-expression";
+import * as t from "../../types";
 
-module.exports = function (exports, opts) {
+export default function (exports, opts) {
   var buildAssignment = function (left, right) {
     return t.assignmentExpression("=", left, right);
   };

src/babel/transformation/helpers/build-react-transformer.js

@@ -3,13 +3,13 @@
 
 // jsx
 
-var isString = require("lodash/lang/isString");
-var messages = require("../../messages");
-var esutils  = require("esutils");
-var react    = require("./react");
-var t        = require("../../types");
+import isString from "lodash/lang/isString";
+import * as messages from "../../messages";
+import esutils from "esutils";
+import * as react from "./react";
+import * as t from "../../types";
 
-module.exports = function (exports, opts) {
+export default function (exports, opts) {
   exports.check = function (node) {
     if (t.isJSX(node)) return true;
     if (react.isCreateClass(node)) return true;

src/babel/transformation/helpers/define-map.js

@@ -1,39 +1,45 @@
-var cloneDeep = require("lodash/lang/cloneDeep");
-var traverse  = require("../../traversal");
-var clone     = require("lodash/lang/clone");
-var each      = require("lodash/collection/each");
-var has       = require("lodash/object/has");
-var t         = require("../../types");
+import cloneDeep from "lodash/lang/cloneDeep";
+import traverse from "../../traversal";
+import each from "lodash/collection/each";
+import has from "lodash/object/has";
+import * as t from "../../types";
 
-exports.push = function (mutatorMap, key, kind, computed, value) {
-  var alias;
+export function push(mutatorMap, key, kind, computed, value) {
+  var alias = t.toKeyAlias({ computed }, key);
 
-  if (t.isIdentifier(key)) {
-    alias = key.name;
-    if (computed) alias = "computed:" + alias;
-  } else if (t.isLiteral(key)) {
-    alias = String(key.value);
-  } else {
-    alias = JSON.stringify(traverse.removeProperties(cloneDeep(key)));
-  }
-
-  var map;
-  if (has(mutatorMap, alias)) {
-    map = mutatorMap[alias];
-  } else {
-    map = {};
-  }
+  var map = {};
+  if (has(mutatorMap, alias)) map = mutatorMap[alias];
   mutatorMap[alias] = map;
 
   map._key = key;
-  if (computed) {
-    map._computed = true;
-  }
+  if (computed) map._computed = true;
 
   map[kind] = value;
-};
+}
 
-exports.build = function (mutatorMap) {
+export function hasComputed(mutatorMap) {
+  for (var key in mutatorMap) {
+    if (mutatorMap[key]._computed) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export function toComputedObjectFromClass(obj) {
+  var objExpr = t.arrayExpression([]);
+
+  for (var i = 0; i < obj.properties.length; i++) {
+    var prop = obj.properties[i];
+    var val = prop.value;
+    val.properties.unshift(t.property("init", t.identifier("key"), t.toComputedKey(prop)));
+    objExpr.elements.push(val);
+  }
+
+  return objExpr;
+}
+
+export function toClassObject(mutatorMap) {
   var objExpr = t.objectExpression([]);
 
   each(mutatorMap, function (map) {
@@ -41,28 +47,16 @@ exports.build = function (mutatorMap) {
 
     var propNode = t.property("init", map._key, mapNode, map._computed);
 
-    if (!map.get && !map.set) {
-      map.writable = t.literal(true);
-    }
-
-    if (map.enumerable === false) {
-      delete map.enumerable;
-    } else {
-      map.enumerable = t.literal(true);
-    }
-
-    map.configurable = t.literal(true);
-
     each(map, function (node, key) {
       if (key[0] === "_") return;
 
-      node = clone(node);
       var inheritNode = node;
       if (t.isMethodDefinition(node)) node = node.value;
 
       var prop = t.property("init", t.identifier(key), node);
       t.inheritsComments(prop, inheritNode);
       t.removeComments(inheritNode);
+
       mapNode.properties.push(prop);
     });
 
@@ -70,4 +64,14 @@ exports.build = function (mutatorMap) {
   });
 
   return objExpr;
-};
+}
+
+export function toDefineObject(mutatorMap) {
+  each(mutatorMap, function (map) {
+    if (map.value) map.writable = t.literal(true);
+    map.configurable = t.literal(true);
+    map.enumerable = t.literal(true);
+  });
+
+  return toClassObject(mutatorMap);
+}

src/babel/transformation/helpers/explode-assignable-expression.js

@@ -1,4 +1,4 @@
-var t = require("../../types");
+import * as t from "../../types";
 
 var getObjRef = function (node, nodes, file, scope) {
   var ref;
@@ -23,7 +23,7 @@ var getObjRef = function (node, nodes, file, scope) {
       return ref;
     }
   } else {
-    throw new Error("We can't explode this node type " + node.type);
+    throw new Error(`We can't explode this node type ${node.type}`);
   }
 
   var temp = scope.generateUidBasedOnNode(ref);
@@ -45,7 +45,7 @@ var getPropRef = function (node, nodes, file, scope) {
   return temp;
 };
 
-module.exports = function (node, nodes, file, scope, allowedSingleIdent) {
+export default function (node, nodes, file, scope, allowedSingleIdent) {
   var obj;
   if (t.isIdentifier(node) && allowedSingleIdent) {
     obj = node;

src/babel/transformation/helpers/get-function-arity.js

@@ -1,6 +1,6 @@
-var t = require("../../types");
+import * as t from "../../types";
 
-module.exports = function (node) {
+export default function (node) {
   var lastNonDefault = 0;
   for (var i = 0; i < node.params.length; i++) {
     if (!t.isAssignmentPattern(node.params[i])) lastNonDefault = i + 1;

src/babel/transformation/helpers/name-method.js

@@ -1,12 +1,12 @@
-var getFunctionArity = require("./get-function-arity");
-var util             = require("../../util");
-var t                = require("../../types");
+import getFunctionArity from "./get-function-arity";
+import * as util from  "../../util";
+import * as t from "../../types";
 
 var visitor = {
   enter(node, parent, scope, state) {
     // check if this node is a referenced identifier that matches the same as our
     // function id
-    if (!t.isReferencedIdentifier(node, parent, { name: state.name })) return;
+    if (!this.isReferencedIdentifier({ name: state.name })) return;
 
     // check that we don't have a local variable declared as that removes the need
     // for the wrapper
@@ -49,7 +49,7 @@ var visit = function (node, name, scope) {
     selfReference:  false,
     outerDeclar:    scope.getBindingIdentifier(name),
     references:     [],
-    name:           name,
+    name:           name
   };
 
   // check to see if we have a local binding of the id we're setting inside of
@@ -89,7 +89,12 @@ var visit = function (node, name, scope) {
   return state;
 };
 
-exports.property = function (node, file, scope) {
+export function custom(node, id, scope) {
+  var state = visit(node, id.name, scope);
+  return wrap(state, node, id, scope);
+}
+
+export function property(node, file, scope) {
   var key = t.toComputedKey(node, node.key);
   if (!t.isLiteral(key)) return node; // we can't set a function id with this
 
@@ -99,28 +104,35 @@ exports.property = function (node, file, scope) {
   var method = node.value;
   var state  = visit(method, name, scope);
   node.value = wrap(state, method, id, scope);
-};
+}
 
-exports.bare = function (node, parent, scope) {
+export function bare(node, parent, scope) {
   // has an `id` so we don't need to infer one
-  if (node.id) return;
+  if (node.id) return node;
 
   var id;
-  if (t.isProperty(parent) && parent.kind === "init" && !parent.computed) {
+  if (t.isProperty(parent) && parent.kind === "init" && (!parent.computed || t.isLiteral(parent.key))) {
     // { foo() {} };
     id = parent.key;
   } else if (t.isVariableDeclarator(parent)) {
     // var foo = function () {};
     id = parent.id;
+  } else {
+    return node;
+  }
+
+  var name;
+  if (t.isLiteral(id)) {
+    name = id.value;
+  } else if (t.isIdentifier(id)) {
+    name = id.name;
   } else {
     return;
   }
 
-  if (!t.isIdentifier(id)) return;
-
-  var name = t.toIdentifier(id.name);
+  name = t.toIdentifier(name);
   id = t.identifier(name);
 
   var state = visit(node, name, scope);
   return wrap(state, node, id, scope);
-};
+}

src/babel/transformation/helpers/react.js

@@ -1,8 +1,8 @@
-var t = require("../../types");
+import * as t from "../../types";
 
 var isCreateClassCallExpression = t.buildMatchMemberExpression("React.createClass");
 
-exports.isCreateClass = function (node) {
+export function isCreateClass(node) {
   if (!node || !t.isCallExpression(node)) return false;
 
   // not React.createClass call member object
@@ -17,10 +17,10 @@ exports.isCreateClass = function (node) {
   if (!t.isObjectExpression(first)) return false;
 
   return true;
-};
+}
 
-exports.isReactComponent = t.buildMatchMemberExpression("React.Component");
+export var isReactComponent = t.buildMatchMemberExpression("React.Component");
 
-exports.isCompatTag = function (tagName) {
+export function isCompatTag(tagName) {
   return tagName && /^[a-z]|\-/.test(tagName);
-};
+}

src/babel/transformation/helpers/regex.js

@@ -0,0 +1,13 @@
+import pull from "lodash/array/pull";
+import * as t from "../../types";
+
+export function is(node, flag) {
+  return t.isLiteral(node) && node.regex && node.regex.flags.indexOf(flag) >= 0;
+}
+
+export function pullFlag(node, flag) {
+  var flags = node.regex.flags.split("");
+  if (node.regex.flags.indexOf(flag) < 0) return;
+  pull(flags, flag);
+  node.regex.flags = flags.join("");
+}

src/babel/transformation/helpers/remap-async-to-generator.js

@@ -1,7 +1,7 @@
-var t = require("../../types");
+import * as t from "../../types";
 
-var visitor = {
-  enter(node) {
+var awaitVisitor = {
+  enter(node, parent, scope, state) {
     if (t.isFunction(node)) this.skip();
 
     if (t.isAwaitExpression(node)) {
@@ -16,15 +16,25 @@ var visitor = {
   }
 };
 
-module.exports = function (node, callId, scope) {
+var referenceVisitor = {
+  enter(node, parent, scope, state) {
+    var name = state.id.name;
+    if (t.isReferencedIdentifier(node, parent, { name: name }) && scope.bindingIdentifierEquals(name, state.id)) {
+      return state.ref ||= scope.generateUidIdentifier(name);
+    }
+  }
+};
+
+export default function (node, callId, scope) {
   node.async = false;
   node.generator = true;
 
-  scope.traverse(node, visitor);
+  scope.traverse(node, awaitVisitor, state);
 
   var call = t.callExpression(callId, [node]);
+
   var id = node.id;
-  delete node.id;
+  node.id = null;
 
   if (t.isFunctionDeclaration(node)) {
     var declar = t.variableDeclaration("let", [
@@ -33,6 +43,16 @@ module.exports = function (node, callId, scope) {
     declar._blockHoist = true;
     return declar;
   } else {
+    if (id) {
+      var state = { id: id };
+      scope.traverse(node, referenceVisitor, state);
+
+      if (state.ref) {
+        scope.parent.push({ id: state.ref });
+        return t.assignmentExpression("=", state.ref, call);
+      }
+    }
+
     return call;
   }
 };

src/babel/transformation/helpers/replace-supers.js

@@ -1,19 +1,19 @@
 module.exports = ReplaceSupers;
 
-var messages = require("../../messages");
-var t        = require("../../types");
+import * as messages from "../../messages";
+import * as t from "../../types";
 
 
-var isIllegalBareSuper = function (node, parent) {
+function isIllegalBareSuper(node, parent) {
   if (!isSuper(node, parent)) return false;
   if (t.isMemberExpression(parent, { computed: false })) return false;
   if (t.isCallExpression(parent, { callee: node })) return false;
   return true;
-};
+}
 
-var isSuper = function (node, parent) {
+function isSuper(node, parent) {
   return t.isIdentifier(node, { name: "super" }) && t.isReferenced(node, parent);
-};
+}
 
 var visitor = {
   enter(node, parent, scope, state) {
@@ -47,22 +47,23 @@ export default class ReplaceSupers {
 
   /**
    * Description
-   *
-   * @param {Object} opts
-   * @param {Boolean} [inClass]
    */
 
-  constructor(opts, inClass) {
+  constructor(opts: Object, inClass?: boolean = false) {
     this.topLevelThisReference = opts.topLevelThisReference;
     this.methodNode            = opts.methodNode;
-    this.className             = opts.className;
-    this.superName             = opts.superName;
+    this.superRef              = opts.superRef;
     this.isStatic              = opts.isStatic;
     this.hasSuper              = false;
     this.inClass               = inClass;
     this.isLoose               = opts.isLoose;
     this.scope                 = opts.scope;
     this.file                  = opts.file;
+    this.opts                  = opts;
+  }
+
+  getObjectRef() {
+    return this.opts.objectRef || this.opts.getObjectRef();
   }
 
   /**
@@ -72,22 +73,16 @@ export default class ReplaceSupers {
    *
    *   _set(Object.getPrototypeOf(CLASS.prototype), "METHOD", "VALUE", this)
    *
-   * @param {Node} property
-   * @param {Node} value
-   * @param {Boolean} isComputed
-   * @param {Node} thisExpression
-   *
-   * @returns {Node}
    */
 
-  setSuperProperty(property, value, isComputed, thisExpression) {
+  setSuperProperty(property: Object, value: Object, isComputed: boolean, thisExpression: Object): Object {
     return t.callExpression(
       this.file.addHelper("set"),
       [
         t.callExpression(
           t.memberExpression(t.identifier("Object"), t.identifier("getPrototypeOf")),
           [
-            this.isStatic ? this.className : t.memberExpression(this.className, t.identifier("prototype"))
+            this.isStatic ? this.getObjectRef() : t.memberExpression(this.getObjectRef(), t.identifier("prototype"))
           ]
         ),
         isComputed ? property : t.literal(property.name),
@@ -104,21 +99,16 @@ export default class ReplaceSupers {
    *
    *   _get(Object.getPrototypeOf(CLASS.prototype), "METHOD", this)
    *
-   * @param {Node} property
-   * @param {Boolean} isComputed
-   * @param {Node} thisExpression
-   *
-   * @returns {Node}
    */
 
-  getSuperProperty(property, isComputed, thisExpression) {
+  getSuperProperty(property: Object, isComputed: boolean, thisExpression: Object): Object {
     return t.callExpression(
       this.file.addHelper("get"),
       [
         t.callExpression(
           t.memberExpression(t.identifier("Object"), t.identifier("getPrototypeOf")),
           [
-            this.isStatic ? this.className : t.memberExpression(this.className, t.identifier("prototype"))
+            this.isStatic ? this.getObjectRef() : t.memberExpression(this.getObjectRef(), t.identifier("prototype"))
           ]
         ),
         isComputed ? property : t.literal(property.name),
@@ -137,12 +127,9 @@ export default class ReplaceSupers {
 
   /**
    * Description
-   *
-   * @param {Object} node
-   * @param {Boolean} topLevel
    */
 
-  traverseLevel(node, topLevel) {
+  traverseLevel(node: Object, topLevel: boolean) {
     var state = { self: this, topLevel: topLevel };
     this.scope.traverse(node, visitor, state);
   }
@@ -165,29 +152,24 @@ export default class ReplaceSupers {
 
   /**
    * Description
-   *
-   * @param {Object} node
-   * @param {Object} id
-   * @param {Object} parent
-   * @returns {Object}
    */
 
-  getLooseSuperProperty(id, parent) {
+  getLooseSuperProperty(id: Object, parent: Object) {
     var methodNode = this.methodNode;
     var methodName = methodNode.key;
-    var superName  = this.superName || t.identifier("Function");
+    var superRef   = this.superRef || t.identifier("Function");
 
     if (parent.property === id) {
       return;
     } else if (t.isCallExpression(parent, { callee: id })) {
-      // super(); -> ClassName.prototype.MethodName.call(this);
+      // super(); -> objectRef.prototype.MethodName.call(this);
       parent.arguments.unshift(t.thisExpression());
 
       if (methodName.name === "constructor") {
         // constructor() { super(); }
-        return t.memberExpression(superName, t.identifier("call"));
+        return t.memberExpression(superRef, t.identifier("call"));
       } else {
-        id = superName;
+        id = superRef;
 
         // foo() { super(); }
         if (!methodNode.static) {
@@ -198,22 +180,18 @@ export default class ReplaceSupers {
         return t.memberExpression(id, t.identifier("call"));
       }
     } else if (t.isMemberExpression(parent) && !methodNode.static) {
-      // super.test -> ClassName.prototype.test
-      return t.memberExpression(superName, t.identifier("prototype"));
+      // super.test -> objectRef.prototype.test
+      return t.memberExpression(superRef, t.identifier("prototype"));
     } else {
-      return superName;
+      return superRef;
     }
   }
 
   /**
    * Description
-   *
-   * @param {Function} getThisReference
-   * @param {Object} node
-   * @param {Object} parent
    */
 
-  looseHandle(getThisReference, node, parent) {
+  looseHandle(getThisReference: Function, node: Object, parent: Object) {
     if (t.isIdentifier(node, { name: "super" })) {
       this.hasSuper = true;
       return this.getLooseSuperProperty(node, parent);
@@ -222,7 +200,7 @@ export default class ReplaceSupers {
       if (!t.isMemberExpression(callee)) return;
       if (callee.object.name !== "super") return;
 
-      // super.test(); -> ClassName.prototype.MethodName.call(this);
+      // super.test(); -> objectRef.prototype.MethodName.call(this);
       this.hasSuper = true;
       t.appendToMemberExpression(callee, t.identifier("call"));
       node.arguments.unshift(getThisReference());
@@ -231,13 +209,9 @@ export default class ReplaceSupers {
 
   /**
    * Description
-   *
-   * @param {Function} getThisReference
-   * @param {Object} node
-   * @param {Object} parent
    */
 
-  specHandle(getThisReference, node, parent) {
+  specHandle(getThisReference: Function, node: Object, parent: Object) {
     var methodNode = this.methodNode;
     var property;
     var computed;
@@ -251,7 +225,7 @@ export default class ReplaceSupers {
     if (t.isCallExpression(node)) {
       var callee = node.callee;
       if (isSuper(callee, node)) {
-        // super(); -> _get(Object.getPrototypeOf(ClassName), "MethodName", this).call(this);
+        // super(); -> _get(Object.getPrototypeOf(objectRef), "MethodName", this).call(this);
         property = methodNode.key;
         computed = methodNode.computed;
         args = node.arguments;
@@ -264,17 +238,17 @@ export default class ReplaceSupers {
           throw this.file.errorWithNode(node, messages.get("classesIllegalSuperCall", methodName));
         }
       } else if (t.isMemberExpression(callee) && isSuper(callee.object, callee)) {
-        // super.test(); -> _get(Object.getPrototypeOf(ClassName.prototype), "test", this).call(this);
+        // super.test(); -> _get(Object.getPrototypeOf(objectRef.prototype), "test", this).call(this);
         property = callee.property;
         computed = callee.computed;
         args = node.arguments;
       }
     } else if (t.isMemberExpression(node) && isSuper(node.object, node)) {
-      // super.name; -> _get(Object.getPrototypeOf(ClassName.prototype), "name", this);
+      // super.name; -> _get(Object.getPrototypeOf(objectRef.prototype), "name", this);
       property = node.property;
       computed = node.computed;
     } else if (t.isAssignmentExpression(node) && isSuper(node.left.object, node.left) && methodNode.kind === "set") {
-      // super.name = "val"; -> _set(Object.getPrototypeOf(ClassName.prototype), "name", this);
+      // super.name = "val"; -> _set(Object.getPrototypeOf(objectRef.prototype), "name", this);
       this.hasSuper = true;
       return this.setSuperProperty(node.left.property, node.right, node.left.computed, getThisReference());
     }

src/babel/transformation/helpers/strict.js

@@ -1,13 +1,13 @@
-var t = require("../../types");
+import * as t from "../../types";
 
-exports.has = function (node) {
+export function has(node) {
   var first = node.body[0];
   return t.isExpressionStatement(first) && t.isLiteral(first.expression, { value: "use strict" });
-};
+}
 
-exports.wrap = function (node, callback) {
+export function wrap(node, callback) {
   var useStrictNode;
-  if (exports.has(node)) {
+  if (has(node)) {
     useStrictNode = node.body.shift();
   }
 
@@ -16,4 +16,4 @@ exports.wrap = function (node, callback) {
   if (useStrictNode) {
     node.body.unshift(useStrictNode);
   }
-};
+}

src/babel/transformation/index.js

@@ -1,12 +1,10 @@
-module.exports = transform;
+import normalizeAst from "../helpers/normalize-ast";
+import Transformer from "./transformer";
+import object from "../helpers/object";
+import File from "./file";
+import each from "lodash/collection/each";
 
-var normalizeAst = require("../helpers/normalize-ast");
-var Transformer  = require("./transformer");
-var object       = require("../helpers/object");
-var File         = require("./file");
-var each         = require("lodash/collection/each");
-
-function transform(code, opts) {
+export default function transform(code: code, opts?: Object) {
   var file = new File(opts);
   return file.parse(code);
 }
@@ -20,16 +18,19 @@ transform.fromAst = function (ast, code, opts) {
   return file.generate();
 };
 
-transform._ensureTransformerNames = function (type, rawKeys) {
+transform._ensureTransformerNames = function (type: string, rawKeys: Array<string>) {
   var keys = [];
 
   for (var i = 0; i < rawKeys.length; i++) {
     var key = rawKeys[i];
 
     var deprecatedKey = transform.deprecatedTransformerMap[key];
-    if (deprecatedKey) {
+    var aliasKey = transform.aliasTransformerMap[key];
+    if (aliasKey) {
+      keys.push(aliasKey);
+    } else if (deprecatedKey) {
       // deprecated key, remap it to the new one
-      console.error("The transformer " + key + " has been renamed to " + deprecatedKey);
+      console.error(`The transformer ${key} has been renamed to ${deprecatedKey}`);
       rawKeys.push(deprecatedKey);
     } else if (transform.transformers[key]) {
       // valid key
@@ -39,7 +40,7 @@ transform._ensureTransformerNames = function (type, rawKeys) {
       keys = keys.concat(transform.namespaces[key]);
     } else {
       // invalid key
-      throw new ReferenceError("Unknown transformer " + key + " specified in " + type);
+      throw new ReferenceError(`Unknown transformer ${key} specified in ${type}`);
     }
   }
 
@@ -51,9 +52,10 @@ transform.transformers          = object();
 transform.namespaces            = object();
 
 transform.deprecatedTransformerMap = require("./transformers/deprecated");
+transform.aliasTransformerMap = require("./transformers/aliases");
 transform.moduleFormatters = require("./modules");
 
-var rawTransformers = require("./transformers");
+import rawTransformers from "./transformers";
 
 each(rawTransformers, function (transformer, key) {
   var namespace = key.split(".")[0];

src/babel/transformation/logger.js

@@ -0,0 +1,22 @@
+import * as util from  "../util";
+
+export default class Logger {
+  constructor(file: File) {
+    this.filename = file.opts.filename;
+    this.file     = file;
+  }
+
+  _buildMessage(msg: string): string {
+    var parts = this.filename;
+    if (msg) parts += `: ${msg}`;
+    return parts;
+  }
+
+  debug(msg: string) {
+    util.debug(this._buildMessage(msg));
+  }
+
+  deopt(node: Object, msg: string) {
+    util.debug(this._buildMessage(msg));
+  }
+}

src/babel/transformation/modules/_default.js

@@ -1,8 +1,8 @@
-var messages = require("../../messages");
-var extend   = require("lodash/object/extend");
-var object   = require("../../helpers/object");
-var util     = require("../../util");
-var t        = require("../../types");
+import * as messages from "../../messages";
+import extend from "lodash/object/extend";
+import object from "../../helpers/object";
+import * as util from  "../../util";
+import * as t from "../../types";
 
 var remapVisitor = {
   enter(node, parent, scope, formatter) {
@@ -42,8 +42,8 @@ var remapVisitor = {
 };
 
 var importsVisitor = {
-  enter(node, parent, scope, formatter) {
-    if (t.isImportDeclaration(node)) {
+  ImportDeclaration: {
+    enter(node, parent, scope, formatter) {
       formatter.hasLocalImports = true;
       extend(formatter.localImports, t.getBindingIdentifiers(node));
       formatter.bumpImportOccurences(node);
@@ -52,9 +52,9 @@ var importsVisitor = {
 };
 
 var exportsVisitor = {
-  enter(node, parent, scope, formatter) {
-    var declar = node && node.declaration;
-    if (t.isExportDeclaration(node)) {
+  ExportDeclaration: {
+    enter(node, parent, scope, formatter) {
+      var declar = node.declaration;
       formatter.hasLocalImports = true;
 
       if (declar && t.isStatement(declar)) {

src/babel/transformation/modules/_strict.js

@@ -1,6 +1,6 @@
-var util = require("../../util");
+import * as util from "../../util";
 
-module.exports = function (Parent) {
+export default function (Parent) {
   var Constructor = function () {
     this.noInteropRequireImport = true;
     this.noInteropRequireExport = true;

src/babel/transformation/modules/amd.js

@@ -1,9 +1,9 @@
-var DefaultFormatter = require("./_default");
-var CommonFormatter  = require("./common");
-var includes         = require("lodash/collection/includes");
-var values           = require("lodash/object/values");
-var util             = require("../../util");
-var t                = require("../../types");
+import DefaultFormatter from "./_default";
+import CommonFormatter from "./common";
+import includes from "lodash/collection/includes";
+import values from "lodash/object/values";
+import * as util from  "../../util";
+import * as t from "../../types";
 
 export default class AMDFormatter extends DefaultFormatter {
   init = CommonFormatter.prototype.init;

src/babel/transformation/modules/common.js

@@ -1,7 +1,7 @@
-var DefaultFormatter = require("./_default");
-var includes         = require("lodash/collection/includes");
-var util             = require("../../util");
-var t                = require("../../types");
+import DefaultFormatter from "./_default";
+import includes from "lodash/collection/includes";
+import * as util from  "../../util";
+import * as t from "../../types";
 
 export default class CommonJSFormatter extends DefaultFormatter {
   init() {
@@ -13,7 +13,7 @@ export default class CommonJSFormatter extends DefaultFormatter {
     if (!this.noInteropRequireImport && this.hasNonDefaultExports) {
       var templateName = "exports-module-declaration";
       if (this.file.isLoose("es6.modules")) templateName += "-loose";
-      file.ast.program.body.push(util.template(templateName, true));
+      file.ast.program.body.unshift(util.template(templateName, true));
     }
   };
 

src/babel/transformation/modules/ignore.js

@@ -1,4 +1,4 @@
-var t = require("../../types");
+import * as t from "../../types";
 
 export default class IgnoreFormatter {
   exportDeclaration(node, nodes) {

src/babel/transformation/modules/index.js

@@ -1,4 +1,4 @@
-module.exports = {
+export default {
   commonStrict: require("./common-strict"),
   amdStrict:    require("./amd-strict"),
   umdStrict:    require("./umd-strict"),

src/babel/transformation/modules/system.js

@@ -1,10 +1,10 @@
-var DefaultFormatter = require("./_default");
-var AMDFormatter     = require("./amd");
-var util             = require("../../util");
-var last             = require("lodash/array/last");
-var each             = require("lodash/collection/each");
-var map              = require("lodash/collection/map");
-var t                = require("../../types");
+import DefaultFormatter from "./_default";
+import AMDFormatter from "./amd";
+import * as util from  "../../util";
+import last from "lodash/array/last";
+import each from "lodash/collection/each";
+import map from "lodash/collection/map";
+import * as t from "../../types";
 
 var hoistVariablesVisitor = {
   enter(node, parent, scope, hoistDeclarators) {
@@ -142,9 +142,9 @@ export default class SystemFormatter extends AMDFormatter {
 
     return t.arrayExpression(map(this.ids, function (uid, source) {
       var state = {
+        hoistDeclarators: hoistDeclarators,
         source:           source,
-        nodes:            [],
-        hoistDeclarators: hoistDeclarators
+        nodes:            []
       };
 
       scope.traverse(block, runnerSettersVisitor, state);
@@ -161,11 +161,11 @@ export default class SystemFormatter extends AMDFormatter {
     var block = t.blockStatement(program.body);
 
     var runner = util.template("system", {
-      MODULE_NAME: moduleNameLiteral,
       MODULE_DEPENDENCIES: t.arrayExpression(this.buildDependencyLiterals()),
-      EXPORT_IDENTIFIER: this.exportIdentifier,
-      SETTERS: this.buildRunnerSetters(block, hoistDeclarators),
-      EXECUTE: t.functionExpression(null, [], block)
+      EXPORT_IDENTIFIER:   this.exportIdentifier,
+      MODULE_NAME:         moduleNameLiteral,
+      SETTERS:             this.buildRunnerSetters(block, hoistDeclarators),
+      EXECUTE:             t.functionExpression(null, [], block)
     }, true);
 
     var handlerBody = runner.expression.arguments[2].body.body;

src/babel/transformation/modules/umd.js

@@ -1,7 +1,7 @@
-var AMDFormatter = require("./amd");
-var values       = require("lodash/object/values");
-var util         = require("../../util");
-var t            = require("../../types");
+import AMDFormatter from "./amd";
+import values from "lodash/object/values";
+import * as util from  "../../util";
+import * as t from "../../types";
 
 export default class UMDFormatter extends AMDFormatter {
   transform(program) {

src/babel/transformation/templates/.babelrc

@@ -1,3 +1,3 @@
 {
-  "blacklist": ["useStrict", "es6.blockScoping"]
+  "blacklist": ["useStrict", "es6.blockScoping", "regenerator"]
 }

src/babel/transformation/templates/create-class.js

@@ -0,0 +1,16 @@
+(function() {
+  function defineProperties(target, props) {
+    for (var key in props) {
+      var prop = props[key];
+      prop.configurable = true;
+      if (prop.value) prop.writable = true;
+    }
+    Object.defineProperties(target, props);
+  }
+
+  return function (Constructor, protoProps, staticProps) {
+    if (protoProps) defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) defineProperties(Constructor, staticProps);
+    return Constructor;
+  };
+})()

src/babel/transformation/templates/create-computed-class.js

@@ -0,0 +1,16 @@
+(function() {
+  function defineProperties(target, props) {
+    for (var i = 0; i < props.length; i ++) {
+      var prop = props[i];
+      prop.configurable = true;
+      if (prop.value) prop.writable = true;
+      Object.defineProperty(target, prop.key, prop);
+    }
+  }
+
+  return function (Constructor, protoProps, staticProps) {
+    if (protoProps) defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) defineProperties(Constructor, staticProps);
+    return Constructor;
+  };
+})()

src/babel/transformation/templates/for-of.js

@@ -1,3 +1,21 @@
-for (var ITERATOR_KEY = OBJECT[Symbol.iterator](), STEP_KEY; !(STEP_KEY = ITERATOR_KEY.next()).done; ) {
+var ITERATOR_COMPLETION = true;
+var ITERATOR_HAD_ERROR_KEY = false;
+var ITERATOR_ERROR_KEY = undefined;
+try {
+  for (var ITERATOR_KEY = OBJECT[Symbol.iterator](), STEP_KEY; !(ITERATOR_COMPLETION = (STEP_KEY = ITERATOR_KEY.next()).done); ITERATOR_COMPLETION = true) {
 
+  }
+} catch (err) {
+  ITERATOR_HAD_ERROR_KEY = true;
+  ITERATOR_ERROR_KEY = err;
+} finally {
+  try {
+    if (!ITERATOR_COMPLETION && ITERATOR_KEY.return) {
+      ITERATOR_KEY.return();
+    }
+  } finally {
+    if (ITERATOR_HAD_ERROR_KEY) {
+      throw ITERATOR_ERROR_KEY;
+    }
+  }
 }

src/babel/transformation/templates/prototype-properties.js

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

src/babel/transformation/templates/self-contained-helpers-head.js

@@ -1,2 +1,2 @@
-var helpers = exports.default = {};
+exports.default = HELPER;
 exports.__esModule = true;

src/babel/transformation/templates/umd-commonjs-strict.js

@@ -0,0 +1,11 @@
+(function (root, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(AMD_ARGUMENTS, factory);
+  } else if (typeof exports === 'object') {
+    factory(COMMON_ARGUMENTS);
+  } else {
+    factory(BROWSER_ARGUMENTS);
+  }
+})(UMD_ROOT, function (FACTORY_PARAMETERS) {
+  FACTORY_BODY
+});

src/babel/transformation/transformer-pass.js

@@ -1,4 +1,4 @@
-var includes = require("lodash/collection/includes");
+import includes from "lodash/collection/includes";
 
 /**
  * This class is responsible for traversing over the provided `File`s
@@ -6,14 +6,15 @@ var includes = require("lodash/collection/includes");
  */
 
 export default class TransformerPass {
-  constructor(file, transformer) {
+  constructor(file: File, transformer: Transformer) {
     this.transformer = transformer;
     this.shouldRun   = !transformer.check;
     this.handlers    = transformer.handlers;
     this.file        = file;
+    this.ran         = false;
   }
 
-  canRun() {
+  canRun(): boolean {
     var transformer = this.transformer;
 
     var opts = this.file.opts;
@@ -42,7 +43,7 @@ export default class TransformerPass {
     return true;
   }
 
-  checkNode(node) {
+  checkNode(node: Object): boolean {
     var check = this.transformer.check;
     if (check) {
       return this.shouldRun = check(node);
@@ -56,8 +57,10 @@ export default class TransformerPass {
 
     var file = this.file;
 
-    file.debug("Running transformer " + this.transformer.key);
+    file.log.debug(`Running transformer ${this.transformer.key}`);
 
     file.scope.traverse(file.ast, this.handlers, file);
+
+    this.ran = true;
   }
 }

src/babel/transformation/transformer.js

@@ -1,9 +1,9 @@
-var TransformerPass = require("./transformer-pass");
-var isFunction      = require("lodash/lang/isFunction");
-var traverse        = require("../traversal");
-var isObject        = require("lodash/lang/isObject");
-var assign          = require("lodash/object/assign");
-var each            = require("lodash/collection/each");
+import TransformerPass from "./transformer-pass";
+import isFunction from "lodash/lang/isFunction";
+import traverse from "../traversal";
+import isObject from "lodash/lang/isObject";
+import assign from "lodash/object/assign";
+import each from "lodash/collection/each";
 
 /**
  * This is the class responsible for normalising a transformers handlers
@@ -12,7 +12,7 @@ var each            = require("lodash/collection/each");
  */
 
 export default class Transformer {
-  constructor(key, transformer, opts) {
+  constructor(transformerKey: key, transformer: Object, opts: Object) {
     transformer = assign({}, transformer);
 
     var take = function (key) {
@@ -33,10 +33,10 @@ export default class Transformer {
 
     this.handlers = this.normalize(transformer);
     this.opts     ||= {};
-    this.key      = key;
+    this.key      = transformerKey;
   }
 
-  normalize(transformer) {
+  normalize(transformer: Object): Object {
     if (isFunction(transformer)) {
       transformer = { ast: transformer };
     }
@@ -65,7 +65,7 @@ export default class Transformer {
     return transformer;
   }
 
-  buildPass(file) {
+  buildPass(file: File): TransformerPass {
     return new TransformerPass(file, this);
   }
 }

src/babel/transformation/transformers/aliases.json

@@ -0,0 +1,3 @@
+{
+  "useStrict": "strict"
+}

src/babel/transformation/transformers/deprecated.json

@@ -1,3 +1,9 @@
 {
-  "selfContained": "runtime"
+  "selfContained": "runtime",
+  "unicode-regex": "regex.unicode",
+  "spec.typeofSymbol": "es6.symbols",
+
+  "minification.deadCodeElimination": "utility.deadCodeElimination",
+  "minification.removeConsoleCalls": "utility.removeConsole",
+  "minification.removeDebugger": "utility.removeDebugger"
 }

src/babel/transformation/transformers/es3/member-expression-literals.js

@@ -1,6 +1,6 @@
-var t = require("../../../types");
+import * as t from "../../../types";
 
-exports.MemberExpression = function (node) {
+export function MemberExpression(node) {
   var prop = node.property;
   if (node.computed && t.isLiteral(prop) && t.isValidIdentifier(prop.value)) {
     // foo["bar"] => foo.bar
@@ -11,4 +11,4 @@ exports.MemberExpression = function (node) {
     node.property = t.literal(prop.name);
     node.computed = true;
   }
-};
+}

src/babel/transformation/transformers/es3/property-literals.js

@@ -1,6 +1,6 @@
-var t = require("../../../types");
+import * as t from "../../../types";
 
-exports.Property = function (node) {
+export function Property(node) {
   var key = node.key;
   if (t.isLiteral(key) && t.isValidIdentifier(key.value)) {
     // "foo": "bar" -> foo: "bar"
@@ -10,4 +10,4 @@ exports.Property = function (node) {
     // default: "bar" -> "default": "bar"
     node.key = t.literal(key.name);
   }
-};
+}

src/babel/transformation/transformers/es5/properties.mutators.js

@@ -1,11 +1,11 @@
-var defineMap = require("../../helpers/define-map");
-var t         = require("../../../types");
+import * as defineMap from "../../helpers/define-map";
+import * as t from "../../../types";
 
-exports.check = function (node) {
+export function check(node) {
   return t.isProperty(node) && (node.kind === "get" || node.kind === "set");
-};
+}
 
-exports.ObjectExpression = function (node) {
+export function ObjectExpression(node) {
   var mutatorMap = {};
   var hasAny = false;
 
@@ -23,6 +23,6 @@ exports.ObjectExpression = function (node) {
 
   return t.callExpression(
     t.memberExpression(t.identifier("Object"), t.identifier("defineProperties")),
-    [node, defineMap.build(mutatorMap)]
+    [node, defineMap.toDefineObject(mutatorMap)]
   );
-};
+}

src/babel/transformation/transformers/es6/arrow-functions.js

@@ -1,8 +1,8 @@
-var t = require("../../../types");
+import * as t from "../../../types";
 
-exports.check = t.isArrowFunctionExpression;
+export var check = t.isArrowFunctionExpression;
 
-exports.ArrowFunctionExpression = function (node) {
+export function ArrowFunctionExpression(node) {
   t.ensureBlock(node);
 
   node._aliasFunction = "arrow";
@@ -10,4 +10,4 @@ exports.ArrowFunctionExpression = function (node) {
   node.type = "FunctionExpression";
 
   return node;
-};
+}

src/babel/transformation/transformers/es6/block-scoping-tdz.js

@@ -1,8 +1,8 @@
-var t = require("../../../types");
+import * as t from "../../../types";
 
 var visitor = {
   enter(node, parent, scope, state) {
-    if (!t.isReferencedIdentifier(node, parent)) return;
+    if (!this.isReferencedIdentifier()) return;
 
     var declared = state.letRefs[node.name];
     if (!declared) return;
@@ -26,18 +26,16 @@ var visitor = {
   }
 };
 
-exports.optional = true;
+export var optional = true;
 
-exports.Loop =
-exports.Program =
-exports.BlockStatement = function (node, parent, scope, file) {
+export function BlockStatement(node, parent, scope, file) {
   var letRefs = node._letReferences;
   if (!letRefs) return;
 
-  var state = {
+  scope.traverse(node, visitor, {
     letRefs: letRefs,
     file:    file
-  };
+  });
+}
 
-  scope.traverse(node, visitor, state);
-};
+export { BlockStatement as Program, BlockStatement as Loop };

src/babel/transformation/transformers/es6/block-scoping.js

@@ -1,15 +1,11 @@
-var traverse = require("../../../traversal");
-var object   = require("../../../helpers/object");
-var util     = require("../../../util");
-var t        = require("../../../types");
-var values   = require("lodash/object/values");
-var extend   = require("lodash/object/extend");
+import traverse from "../../../traversal";
+import object from "../../../helpers/object";
+import * as util from  "../../../util";
+import * as t from "../../../types";
+import values from "lodash/object/values";
+import extend from "lodash/object/extend";
 
-exports.check = function (node) {
-  return t.isVariableDeclaration(node) && (node.kind === "let" || node.kind === "const");
-};
-
-var isLet = function (node, parent) {
+function isLet(node, parent) {
   if (!t.isVariableDeclaration(node)) return false;
   if (node._let) return true;
   if (node.kind !== "let") return false;
@@ -25,23 +21,27 @@ var isLet = function (node, parent) {
   node._let = true;
   node.kind = "var";
   return true;
-};
+}
 
-var isLetInitable = function (node, parent) {
+function isLetInitable(node, parent) {
   return !t.isFor(parent) || !t.isFor(parent, { left: node });
-};
+}
 
-var isVar = function (node, parent) {
+function isVar(node, parent) {
   return t.isVariableDeclaration(node, { kind: "var" }) && !isLet(node, parent);
-};
+}
 
-var standardizeLets = function (declars) {
+function standardizeLets(declars) {
   for (var i = 0; i < declars.length; i++) {
     delete declars[i]._let;
   }
-};
+}
 
-exports.VariableDeclaration = function (node, parent, scope, file) {
+export function check(node) {
+  return t.isVariableDeclaration(node) && (node.kind === "let" || node.kind === "const");
+}
+
+export function VariableDeclaration(node, parent, scope, file) {
   if (!isLet(node, parent)) return;
 
   if (isLetInitable(node) && file.transformers["es6.blockScopingTDZ"].canRun()) {
@@ -61,25 +61,27 @@ exports.VariableDeclaration = function (node, parent, scope, file) {
 
     return nodes;
   }
-};
+}
 
-exports.Loop = function (node, parent, scope, file) {
+export function Loop(node, parent, scope, file) {
   var init = node.left || node.init;
   if (isLet(init, node)) {
     t.ensureBlock(node);
     node.body._letDeclarators = [init];
   }
-  var blockScoping = new BlockScoping(node, node.body, parent, scope, file);
-  blockScoping.run();
-};
 
-exports.Program =
-exports.BlockStatement = function (block, parent, scope, file) {
+  var blockScoping = new BlockScoping(this, node.body, parent, scope, file);
+  return blockScoping.run();
+}
+
+export function BlockStatement(block, parent, scope, file) {
   if (!t.isLoop(parent)) {
-    var blockScoping = new BlockScoping(false, block, parent, scope, file);
+    var blockScoping = new BlockScoping(null, block, parent, scope, file);
     blockScoping.run();
   }
-};
+}
+
+export { BlockStatement as Program };
 
 function replace(node, parent, scope, remaps) {
   if (!t.isReferencedIdentifier(node, parent)) return;
@@ -108,7 +110,7 @@ function traverseReplace(node, parent, scope, remaps) {
 
 var letReferenceBlockVisitor = {
   enter(node, parent, scope, state) {
-    if (t.isFunction(node)) {
+    if (this.isFunction()) {
       scope.traverse(node, letReferenceFunctionVisitor, state);
       return this.skip();
     }
@@ -118,7 +120,7 @@ var letReferenceBlockVisitor = {
 var letReferenceFunctionVisitor = {
   enter(node, parent, scope, state) {
     // not a direct reference
-    if (!t.isReferencedIdentifier(node, parent)) return;
+    if (!this.isReferencedIdentifier()) return;
 
     // this scope has a variable with the same name so it couldn't belong
     // to our let scope
@@ -133,17 +135,17 @@ var letReferenceFunctionVisitor = {
 
 var hoistVarDeclarationsVisitor = {
   enter(node, parent, scope, self) {
-    if (t.isForStatement(node)) {
+    if (this.isForStatement()) {
       if (isVar(node.init, node)) {
         node.init = t.sequenceExpression(self.pushDeclar(node.init));
       }
-    } else if (t.isFor(node)) {
+    } else if (this.isFor()) {
       if (isVar(node.left, node)) {
         node.left = node.left.declarations[0].id;
       }
     } else if (isVar(node, parent)) {
       return self.pushDeclar(node).map(t.expressionStatement);
-    } else if (t.isFunction(node)) {
+    } else if (this.isFunction()) {
       return this.skip();
     }
   }
@@ -151,7 +153,7 @@ var hoistVarDeclarationsVisitor = {
 
 var loopLabelVisitor = {
   enter(node, parent, scope, state) {
-    if (t.isLabeledStatement(node)) {
+    if (this.isLabeledStatement()) {
       state.innerLabels.push(node.label.name);
     }
   }
@@ -169,13 +171,13 @@ var loopVisitor = {
   enter(node, parent, scope, state) {
     var replace;
 
-    if (t.isLoop(node)) {
+    if (this.isLoop()) {
       state.ignoreLabeless = true;
       scope.traverse(node, loopVisitor, state);
       state.ignoreLabeless = false;
     }
 
-    if (t.isFunction(node) || t.isLoop(node)) {
+    if (this.isFunction() || this.isLoop()) {
       return this.skip();
     }
 
@@ -188,7 +190,7 @@ var loopVisitor = {
           return;
         }
 
-        loopText = loopText + "|" + node.label.name;
+        loopText = `${loopText}|${node.label.name}`;
       } else {
         // we shouldn't be transforming these statements because
         // they don't refer to the actual loop we're scopifying
@@ -203,7 +205,7 @@ var loopVisitor = {
       replace = t.literal(loopText);
     }
 
-    if (t.isReturnStatement(node)) {
+    if (this.isReturnStatement()) {
       state.hasReturn = true;
       replace = t.objectExpression([
         t.property("init", t.identifier("v"), node.argument || t.identifier("undefined"))
@@ -221,25 +223,24 @@ class BlockScoping {
 
   /**
    * Description
-   *
-   * @param {Boolean|Node} loopParent
-   * @param {Node} block
-   * @param {Node} parent
-   * @param {Scope} scope
-   * @param {File} file
    */
 
-  constructor(loopParent, block, parent, scope, file) {
-    this.loopParent = loopParent;
-    this.parent     = parent;
-    this.scope      = scope;
-    this.block      = block;
-    this.file       = file;
+  constructor(loopPath?: TraversalPath, block: Object, parent: Object, scope: Scope, file: File) {
+    this.parent = parent;
+    this.scope  = scope;
+    this.block  = block;
+    this.file   = file;
 
     this.outsideLetReferences = object();
     this.hasLetReferences     = false;
     this.letReferences        = block._letReferences = object();
     this.body                 = [];
+
+    if (loopPath) {
+      this.loopParent = loopPath.parent;
+      this.loopLabel  = t.isLabeledStatement(this.loopParent) && this.loopParent.label;
+      this.loop       = loopPath.node;
+    }
   }
 
   /**
@@ -264,6 +265,10 @@ class BlockScoping {
     } else {
       this.remap();
     }
+
+    if (this.loopLabel && !t.isLabeledStatement(this.loopParent)) {
+      return t.labeledStatement(this.loopLabel, this.loop);
+    }
   }
 
   /**
@@ -302,11 +307,11 @@ class BlockScoping {
 
     //
 
-    var loopParent = this.loopParent;
-    if (loopParent) {
-      traverseReplace(loopParent.right, loopParent, scope, remaps);
-      traverseReplace(loopParent.test, loopParent, scope, remaps);
-      traverseReplace(loopParent.update, loopParent, scope, remaps);
+    var loop = this.loop;
+    if (loop) {
+      traverseReplace(loop.right, loop, scope, remaps);
+      traverseReplace(loop.test, loop, scope, remaps);
+      traverseReplace(loop.update, loop, scope, remaps);
     }
 
     scope.traverse(this.block, replaceVisitor, remaps);
@@ -322,11 +327,11 @@ class BlockScoping {
     var outsideRefs = this.outsideLetReferences;
 
     // remap loop heads with colliding variables
-    if (this.loopParent) {
+    if (this.loop) {
       for (var name in outsideRefs) {
         var id = outsideRefs[name];
 
-        if (this.scope.hasGlobal(id.name)) {
+        if (this.scope.hasGlobal(id.name) || this.scope.parentHasBinding(id.name)) {
           delete outsideRefs[id.name];
           delete this.letReferences[id.name];
 
@@ -443,7 +448,7 @@ class BlockScoping {
       ignoreLabeless:   false,
       innerLabels:      [],
       hasReturn:        false,
-      isLoop:           !!this.loopParent,
+      isLoop:           !!this.loop,
       map:              {}
     };
 
@@ -465,12 +470,9 @@ class BlockScoping {
   /**
    * Turn a `VariableDeclaration` into an array of `AssignmentExpressions` with
    * their declarations hoisted to before the closure wrapper.
-   *
-   * @param {Node} node VariableDeclaration
-   * @returns {Array}
    */
 
-  pushDeclar(node) {
+  pushDeclar(node: { type: "VariableDeclaration" }): Array<Object> {
     this.body.push(t.variableDeclaration(node.kind, node.declarations.map(function (declar) {
       return t.variableDeclarator(declar.id);
     })));
@@ -490,12 +492,9 @@ class BlockScoping {
 
   /**
    * Push the closure to the body.
-   *
-   * @param {Node} ret Identifier
-   * @param {Node} call CallExpression
    */
 
-  build(ret, call) {
+  build(ret: { type: "Identifier" }, call: { type: "CallExpression" }) {
     var has = this.has;
     if (has.hasReturn || has.hasBreakContinue) {
       this.buildHas(ret, call);
@@ -506,19 +505,16 @@ class BlockScoping {
 
   /**
    * Description
-   *
-   * @param {Node} ret Identifier
-   * @param {Node} call CallExpression
    */
 
-  buildHas(ret, call) {
+  buildHas(ret: { type: "Identifier" }, call: { type: "CallExpression" }) {
     var body = this.body;
 
     body.push(t.variableDeclaration("var", [
       t.variableDeclarator(ret, call)
     ]));
 
-    var loopParent = this.loopParent;
+    var loop = this.loop;
     var retCheck;
     var has = this.has;
     var cases = [];
@@ -531,9 +527,8 @@ class BlockScoping {
     }
 
     if (has.hasBreakContinue) {
-      if (!loopParent) {
-        throw new Error("Has no loop parent but we're trying to reassign breaks " +
-                        "and continues, something is going wrong here.");
+      if (!loop) {
+        throw new Error("Aren't in a loop and we're trying to reassign breaks and continues, something is going wrong here.");
       }
 
       for (var key in has.map) {
@@ -551,6 +546,14 @@ class BlockScoping {
           single.consequent[0]
         )));
       } else {
+        // #998
+        for (var i = 0; i < cases.length; i++) {
+          var caseConsequent = cases[i].consequent[0];
+          if (t.isBreakStatement(caseConsequent) && !caseConsequent.label) {
+            caseConsequent.label = this.loopLabel ||= this.file.scope.generateUidIdentifier("loop");
+          }
+        }
+
         body.push(this.file.attachAuxiliaryComment(t.switchStatement(ret, cases)));
       }
     } else {

src/babel/transformation/transformers/es6/classes.js

@@ -1,59 +1,83 @@
-var ReplaceSupers = require("../../helpers/replace-supers");
-var nameMethod    = require("../../helpers/name-method");
-var defineMap     = require("../../helpers/define-map");
-var messages      = require("../../../messages");
-var util          = require("../../../util");
-var t             = require("../../../types");
+import ReplaceSupers from "../../helpers/replace-supers";
+import * as nameMethod from "../../helpers/name-method";
+import * as defineMap from "../../helpers/define-map";
+import * as messages from "../../../messages";
+import * as util from  "../../../util";
+import traverse from "../../../traversal";
+import * as t from "../../../types";
 
-exports.check = t.isClass;
+export var check = t.isClass;
 
-exports.ClassDeclaration = function (node, parent, scope, file) {
-  return new ClassTransformer(node, file, scope, true).run();
-};
+export function ClassDeclaration(node, parent, scope, file) {
+  return t.variableDeclaration("let", [
+    t.variableDeclarator(node.id, t.toExpression(node))
+  ]);
+}
 
-exports.ClassExpression = function (node, parent, scope, file) {
-  if (!node.id) {
-    if (t.isProperty(parent) && parent.value === node && !parent.computed && t.isIdentifier(parent.key)) {
-      // var o = { foo: class {} };
-      node.id = parent.key;
+export function ClassExpression(node, parent, scope, file) {
+  return new ClassTransformer(node, parent, scope, file).run();
+}
+
+var verifyConstructorVisitor = traverse.explode({
+  MethodDefinition: {
+    enter() {
+      this.skip();
     }
+  },
 
-    if (t.isVariableDeclarator(parent) && t.isIdentifier(parent.id)) {
-      // var foo = class {};
-      node.id = parent.id;
+  Property: {
+    enter(node) {
+      if (node.method) this.skip();
+    }
+  },
+
+  CallExpression: {
+    enter(node, parent, scope, state) {
+      if (t.isIdentifier(node.callee, { name: "super" })) {
+        state.hasBareSuper = true;
+
+        if (!state.hasSuper) {
+          throw state.file.errorWithNode(node, "super call is only allowed in derived constructor");
+        }
+      }
+    }
+  },
+
+  ThisExpression: {
+    enter(node, parent, scope, state) {
+      if (state.hasSuper && !state.hasBareSuper) {
+        throw state.file.errorWithNode(node, "'this' is not allowed before super()");
+      }
     }
   }
-
-  return new ClassTransformer(node, file, scope, false).run();
-};
+});
 
 class ClassTransformer {
 
   /**
    * Description
-   *
-   * @param {Node} node
-   * @param {File} file
-   * @param {Scope} scope
-   * @param {Boolean} isStatement
    */
 
-  constructor(node, file, scope, isStatement) {
-    this.isStatement = isStatement;
-    this.scope       = scope;
-    this.node        = node;
-    this.file        = file;
+  constructor(node: Object, parent: Object, scope: Scope, file: File) {
+    this.parent = parent;
+    this.scope  = scope;
+    this.node   = node;
+    this.file   = file;
 
     this.hasInstanceMutators = false;
     this.hasStaticMutators   = false;
 
     this.instanceMutatorMap = {};
     this.staticMutatorMap   = {};
-    this.hasConstructor     = false;
-    this.className          = node.id || scope.generateUidIdentifier("class");
-    this.superName          = node.superClass || t.identifier("Function");
-    this.hasSuper           = !!node.superClass;
-    this.isLoose            = file.isLoose("es6.classes");
+
+    this.hasConstructor = false;
+    this.className      = node.id;
+    this.classRef       = node.id || scope.generateUidIdentifier("class");
+
+    this.superName = node.superClass || t.identifier("Function");
+    this.hasSuper  = !!node.superClass;
+
+    this.isLoose = file.isLoose("es6.classes");
   }
 
   /**
@@ -66,39 +90,35 @@ class ClassTransformer {
     var superName = this.superName;
     var className = this.className;
     var classBody = this.node.body.body;
+    var classRef  = this.classRef;
     var file      = this.file;
 
     //
 
     var body = this.body = [];
 
+    //
+
     var constructorBody = t.blockStatement([
       t.expressionStatement(t.callExpression(file.addHelper("class-call-check"), [
         t.thisExpression(),
-        className
+        classRef
       ]))
     ]);
 
     var constructor;
-    if (this.node.id) {
-      constructor = t.functionDeclaration(className, [], constructorBody);
+
+    if (this.className) {
+      constructor = t.functionDeclaration(this.className, [], constructorBody);
       body.push(constructor);
     } else {
-      var constructorName = null;
-      // when a class has no parent and there is only a constructor or no body
-      // then the constructor is not wrapped in a closure and needs to be named
-      var containsOnlyConstructor = classBody.length === 1 && classBody[0].key.name === "constructor";
-      if (!this.hasSuper && (classBody.length === 0 || containsOnlyConstructor)) {
-        constructorName = className;
-      }
-
-      constructor = t.functionExpression(constructorName, [], constructorBody);
-      body.push(t.variableDeclaration("var", [
-        t.variableDeclarator(className, constructor)
-      ]));
+      constructor = t.functionExpression(null, [], constructorBody);
     }
+
     this.constructor = constructor;
 
+    //
+
     var closureParams = [];
     var closureArgs = [];
 
@@ -107,40 +127,40 @@ class ClassTransformer {
     if (this.hasSuper) {
       closureArgs.push(superName);
 
-      if (!t.isIdentifier(superName)) {
-        superName = this.scope.generateUidBasedOnNode(superName, this.file);
-      }
-
+      superName = this.scope.generateUidBasedOnNode(superName, this.file);
       closureParams.push(superName);
 
       this.superName = superName;
-      body.push(t.expressionStatement(t.callExpression(file.addHelper("inherits"), [className, superName])));
+      body.push(t.expressionStatement(t.callExpression(file.addHelper("inherits"), [classRef, superName])));
     }
 
+    //
+
     this.buildBody();
 
-    t.inheritsComments(body[0], this.node);
 
-    var init;
-
-    if (body.length === 1) {
-      // only a constructor so no need for a closure container
-      init = t.toExpression(constructor);
+    if (this.className) {
+      // named class with only a constructor
+      if (body.length === 1) return t.toExpression(body[0]);
     } else {
-      body.push(t.returnStatement(className));
-      init = t.callExpression(
-        t.functionExpression(null, closureParams, t.blockStatement(body)),
-        closureArgs
-      );
+      // infer class name if this is a nameless class expression
+      constructor = nameMethod.bare(constructor, this.parent, this.scope);
+
+      body.unshift(t.variableDeclaration("var", [
+        t.variableDeclarator(classRef, constructor)
+      ]));
+
+      t.inheritsComments(body[0], this.node);
     }
 
-    if (this.isStatement) {
-      return t.variableDeclaration("let", [
-        t.variableDeclarator(className, init)
-      ]);
-    } else {
-      return init;
-    }
+    //
+
+    body.push(t.returnStatement(classRef));
+
+    return t.callExpression(
+      t.functionExpression(null, closureParams, t.blockStatement(body)),
+      closureArgs
+    );
   }
 
   /**
@@ -157,18 +177,22 @@ class ClassTransformer {
     for (var i = 0; i < classBody.length; i++) {
       var node = classBody[i];
       if (t.isMethodDefinition(node)) {
+        var isConstructor = (!node.computed && t.isIdentifier(node.key, { name: "constructor" })) || t.isLiteral(node.key, { value: "constructor" });
+        if (isConstructor) this.verifyConstructor(node);
+
         var replaceSupers = new ReplaceSupers({
           methodNode: node,
-          className:  this.className,
-          superName:  this.superName,
+          objectRef:  this.classRef,
+          superRef:   this.superName,
           isStatic:   node.static,
           isLoose:    this.isLoose,
           scope:      this.scope,
           file:       this.file
         }, true);
+
         replaceSupers.replace();
 
-        if ((!node.computed && t.isIdentifier(node.key, { name: "constructor" })) || t.isLiteral(node.key, { value: "constructor" })) {
+        if (isConstructor) {
           this.pushConstructor(node);
         } else {
           this.pushMethod(node);
@@ -182,7 +206,7 @@ class ClassTransformer {
     }
 
     // we have no constructor, we have a super, and the super doesn't appear to be falsy
-    if (!this.hasConstructor && this.hasSuper && !t.isFalsyExpression(superName)) {
+    if (!this.hasConstructor && this.hasSuper && t.evaluateTruthy(superName, this.scope) !== false) {
       var helperName = "class-super-constructor-call";
       if (this.isLoose) helperName += "-loose";
       constructor.body.body.push(util.template(helperName, {
@@ -193,34 +217,59 @@ class ClassTransformer {
 
     var instanceProps;
     var staticProps;
+    var classHelper = "create-class";
 
     if (this.hasInstanceMutators) {
-      instanceProps = defineMap.build(this.instanceMutatorMap);
+      instanceProps = defineMap.toClassObject(this.instanceMutatorMap);
     }
 
     if (this.hasStaticMutators) {
-      staticProps = defineMap.build(this.staticMutatorMap);
+      staticProps = defineMap.toClassObject(this.staticMutatorMap);
     }
 
     if (instanceProps || staticProps) {
-      staticProps ||= t.literal(null);
+      if (defineMap.hasComputed(this.instanceMutatorMap) || defineMap.hasComputed(this.staticMutatorMap)) {
+        if (instanceProps) instanceProps = defineMap.toComputedObjectFromClass(instanceProps);
+        if (staticProps) staticProps = defineMap.toComputedObjectFromClass(staticProps);
+        classHelper = "create-computed-class";
+      }
 
-      var args = [className, staticProps];
-      if (instanceProps) args.push(instanceProps);
+      instanceProps ||= t.literal(null);
+
+      var args = [this.classRef, instanceProps];
+      if (staticProps) args.push(staticProps);
 
       body.push(t.expressionStatement(
-        t.callExpression(this.file.addHelper("prototype-properties"), args)
+        t.callExpression(this.file.addHelper(classHelper), args)
       ));
     }
   }
 
   /**
-   * Push a method to its respective mutatorMap.
-   *
-   * @param {Node} node MethodDefinition
+   * Description
    */
 
-  pushMethod(node) {
+   verifyConstructor(node: Object) {
+    return; // enable this for the next major
+
+    var state = {
+      hasBareSuper: false,
+      hasSuper:     this.hasSuper,
+      file:         this.file
+    };
+
+    traverse(node, verifyConstructorVisitor, this.scope, state);
+
+    if (!state.hasBareSuper && this.hasSuper) {
+      throw this.file.errorWithNode(node, "Derived constructor must call super()");
+    }
+   }
+
+  /**
+   * Push a method to its respective mutatorMap.
+   */
+
+  pushMethod(node: { type: "MethodDefinition" }) {
     var methodName = node.key;
 
     var kind = node.kind;
@@ -231,9 +280,9 @@ class ClassTransformer {
       if (this.isLoose) {
         // use assignments instead of define properties for loose classes
 
-        var className = this.className;
-        if (!node.static) className = t.memberExpression(className, t.identifier("prototype"));
-        methodName = t.memberExpression(className, methodName, node.computed);
+        var classRef = this.classRef;
+        if (!node.static) classRef = t.memberExpression(classRef, t.identifier("prototype"));
+        methodName = t.memberExpression(classRef, methodName, node.computed);
 
         var expr = t.expressionStatement(t.assignmentExpression("=", methodName, node.value));
         t.inheritsComments(expr, node);
@@ -253,22 +302,19 @@ class ClassTransformer {
     }
 
     defineMap.push(mutatorMap, methodName, kind, node.computed, node);
-    defineMap.push(mutatorMap, methodName, "enumerable", node.computed, false);
   }
 
   /**
    * Description
-   *
-   * @param {Node} node
    */
 
-  pushProperty(node) {
+  pushProperty(node: Object) {
     if (!node.value) return;
 
     var key;
 
     if (node.static) {
-      key = t.memberExpression(this.className, node.key);
+      key = t.memberExpression(this.classRef, node.key);
       this.body.push(
         t.expressionStatement(t.assignmentExpression("=", key, node.value))
       );
@@ -282,11 +328,9 @@ class ClassTransformer {
 
   /**
    * Replace the constructor body of our class.
-   *
-   * @param {Node} method MethodDefinition
    */
 
-  pushConstructor(method) {
+  pushConstructor(method: { type: "MethodDefinition" }) {
     if (method.kind) {
       throw this.file.errorWithNode(method, messages.get("classesIllegalConstructorKind"));
     }
@@ -301,6 +345,8 @@ class ClassTransformer {
 
     construct._ignoreUserWhitespace = true;
     construct.params                = fn.params;
-    construct.body.body             = construct.body.body.concat(fn.body.body);
+
+    t.inherits(construct.body, fn.body);
+    construct.body.body = construct.body.body.concat(fn.body.body);
   }
 }

src/babel/transformation/transformers/es6/constants.js

@@ -1,14 +1,14 @@
-var messages = require("../../../messages");
-var t        = require("../../../types");
+import * as messages from "../../../messages";
+import * as t from "../../../types";
 
-exports.check = function (node) {
+export function check(node) {
   return t.isVariableDeclaration(node, { kind: "const" });
-};
+}
 
 var visitor = {
   enter(node, parent, scope, state) {
-    if (t.isAssignmentExpression(node) || t.isUpdateExpression(node)) {
-      var ids = t.getBindingIdentifiers(node);
+    if (this.isAssignmentExpression() || this.isUpdateExpression()) {
+      var ids = this.getBindingIdentifiers();
 
       for (var name in ids) {
         var id = ids[name];
@@ -30,19 +30,19 @@ var visitor = {
 
         throw state.file.errorWithNode(id, messages.get("readOnly", name));
       }
-    } else if (t.isScope(node, parent)) {
+    } else if (this.isScope()) {
       this.skip();
     }
   }
 };
 
-exports.Scopable = function (node, parent, scope, file) {
+export function Scopable(node, parent, scope, file) {
   scope.traverse(node, visitor, {
     constants: scope.getAllBindingsOfKind("const"),
     file:      file
   });
-};
+}
 
-exports.VariableDeclaration = function (node) {
+export function VariableDeclaration(node) {
   if (node.kind === "const") node.kind = "let";
-};
+}