diff --git a/.eslintrc.js b/.eslintrc.js
index 7d1f2d45..c065517d 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -1,31 +1,34 @@
-module.exports = { 
-    env: { 
-        es6: true, 
-        browser: true, 
-        commonjs: true, 
-        node: true 
-    }, 
-    extends: 'eslint:recommended', 
-    parserOptions: { 
-        sourceType: 'module' 
-    }, 
-    rules: { 
-        indent: ['error', 4], 
+module.exports = {
+    env: {
+        es6: true,
+        browser: true,
+        commonjs: true,
+        node: true
+    },
+    extends: 'eslint:recommended',
+    parser: 'babel-eslint',
+    parserOptions: {
+        sourceType: 'module'
+    },
+    rules: {
+        indent: ['error', 4],
         'linebreak-style': [
-            'error', 
+            'error',
             'unix'
-        ], 
+        ],
         quotes: [
-            'error', 
+            'error',
             'single'
-        ], 
+        ],
         semi: [
-            'error', 
+            'error',
             'always'
-        ], 
-        'no-console': 0, 
-        'no-undef': 
-        'warn', 
-        'no-unused-vars': 'warn' 
-    } 
+        ],
+        'no-console': 0,
+        'no-undef': 'warn'
+    },
+    globals: {
+      BigInt64Array: true,
+      BigUint64Array: true
+    }
 };
diff --git a/.travis.yml b/.travis.yml
index 109e76fc..8837315d 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,20 +1,38 @@
 language: rust
 sudo: false
 
+INSTALL_NODE_VIA_NVM: &INSTALL_NODE_VIA_NVM
+  - rustup target add wasm32-unknown-unknown
+  - curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.33.8/install.sh | bash
+  - source ~/.nvm/nvm.sh
+  - nvm install v10.5
+
+
+DEPLOY_TO_GITHUB: &DEPLOY_TO_GITHUB
+  before_deploy:
+    |
+      name="wasm-bindgen-$TRAVIS_TAG-$TARGET"
+      mkdir "$name"
+      cp "target/$TARGET/release/{wasm-bindgen,wasm2es6js}" "$name/"
+      cp README.md LICENSE-MIT LICENSE-APACHE "$name/"
+      tar czvf "$name.tar.gz" "$name"
+  deploy:
+    api_key:
+      secure: "qCiELnEnvyKpWHDttgTNf+ElZGbWlvthu5aOIj5nYfov+h6g1+mkWnDFP6at/WPlE78zE/f/z/dL2KB2I7w/cxH/T4P1nWh0A9DvrpY6hqWkK2pgN5dPeWE/a4flI7AdH0A6wMRw7m00uMgDjlzN78v7XueccpJCxSO5allQN5jweAQvMX2QA07TbLRJc7Lq6lfVwSf8OfrcO8qCbcIzJTsC4vtbh6jkUYg1OAaU2tAYlskBy9ZYmHWCExIAu/zxzcJY9OpApPD9Ea4CyrsfjniAyRBJ87Weh/sP4XhiWeRPVmvA4HAzv4Pps9ps+Ar5QmsX53rhKQ3id7/VPR8ggaAHxrYUiJPvJRtbP6cKKOlDiK0ooP+vI4vjxWeNVj9ibEolSYOlT0ENIvPK1BppA6VgAoJOjwPr0Q16Ma4AmvLkIkowJiXCm2Jlje/5c0vPEAGJVgUtkj3jFQzgXwyEMpzxUlhHmYpmnfeaM0tK/Kiiwe1monL/ydMlyfV55kNylylCg+XoTnf420AFChKbD4DM5Z7ZsjU9g8fF3LUoN0sKpmLDp+GvwjLi9YtGogWB71Q2MFp43MSL0YLshkyYYoZKrVMiy5J9hKNUxhT2jNEq53Z69syIHHMCxHL9GoAcuHxIKOA7uTMW0aCoyy2I+dfAKKsrUGwGYaNC5LZdUQI="
+    file_glob: true
+    file:
+      - wasm-bindgen-$TRAVIS_TAG-$TARGET.tar.gz
+    on:
+      tags: true
+    provider: releases
+    skip_cleanup: true
+
 matrix:
   include:
-    # CLI builds on stable
-    - rust: stable
-      install: true
-      script: cargo build --manifest-path crates/cli/Cargo.toml
-
     # Tests pass on nightly
     - rust: nightly
-      before_install:
-        - rustup target add wasm32-unknown-unknown
-        - curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.33.11/install.sh | bash
-        - source ~/.nvm/nvm.sh
-        - nvm install v10.5
+      env: JOB=test-bindgen
+      before_install: *INSTALL_NODE_VIA_NVM
       install:
         # dirties git repository, there doesn't seem to be a way to resolve this other than
         # to run `npm install` twice or by using `npm ci` (which is currently broken)
@@ -22,82 +40,70 @@ matrix:
       script:
         - cargo test
         # Check JS output from all tests against eslint
-        - ./node_modules/.bin/eslint ./target/generated-tests/*/out*.js
-      env: RUST_BACKTRACE=1
+        - ./node_modules/.bin/eslint ./target/generated-tests/*/out*js
+      addons:
+        firefox: latest
+
+    # All examples work
+    - rust: nightly
+      env: JOB=examples-build
+      install: *INSTALL_NODE_VIA_NVM
+      script:
+        - mkdir node_modules
+        - |
+          for dir in `ls examples | grep -v README | grep -v asm.js | grep -v no_modules`; do
+            (cd examples/$dir &&
+             sed -i 's/: "webpack-dev-server"/: "webpack"/' package.json &&
+             ln -s ../../node_modules . &&
+             ./build.sh) || exit 1;
+          done
 
     # Tests pass on nightly using yarn
     - rust: nightly
-      before_install:
-        - rustup target add wasm32-unknown-unknown
-        - curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.33.11/install.sh | bash
-        - source ~/.nvm/nvm.sh
-        - nvm install v10.5
+      env: JOB=test-yarn-smoke
+      before_install: *INSTALL_NODE_VIA_NVM
+      install:
         - curl -o- -L https://yarnpkg.com/install.sh | bash -s -- --version 1.7.0
         - export PATH=$HOME/.yarn/bin:$PATH
-      install:
         - yarn install --freeze-lockfile
-      script:
-        - cargo test
-        # Check JS output from all tests against eslint
-        - ./node_modules/.bin/eslint ./target/generated-tests/*/out*.js
-      env: RUST_BACKTRACE=1
+      script: cargo test api::works
 
     # WebIDL tests pass on nightly
     - rust: nightly
+      env: JOB=test-webidl
       before_install: rustup component add rustfmt-preview --toolchain nightly
-      script: (cd crates/webidl && cargo test)
-      env: RUST_BACKTRACE=1 RUST_LOG=wasm_bindgen_webidl
+      script: cargo test --manifest-path crates/webidl/Cargo.toml
 
     # Dist linux binary
-    - env: TARGET=x86_64-unknown-linux-musl DEPLOY=1
-      rust: nightly
+    - rust: nightly
+      env: JOB=dist-linux TARGET=x86_64-unknown-linux-musl
       before_script: rustup target add $TARGET
       script: cargo build --manifest-path crates/cli/Cargo.toml --release --target $TARGET
       addons:
         apt:
           packages:
           - musl-tools
+      <<: *DEPLOY_TO_GITHUB
 
     # Dist OSX binary
-    - os: osx
-      rust: nightly
-      env: MACOSX_DEPLOYMENT_TARGET=10.7 DEPLOY=1 TARGET=x86_64-apple-darwin
+    - rust: nightly
+      os: osx
+      env: JOB=dist-osx MACOSX_DEPLOYMENT_TARGET=10.7 TARGET=x86_64-apple-darwin
       script: cargo build --manifest-path crates/cli/Cargo.toml --release --target $TARGET
-      install: true
+      <<: *DEPLOY_TO_GITHUB
 
-    # We can build the tool on nightly
+    # CLI builds on stable
+    - rust: stable
+      env: JOB=check-stable-cli
+      script: cargo check --manifest-path crates/cli/Cargo.toml
+    # CLI builds on nightly
     - rust: nightly
-      script: cargo install --debug --path crates/cli
-
-    # All examples work
-    - rust: nightly
-      before_install:
-        - rustup target add wasm32-unknown-unknown
-        - curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.33.8/install.sh | bash
-        - source ~/.nvm/nvm.sh
-        - nvm install v10.5
-      script:
-        - |
-          (cd examples/hello_world && sed -i 's/: "webpack-dev-server"/: "webpack"/' package.json && ./build.sh)
-        - |
-          (cd examples/smorgasboard && sed -i 's/: "webpack-dev-server"/: "webpack"/' package.json && ./build.sh)
-        - |
-          (cd examples/console_log && sed -i 's/: "webpack-dev-server"/: "webpack"/' package.json && ./build.sh)
-        - |
-          (cd examples/math && sed -i 's/: "webpack-dev-server"/: "webpack"/' package.json && ./build.sh)
-        - |
-          (cd examples/dom && sed -i 's/: "webpack-dev-server"/: "webpack"/' package.json && ./build.sh)
-        - |
-          (cd examples/wasm-in-wasm && sed -i 's/: "webpack-dev-server"/: "webpack"/' package.json && ./build.sh)
-        - |
-          (cd examples/char && sed -i 's/: "webpack-dev-server"/: "webpack"/' package.json && ./build.sh)
-        - |
-          (cd examples/closures && sed -i 's/: "webpack-dev-server"/: "webpack"/' package.json && ./build.sh)
-        - |
-          (cd examples/comments && sed -i 's/: "webpack-dev-server"/: "webpack"/' package.json && ./build.sh)
+      env: JOB=check-nightly-cli
+      script: cargo check --manifest-path crates/cli/Cargo.toml
 
     # Build the guide.
     - rust: stable
+      env: JOB=guide-build-and-deploy
       cache:
         - cargo
       before_script:
@@ -119,25 +125,3 @@ matrix:
 notifications:
   email:
     on_success: never
-
-before_deploy:
-  |
-    if [[ "$DEPLOY" == "1" ]]; then
-        name="wasm-bindgen-$TRAVIS_TAG-$TARGET"
-        mkdir "$name"
-        cp "target/$TARGET/release/{wasm-bindgen,wasm2es6js}" "$name/"
-        cp README.md LICENSE-MIT LICENSE-APACHE "$name/"
-        tar czvf "$name.tar.gz" "$name"
-    fi
-
-deploy:
-  api_key:
-    secure: "qCiELnEnvyKpWHDttgTNf+ElZGbWlvthu5aOIj5nYfov+h6g1+mkWnDFP6at/WPlE78zE/f/z/dL2KB2I7w/cxH/T4P1nWh0A9DvrpY6hqWkK2pgN5dPeWE/a4flI7AdH0A6wMRw7m00uMgDjlzN78v7XueccpJCxSO5allQN5jweAQvMX2QA07TbLRJc7Lq6lfVwSf8OfrcO8qCbcIzJTsC4vtbh6jkUYg1OAaU2tAYlskBy9ZYmHWCExIAu/zxzcJY9OpApPD9Ea4CyrsfjniAyRBJ87Weh/sP4XhiWeRPVmvA4HAzv4Pps9ps+Ar5QmsX53rhKQ3id7/VPR8ggaAHxrYUiJPvJRtbP6cKKOlDiK0ooP+vI4vjxWeNVj9ibEolSYOlT0ENIvPK1BppA6VgAoJOjwPr0Q16Ma4AmvLkIkowJiXCm2Jlje/5c0vPEAGJVgUtkj3jFQzgXwyEMpzxUlhHmYpmnfeaM0tK/Kiiwe1monL/ydMlyfV55kNylylCg+XoTnf420AFChKbD4DM5Z7ZsjU9g8fF3LUoN0sKpmLDp+GvwjLi9YtGogWB71Q2MFp43MSL0YLshkyYYoZKrVMiy5J9hKNUxhT2jNEq53Z69syIHHMCxHL9GoAcuHxIKOA7uTMW0aCoyy2I+dfAKKsrUGwGYaNC5LZdUQI="
-  file_glob: true
-  file:
-    - wasm-bindgen-$TRAVIS_TAG-$TARGET.tar.gz
-  on:
-    condition: $DEPLOY = 1
-    tags: true
-  provider: releases
-  skip_cleanup: true
diff --git a/Cargo.toml b/Cargo.toml
index 40ff56ac..6b57144e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -33,7 +33,7 @@ serde = { version = "1.0", optional = true }
 serde_json = { version = "1.0", optional = true }
 
 [dev-dependencies]
-wasm-bindgen-cli-support = { path = "crates/cli-support", version = '=0.2.11' }
+wasm-bindgen-test-project-builder = { path = "crates/test-project-builder", version = '=0.2.11' }
 
 [workspace]
 members = [
diff --git a/crates/backend/src/ast.rs b/crates/backend/src/ast.rs
index 962df0f8..d1d41903 100644
--- a/crates/backend/src/ast.rs
+++ b/crates/backend/src/ast.rs
@@ -84,6 +84,7 @@ pub struct ImportStatic {
 pub struct ImportType {
     pub vis: syn::Visibility,
     pub name: Ident,
+    pub attrs: Vec<syn::Attribute>,
 }
 
 #[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
@@ -469,6 +470,7 @@ impl Program {
         ImportKind::Type(ImportType {
             vis: f.vis,
             name: f.ident,
+            attrs: f.attrs,
         })
     }
 
diff --git a/crates/backend/src/codegen.rs b/crates/backend/src/codegen.rs
index d19e0431..984bc4d5 100644
--- a/crates/backend/src/codegen.rs
+++ b/crates/backend/src/codegen.rs
@@ -505,8 +505,10 @@ impl ToTokens for ast::ImportType {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         let vis = &self.vis;
         let name = &self.name;
+        let attrs = &self.attrs;
         (quote! {
             #[allow(bad_style)]
+            #(#attrs)*
             #vis struct #name {
                 obj: ::wasm_bindgen::JsValue,
             }
diff --git a/crates/cli-support/src/js/mod.rs b/crates/cli-support/src/js/mod.rs
index 3a42fd2d..e1e9d8a3 100644
--- a/crates/cli-support/src/js/mod.rs
+++ b/crates/cli-support/src/js/mod.rs
@@ -60,7 +60,7 @@ impl<'a> Context<'a> {
         if let Some(ref c) = comments {
             self.globals.push_str(c);
         }
-        let global = if self.config.nodejs {
+        let global = if self.use_node_require() {
             if contents.starts_with("class") {
                 format!("{1}\nmodule.exports.{0} = {0};\n", name, contents)
             } else {
@@ -410,12 +410,14 @@ impl<'a> Context<'a> {
                         .unwrap_or("wasm_bindgen"),
             )
         } else {
-            let import_wasm = if self.config.nodejs {
+            let import_wasm = if self.globals.len() == 0 {
+                String::new()
+            } else if self.use_node_require() {
                 self.footer
                     .push_str(&format!("wasm = require('./{}_bg');", module_name));
                 format!("var wasm;")
             } else {
-                format!("import * as wasm from './{}_bg.wasm';", module_name)
+                format!("import * as wasm from './{}_bg';", module_name)
             };
 
             format!(
@@ -956,7 +958,6 @@ impl<'a> Context<'a> {
             return Ok(());
         }
         self.require_internal_export("__wbindgen_malloc")?;
-        self.expose_uint64_memory();
         self.global(&format!(
             "
             function {}(arg) {{
@@ -976,7 +977,9 @@ impl<'a> Context<'a> {
         if !self.exposed_globals.insert("text_encoder") {
             return;
         }
-        if self.config.nodejs {
+        if self.config.nodejs_experimental_modules {
+            self.imports.push_str("import { TextEncoder } from 'util';\n");
+        } else if self.config.nodejs {
             self.global(
                 "
                 const TextEncoder = require('util').TextEncoder;
@@ -1002,7 +1005,9 @@ impl<'a> Context<'a> {
         if !self.exposed_globals.insert("text_decoder") {
             return;
         }
-        if self.config.nodejs {
+        if self.config.nodejs_experimental_modules {
+            self.imports.push_str("import { TextDecoder } from 'util';\n");
+        } else if self.config.nodejs {
             self.global(
                 "
                 const TextDecoder = require('util').TextDecoder;
@@ -1059,7 +1064,7 @@ impl<'a> Context<'a> {
         if !self.exposed_globals.insert("get_array_js_value_from_wasm") {
             return;
         }
-        self.expose_get_array_u32_from_wasm();
+        self.expose_uint32_memory();
         self.expose_take_object();
         self.global(
             "
@@ -1584,6 +1589,10 @@ impl<'a> Context<'a> {
         *section.payload_mut() = contents.into_bytes();
         self.module.sections_mut().push(Section::Custom(section));
     }
+
+    fn use_node_require(&self) -> bool {
+        self.config.nodejs && !self.config.nodejs_experimental_modules
+    }
 }
 
 impl<'a, 'b> SubContext<'a, 'b> {
@@ -1807,9 +1816,10 @@ impl<'a, 'b> SubContext<'a, 'b> {
                     let target = if let Some(g) = getter {
                         if import.structural {
                             format!(
-                                "function(y) {{
-                                return this.{};
+                                "function() {{
+                                    return {}.{};
                                 }}",
+                                if is_static { &class } else { "this" },
                                 g
                             )
                         } else {
@@ -1826,8 +1836,9 @@ impl<'a, 'b> SubContext<'a, 'b> {
                         if import.structural {
                             format!(
                                 "function(y) {{
-                                this.{} = y;
+                                {}.{} = y;
                             }}",
+                                if is_static { &class } else { "this" },
                                 s
                             )
                         } else {
@@ -1943,7 +1954,7 @@ impl<'a, 'b> SubContext<'a, 'b> {
             let name = import.js_namespace.as_ref().map(|s| &**s).unwrap_or(item);
 
             if self.cx.imported_names.insert(name.to_string()) {
-                if self.cx.config.nodejs {
+                if self.cx.use_node_require() {
                     self.cx.imports.push_str(&format!(
                         "\
                          const {} = require('{}').{};\n\
diff --git a/crates/cli-support/src/lib.rs b/crates/cli-support/src/lib.rs
index df7ce473..04ed9f2b 100644
--- a/crates/cli-support/src/lib.rs
+++ b/crates/cli-support/src/lib.rs
@@ -24,6 +24,7 @@ pub mod wasm2es6js;
 pub struct Bindgen {
     path: Option<PathBuf>,
     nodejs: bool,
+    nodejs_experimental_modules: bool,
     browser: bool,
     no_modules: bool,
     no_modules_global: Option<String>,
@@ -37,6 +38,7 @@ impl Bindgen {
         Bindgen {
             path: None,
             nodejs: false,
+            nodejs_experimental_modules: false,
             browser: false,
             no_modules: false,
             no_modules_global: None,
@@ -56,6 +58,11 @@ impl Bindgen {
         self
     }
 
+    pub fn nodejs_experimental_modules(&mut self, node: bool) -> &mut Bindgen {
+        self.nodejs_experimental_modules = node;
+        self
+    }
+
     pub fn browser(&mut self, browser: bool) -> &mut Bindgen {
         self.browser = browser;
         self
@@ -162,7 +169,8 @@ impl Bindgen {
             cx.finalize(stem)?
         };
 
-        let js_path = out_dir.join(stem).with_extension("js");
+        let extension = if self.nodejs_experimental_modules { "mjs" } else { "js" };
+        let js_path = out_dir.join(stem).with_extension(extension);
         File::create(&js_path)
             .and_then(|mut f| f.write_all(reset_indentation(&js).as_bytes()))
             .with_context(|_| format!("failed to write `{}`", js_path.display()))?;
@@ -177,7 +185,7 @@ impl Bindgen {
         let wasm_path = out_dir.join(format!("{}_bg", stem)).with_extension("wasm");
 
         if self.nodejs {
-            let js_path = wasm_path.with_extension("js");
+            let js_path = wasm_path.with_extension(extension);
             let shim = self.generate_node_wasm_import(&module, &wasm_path);
             File::create(&js_path)
                 .and_then(|mut f| f.write_all(shim.as_bytes()))
@@ -200,22 +208,62 @@ impl Bindgen {
         }
 
         let mut shim = String::new();
+
+        if self.nodejs_experimental_modules {
+            for (i, module) in imports.iter().enumerate() {
+                shim.push_str(&format!("import * as import{} from '{}';\n",
+                                       i, module));
+            }
+            // On windows skip the leading `/` which comes out when we parse a
+            // url to use `C:\...` instead of `\C:\...`
+            shim.push_str(&format!("
+                import * as path from 'path';
+                import * as fs from 'fs';
+                import * as url from 'url';
+                import * as process from 'process';
+
+                let file = path.dirname(url.parse(import.meta.url).pathname);
+                if (process.platform === 'win32') {{
+                    file = file.substring(1);
+                }}
+                const bytes = fs.readFileSync(path.join(file, '{}'));
+            ", path.file_name().unwrap().to_str().unwrap()));
+        } else {
+            shim.push_str(&format!("
+                const path = require('path').join(__dirname, '{}');
+                const bytes = require('fs').readFileSync(path);
+            ", path.file_name().unwrap().to_str().unwrap()));
+        }
         shim.push_str("let imports = {};\n");
-        for module in imports {
-            shim.push_str(&format!("imports['{0}'] = require('{0}');\n", module));
+        for (i, module) in imports.iter().enumerate() {
+            if self.nodejs_experimental_modules {
+                shim.push_str(&format!("imports['{}'] = import{};\n", module, i));
+            } else {
+                shim.push_str(&format!("imports['{0}'] = require('{0}');\n", module));
+            }
         }
 
         shim.push_str(&format!(
             "
-            const join = require('path').join;
-            const bytes = require('fs').readFileSync(join(__dirname, '{}'));
-            const wasmModule = new WebAssembly.Module(bytes);
-            const wasmInstance = new WebAssembly.Instance(wasmModule, imports);
-            module.exports = wasmInstance.exports;
+                const wasmModule = new WebAssembly.Module(bytes);
+                const wasmInstance = new WebAssembly.Instance(wasmModule, imports);
             ",
-            path.file_name().unwrap().to_str().unwrap()
         ));
 
+        if self.nodejs_experimental_modules {
+            if let Some(e) = m.export_section() {
+                for name in e.entries().iter().map(|e| e.field()) {
+                    shim.push_str("export const ");
+                    shim.push_str(name);
+                    shim.push_str(" = wasmInstance.exports.");
+                    shim.push_str(name);
+                    shim.push_str(";\n");
+                }
+            }
+        } else {
+            shim.push_str("module.exports = wasmInstance.exports;\n");
+        }
+
         reset_indentation(&shim)
     }
 }
diff --git a/crates/test-project-builder/Cargo.toml b/crates/test-project-builder/Cargo.toml
new file mode 100644
index 00000000..74e51f1e
--- /dev/null
+++ b/crates/test-project-builder/Cargo.toml
@@ -0,0 +1,8 @@
+[package]
+name = "wasm-bindgen-test-project-builder"
+version = "0.2.11"
+authors = ["Nick Fitzgerald <fitzgen@gmail.com>"]
+
+[dependencies]
+lazy_static = "1"
+wasm-bindgen-cli-support = { path = "../cli-support", version = '=0.2.11' }
diff --git a/crates/test-project-builder/src/lib.rs b/crates/test-project-builder/src/lib.rs
new file mode 100644
index 00000000..7528bba8
--- /dev/null
+++ b/crates/test-project-builder/src/lib.rs
@@ -0,0 +1,830 @@
+#[macro_use]
+extern crate lazy_static;
+extern crate wasm_bindgen_cli_support as cli;
+
+use std::env;
+use std::fs::{self, File};
+use std::thread;
+use std::io::{self, Read, Write};
+use std::path::{Path, PathBuf};
+use std::process::{Command, Stdio, Child, ChildStdin};
+use std::net::TcpStream;
+use std::sync::atomic::*;
+use std::sync::{Once, ONCE_INIT, Mutex};
+use std::time::{Duration, Instant};
+
+static CNT: AtomicUsize = ATOMIC_USIZE_INIT;
+thread_local!(static IDX: usize = CNT.fetch_add(1, Ordering::SeqCst));
+
+pub struct Project {
+    files: Vec<(String, String)>,
+    debug: bool,
+    node: bool,
+    nodejs_experimental_modules: bool,
+    no_std: bool,
+    serde: bool,
+    rlib: bool,
+    webpack: bool,
+    node_args: Vec<String>,
+    deps: Vec<String>,
+    headless: bool,
+}
+
+pub fn project() -> Project {
+    let dir = Path::new(env!("CARGO_MANIFEST_DIR")).join("../..");
+    let mut lockfile = String::new();
+    fs::File::open(&dir.join("Cargo.lock"))
+        .unwrap()
+        .read_to_string(&mut lockfile)
+        .unwrap();
+    Project {
+        debug: true,
+        no_std: false,
+        node: true,
+        nodejs_experimental_modules: true,
+        webpack: false,
+        serde: false,
+        rlib: false,
+        headless: false,
+        deps: Vec::new(),
+        node_args: Vec::new(),
+        files: vec![
+            ("Cargo.lock".to_string(), lockfile),
+        ],
+    }
+}
+
+fn root() -> PathBuf {
+    let idx = IDX.with(|x| *x);
+
+    let mut me = env::current_exe().unwrap();
+    me.pop(); // chop off exe name
+    me.pop(); // chop off `deps`
+    me.pop(); // chop off `debug` / `release`
+    me.push("generated-tests");
+    me.push(&format!("test{}", idx));
+    return me;
+}
+
+fn assert_bigint_support() -> Option<&'static str> {
+    static BIGINT_SUPPORED: AtomicUsize = ATOMIC_USIZE_INIT;
+    static INIT: Once = ONCE_INIT;
+
+    INIT.call_once(|| {
+        let mut cmd = Command::new("node");
+        cmd.arg("-e").arg("BigInt");
+        cmd.stdin(Stdio::null())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped());
+        if cmd.status().unwrap().success() {
+            BIGINT_SUPPORED.store(1, Ordering::SeqCst);
+            return;
+        }
+
+        cmd.arg("--harmony-bigint");
+        if cmd.status().unwrap().success() {
+            BIGINT_SUPPORED.store(2, Ordering::SeqCst);
+            return;
+        }
+    });
+
+    match BIGINT_SUPPORED.load(Ordering::SeqCst) {
+        1 => return None,
+        2 => return Some("--harmony-bigint"),
+        _ => panic!(
+            "the version of node.js that is installed for these tests \
+             does not support `BigInt`, you may wish to try installing \
+             node 10 to fix this"
+        ),
+    }
+}
+
+impl Project {
+    /// Add a new file with the specified contents to this project, the `name`
+    /// can have slahes for files in subdirectories.
+    pub fn file(&mut self, name: &str, contents: &str) -> &mut Project {
+        self.files.push((name.to_string(), contents.to_string()));
+        self
+    }
+
+    /// Enable debug mode in wasm-bindgen for this test
+    pub fn debug(&mut self, debug: bool) -> &mut Project {
+        self.debug = debug;
+        self
+    }
+
+    /// Depend on `wasm-bindgen` without the `std` feature enabled.
+    pub fn no_std(&mut self, no_std: bool) -> &mut Project {
+        self.no_std = no_std;
+        self
+    }
+
+    /// Depend on the `serde` feature of `wasm-bindgen`
+    pub fn serde(&mut self, serde: bool) -> &mut Project {
+        self.serde = serde;
+        self
+    }
+
+    /// Generate an rlib instead of a cdylib in the generated Cargo project
+    pub fn rlib(&mut self, rlib: bool) -> &mut Project {
+        self.rlib = rlib;
+        self
+    }
+
+    /// Depend on a crate from crates.io, like serde.
+    pub fn depend(&mut self, dep: &str) -> &mut Project {
+        self.deps.push(dep.to_string());
+        self
+    }
+
+    /// Enables or disables node.js experimental modules output
+    pub fn nodejs_experimental_modules(&mut self, node: bool) -> &mut Project {
+        self.nodejs_experimental_modules = node;
+        self
+    }
+
+    /// Enables or disables the usage of webpack for this project
+    pub fn webpack(&mut self, webpack: bool) -> &mut Project {
+        self.webpack = webpack;
+        self
+    }
+
+    /// Add a path dependency to the generated project
+    pub fn add_local_dependency(&mut self, name: &str, path: &str) -> &mut Project {
+        self.deps
+            .push(format!("{} = {{ path = '{}' }}", name, path));
+        self
+    }
+
+    /// Returns the crate name that will be used for the generated crate, this
+    /// name changes between test runs and is generated at runtime.
+    pub fn crate_name(&self) -> String {
+        format!("test{}", IDX.with(|x| *x))
+    }
+
+    /// Flag this project as requiring bigint support in Node
+    pub fn requires_bigint(&mut self) -> &mut Project {
+        if let Some(arg) = assert_bigint_support() {
+            self.node_args.push(arg.to_string());
+        }
+        self
+    }
+
+    /// This test requires a headless web browser
+    pub fn headless(&mut self, headless: bool) -> &mut Project {
+        self.headless = headless;
+        self
+    }
+
+    /// Write this project to the filesystem, ensuring all files are ready to
+    /// go.
+    pub fn build(&mut self) -> (PathBuf, PathBuf) {
+        if self.headless {
+            self.webpack = true;
+        }
+        if self.webpack {
+            self.node = false;
+            self.nodejs_experimental_modules = false;
+        }
+
+        self.ensure_webpack_config();
+        self.ensure_test_entry();
+
+        if self.headless {
+            self.ensure_index_html();
+            self.ensure_run_headless_js();
+        }
+
+        let webidl_modules = self.generate_webidl_bindings();
+        self.generate_js_entry(webidl_modules);
+
+        let mut manifest = format!(
+            r#"
+            [package]
+            name = "test{}"
+            version = "0.0.1"
+            authors = []
+
+            [workspace]
+
+            [lib]
+        "#,
+            IDX.with(|x| *x)
+        );
+
+        if !self.rlib {
+            manifest.push_str("crate-type = [\"cdylib\"]\n");
+        }
+
+        manifest.push_str("[build-dependencies]\n");
+        manifest.push_str("wasm-bindgen-webidl = { path = '");
+        manifest.push_str(env!("CARGO_MANIFEST_DIR"));
+        manifest.push_str("/../webidl' }\n");
+
+        manifest.push_str("[dependencies]\n");
+        for dep in self.deps.iter() {
+            manifest.push_str(dep);
+            manifest.push_str("\n");
+        }
+        manifest.push_str("wasm-bindgen = { path = '");
+        manifest.push_str(env!("CARGO_MANIFEST_DIR"));
+        manifest.push_str("/../..'");
+        if self.no_std {
+            manifest.push_str(", default-features = false");
+        }
+        if self.serde {
+            manifest.push_str(", features = ['serde-serialize']");
+        }
+        manifest.push_str(" }\n");
+        self.files.push(("Cargo.toml".to_string(), manifest));
+
+        let root = root();
+        drop(fs::remove_dir_all(&root));
+        for &(ref file, ref contents) in self.files.iter() {
+            let mut dst = root.join(file);
+            if self.nodejs_experimental_modules &&
+                dst.extension().and_then(|s| s.to_str()) == Some("js")
+            {
+                dst = dst.with_extension("mjs");
+            }
+            if dst.extension().and_then(|s| s.to_str()) == Some("ts") &&
+                !self.webpack
+            {
+                panic!("webpack needs to be enabled to use typescript");
+            }
+            fs::create_dir_all(dst.parent().unwrap()).unwrap();
+            fs::File::create(&dst)
+                .unwrap()
+                .write_all(contents.as_ref())
+                .unwrap();
+        }
+        let target_dir = root.parent().unwrap() // chop off test name
+            .parent().unwrap(); // chop off `generated-tests`
+        (root.clone(), target_dir.to_path_buf())
+    }
+
+    fn ensure_webpack_config(&mut self) {
+        if !self.webpack {
+            return
+        }
+
+        let needs_typescript = self.files.iter().any(|t| t.0.ends_with(".ts"));
+
+        let mut rules = String::new();
+        let mut extensions = format!("'.js', '.wasm'");
+        if needs_typescript {
+            rules.push_str("
+                {
+                    test: /.ts$/,
+                    use: 'ts-loader',
+                    exclude: /node_modules/,
+                }
+            ");
+            extensions.push_str(", '.ts'");
+        }
+        let target = if self.headless { "web" } else { "node" };
+        self.files.push((
+            "webpack.config.js".to_string(),
+            format!(r#"
+                const path = require('path');
+                const fs = require('fs');
+
+                let nodeModules = {{}};
+
+                // Webpack bundles the modules from node_modules.
+                // For node target, we will not have `fs` module
+                // inside the `node_modules` folder.
+                // This reads the directories in `node_modules`
+                // and give that to externals and webpack ignores
+                // to bundle the modules listed as external.
+                if ('{2}' == 'node') {{
+                    fs.readdirSync('node_modules')
+                        .filter(module => module !== '.bin')
+                        .forEach(mod => {{
+                            // External however,expects browser environment.
+                            // To make it work in `node` target we
+                            // prefix commonjs here.
+                            nodeModules[mod] = 'commonjs ' + mod;
+                        }});
+                }}
+
+                module.exports = {{
+                  entry: './run.js',
+                  mode: "development",
+                  devtool: "source-map",
+                  module: {{
+                    rules: [{}]
+                  }},
+                  resolve: {{
+                    extensions: [{}]
+                  }},
+                  output: {{
+                    filename: 'bundle.js',
+                    path: path.resolve(__dirname, '.')
+                  }},
+                  target: '{}',
+                  externals: nodeModules
+                }};
+            "#, rules, extensions, target)
+        ));
+        if needs_typescript {
+            self.files.push((
+                "tsconfig.json".to_string(),
+                r#"
+                    {
+                      "compilerOptions": {
+                        "noEmitOnError": true,
+                        "noImplicitAny": true,
+                        "noImplicitThis": true,
+                        "noUnusedParameters": true,
+                        "noUnusedLocals": true,
+                        "noImplicitReturns": true,
+                        "strictFunctionTypes": true,
+                        "strictNullChecks": true,
+                        "alwaysStrict": true,
+                        "strict": true,
+                        "target": "es5",
+                        "lib": ["es2015"]
+                      }
+                    }
+                "#.to_string(),
+            ));
+        }
+    }
+
+    fn ensure_test_entry(&mut self) {
+        if !self
+            .files
+            .iter()
+            .any(|(path, _)| path == "test.ts" || path == "test.js")
+        {
+            self.files.push((
+                "test.js".to_string(),
+                r#"export {test} from './out';"#.to_string(),
+            ));
+        }
+    }
+
+    fn ensure_index_html(&mut self) {
+        self.file(
+            "index.html",
+            r#"
+                <!DOCTYPE html>
+                <html>
+                    <body>
+                        <div id="error"></div>
+                        <div id="logs"></div>
+                        <div id="status"></div>
+                        <script src="bundle.js"></script>
+                    </body>
+                </html>
+            "#,
+        );
+    }
+
+    fn ensure_run_headless_js(&mut self) {
+        self.file("run-headless.js", include_str!("run-headless.js"));
+    }
+
+    fn generate_webidl_bindings(&mut self) -> Vec<PathBuf> {
+        let mut res = Vec::new();
+        let mut origpaths = Vec::new();
+
+        for (path, _) in &self.files {
+            let path = Path::new(&path);
+            let extension = path.extension().map(|x| x.to_str().unwrap());
+
+            if extension != Some("webidl") {
+                continue;
+            }
+
+            res.push(path.with_extension("rs"));
+            origpaths.push(path.to_owned());
+        }
+
+        if res.is_empty() {
+            return res;
+        }
+
+        let mut buildrs = r#"
+            extern crate wasm_bindgen_webidl;
+
+            use wasm_bindgen_webidl::compile_file;
+            use std::env;
+            use std::fs::{self, File};
+            use std::io::Write;
+            use std::path::Path;
+
+            fn main() {
+                let dest = env::var("OUT_DIR").unwrap();
+        "#.to_string();
+
+        for (path, origpath) in res.iter().zip(origpaths.iter()) {
+            buildrs.push_str(&format!(
+                r#"
+                fs::create_dir_all("{}").unwrap();
+                File::create(&Path::new(&dest).join("{}"))
+                    .unwrap()
+                    .write_all(
+                        compile_file(Path::new("{}"))
+                            .unwrap()
+                            .as_bytes()
+                    )
+                    .unwrap();
+                "#,
+                path.parent().unwrap().to_str().unwrap(),
+                path.to_str().unwrap(),
+                origpath.to_str().unwrap(),
+            ));
+
+            self.files.push((
+                Path::new("src").join(path).to_str().unwrap().to_string(),
+                format!(
+                    r#"include!(concat!(env!("OUT_DIR"), "/{}"));"#,
+                    path.display()
+                ),
+            ));
+        }
+
+        buildrs.push('}');
+
+        self.files.push(("build.rs".to_string(), buildrs));
+
+        res
+    }
+
+    fn generate_js_entry(&mut self, modules: Vec<PathBuf>) {
+        let mut runjs = String::new();
+        let esm_imports = self.webpack || !self.node || self.nodejs_experimental_modules;
+
+
+        if self.headless {
+            runjs.push_str(
+                r#"
+                    window.document.body.innerHTML += "\nTEST_START\n";
+                    console.log = function(...args) {
+                        const logs = document.getElementById('logs');
+                        for (let msg of args) {
+                            logs.innerHTML += `${msg}<br/>\n`;
+                        }
+                    };
+                "#,
+            );
+        } else if esm_imports {
+            runjs.push_str("import * as process from 'process';\n");
+        } else {
+            runjs.push_str("const process = require('process');\n");
+        }
+
+        runjs.push_str("
+            function run(test, wasm) {
+                test.test();
+
+                if (wasm.assertStackEmpty)
+                    wasm.assertStackEmpty();
+                if (wasm.assertSlabEmpty)
+                    wasm.assertSlabEmpty();
+            }
+        ");
+
+        if self.headless {
+            runjs.push_str("
+                function onerror(error) {
+                    const errors = document.getElementById('error');
+                    let content = `exception: ${e.message}\\nstack: ${e.stack}`;
+                    errors.innerHTML = `<pre>${content}</pre>`;
+                }
+            ");
+        } else {
+            runjs.push_str("
+                function onerror(error) {
+                    console.error(error);
+                    process.exit(1);
+                }
+            ");
+        }
+
+        if esm_imports {
+            runjs.push_str("console.log('importing modules...');\n");
+            runjs.push_str("const modules = [];\n");
+            for module in modules.iter() {
+                runjs.push_str(&format!("modules.push(import('./{}'))",
+                                        module.with_extension("").display()));
+            }
+            let import_wasm = if self.debug {
+                "import('./out')"
+            } else {
+                "new Promise((a, b) => a({}))"
+            };
+            runjs.push_str(&format!("
+                Promise.all(modules)
+                    .then(results => {{
+                        results.map(module => Object.assign(global, module));
+                        return Promise.all([import('./test'), {}])
+                    }})
+                    .then(result => run(result[0], result[1]))
+            ", import_wasm));
+
+            if self.headless {
+                runjs.push_str(".then(() => {
+                    document.getElementById('status').innerHTML = 'good';
+                })");
+            }
+            runjs.push_str(".catch(onerror)\n");
+
+            if self.headless {
+                runjs.push_str("
+                    .finally(() => {
+                        window.document.body.innerHTML += \"\\nTEST_DONE\";
+                    })
+                ");
+            }
+        } else {
+            assert!(!self.debug);
+            assert!(modules.is_empty());
+            runjs.push_str("
+                const test = require('./test');
+                try {
+                    run(test, {});
+                } catch (e) {
+                    onerror(e);
+                }
+            ");
+        }
+        self.files.push(("run.js".to_string(), runjs));
+    }
+
+    /// Build the Cargo project for the wasm target, returning the root of the
+    /// project and the target directory where output is located.
+    pub fn cargo_build(&mut self) -> (PathBuf, PathBuf) {
+        let (root, target_dir) = self.build();
+        let mut cmd = Command::new("cargo");
+        cmd.arg("build")
+            .arg("--target")
+            .arg("wasm32-unknown-unknown")
+            .current_dir(&root)
+            .env("CARGO_TARGET_DIR", &target_dir)
+            // Catch any warnings in generated code because we don't want any
+            .env("RUSTFLAGS", "-Dwarnings");
+        run(&mut cmd, "cargo");
+        (root, target_dir)
+    }
+
+    /// Generate wasm-bindgen bindings for the compiled artifacts of this
+    /// project, returning the root of the project as well as the target
+    /// directory where output was generated.
+    pub fn gen_bindings(&mut self) -> (PathBuf, PathBuf) {
+        let (root, target_dir) = self.cargo_build();
+        let idx = IDX.with(|x| *x);
+        let out = target_dir.join(&format!("wasm32-unknown-unknown/debug/test{}.wasm", idx));
+
+        let as_a_module = root.join("out.wasm");
+        fs::hard_link(&out, &as_a_module).unwrap();
+
+        let _x = wrap_step("running wasm-bindgen");
+        let res = cli::Bindgen::new()
+            .input_path(&as_a_module)
+            .typescript(self.webpack)
+            .debug(self.debug)
+            .nodejs(self.node)
+            .nodejs_experimental_modules(self.nodejs_experimental_modules)
+            .generate(&root);
+
+        if let Err(e) = res {
+            for e in e.causes() {
+                println!("- {}", e);
+            }
+            panic!("failed");
+        }
+
+        (root, target_dir)
+    }
+
+    /// Execute this project's `run.js`, ensuring that everything runs through
+    /// node or a browser correctly
+    pub fn test(&mut self) {
+        let (root, _target_dir) = self.gen_bindings();
+
+        if !self.webpack {
+            let mut cmd = Command::new("node");
+            cmd.args(&self.node_args);
+            if self.nodejs_experimental_modules {
+                cmd.arg("--experimental-modules").arg("run.mjs");
+            } else {
+                cmd.arg("run.js");
+            }
+            cmd.current_dir(&root);
+            run(&mut cmd, "node");
+            return
+        }
+
+        // Generate typescript bindings for the wasm module
+        {
+            let _x = wrap_step("running wasm2es6js");
+            let mut wasm = Vec::new();
+            File::open(root.join("out_bg.wasm"))
+                .unwrap()
+                .read_to_end(&mut wasm)
+                .unwrap();
+            let obj = cli::wasm2es6js::Config::new()
+                .base64(true)
+                .generate(&wasm)
+                .expect("failed to convert wasm to js");
+            File::create(root.join("out_bg.d.ts"))
+                .unwrap()
+                .write_all(obj.typescript().as_bytes())
+                .unwrap();
+        }
+
+        // move files from the root into each test, it looks like this may be
+        // needed for webpack to work well when invoked concurrently.
+        fs::hard_link("package.json", root.join("package.json")).unwrap();
+        if !Path::new("node_modules").exists() {
+            panic!("\n\nfailed to find `node_modules`, have you run `npm install` yet?\n\n");
+        }
+        let cwd = env::current_dir().unwrap();
+        symlink_dir(&cwd.join("node_modules"), &root.join("node_modules")).unwrap();
+
+        if self.headless {
+            return self.test_headless(&root)
+        }
+
+        // Execute webpack to generate a bundle
+        let mut cmd = self.npm();
+        cmd.arg("run").arg("run-webpack").current_dir(&root);
+        run(&mut cmd, "npm");
+
+        let mut cmd = Command::new("node");
+        cmd.args(&self.node_args);
+        cmd.arg(root.join("bundle.js")).current_dir(&root);
+        run(&mut cmd, "node");
+    }
+
+    fn npm(&self) -> Command {
+        if cfg!(windows) {
+            let mut c = Command::new("cmd");
+            c.arg("/c");
+            c.arg("npm");
+            c
+        } else {
+            Command::new("npm")
+        }
+    }
+
+    fn test_headless(&mut self, root: &Path) {
+        // Serialize all headless tests since they require starting
+        // webpack-dev-server on the same port.
+        lazy_static! {
+            static ref MUTEX: Mutex<()> = Mutex::new(());
+        }
+        let _lock = MUTEX.lock().unwrap();
+
+        let mut cmd = self.npm();
+        cmd.arg("run")
+            .arg("run-webpack-dev-server")
+            .arg("--")
+            .arg("--quiet")
+            .arg("--watch-stdin")
+            .current_dir(&root);
+        let _server = run_in_background(&mut cmd, "webpack-dev-server".into());
+
+        // wait for webpack-dev-server to come online and bind its port
+        loop {
+            if TcpStream::connect("127.0.0.1:8080").is_ok() {
+                break;
+            }
+            thread::sleep(Duration::from_millis(100));
+        }
+
+        let path = env::var_os("PATH").unwrap_or_default();
+        let mut path = env::split_paths(&path).collect::<Vec<_>>();
+        path.push(root.join("node_modules/geckodriver"));
+
+        let mut cmd = Command::new("node");
+        cmd.args(&self.node_args)
+            .arg(root.join("run-headless.js"))
+            .current_dir(&root)
+            .env("PATH", env::join_paths(&path).unwrap());
+        run(&mut cmd, "node");
+    }
+
+    /// Reads JS generated by `wasm-bindgen` to a string.
+    pub fn read_js(&self) -> String {
+        let path = root().join(if self.nodejs_experimental_modules {
+            "out.mjs"
+        } else {
+            "out.js"
+        });
+        println!("js, {:?}", &path);
+        fs::read_to_string(path).expect("Unable to read js")
+    }
+}
+
+#[cfg(unix)]
+fn symlink_dir(a: &Path, b: &Path) -> io::Result<()> {
+    use std::os::unix::fs::symlink;
+    symlink(a, b)
+}
+
+#[cfg(windows)]
+fn symlink_dir(a: &Path, b: &Path) -> io::Result<()> {
+    use std::os::windows::fs::symlink_dir;
+    symlink_dir(a, b)
+}
+
+fn wrap_step(desc: &str) -> WrapStep {
+    println!("···················································");
+    println!("{}", desc);
+    WrapStep { start: Instant::now() }
+}
+
+struct WrapStep { start: Instant }
+
+impl Drop for WrapStep {
+    fn drop(&mut self) {
+        let dur = self.start.elapsed();
+        println!(
+            "dur: {}.{:03}s",
+            dur.as_secs(),
+            dur.subsec_nanos() / 1_000_000
+        );
+    }
+}
+
+pub fn run(cmd: &mut Command, program: &str) {
+    let _x = wrap_step(&format!("running {:?}", cmd));
+    let output = match cmd.output() {
+        Ok(output) => output,
+        Err(err) => panic!("failed to spawn `{}`: {}", program, err),
+    };
+    println!("exit: {}", output.status);
+    if output.stdout.len() > 0 {
+        println!("stdout ---\n{}", String::from_utf8_lossy(&output.stdout));
+    }
+    if output.stderr.len() > 0 {
+        println!("stderr ---\n{}", String::from_utf8_lossy(&output.stderr));
+    }
+    assert!(output.status.success());
+}
+
+struct BackgroundChild {
+    name: String,
+    child: Child,
+    stdin: Option<ChildStdin>,
+    stdout: Option<thread::JoinHandle<io::Result<String>>>,
+    stderr: Option<thread::JoinHandle<io::Result<String>>>,
+}
+
+impl Drop for BackgroundChild {
+    fn drop(&mut self) {
+        drop(self.stdin.take());
+        let status = self.child.wait().expect("failed to wait on child");
+        let stdout = self
+            .stdout
+            .take()
+            .unwrap()
+            .join()
+            .unwrap()
+            .expect("failed to read stdout");
+        let stderr = self
+            .stderr
+            .take()
+            .unwrap()
+            .join()
+            .unwrap()
+            .expect("failed to read stderr");
+
+        println!("···················································");
+        println!("background {}", self.name);
+        println!("status: {}", status);
+        println!("stdout ---\n{}", stdout);
+        println!("stderr ---\n{}", stderr);
+    }
+}
+
+fn run_in_background(cmd: &mut Command, name: String) -> BackgroundChild {
+    cmd.stdout(Stdio::piped());
+    cmd.stderr(Stdio::piped());
+    cmd.stdin(Stdio::piped());
+    let mut child = cmd.spawn().expect(&format!("should spawn {} OK", name));
+    let mut stdout = child.stdout.take().unwrap();
+    let mut stderr = child.stderr.take().unwrap();
+    let stdin = child.stdin.take().unwrap();
+    let stdout = thread::spawn(move || {
+        let mut t = String::new();
+        stdout.read_to_string(&mut t)?;
+        Ok(t)
+    });
+    let stderr = thread::spawn(move || {
+        let mut t = String::new();
+        stderr.read_to_string(&mut t)?;
+        Ok(t)
+    });
+    BackgroundChild {
+        name,
+        child,
+        stdout: Some(stdout),
+        stderr: Some(stderr),
+        stdin: Some(stdin),
+    }
+}
diff --git a/crates/test-project-builder/src/run-headless.js b/crates/test-project-builder/src/run-headless.js
new file mode 100644
index 00000000..9775288e
--- /dev/null
+++ b/crates/test-project-builder/src/run-headless.js
@@ -0,0 +1,128 @@
+const process = require("process");
+const { promisify } = require("util");
+const { Builder, By, Key, logging, promise, until } = require("selenium-webdriver");
+const firefox = require("selenium-webdriver/firefox");
+
+promise.USE_PROMISE_MANAGER = false;
+
+const prefs = new logging.Preferences();
+prefs.setLevel(logging.Type.BROWSER, logging.Level.DEBUG);
+
+const opts = new firefox.Options();
+opts.headless();
+if (process.env.WASM_BINDGEN_FIREFOX_BIN_PATH) {
+  console.log("Using custom firefox-bin: $WASM_BINDGEN_FIREFOX_BIN_PATH =",
+              process.env.WASM_BINDGEN_FIREFOX_BIN_PATH);
+  opts.setBinary(process.env.WASM_BINDGEN_FIREFOX_BIN_PATH);
+}
+
+console.log("Using Firefox options:", opts);
+
+const driver = new Builder()
+  .forBrowser("firefox")
+  .setFirefoxOptions(opts)
+  .build();
+
+const SECONDS = 1000;
+const MINUTES = 60 * SECONDS;
+
+const start = Date.now();
+const timeSinceStart = () => {
+  const elapsed = Date.now() - start;
+  const minutes = Math.floor(elapsed / MINUTES);
+  const seconds = elapsed % MINUTES / SECONDS;
+  return `${minutes}m${seconds.toFixed(3)}s`;
+};
+
+async function logged(msg, promise) {
+  console.log(`${timeSinceStart()}: START: ${msg}`);
+  try {
+    const value = await promise;
+    console.log(`${timeSinceStart()}: END: ${msg}`);
+    return value;
+  } catch (e) {
+    console.log(`${timeSinceStart()}: ERROR: ${msg}: ${e}\n\n${e.stack}`);
+    throw e;
+  }
+}
+
+async function main() {
+  let body;
+  try {
+    await logged(
+      "load http://localhost:8080/index.html",
+      driver.get("http://localhost:8080/index.html")
+    );
+
+    body = driver.findElement(By.tagName("body"));
+
+    await logged(
+      "Waiting for <body> to include text 'TEST_START'",
+      driver.wait(
+        until.elementTextContains(body, "TEST_START"),
+        1 * MINUTES
+      )
+    );
+
+    await logged(
+      "Waiting for <body> to include text 'TEST_DONE'",
+      driver.wait(
+        until.elementTextContains(body, "TEST_DONE"),
+        1 * MINUTES
+      )
+    );
+
+    const status = await logged(
+      "get #status text",
+      body.findElement(By.id("status")).getText()
+    );
+
+    console.log(`Test status is: "${status}"`);
+    if (status != "good") {
+      throw new Error(`test failed with status = ${status}`);
+    }
+  } finally {
+    const logs = await logged(
+      "getting browser logs",
+      body.findElement(By.id("logs")).getText()
+    );
+
+    if (logs.length > 0) {
+      console.log("logs:");
+      logs.split("\n").forEach(line => {
+        console.log(`    ${line}`);
+      });
+    }
+
+    const errors = await logged(
+      "getting browser errors",
+      body.findElement(By.id("error")).getText()
+    );
+
+    if (errors.length > 0) {
+      console.log("errors:");
+      errors.split("\n").forEach(line => {
+        console.log(`    ${line}`);
+      });
+    }
+
+    const bodyText = await logged(
+      "getting browser body",
+      body.getText()
+    );
+
+    if (bodyText.length > 0) {
+      console.log("body:");
+      bodyText.split("\n").forEach(line => {
+        console.log(`    ${line}`);
+      });
+    }
+  }
+}
+
+main()
+  .finally(() => driver.quit())
+  .catch(e => {
+    console.error(`Got an error: ${e}\n\nStack: ${e.stack}`);
+    process.exit(1);
+  });
diff --git a/crates/webidl/src/lib.rs b/crates/webidl/src/lib.rs
index 3d589cf9..8e3b4b26 100644
--- a/crates/webidl/src/lib.rs
+++ b/crates/webidl/src/lib.rs
@@ -171,6 +171,7 @@ impl WebidlParse<()> for webidl::ast::NonPartialInterface {
                     pub_token: Default::default(),
                 }),
                 name: rust_ident(&self.name),
+                attrs: Vec::new(),
             }),
         });
 
@@ -379,7 +380,7 @@ impl<'a> WebidlParse<&'a str> for webidl::ast::StaticOperation {
         if util::is_chrome_only(&self.extended_attributes) {
             return Ok(())
         }
-        
+
         create_basic_method(
             &self.arguments,
             self.name.as_ref(),
diff --git a/guide/src/contributing.md b/guide/src/contributing.md
index befa77b4..dbf4f6f5 100644
--- a/guide/src/contributing.md
+++ b/guide/src/contributing.md
@@ -42,3 +42,16 @@ Finally, you can run the tests with `cargo`:
 ```shell
 cargo test
 ```
+
+### Headless Browser Tests
+
+Some tests are configured to run in a headless Firefox instance. To run these
+tests, you must have Firefox installed. If you have Firefox installed in a
+non-default, custom location you can set the `WASM_BINDGEN_FIREFOX_BIN_PATH`
+environment variable to the path to your `firefox-bin`.
+
+For example:
+
+```shell
+WASM_BINDGEN_FIREFOX_BIN_PATH=/home/fitzgen/firefox/firefox-bin cargo test
+```
diff --git a/guide/src/design/rust-type-conversions.md b/guide/src/design/rust-type-conversions.md
index 2eacc4c4..f5e939a2 100644
--- a/guide/src/design/rust-type-conversions.md
+++ b/guide/src/design/rust-type-conversions.md
@@ -40,7 +40,7 @@ Rust arguments of JS functions imported to Rust.
 ### From JS to Rust
 
 Unfortunately the opposite direction from above, going from JS to Rust, is a bit
-mroe complicated. Here we've got three traits:
+more complicated. Here we've got three traits:
 
 ```rust
 pub trait FromWasmAbi: WasmDescribe {
diff --git a/package-lock.json b/package-lock.json
deleted file mode 100644
index e7cc5c8f..00000000
--- a/package-lock.json
+++ /dev/null
@@ -1,8091 +0,0 @@
-{
-  "requires": true,
-  "lockfileVersion": 1,
-  "dependencies": {
-    "@mrmlnc/readdir-enhanced": {
-      "version": "2.2.1",
-      "resolved": "https://registry.npmjs.org/@mrmlnc/readdir-enhanced/-/readdir-enhanced-2.2.1.tgz",
-      "integrity": "sha512-bPHp6Ji8b41szTOcaP63VlnbbO5Ny6dwAATtY6JTjh5N2OLrb5Qk/Th5cRkRQhkWCt+EJsYrNB0MiL+Gpn6e3g==",
-      "dev": true,
-      "requires": {
-        "call-me-maybe": "^1.0.1",
-        "glob-to-regexp": "^0.3.0"
-      }
-    },
-    "@nodelib/fs.stat": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-1.1.0.tgz",
-      "integrity": "sha512-LAQ1d4OPfSJ/BMbI2DuizmYrrkD9JMaTdi2hQTlI53lQ4kRQPyZQRS4CYQ7O66bnBBnP/oYdRxbk++X0xuFU6A==",
-      "dev": true
-    },
-    "@samverschueren/stream-to-observable": {
-      "version": "0.3.0",
-      "resolved": "https://registry.npmjs.org/@samverschueren/stream-to-observable/-/stream-to-observable-0.3.0.tgz",
-      "integrity": "sha512-MI4Xx6LHs4Webyvi6EbspgyAb4D2Q2VtnCQ1blOJcoLS6mVa8lNN2rkIy1CVxfTUpoyIbCTkXES1rLXztFD1lg==",
-      "dev": true,
-      "requires": {
-        "any-observable": "^0.3.0"
-      }
-    },
-    "@sindresorhus/is": {
-      "version": "0.7.0",
-      "resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-0.7.0.tgz",
-      "integrity": "sha512-ONhaKPIufzzrlNbqtWFFd+jlnemX6lJAgq9ZeiZtS7I1PIf/la7CW4m83rTXRnVnsMbW2k56pGYu7AUFJD9Pow==",
-      "dev": true
-    },
-    "@types/node": {
-      "version": "9.6.20",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-9.6.20.tgz",
-      "integrity": "sha512-mIMXUbH2MmJAQQjzFUIRpxa+FtA27IaHMrIgoJ1fyu/EfpVN/UZw3ISMNnwVec4lau8R8SM4pNFXSCZpJFX2Bw==",
-      "dev": true
-    },
-    "@webassemblyjs/ast": {
-      "version": "1.5.10",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.5.10.tgz",
-      "integrity": "sha512-4BObuKRfeAnKdz5PfTp6MqSoCdj0z9EXu00PsQLzqcC55Htw5r9OXebS+sPF8T5tRTRI5/2w0CR52s/4vJ2fkw==",
-      "dev": true,
-      "requires": {
-        "@webassemblyjs/helper-module-context": "1.5.10",
-        "@webassemblyjs/helper-wasm-bytecode": "1.5.10",
-        "@webassemblyjs/wast-parser": "1.5.10",
-        "debug": "^3.1.0",
-        "mamacro": "^0.0.3"
-      },
-      "dependencies": {
-        "debug": {
-          "version": "3.1.0",
-          "resolved": "https://registry.npmjs.org/debug/-/debug-3.1.0.tgz",
-          "integrity": "sha512-OX8XqP7/1a9cqkxYw2yXss15f26NKWBpDXQd0/uK/KPqdQhxbPa994hnzjcE2VqQpDslf55723cKPUOGSmMY3g==",
-          "dev": true,
-          "requires": {
-            "ms": "2.0.0"
-          }
-        }
-      }
-    },
-    "@webassemblyjs/floating-point-hex-parser": {
-      "version": "1.5.10",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.5.10.tgz",
-      "integrity": "sha512-ns6H/06BTnk7thnN8O6MK9xMqodgaVKkjBaC8nXGLeAtX2ONHxQL2NnY4XgUzyo7yRwGVAPBxdl7yxzc0iy9Eg==",
-      "dev": true
-    },
-    "@webassemblyjs/helper-api-error": {
-      "version": "1.5.10",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-api-error/-/helper-api-error-1.5.10.tgz",
-      "integrity": "sha512-OeWjB1Ie44sg5Nr8GVot5l+uclK4fWEQGH1b+HQ7x9GN9UxcJUIG3+u5dj2MTkthneQT1hUo09Wtpb/bY7zfXA==",
-      "dev": true
-    },
-    "@webassemblyjs/helper-buffer": {
-      "version": "1.5.10",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-buffer/-/helper-buffer-1.5.10.tgz",
-      "integrity": "sha512-soggPYDku3gDl+zV1TVle3zLWgiU1Kli4QJdWCoeyX95RhGtF2A5tP7U3ypLlBb74SdoYYFVn3Fm7HXIWj1wzA==",
-      "dev": true,
-      "requires": {
-        "debug": "^3.1.0"
-      },
-      "dependencies": {
-        "debug": {
-          "version": "3.1.0",
-          "resolved": "https://registry.npmjs.org/debug/-/debug-3.1.0.tgz",
-          "integrity": "sha512-OX8XqP7/1a9cqkxYw2yXss15f26NKWBpDXQd0/uK/KPqdQhxbPa994hnzjcE2VqQpDslf55723cKPUOGSmMY3g==",
-          "dev": true,
-          "requires": {
-            "ms": "2.0.0"
-          }
-        }
-      }
-    },
-    "@webassemblyjs/helper-code-frame": {
-      "version": "1.5.10",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-code-frame/-/helper-code-frame-1.5.10.tgz",
-      "integrity": "sha512-1mNetGdoMMSW+spR7eC5kJZCA8g9aK7G0t2Mc5Q0p9Kw8p+gFgf9dO7fbThHP/+tNLHM6+SwUQ+S8s4BLhBtZQ==",
-      "dev": true,
-      "requires": {
-        "@webassemblyjs/wast-printer": "1.5.10"
-      }
-    },
-    "@webassemblyjs/helper-fsm": {
-      "version": "1.5.10",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-fsm/-/helper-fsm-1.5.10.tgz",
-      "integrity": "sha512-ekKmiumHOJrlzZhrigZ19COsCbqNeHtnRN2wktMIaCHGobW/FW+d4Qv1svc0BetjoXo/DhSgVvhHoxaKSO3yPw==",
-      "dev": true
-    },
-    "@webassemblyjs/helper-module-context": {
-      "version": "1.5.10",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-module-context/-/helper-module-context-1.5.10.tgz",
-      "integrity": "sha512-ce2KTWDlSCHhJZMOX+bgHGIKwYsx27MWySqffl8pqu9K+M1G4TlZCfRlN1dV85rAhn5OknOAHRBmRtceklY2/g==",
-      "dev": true,
-      "requires": {
-        "mamacro": "^0.0.3"
-      }
-    },
-    "@webassemblyjs/helper-wasm-bytecode": {
-      "version": "1.5.10",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.5.10.tgz",
-      "integrity": "sha512-0noYMZDkkUZvHNpcOp9+ElMTwPxIyEWVc1bdjJ38qZTIX9ytCgRifs2DrF/1FfUxzI3d3xXFqrqCFfp+amAOaA==",
-      "dev": true
-    },
-    "@webassemblyjs/helper-wasm-section": {
-      "version": "1.5.10",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.5.10.tgz",
-      "integrity": "sha512-rXH6br9w+CYY/tN+N7MFmnUD5J/D4sBsl1K8liqKGpAXlsGp9SmEeqXy8yBWJ1wH3J3rNGaxQNbk9VR3qZgn0w==",
-      "dev": true,
-      "requires": {
-        "@webassemblyjs/ast": "1.5.10",
-        "@webassemblyjs/helper-buffer": "1.5.10",
-        "@webassemblyjs/helper-wasm-bytecode": "1.5.10",
-        "@webassemblyjs/wasm-gen": "1.5.10",
-        "debug": "^3.1.0"
-      },
-      "dependencies": {
-        "debug": {
-          "version": "3.1.0",
-          "resolved": "https://registry.npmjs.org/debug/-/debug-3.1.0.tgz",
-          "integrity": "sha512-OX8XqP7/1a9cqkxYw2yXss15f26NKWBpDXQd0/uK/KPqdQhxbPa994hnzjcE2VqQpDslf55723cKPUOGSmMY3g==",
-          "dev": true,
-          "requires": {
-            "ms": "2.0.0"
-          }
-        }
-      }
-    },
-    "@webassemblyjs/ieee754": {
-      "version": "1.5.10",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/ieee754/-/ieee754-1.5.10.tgz",
-      "integrity": "sha512-WWlO5quQd3qOUT4wJiuodh5E1A8BfXYkOueuZZjEPL3budH5snqdWsPDieTqkBJnfCZGwRkRSn14OH4OPY1hsw==",
-      "dev": true,
-      "requires": {
-        "ieee754": "^1.1.11"
-      }
-    },
-    "@webassemblyjs/leb128": {
-      "version": "1.5.10",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/leb128/-/leb128-1.5.10.tgz",
-      "integrity": "sha512-b+DWTy6RsRznpCKvsP3V5yNkk6YWs+7kLOJ3GU1ITyz846VIzVJda+K0mr31fgXzob/QWToWEx8ajk+PrOegkQ==",
-      "dev": true,
-      "requires": {
-        "leb": "^0.3.0"
-      }
-    },
-    "@webassemblyjs/utf8": {
-      "version": "1.5.10",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/utf8/-/utf8-1.5.10.tgz",
-      "integrity": "sha512-MQM04pZd0DoxukOPBJD4uaeVQ4iaWzRqsq7iDvJQBqcxIIEwi2iAPv+xjL2PbVwosCvwkh7FzKK3FHVQUjTlTQ==",
-      "dev": true
-    },
-    "@webassemblyjs/wasm-edit": {
-      "version": "1.5.10",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-edit/-/wasm-edit-1.5.10.tgz",
-      "integrity": "sha512-mrMZw5A0+p6A58iquzq/d0SJej481H4pNwPO65rEjzDsHs+yykT6de26VQD2GtaCTThfSNcw3JJXWJ1biqO/+g==",
-      "dev": true,
-      "requires": {
-        "@webassemblyjs/ast": "1.5.10",
-        "@webassemblyjs/helper-buffer": "1.5.10",
-        "@webassemblyjs/helper-wasm-bytecode": "1.5.10",
-        "@webassemblyjs/helper-wasm-section": "1.5.10",
-        "@webassemblyjs/wasm-gen": "1.5.10",
-        "@webassemblyjs/wasm-opt": "1.5.10",
-        "@webassemblyjs/wasm-parser": "1.5.10",
-        "@webassemblyjs/wast-printer": "1.5.10",
-        "debug": "^3.1.0"
-      },
-      "dependencies": {
-        "debug": {
-          "version": "3.1.0",
-          "resolved": "https://registry.npmjs.org/debug/-/debug-3.1.0.tgz",
-          "integrity": "sha512-OX8XqP7/1a9cqkxYw2yXss15f26NKWBpDXQd0/uK/KPqdQhxbPa994hnzjcE2VqQpDslf55723cKPUOGSmMY3g==",
-          "dev": true,
-          "requires": {
-            "ms": "2.0.0"
-          }
-        }
-      }
-    },
-    "@webassemblyjs/wasm-gen": {
-      "version": "1.5.10",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-gen/-/wasm-gen-1.5.10.tgz",
-      "integrity": "sha512-MXYoZg7zaRGmU2h2FBa6Oo+y0etuDZycx0h7nrBD4LzVqhufenoWY4Be6K4IMU0L/fRb/GMp17Vfqg4m/J8EuQ==",
-      "dev": true,
-      "requires": {
-        "@webassemblyjs/ast": "1.5.10",
-        "@webassemblyjs/helper-wasm-bytecode": "1.5.10",
-        "@webassemblyjs/ieee754": "1.5.10",
-        "@webassemblyjs/leb128": "1.5.10",
-        "@webassemblyjs/utf8": "1.5.10"
-      }
-    },
-    "@webassemblyjs/wasm-opt": {
-      "version": "1.5.10",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-opt/-/wasm-opt-1.5.10.tgz",
-      "integrity": "sha512-1A1rVPa1URgjCmEVZupRgrrbqwfCh6hJVkogK22JNygS+wn1gg1jgjN82Zd3NDhm738TwY61936n3y25GC+mfQ==",
-      "dev": true,
-      "requires": {
-        "@webassemblyjs/ast": "1.5.10",
-        "@webassemblyjs/helper-buffer": "1.5.10",
-        "@webassemblyjs/wasm-gen": "1.5.10",
-        "@webassemblyjs/wasm-parser": "1.5.10",
-        "debug": "^3.1.0"
-      },
-      "dependencies": {
-        "debug": {
-          "version": "3.1.0",
-          "resolved": "https://registry.npmjs.org/debug/-/debug-3.1.0.tgz",
-          "integrity": "sha512-OX8XqP7/1a9cqkxYw2yXss15f26NKWBpDXQd0/uK/KPqdQhxbPa994hnzjcE2VqQpDslf55723cKPUOGSmMY3g==",
-          "dev": true,
-          "requires": {
-            "ms": "2.0.0"
-          }
-        }
-      }
-    },
-    "@webassemblyjs/wasm-parser": {
-      "version": "1.5.10",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-parser/-/wasm-parser-1.5.10.tgz",
-      "integrity": "sha512-VWSi7NWmfEuMpZ0+CTnBzz8qhxw7R17CwmbcJ+QJ0wfqReWEgP/J5yI4mN/C/lEoYuroFUF+sTWoDQqzH4FNdQ==",
-      "dev": true,
-      "requires": {
-        "@webassemblyjs/ast": "1.5.10",
-        "@webassemblyjs/helper-api-error": "1.5.10",
-        "@webassemblyjs/helper-wasm-bytecode": "1.5.10",
-        "@webassemblyjs/ieee754": "1.5.10",
-        "@webassemblyjs/leb128": "1.5.10",
-        "@webassemblyjs/wasm-parser": "1.5.10"
-      }
-    },
-    "@webassemblyjs/wast-parser": {
-      "version": "1.5.10",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/wast-parser/-/wast-parser-1.5.10.tgz",
-      "integrity": "sha512-RORXT40qjkFgowmFzqGFGBW3fuNd7UKJwyuYXeXLzqQOoPBySE1lsSrku0aQIcVl086dy297A+De5vPCfF/Rfg==",
-      "dev": true,
-      "requires": {
-        "@webassemblyjs/ast": "1.5.10",
-        "@webassemblyjs/floating-point-hex-parser": "1.5.10",
-        "@webassemblyjs/helper-api-error": "1.5.10",
-        "@webassemblyjs/helper-code-frame": "1.5.10",
-        "@webassemblyjs/helper-fsm": "1.5.10",
-        "long": "^3.2.0",
-        "mamacro": "^0.0.3"
-      }
-    },
-    "@webassemblyjs/wast-printer": {
-      "version": "1.5.10",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/wast-printer/-/wast-printer-1.5.10.tgz",
-      "integrity": "sha512-n4zZJmnETVc4RRs9wAZQr3dXUwC+Yyx+xwkaWdTk36NqgM89CPVLBpw8htKyKG+BX/tgk+VOXRwO+1x5Cf3J8Q==",
-      "dev": true,
-      "requires": {
-        "@webassemblyjs/ast": "1.5.10",
-        "@webassemblyjs/wast-parser": "1.5.10",
-        "long": "^3.2.0"
-      }
-    },
-    "acorn": {
-      "version": "5.6.2",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-5.6.2.tgz",
-      "integrity": "sha512-zUzo1E5dI2Ey8+82egfnttyMlMZ2y0D8xOCO3PNPPlYXpl8NZvF6Qk9L9BEtJs+43FqEmfBViDqc5d1ckRDguw==",
-      "dev": true
-    },
-    "acorn-dynamic-import": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/acorn-dynamic-import/-/acorn-dynamic-import-3.0.0.tgz",
-      "integrity": "sha512-zVWV8Z8lislJoOKKqdNMOB+s6+XV5WERty8MnKBeFgwA+19XJjJHs2RP5dzM57FftIs+jQnRToLiWazKr6sSWg==",
-      "dev": true,
-      "requires": {
-        "acorn": "^5.0.0"
-      }
-    },
-    "acorn-jsx": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-3.0.1.tgz",
-      "integrity": "sha1-r9+UiPsezvyDSPb7IvRk4ypYs2s=",
-      "dev": true,
-      "requires": {
-        "acorn": "^3.0.4"
-      },
-      "dependencies": {
-        "acorn": {
-          "version": "3.3.0",
-          "resolved": "https://registry.npmjs.org/acorn/-/acorn-3.3.0.tgz",
-          "integrity": "sha1-ReN/s56No/JbruP/U2niu18iAXo=",
-          "dev": true
-        }
-      }
-    },
-    "ajv": {
-      "version": "6.5.0",
-      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.5.0.tgz",
-      "integrity": "sha512-VDUX1oSajablmiyFyED9L1DFndg0P9h7p1F+NO8FkIzei6EPrR6Zu1n18rd5P8PqaSRd/FrWv3G1TVBqpM83gA==",
-      "dev": true,
-      "requires": {
-        "fast-deep-equal": "^2.0.1",
-        "fast-json-stable-stringify": "^2.0.0",
-        "json-schema-traverse": "^0.3.0",
-        "uri-js": "^4.2.1"
-      }
-    },
-    "ajv-keywords": {
-      "version": "3.2.0",
-      "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.2.0.tgz",
-      "integrity": "sha1-6GuBnGAs+IIa1jdBNpjx3sAhhHo=",
-      "dev": true
-    },
-    "ansi-escapes": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-3.1.0.tgz",
-      "integrity": "sha512-UgAb8H9D41AQnu/PbWlCofQVcnV4Gs2bBJi9eZPxfU/hgglFh3SMDMENRIqdr7H6XFnXdoknctFByVsCOotTVw==",
-      "dev": true
-    },
-    "ansi-regex": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz",
-      "integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=",
-      "dev": true
-    },
-    "ansi-styles": {
-      "version": "3.2.1",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
-      "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
-      "dev": true,
-      "requires": {
-        "color-convert": "^1.9.0"
-      }
-    },
-    "any-observable": {
-      "version": "0.3.0",
-      "resolved": "https://registry.npmjs.org/any-observable/-/any-observable-0.3.0.tgz",
-      "integrity": "sha512-/FQM1EDkTsf63Ub2C6O7GuYFDsSXUwsaZDurV0np41ocwq0jthUAYCmhBX9f+KwlaCgIuWyr/4WlUQUBfKfZog==",
-      "dev": true
-    },
-    "anymatch": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-2.0.0.tgz",
-      "integrity": "sha512-5teOsQWABXHHBFP9y3skS5P3d/WfWXpv3FUpy+LorMrNYaT9pI4oLMQX7jzQ2KklNpGpWHzdCXTDT2Y3XGlZBw==",
-      "dev": true,
-      "requires": {
-        "micromatch": "^3.1.4",
-        "normalize-path": "^2.1.1"
-      }
-    },
-    "aproba": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/aproba/-/aproba-1.2.0.tgz",
-      "integrity": "sha512-Y9J6ZjXtoYh8RnXVCMOU/ttDmk1aBjunq9vO0ta5x85WDQiQfUF9sIPBITdbiiIVcBo03Hi3jMxigBtsddlXRw==",
-      "dev": true
-    },
-    "argparse": {
-      "version": "1.0.10",
-      "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz",
-      "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==",
-      "dev": true,
-      "requires": {
-        "sprintf-js": "~1.0.2"
-      }
-    },
-    "arr-diff": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/arr-diff/-/arr-diff-4.0.0.tgz",
-      "integrity": "sha1-1kYQdP6/7HHn4VI1dhoyml3HxSA=",
-      "dev": true
-    },
-    "arr-flatten": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/arr-flatten/-/arr-flatten-1.1.0.tgz",
-      "integrity": "sha512-L3hKV5R/p5o81R7O02IGnwpDmkp6E982XhtbuwSe3O4qOtMMMtodicASA1Cny2U+aCXcNpml+m4dPsvsJ3jatg==",
-      "dev": true
-    },
-    "arr-union": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/arr-union/-/arr-union-3.1.0.tgz",
-      "integrity": "sha1-45sJrqne+Gao8gbiiK9jkZuuOcQ=",
-      "dev": true
-    },
-    "array-differ": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/array-differ/-/array-differ-1.0.0.tgz",
-      "integrity": "sha1-7/UuN1gknTO+QCuLuOVkuytdQDE=",
-      "dev": true
-    },
-    "array-union": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/array-union/-/array-union-1.0.2.tgz",
-      "integrity": "sha1-mjRBDk9OPaI96jdb5b5w8kd47Dk=",
-      "dev": true,
-      "requires": {
-        "array-uniq": "^1.0.1"
-      }
-    },
-    "array-uniq": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/array-uniq/-/array-uniq-1.0.3.tgz",
-      "integrity": "sha1-r2rId6Jcx/dOBYiUdThY39sk/bY=",
-      "dev": true
-    },
-    "array-unique": {
-      "version": "0.3.2",
-      "resolved": "https://registry.npmjs.org/array-unique/-/array-unique-0.3.2.tgz",
-      "integrity": "sha1-qJS3XUvE9s1nnvMkSp/Y9Gri1Cg=",
-      "dev": true
-    },
-    "arrify": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/arrify/-/arrify-1.0.1.tgz",
-      "integrity": "sha1-iYUI2iIm84DfkEcoRWhJwVAaSw0=",
-      "dev": true
-    },
-    "asn1.js": {
-      "version": "4.10.1",
-      "resolved": "https://registry.npmjs.org/asn1.js/-/asn1.js-4.10.1.tgz",
-      "integrity": "sha512-p32cOF5q0Zqs9uBiONKYLm6BClCoBCM5O9JfeUSlnQLBTxYdTK+pW+nXflm8UkKd2UYlEbYz5qEi0JuZR9ckSw==",
-      "dev": true,
-      "requires": {
-        "bn.js": "^4.0.0",
-        "inherits": "^2.0.1",
-        "minimalistic-assert": "^1.0.0"
-      }
-    },
-    "assert": {
-      "version": "1.4.1",
-      "resolved": "https://registry.npmjs.org/assert/-/assert-1.4.1.tgz",
-      "integrity": "sha1-mZEtWRg2tab1s0XA8H7vwI/GXZE=",
-      "dev": true,
-      "requires": {
-        "util": "0.10.3"
-      },
-      "dependencies": {
-        "inherits": {
-          "version": "2.0.1",
-          "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.1.tgz",
-          "integrity": "sha1-sX0I0ya0Qj5Wjv9xn5GwscvfafE=",
-          "dev": true
-        },
-        "util": {
-          "version": "0.10.3",
-          "resolved": "https://registry.npmjs.org/util/-/util-0.10.3.tgz",
-          "integrity": "sha1-evsa/lCAUkZInj23/g7TeTNqwPk=",
-          "dev": true,
-          "requires": {
-            "inherits": "2.0.1"
-          }
-        }
-      }
-    },
-    "assign-symbols": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/assign-symbols/-/assign-symbols-1.0.0.tgz",
-      "integrity": "sha1-WWZ/QfrdTyDMvCu5a41Pf3jsA2c=",
-      "dev": true
-    },
-    "ast-types": {
-      "version": "0.11.5",
-      "resolved": "https://registry.npmjs.org/ast-types/-/ast-types-0.11.5.tgz",
-      "integrity": "sha512-oJjo+5e7/vEc2FBK8gUalV0pba4L3VdBIs2EKhOLHLcOd2FgQIVQN9xb0eZ9IjEWyAL7vq6fGJxOvVvdCHNyMw==",
-      "dev": true
-    },
-    "async": {
-      "version": "1.5.2",
-      "resolved": "https://registry.npmjs.org/async/-/async-1.5.2.tgz",
-      "integrity": "sha1-7GphrlZIDAw8skHJVhjiCJL5Zyo=",
-      "dev": true
-    },
-    "async-each": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/async-each/-/async-each-1.0.1.tgz",
-      "integrity": "sha1-GdOGodntxufByF04iu28xW0zYC0=",
-      "dev": true
-    },
-    "atob": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/atob/-/atob-2.1.1.tgz",
-      "integrity": "sha1-ri1acpR38onWDdf5amMUoi3Wwio=",
-      "dev": true
-    },
-    "babel-code-frame": {
-      "version": "6.26.0",
-      "resolved": "https://registry.npmjs.org/babel-code-frame/-/babel-code-frame-6.26.0.tgz",
-      "integrity": "sha1-Y/1D99weO7fONZR9uP42mj9Yx0s=",
-      "dev": true,
-      "requires": {
-        "chalk": "^1.1.3",
-        "esutils": "^2.0.2",
-        "js-tokens": "^3.0.2"
-      },
-      "dependencies": {
-        "ansi-regex": {
-          "version": "2.1.1",
-          "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz",
-          "integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8=",
-          "dev": true
-        },
-        "ansi-styles": {
-          "version": "2.2.1",
-          "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-2.2.1.tgz",
-          "integrity": "sha1-tDLdM1i2NM914eRmQ2gkBTPB3b4=",
-          "dev": true
-        },
-        "chalk": {
-          "version": "1.1.3",
-          "resolved": "https://registry.npmjs.org/chalk/-/chalk-1.1.3.tgz",
-          "integrity": "sha1-qBFcVeSnAv5NFQq9OHKCKn4J/Jg=",
-          "dev": true,
-          "requires": {
-            "ansi-styles": "^2.2.1",
-            "escape-string-regexp": "^1.0.2",
-            "has-ansi": "^2.0.0",
-            "strip-ansi": "^3.0.0",
-            "supports-color": "^2.0.0"
-          }
-        },
-        "strip-ansi": {
-          "version": "3.0.1",
-          "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz",
-          "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=",
-          "dev": true,
-          "requires": {
-            "ansi-regex": "^2.0.0"
-          }
-        },
-        "supports-color": {
-          "version": "2.0.0",
-          "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-2.0.0.tgz",
-          "integrity": "sha1-U10EXOa2Nj+kARcIRimZXp3zJMc=",
-          "dev": true
-        }
-      }
-    },
-    "babel-core": {
-      "version": "6.26.3",
-      "resolved": "https://registry.npmjs.org/babel-core/-/babel-core-6.26.3.tgz",
-      "integrity": "sha512-6jyFLuDmeidKmUEb3NM+/yawG0M2bDZ9Z1qbZP59cyHLz8kYGKYwpJP0UwUKKUiTRNvxfLesJnTedqczP7cTDA==",
-      "dev": true,
-      "requires": {
-        "babel-code-frame": "^6.26.0",
-        "babel-generator": "^6.26.0",
-        "babel-helpers": "^6.24.1",
-        "babel-messages": "^6.23.0",
-        "babel-register": "^6.26.0",
-        "babel-runtime": "^6.26.0",
-        "babel-template": "^6.26.0",
-        "babel-traverse": "^6.26.0",
-        "babel-types": "^6.26.0",
-        "babylon": "^6.18.0",
-        "convert-source-map": "^1.5.1",
-        "debug": "^2.6.9",
-        "json5": "^0.5.1",
-        "lodash": "^4.17.4",
-        "minimatch": "^3.0.4",
-        "path-is-absolute": "^1.0.1",
-        "private": "^0.1.8",
-        "slash": "^1.0.0",
-        "source-map": "^0.5.7"
-      },
-      "dependencies": {
-        "babylon": {
-          "version": "6.18.0",
-          "resolved": "https://registry.npmjs.org/babylon/-/babylon-6.18.0.tgz",
-          "integrity": "sha512-q/UEjfGJ2Cm3oKV71DJz9d25TPnq5rhBVL2Q4fA5wcC3jcrdn7+SssEybFIxwAvvP+YCsCYNKughoF33GxgycQ==",
-          "dev": true
-        }
-      }
-    },
-    "babel-generator": {
-      "version": "6.26.1",
-      "resolved": "https://registry.npmjs.org/babel-generator/-/babel-generator-6.26.1.tgz",
-      "integrity": "sha512-HyfwY6ApZj7BYTcJURpM5tznulaBvyio7/0d4zFOeMPUmfxkCjHocCuoLa2SAGzBI8AREcH3eP3758F672DppA==",
-      "dev": true,
-      "requires": {
-        "babel-messages": "^6.23.0",
-        "babel-runtime": "^6.26.0",
-        "babel-types": "^6.26.0",
-        "detect-indent": "^4.0.0",
-        "jsesc": "^1.3.0",
-        "lodash": "^4.17.4",
-        "source-map": "^0.5.7",
-        "trim-right": "^1.0.1"
-      },
-      "dependencies": {
-        "jsesc": {
-          "version": "1.3.0",
-          "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-1.3.0.tgz",
-          "integrity": "sha1-RsP+yMGJKxKwgz25vHYiF226s0s=",
-          "dev": true
-        }
-      }
-    },
-    "babel-helper-bindify-decorators": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-helper-bindify-decorators/-/babel-helper-bindify-decorators-6.24.1.tgz",
-      "integrity": "sha1-FMGeXxQte0fxmlJDHlKxzLxAozA=",
-      "dev": true,
-      "requires": {
-        "babel-runtime": "^6.22.0",
-        "babel-traverse": "^6.24.1",
-        "babel-types": "^6.24.1"
-      }
-    },
-    "babel-helper-builder-binary-assignment-operator-visitor": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-helper-builder-binary-assignment-operator-visitor/-/babel-helper-builder-binary-assignment-operator-visitor-6.24.1.tgz",
-      "integrity": "sha1-zORReto1b0IgvK6KAsKzRvmlZmQ=",
-      "dev": true,
-      "requires": {
-        "babel-helper-explode-assignable-expression": "^6.24.1",
-        "babel-runtime": "^6.22.0",
-        "babel-types": "^6.24.1"
-      }
-    },
-    "babel-helper-call-delegate": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-helper-call-delegate/-/babel-helper-call-delegate-6.24.1.tgz",
-      "integrity": "sha1-7Oaqzdx25Bw0YfiL/Fdb0Nqi340=",
-      "dev": true,
-      "requires": {
-        "babel-helper-hoist-variables": "^6.24.1",
-        "babel-runtime": "^6.22.0",
-        "babel-traverse": "^6.24.1",
-        "babel-types": "^6.24.1"
-      }
-    },
-    "babel-helper-define-map": {
-      "version": "6.26.0",
-      "resolved": "https://registry.npmjs.org/babel-helper-define-map/-/babel-helper-define-map-6.26.0.tgz",
-      "integrity": "sha1-pfVtq0GiX5fstJjH66ypgZ+Vvl8=",
-      "dev": true,
-      "requires": {
-        "babel-helper-function-name": "^6.24.1",
-        "babel-runtime": "^6.26.0",
-        "babel-types": "^6.26.0",
-        "lodash": "^4.17.4"
-      }
-    },
-    "babel-helper-explode-assignable-expression": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-helper-explode-assignable-expression/-/babel-helper-explode-assignable-expression-6.24.1.tgz",
-      "integrity": "sha1-8luCz33BBDPFX3BZLVdGQArCLKo=",
-      "dev": true,
-      "requires": {
-        "babel-runtime": "^6.22.0",
-        "babel-traverse": "^6.24.1",
-        "babel-types": "^6.24.1"
-      }
-    },
-    "babel-helper-explode-class": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-helper-explode-class/-/babel-helper-explode-class-6.24.1.tgz",
-      "integrity": "sha1-fcKjkQ3uAHBW4eMdZAztPVTqqes=",
-      "dev": true,
-      "requires": {
-        "babel-helper-bindify-decorators": "^6.24.1",
-        "babel-runtime": "^6.22.0",
-        "babel-traverse": "^6.24.1",
-        "babel-types": "^6.24.1"
-      }
-    },
-    "babel-helper-function-name": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-helper-function-name/-/babel-helper-function-name-6.24.1.tgz",
-      "integrity": "sha1-00dbjAPtmCQqJbSDUasYOZ01gKk=",
-      "dev": true,
-      "requires": {
-        "babel-helper-get-function-arity": "^6.24.1",
-        "babel-runtime": "^6.22.0",
-        "babel-template": "^6.24.1",
-        "babel-traverse": "^6.24.1",
-        "babel-types": "^6.24.1"
-      }
-    },
-    "babel-helper-get-function-arity": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-helper-get-function-arity/-/babel-helper-get-function-arity-6.24.1.tgz",
-      "integrity": "sha1-j3eCqpNAfEHTqlCQj4mwMbG2hT0=",
-      "dev": true,
-      "requires": {
-        "babel-runtime": "^6.22.0",
-        "babel-types": "^6.24.1"
-      }
-    },
-    "babel-helper-hoist-variables": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-helper-hoist-variables/-/babel-helper-hoist-variables-6.24.1.tgz",
-      "integrity": "sha1-HssnaJydJVE+rbyZFKc/VAi+enY=",
-      "dev": true,
-      "requires": {
-        "babel-runtime": "^6.22.0",
-        "babel-types": "^6.24.1"
-      }
-    },
-    "babel-helper-optimise-call-expression": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-helper-optimise-call-expression/-/babel-helper-optimise-call-expression-6.24.1.tgz",
-      "integrity": "sha1-96E0J7qfc/j0+pk8VKl4gtEkQlc=",
-      "dev": true,
-      "requires": {
-        "babel-runtime": "^6.22.0",
-        "babel-types": "^6.24.1"
-      }
-    },
-    "babel-helper-regex": {
-      "version": "6.26.0",
-      "resolved": "https://registry.npmjs.org/babel-helper-regex/-/babel-helper-regex-6.26.0.tgz",
-      "integrity": "sha1-MlxZ+QL4LyS3T6zu0DY5VPZJXnI=",
-      "dev": true,
-      "requires": {
-        "babel-runtime": "^6.26.0",
-        "babel-types": "^6.26.0",
-        "lodash": "^4.17.4"
-      }
-    },
-    "babel-helper-remap-async-to-generator": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-helper-remap-async-to-generator/-/babel-helper-remap-async-to-generator-6.24.1.tgz",
-      "integrity": "sha1-XsWBgnrXI/7N04HxySg5BnbkVRs=",
-      "dev": true,
-      "requires": {
-        "babel-helper-function-name": "^6.24.1",
-        "babel-runtime": "^6.22.0",
-        "babel-template": "^6.24.1",
-        "babel-traverse": "^6.24.1",
-        "babel-types": "^6.24.1"
-      }
-    },
-    "babel-helper-replace-supers": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-helper-replace-supers/-/babel-helper-replace-supers-6.24.1.tgz",
-      "integrity": "sha1-v22/5Dk40XNpohPKiov3S2qQqxo=",
-      "dev": true,
-      "requires": {
-        "babel-helper-optimise-call-expression": "^6.24.1",
-        "babel-messages": "^6.23.0",
-        "babel-runtime": "^6.22.0",
-        "babel-template": "^6.24.1",
-        "babel-traverse": "^6.24.1",
-        "babel-types": "^6.24.1"
-      }
-    },
-    "babel-helpers": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-helpers/-/babel-helpers-6.24.1.tgz",
-      "integrity": "sha1-NHHenK7DiOXIUOWX5Yom3fN2ArI=",
-      "dev": true,
-      "requires": {
-        "babel-runtime": "^6.22.0",
-        "babel-template": "^6.24.1"
-      }
-    },
-    "babel-messages": {
-      "version": "6.23.0",
-      "resolved": "https://registry.npmjs.org/babel-messages/-/babel-messages-6.23.0.tgz",
-      "integrity": "sha1-8830cDhYA1sqKVHG7F7fbGLyYw4=",
-      "dev": true,
-      "requires": {
-        "babel-runtime": "^6.22.0"
-      }
-    },
-    "babel-plugin-check-es2015-constants": {
-      "version": "6.22.0",
-      "resolved": "https://registry.npmjs.org/babel-plugin-check-es2015-constants/-/babel-plugin-check-es2015-constants-6.22.0.tgz",
-      "integrity": "sha1-NRV7EBQm/S/9PaP3XH0ekYNbv4o=",
-      "dev": true,
-      "requires": {
-        "babel-runtime": "^6.22.0"
-      }
-    },
-    "babel-plugin-syntax-async-functions": {
-      "version": "6.13.0",
-      "resolved": "https://registry.npmjs.org/babel-plugin-syntax-async-functions/-/babel-plugin-syntax-async-functions-6.13.0.tgz",
-      "integrity": "sha1-ytnK0RkbWtY0vzCuCHI5HgZHvpU=",
-      "dev": true
-    },
-    "babel-plugin-syntax-async-generators": {
-      "version": "6.13.0",
-      "resolved": "https://registry.npmjs.org/babel-plugin-syntax-async-generators/-/babel-plugin-syntax-async-generators-6.13.0.tgz",
-      "integrity": "sha1-a8lj67FuzLrmuStZbrfzXDQqi5o=",
-      "dev": true
-    },
-    "babel-plugin-syntax-class-constructor-call": {
-      "version": "6.18.0",
-      "resolved": "https://registry.npmjs.org/babel-plugin-syntax-class-constructor-call/-/babel-plugin-syntax-class-constructor-call-6.18.0.tgz",
-      "integrity": "sha1-nLnTn+Q8hgC+yBRkVt3L1OGnZBY=",
-      "dev": true
-    },
-    "babel-plugin-syntax-class-properties": {
-      "version": "6.13.0",
-      "resolved": "https://registry.npmjs.org/babel-plugin-syntax-class-properties/-/babel-plugin-syntax-class-properties-6.13.0.tgz",
-      "integrity": "sha1-1+sjt5oxf4VDlixQW4J8fWysJ94=",
-      "dev": true
-    },
-    "babel-plugin-syntax-decorators": {
-      "version": "6.13.0",
-      "resolved": "https://registry.npmjs.org/babel-plugin-syntax-decorators/-/babel-plugin-syntax-decorators-6.13.0.tgz",
-      "integrity": "sha1-MSVjtNvePMgGzuPkFszurd0RrAs=",
-      "dev": true
-    },
-    "babel-plugin-syntax-dynamic-import": {
-      "version": "6.18.0",
-      "resolved": "https://registry.npmjs.org/babel-plugin-syntax-dynamic-import/-/babel-plugin-syntax-dynamic-import-6.18.0.tgz",
-      "integrity": "sha1-jWomIpyDdFqZgqRBBRVyyqF5sdo=",
-      "dev": true
-    },
-    "babel-plugin-syntax-exponentiation-operator": {
-      "version": "6.13.0",
-      "resolved": "https://registry.npmjs.org/babel-plugin-syntax-exponentiation-operator/-/babel-plugin-syntax-exponentiation-operator-6.13.0.tgz",
-      "integrity": "sha1-nufoM3KQ2pUoggGmpX9BcDF4MN4=",
-      "dev": true
-    },
-    "babel-plugin-syntax-export-extensions": {
-      "version": "6.13.0",
-      "resolved": "https://registry.npmjs.org/babel-plugin-syntax-export-extensions/-/babel-plugin-syntax-export-extensions-6.13.0.tgz",
-      "integrity": "sha1-cKFITw+QiaToStRLrDU8lbmxJyE=",
-      "dev": true
-    },
-    "babel-plugin-syntax-flow": {
-      "version": "6.18.0",
-      "resolved": "https://registry.npmjs.org/babel-plugin-syntax-flow/-/babel-plugin-syntax-flow-6.18.0.tgz",
-      "integrity": "sha1-TDqyCiryaqIM0lmVw5jE63AxDI0=",
-      "dev": true
-    },
-    "babel-plugin-syntax-object-rest-spread": {
-      "version": "6.13.0",
-      "resolved": "https://registry.npmjs.org/babel-plugin-syntax-object-rest-spread/-/babel-plugin-syntax-object-rest-spread-6.13.0.tgz",
-      "integrity": "sha1-/WU28rzhODb/o6VFjEkDpZe7O/U=",
-      "dev": true
-    },
-    "babel-plugin-syntax-trailing-function-commas": {
-      "version": "6.22.0",
-      "resolved": "https://registry.npmjs.org/babel-plugin-syntax-trailing-function-commas/-/babel-plugin-syntax-trailing-function-commas-6.22.0.tgz",
-      "integrity": "sha1-ugNgk3+NBuQBgKQ/4NVhb/9TLPM=",
-      "dev": true
-    },
-    "babel-plugin-transform-async-generator-functions": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-async-generator-functions/-/babel-plugin-transform-async-generator-functions-6.24.1.tgz",
-      "integrity": "sha1-8FiQAUX9PpkHpt3yjaWfIVJYpds=",
-      "dev": true,
-      "requires": {
-        "babel-helper-remap-async-to-generator": "^6.24.1",
-        "babel-plugin-syntax-async-generators": "^6.5.0",
-        "babel-runtime": "^6.22.0"
-      }
-    },
-    "babel-plugin-transform-async-to-generator": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-async-to-generator/-/babel-plugin-transform-async-to-generator-6.24.1.tgz",
-      "integrity": "sha1-ZTbjeK/2yx1VF6wOQOs+n8jQh2E=",
-      "dev": true,
-      "requires": {
-        "babel-helper-remap-async-to-generator": "^6.24.1",
-        "babel-plugin-syntax-async-functions": "^6.8.0",
-        "babel-runtime": "^6.22.0"
-      }
-    },
-    "babel-plugin-transform-class-constructor-call": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-class-constructor-call/-/babel-plugin-transform-class-constructor-call-6.24.1.tgz",
-      "integrity": "sha1-gNwoVQWsBn3LjWxl4vbxGrd2Xvk=",
-      "dev": true,
-      "requires": {
-        "babel-plugin-syntax-class-constructor-call": "^6.18.0",
-        "babel-runtime": "^6.22.0",
-        "babel-template": "^6.24.1"
-      }
-    },
-    "babel-plugin-transform-class-properties": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-class-properties/-/babel-plugin-transform-class-properties-6.24.1.tgz",
-      "integrity": "sha1-anl2PqYdM9NvN7YRqp3vgagbRqw=",
-      "dev": true,
-      "requires": {
-        "babel-helper-function-name": "^6.24.1",
-        "babel-plugin-syntax-class-properties": "^6.8.0",
-        "babel-runtime": "^6.22.0",
-        "babel-template": "^6.24.1"
-      }
-    },
-    "babel-plugin-transform-decorators": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-decorators/-/babel-plugin-transform-decorators-6.24.1.tgz",
-      "integrity": "sha1-eIAT2PjGtSIr33s0Q5Df13Vp4k0=",
-      "dev": true,
-      "requires": {
-        "babel-helper-explode-class": "^6.24.1",
-        "babel-plugin-syntax-decorators": "^6.13.0",
-        "babel-runtime": "^6.22.0",
-        "babel-template": "^6.24.1",
-        "babel-types": "^6.24.1"
-      }
-    },
-    "babel-plugin-transform-es2015-arrow-functions": {
-      "version": "6.22.0",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-arrow-functions/-/babel-plugin-transform-es2015-arrow-functions-6.22.0.tgz",
-      "integrity": "sha1-RSaSy3EdX3ncf4XkQM5BufJE0iE=",
-      "dev": true,
-      "requires": {
-        "babel-runtime": "^6.22.0"
-      }
-    },
-    "babel-plugin-transform-es2015-block-scoped-functions": {
-      "version": "6.22.0",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-block-scoped-functions/-/babel-plugin-transform-es2015-block-scoped-functions-6.22.0.tgz",
-      "integrity": "sha1-u8UbSflk1wy42OC5ToICRs46YUE=",
-      "dev": true,
-      "requires": {
-        "babel-runtime": "^6.22.0"
-      }
-    },
-    "babel-plugin-transform-es2015-block-scoping": {
-      "version": "6.26.0",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-block-scoping/-/babel-plugin-transform-es2015-block-scoping-6.26.0.tgz",
-      "integrity": "sha1-1w9SmcEwjQXBL0Y4E7CgnnOxiV8=",
-      "dev": true,
-      "requires": {
-        "babel-runtime": "^6.26.0",
-        "babel-template": "^6.26.0",
-        "babel-traverse": "^6.26.0",
-        "babel-types": "^6.26.0",
-        "lodash": "^4.17.4"
-      }
-    },
-    "babel-plugin-transform-es2015-classes": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-classes/-/babel-plugin-transform-es2015-classes-6.24.1.tgz",
-      "integrity": "sha1-WkxYpQyclGHlZLSyo7+ryXolhNs=",
-      "dev": true,
-      "requires": {
-        "babel-helper-define-map": "^6.24.1",
-        "babel-helper-function-name": "^6.24.1",
-        "babel-helper-optimise-call-expression": "^6.24.1",
-        "babel-helper-replace-supers": "^6.24.1",
-        "babel-messages": "^6.23.0",
-        "babel-runtime": "^6.22.0",
-        "babel-template": "^6.24.1",
-        "babel-traverse": "^6.24.1",
-        "babel-types": "^6.24.1"
-      }
-    },
-    "babel-plugin-transform-es2015-computed-properties": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-computed-properties/-/babel-plugin-transform-es2015-computed-properties-6.24.1.tgz",
-      "integrity": "sha1-b+Ko0WiV1WNPTNmZttNICjCBWbM=",
-      "dev": true,
-      "requires": {
-        "babel-runtime": "^6.22.0",
-        "babel-template": "^6.24.1"
-      }
-    },
-    "babel-plugin-transform-es2015-destructuring": {
-      "version": "6.23.0",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-destructuring/-/babel-plugin-transform-es2015-destructuring-6.23.0.tgz",
-      "integrity": "sha1-mXux8auWf2gtKwh2/jWNYOdlxW0=",
-      "dev": true,
-      "requires": {
-        "babel-runtime": "^6.22.0"
-      }
-    },
-    "babel-plugin-transform-es2015-duplicate-keys": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-duplicate-keys/-/babel-plugin-transform-es2015-duplicate-keys-6.24.1.tgz",
-      "integrity": "sha1-c+s9MQypaePvnskcU3QabxV2Qj4=",
-      "dev": true,
-      "requires": {
-        "babel-runtime": "^6.22.0",
-        "babel-types": "^6.24.1"
-      }
-    },
-    "babel-plugin-transform-es2015-for-of": {
-      "version": "6.23.0",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-for-of/-/babel-plugin-transform-es2015-for-of-6.23.0.tgz",
-      "integrity": "sha1-9HyVsrYT3x0+zC/bdXNiPHUkhpE=",
-      "dev": true,
-      "requires": {
-        "babel-runtime": "^6.22.0"
-      }
-    },
-    "babel-plugin-transform-es2015-function-name": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-function-name/-/babel-plugin-transform-es2015-function-name-6.24.1.tgz",
-      "integrity": "sha1-g0yJhTvDaxrw86TF26qU/Y6sqos=",
-      "dev": true,
-      "requires": {
-        "babel-helper-function-name": "^6.24.1",
-        "babel-runtime": "^6.22.0",
-        "babel-types": "^6.24.1"
-      }
-    },
-    "babel-plugin-transform-es2015-literals": {
-      "version": "6.22.0",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-literals/-/babel-plugin-transform-es2015-literals-6.22.0.tgz",
-      "integrity": "sha1-T1SgLWzWbPkVKAAZox0xklN3yi4=",
-      "dev": true,
-      "requires": {
-        "babel-runtime": "^6.22.0"
-      }
-    },
-    "babel-plugin-transform-es2015-modules-amd": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-modules-amd/-/babel-plugin-transform-es2015-modules-amd-6.24.1.tgz",
-      "integrity": "sha1-Oz5UAXI5hC1tGcMBHEvS8AoA0VQ=",
-      "dev": true,
-      "requires": {
-        "babel-plugin-transform-es2015-modules-commonjs": "^6.24.1",
-        "babel-runtime": "^6.22.0",
-        "babel-template": "^6.24.1"
-      }
-    },
-    "babel-plugin-transform-es2015-modules-commonjs": {
-      "version": "6.26.2",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-modules-commonjs/-/babel-plugin-transform-es2015-modules-commonjs-6.26.2.tgz",
-      "integrity": "sha512-CV9ROOHEdrjcwhIaJNBGMBCodN+1cfkwtM1SbUHmvyy35KGT7fohbpOxkE2uLz1o6odKK2Ck/tz47z+VqQfi9Q==",
-      "dev": true,
-      "requires": {
-        "babel-plugin-transform-strict-mode": "^6.24.1",
-        "babel-runtime": "^6.26.0",
-        "babel-template": "^6.26.0",
-        "babel-types": "^6.26.0"
-      }
-    },
-    "babel-plugin-transform-es2015-modules-systemjs": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-modules-systemjs/-/babel-plugin-transform-es2015-modules-systemjs-6.24.1.tgz",
-      "integrity": "sha1-/4mhQrkRmpBhlfXxBuzzBdlAfSM=",
-      "dev": true,
-      "requires": {
-        "babel-helper-hoist-variables": "^6.24.1",
-        "babel-runtime": "^6.22.0",
-        "babel-template": "^6.24.1"
-      }
-    },
-    "babel-plugin-transform-es2015-modules-umd": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-modules-umd/-/babel-plugin-transform-es2015-modules-umd-6.24.1.tgz",
-      "integrity": "sha1-rJl+YoXNGO1hdq22B9YCNErThGg=",
-      "dev": true,
-      "requires": {
-        "babel-plugin-transform-es2015-modules-amd": "^6.24.1",
-        "babel-runtime": "^6.22.0",
-        "babel-template": "^6.24.1"
-      }
-    },
-    "babel-plugin-transform-es2015-object-super": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-object-super/-/babel-plugin-transform-es2015-object-super-6.24.1.tgz",
-      "integrity": "sha1-JM72muIcuDp/hgPa0CH1cusnj40=",
-      "dev": true,
-      "requires": {
-        "babel-helper-replace-supers": "^6.24.1",
-        "babel-runtime": "^6.22.0"
-      }
-    },
-    "babel-plugin-transform-es2015-parameters": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-parameters/-/babel-plugin-transform-es2015-parameters-6.24.1.tgz",
-      "integrity": "sha1-V6w1GrScrxSpfNE7CfZv3wpiXys=",
-      "dev": true,
-      "requires": {
-        "babel-helper-call-delegate": "^6.24.1",
-        "babel-helper-get-function-arity": "^6.24.1",
-        "babel-runtime": "^6.22.0",
-        "babel-template": "^6.24.1",
-        "babel-traverse": "^6.24.1",
-        "babel-types": "^6.24.1"
-      }
-    },
-    "babel-plugin-transform-es2015-shorthand-properties": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-shorthand-properties/-/babel-plugin-transform-es2015-shorthand-properties-6.24.1.tgz",
-      "integrity": "sha1-JPh11nIch2YbvZmkYi5R8U3jiqA=",
-      "dev": true,
-      "requires": {
-        "babel-runtime": "^6.22.0",
-        "babel-types": "^6.24.1"
-      }
-    },
-    "babel-plugin-transform-es2015-spread": {
-      "version": "6.22.0",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-spread/-/babel-plugin-transform-es2015-spread-6.22.0.tgz",
-      "integrity": "sha1-1taKmfia7cRTbIGlQujdnxdG+NE=",
-      "dev": true,
-      "requires": {
-        "babel-runtime": "^6.22.0"
-      }
-    },
-    "babel-plugin-transform-es2015-sticky-regex": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-sticky-regex/-/babel-plugin-transform-es2015-sticky-regex-6.24.1.tgz",
-      "integrity": "sha1-AMHNsaynERLN8M9hJsLta0V8zbw=",
-      "dev": true,
-      "requires": {
-        "babel-helper-regex": "^6.24.1",
-        "babel-runtime": "^6.22.0",
-        "babel-types": "^6.24.1"
-      }
-    },
-    "babel-plugin-transform-es2015-template-literals": {
-      "version": "6.22.0",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-template-literals/-/babel-plugin-transform-es2015-template-literals-6.22.0.tgz",
-      "integrity": "sha1-qEs0UPfp+PH2g51taH2oS7EjbY0=",
-      "dev": true,
-      "requires": {
-        "babel-runtime": "^6.22.0"
-      }
-    },
-    "babel-plugin-transform-es2015-typeof-symbol": {
-      "version": "6.23.0",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-typeof-symbol/-/babel-plugin-transform-es2015-typeof-symbol-6.23.0.tgz",
-      "integrity": "sha1-3sCfHN3/lLUqxz1QXITfWdzOs3I=",
-      "dev": true,
-      "requires": {
-        "babel-runtime": "^6.22.0"
-      }
-    },
-    "babel-plugin-transform-es2015-unicode-regex": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-unicode-regex/-/babel-plugin-transform-es2015-unicode-regex-6.24.1.tgz",
-      "integrity": "sha1-04sS9C6nMj9yk4fxinxa4frrNek=",
-      "dev": true,
-      "requires": {
-        "babel-helper-regex": "^6.24.1",
-        "babel-runtime": "^6.22.0",
-        "regexpu-core": "^2.0.0"
-      }
-    },
-    "babel-plugin-transform-exponentiation-operator": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-exponentiation-operator/-/babel-plugin-transform-exponentiation-operator-6.24.1.tgz",
-      "integrity": "sha1-KrDJx/MJj6SJB3cruBP+QejeOg4=",
-      "dev": true,
-      "requires": {
-        "babel-helper-builder-binary-assignment-operator-visitor": "^6.24.1",
-        "babel-plugin-syntax-exponentiation-operator": "^6.8.0",
-        "babel-runtime": "^6.22.0"
-      }
-    },
-    "babel-plugin-transform-export-extensions": {
-      "version": "6.22.0",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-export-extensions/-/babel-plugin-transform-export-extensions-6.22.0.tgz",
-      "integrity": "sha1-U3OLR+deghhYnuqUbLvTkQm75lM=",
-      "dev": true,
-      "requires": {
-        "babel-plugin-syntax-export-extensions": "^6.8.0",
-        "babel-runtime": "^6.22.0"
-      }
-    },
-    "babel-plugin-transform-flow-strip-types": {
-      "version": "6.22.0",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-flow-strip-types/-/babel-plugin-transform-flow-strip-types-6.22.0.tgz",
-      "integrity": "sha1-hMtnKTXUNxT9wyvOhFaNh0Qc988=",
-      "dev": true,
-      "requires": {
-        "babel-plugin-syntax-flow": "^6.18.0",
-        "babel-runtime": "^6.22.0"
-      }
-    },
-    "babel-plugin-transform-object-rest-spread": {
-      "version": "6.26.0",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-object-rest-spread/-/babel-plugin-transform-object-rest-spread-6.26.0.tgz",
-      "integrity": "sha1-DzZpLVD+9rfi1LOsFHgTepY7ewY=",
-      "dev": true,
-      "requires": {
-        "babel-plugin-syntax-object-rest-spread": "^6.8.0",
-        "babel-runtime": "^6.26.0"
-      }
-    },
-    "babel-plugin-transform-regenerator": {
-      "version": "6.26.0",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-regenerator/-/babel-plugin-transform-regenerator-6.26.0.tgz",
-      "integrity": "sha1-4HA2lvveJ/Cj78rPi03KL3s6jy8=",
-      "dev": true,
-      "requires": {
-        "regenerator-transform": "^0.10.0"
-      }
-    },
-    "babel-plugin-transform-strict-mode": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-strict-mode/-/babel-plugin-transform-strict-mode-6.24.1.tgz",
-      "integrity": "sha1-1fr3qleKZbvlkc9e2uBKDGcCB1g=",
-      "dev": true,
-      "requires": {
-        "babel-runtime": "^6.22.0",
-        "babel-types": "^6.24.1"
-      }
-    },
-    "babel-preset-es2015": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-preset-es2015/-/babel-preset-es2015-6.24.1.tgz",
-      "integrity": "sha1-1EBQ1rwsn+6nAqrzjXJ6AhBTiTk=",
-      "dev": true,
-      "requires": {
-        "babel-plugin-check-es2015-constants": "^6.22.0",
-        "babel-plugin-transform-es2015-arrow-functions": "^6.22.0",
-        "babel-plugin-transform-es2015-block-scoped-functions": "^6.22.0",
-        "babel-plugin-transform-es2015-block-scoping": "^6.24.1",
-        "babel-plugin-transform-es2015-classes": "^6.24.1",
-        "babel-plugin-transform-es2015-computed-properties": "^6.24.1",
-        "babel-plugin-transform-es2015-destructuring": "^6.22.0",
-        "babel-plugin-transform-es2015-duplicate-keys": "^6.24.1",
-        "babel-plugin-transform-es2015-for-of": "^6.22.0",
-        "babel-plugin-transform-es2015-function-name": "^6.24.1",
-        "babel-plugin-transform-es2015-literals": "^6.22.0",
-        "babel-plugin-transform-es2015-modules-amd": "^6.24.1",
-        "babel-plugin-transform-es2015-modules-commonjs": "^6.24.1",
-        "babel-plugin-transform-es2015-modules-systemjs": "^6.24.1",
-        "babel-plugin-transform-es2015-modules-umd": "^6.24.1",
-        "babel-plugin-transform-es2015-object-super": "^6.24.1",
-        "babel-plugin-transform-es2015-parameters": "^6.24.1",
-        "babel-plugin-transform-es2015-shorthand-properties": "^6.24.1",
-        "babel-plugin-transform-es2015-spread": "^6.22.0",
-        "babel-plugin-transform-es2015-sticky-regex": "^6.24.1",
-        "babel-plugin-transform-es2015-template-literals": "^6.22.0",
-        "babel-plugin-transform-es2015-typeof-symbol": "^6.22.0",
-        "babel-plugin-transform-es2015-unicode-regex": "^6.24.1",
-        "babel-plugin-transform-regenerator": "^6.24.1"
-      }
-    },
-    "babel-preset-stage-1": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-preset-stage-1/-/babel-preset-stage-1-6.24.1.tgz",
-      "integrity": "sha1-dpLNfc1oSZB+auSgqFWJz7niv7A=",
-      "dev": true,
-      "requires": {
-        "babel-plugin-transform-class-constructor-call": "^6.24.1",
-        "babel-plugin-transform-export-extensions": "^6.22.0",
-        "babel-preset-stage-2": "^6.24.1"
-      }
-    },
-    "babel-preset-stage-2": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-preset-stage-2/-/babel-preset-stage-2-6.24.1.tgz",
-      "integrity": "sha1-2eKWD7PXEYfw5k7sYrwHdnIZvcE=",
-      "dev": true,
-      "requires": {
-        "babel-plugin-syntax-dynamic-import": "^6.18.0",
-        "babel-plugin-transform-class-properties": "^6.24.1",
-        "babel-plugin-transform-decorators": "^6.24.1",
-        "babel-preset-stage-3": "^6.24.1"
-      }
-    },
-    "babel-preset-stage-3": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-preset-stage-3/-/babel-preset-stage-3-6.24.1.tgz",
-      "integrity": "sha1-g2raCp56f6N8sTj7kyb4eTSkg5U=",
-      "dev": true,
-      "requires": {
-        "babel-plugin-syntax-trailing-function-commas": "^6.22.0",
-        "babel-plugin-transform-async-generator-functions": "^6.24.1",
-        "babel-plugin-transform-async-to-generator": "^6.24.1",
-        "babel-plugin-transform-exponentiation-operator": "^6.24.1",
-        "babel-plugin-transform-object-rest-spread": "^6.22.0"
-      }
-    },
-    "babel-register": {
-      "version": "6.26.0",
-      "resolved": "https://registry.npmjs.org/babel-register/-/babel-register-6.26.0.tgz",
-      "integrity": "sha1-btAhFz4vy0htestFxgCahW9kcHE=",
-      "dev": true,
-      "requires": {
-        "babel-core": "^6.26.0",
-        "babel-runtime": "^6.26.0",
-        "core-js": "^2.5.0",
-        "home-or-tmp": "^2.0.0",
-        "lodash": "^4.17.4",
-        "mkdirp": "^0.5.1",
-        "source-map-support": "^0.4.15"
-      }
-    },
-    "babel-runtime": {
-      "version": "6.26.0",
-      "resolved": "https://registry.npmjs.org/babel-runtime/-/babel-runtime-6.26.0.tgz",
-      "integrity": "sha1-llxwWGaOgrVde/4E/yM3vItWR/4=",
-      "dev": true,
-      "requires": {
-        "core-js": "^2.4.0",
-        "regenerator-runtime": "^0.11.0"
-      }
-    },
-    "babel-template": {
-      "version": "6.26.0",
-      "resolved": "https://registry.npmjs.org/babel-template/-/babel-template-6.26.0.tgz",
-      "integrity": "sha1-3gPi0WOWsGn0bdn/+FIfsaDjXgI=",
-      "dev": true,
-      "requires": {
-        "babel-runtime": "^6.26.0",
-        "babel-traverse": "^6.26.0",
-        "babel-types": "^6.26.0",
-        "babylon": "^6.18.0",
-        "lodash": "^4.17.4"
-      },
-      "dependencies": {
-        "babylon": {
-          "version": "6.18.0",
-          "resolved": "https://registry.npmjs.org/babylon/-/babylon-6.18.0.tgz",
-          "integrity": "sha512-q/UEjfGJ2Cm3oKV71DJz9d25TPnq5rhBVL2Q4fA5wcC3jcrdn7+SssEybFIxwAvvP+YCsCYNKughoF33GxgycQ==",
-          "dev": true
-        }
-      }
-    },
-    "babel-traverse": {
-      "version": "6.26.0",
-      "resolved": "https://registry.npmjs.org/babel-traverse/-/babel-traverse-6.26.0.tgz",
-      "integrity": "sha1-RqnL1+3MYsjlwGTi0tjQ9ANXZu4=",
-      "dev": true,
-      "requires": {
-        "babel-code-frame": "^6.26.0",
-        "babel-messages": "^6.23.0",
-        "babel-runtime": "^6.26.0",
-        "babel-types": "^6.26.0",
-        "babylon": "^6.18.0",
-        "debug": "^2.6.8",
-        "globals": "^9.18.0",
-        "invariant": "^2.2.2",
-        "lodash": "^4.17.4"
-      },
-      "dependencies": {
-        "babylon": {
-          "version": "6.18.0",
-          "resolved": "https://registry.npmjs.org/babylon/-/babylon-6.18.0.tgz",
-          "integrity": "sha512-q/UEjfGJ2Cm3oKV71DJz9d25TPnq5rhBVL2Q4fA5wcC3jcrdn7+SssEybFIxwAvvP+YCsCYNKughoF33GxgycQ==",
-          "dev": true
-        }
-      }
-    },
-    "babel-types": {
-      "version": "6.26.0",
-      "resolved": "https://registry.npmjs.org/babel-types/-/babel-types-6.26.0.tgz",
-      "integrity": "sha1-o7Bz+Uq0nrb6Vc1lInozQ4BjJJc=",
-      "dev": true,
-      "requires": {
-        "babel-runtime": "^6.26.0",
-        "esutils": "^2.0.2",
-        "lodash": "^4.17.4",
-        "to-fast-properties": "^1.0.3"
-      }
-    },
-    "babylon": {
-      "version": "7.0.0-beta.47",
-      "resolved": "https://registry.npmjs.org/babylon/-/babylon-7.0.0-beta.47.tgz",
-      "integrity": "sha512-+rq2cr4GDhtToEzKFD6KZZMDBXhjFAr9JjPw9pAppZACeEWqNM294j+NdBzkSHYXwzzBmVjZ3nEVJlOhbR2gOQ==",
-      "dev": true
-    },
-    "balanced-match": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz",
-      "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=",
-      "dev": true
-    },
-    "base": {
-      "version": "0.11.2",
-      "resolved": "https://registry.npmjs.org/base/-/base-0.11.2.tgz",
-      "integrity": "sha512-5T6P4xPgpp0YDFvSWwEZ4NoE3aM4QBQXDzmVbraCkFj8zHM+mba8SyqB5DbZWyR7mYHo6Y7BdQo3MoA4m0TeQg==",
-      "dev": true,
-      "requires": {
-        "cache-base": "^1.0.1",
-        "class-utils": "^0.3.5",
-        "component-emitter": "^1.2.1",
-        "define-property": "^1.0.0",
-        "isobject": "^3.0.1",
-        "mixin-deep": "^1.2.0",
-        "pascalcase": "^0.1.1"
-      },
-      "dependencies": {
-        "define-property": {
-          "version": "1.0.0",
-          "resolved": "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz",
-          "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=",
-          "dev": true,
-          "requires": {
-            "is-descriptor": "^1.0.0"
-          }
-        },
-        "is-accessor-descriptor": {
-          "version": "1.0.0",
-          "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz",
-          "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==",
-          "dev": true,
-          "requires": {
-            "kind-of": "^6.0.0"
-          }
-        },
-        "is-data-descriptor": {
-          "version": "1.0.0",
-          "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz",
-          "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==",
-          "dev": true,
-          "requires": {
-            "kind-of": "^6.0.0"
-          }
-        },
-        "is-descriptor": {
-          "version": "1.0.2",
-          "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz",
-          "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==",
-          "dev": true,
-          "requires": {
-            "is-accessor-descriptor": "^1.0.0",
-            "is-data-descriptor": "^1.0.0",
-            "kind-of": "^6.0.2"
-          }
-        }
-      }
-    },
-    "base64-js": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.3.0.tgz",
-      "integrity": "sha512-ccav/yGvoa80BQDljCxsmmQ3Xvx60/UpBIij5QN21W3wBi/hhIC9OoO+KLpu9IJTS9j4DRVJ3aDDF9cMSoa2lw==",
-      "dev": true
-    },
-    "big.js": {
-      "version": "3.2.0",
-      "resolved": "https://registry.npmjs.org/big.js/-/big.js-3.2.0.tgz",
-      "integrity": "sha512-+hN/Zh2D08Mx65pZ/4g5bsmNiZUuChDiQfTUQ7qJr4/kuopCr88xZsAXv6mBoZEsUI4OuGHlX59qE94K2mMW8Q==",
-      "dev": true
-    },
-    "binary-extensions": {
-      "version": "1.11.0",
-      "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-1.11.0.tgz",
-      "integrity": "sha1-RqoXUftqL5PuXmibsQh9SxTGwgU=",
-      "dev": true
-    },
-    "binaryextensions": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/binaryextensions/-/binaryextensions-2.1.1.tgz",
-      "integrity": "sha512-XBaoWE9RW8pPdPQNibZsW2zh8TW6gcarXp1FZPwT8Uop8ScSNldJEWf2k9l3HeTqdrEwsOsFcq74RiJECW34yA==",
-      "dev": true
-    },
-    "bluebird": {
-      "version": "3.5.1",
-      "resolved": "https://registry.npmjs.org/bluebird/-/bluebird-3.5.1.tgz",
-      "integrity": "sha512-MKiLiV+I1AA596t9w1sQJ8jkiSr5+ZKi0WKrYGUn6d1Fx+Ij4tIj+m2WMQSGczs5jZVxV339chE8iwk6F64wjA==",
-      "dev": true
-    },
-    "bn.js": {
-      "version": "4.11.8",
-      "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.11.8.tgz",
-      "integrity": "sha512-ItfYfPLkWHUjckQCk8xC+LwxgK8NYcXywGigJgSwOP8Y2iyWT4f2vsZnoOXTTbo+o5yXmIUJ4gn5538SO5S3gA==",
-      "dev": true
-    },
-    "brace-expansion": {
-      "version": "1.1.11",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
-      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
-      "dev": true,
-      "requires": {
-        "balanced-match": "^1.0.0",
-        "concat-map": "0.0.1"
-      }
-    },
-    "braces": {
-      "version": "2.3.2",
-      "resolved": "https://registry.npmjs.org/braces/-/braces-2.3.2.tgz",
-      "integrity": "sha512-aNdbnj9P8PjdXU4ybaWLK2IF3jc/EoDYbC7AazW6to3TRsfXxscC9UXOB5iDiEQrkyIbWp2SLQda4+QAa7nc3w==",
-      "dev": true,
-      "requires": {
-        "arr-flatten": "^1.1.0",
-        "array-unique": "^0.3.2",
-        "extend-shallow": "^2.0.1",
-        "fill-range": "^4.0.0",
-        "isobject": "^3.0.1",
-        "repeat-element": "^1.1.2",
-        "snapdragon": "^0.8.1",
-        "snapdragon-node": "^2.0.1",
-        "split-string": "^3.0.2",
-        "to-regex": "^3.0.1"
-      },
-      "dependencies": {
-        "extend-shallow": {
-          "version": "2.0.1",
-          "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz",
-          "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
-          "dev": true,
-          "requires": {
-            "is-extendable": "^0.1.0"
-          }
-        }
-      }
-    },
-    "brorand": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/brorand/-/brorand-1.1.0.tgz",
-      "integrity": "sha1-EsJe/kCkXjwyPrhnWgoM5XsiNx8=",
-      "dev": true
-    },
-    "browserify-aes": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/browserify-aes/-/browserify-aes-1.2.0.tgz",
-      "integrity": "sha512-+7CHXqGuspUn/Sl5aO7Ea0xWGAtETPXNSAjHo48JfLdPWcMng33Xe4znFvQweqc/uzk5zSOI3H52CYnjCfb5hA==",
-      "dev": true,
-      "requires": {
-        "buffer-xor": "^1.0.3",
-        "cipher-base": "^1.0.0",
-        "create-hash": "^1.1.0",
-        "evp_bytestokey": "^1.0.3",
-        "inherits": "^2.0.1",
-        "safe-buffer": "^5.0.1"
-      }
-    },
-    "browserify-cipher": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/browserify-cipher/-/browserify-cipher-1.0.1.tgz",
-      "integrity": "sha512-sPhkz0ARKbf4rRQt2hTpAHqn47X3llLkUGn+xEJzLjwY8LRs2p0v7ljvI5EyoRO/mexrNunNECisZs+gw2zz1w==",
-      "dev": true,
-      "requires": {
-        "browserify-aes": "^1.0.4",
-        "browserify-des": "^1.0.0",
-        "evp_bytestokey": "^1.0.0"
-      }
-    },
-    "browserify-des": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/browserify-des/-/browserify-des-1.0.1.tgz",
-      "integrity": "sha512-zy0Cobe3hhgpiOM32Tj7KQ3Vl91m0njwsjzZQK1L+JDf11dzP9qIvjreVinsvXrgfjhStXwUWAEpB9D7Gwmayw==",
-      "dev": true,
-      "requires": {
-        "cipher-base": "^1.0.1",
-        "des.js": "^1.0.0",
-        "inherits": "^2.0.1"
-      }
-    },
-    "browserify-rsa": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/browserify-rsa/-/browserify-rsa-4.0.1.tgz",
-      "integrity": "sha1-IeCr+vbyApzy+vsTNWenAdQTVSQ=",
-      "dev": true,
-      "requires": {
-        "bn.js": "^4.1.0",
-        "randombytes": "^2.0.1"
-      }
-    },
-    "browserify-sign": {
-      "version": "4.0.4",
-      "resolved": "https://registry.npmjs.org/browserify-sign/-/browserify-sign-4.0.4.tgz",
-      "integrity": "sha1-qk62jl17ZYuqa/alfmMMvXqT0pg=",
-      "dev": true,
-      "requires": {
-        "bn.js": "^4.1.1",
-        "browserify-rsa": "^4.0.0",
-        "create-hash": "^1.1.0",
-        "create-hmac": "^1.1.2",
-        "elliptic": "^6.0.0",
-        "inherits": "^2.0.1",
-        "parse-asn1": "^5.0.0"
-      }
-    },
-    "browserify-zlib": {
-      "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/browserify-zlib/-/browserify-zlib-0.2.0.tgz",
-      "integrity": "sha512-Z942RysHXmJrhqk88FmKBVq/v5tqmSkDz7p54G/MGyjMnCFFnC79XWNbg+Vta8W6Wb2qtSZTSxIGkJrRpCFEiA==",
-      "dev": true,
-      "requires": {
-        "pako": "~1.0.5"
-      }
-    },
-    "buffer": {
-      "version": "4.9.1",
-      "resolved": "https://registry.npmjs.org/buffer/-/buffer-4.9.1.tgz",
-      "integrity": "sha1-bRu2AbB6TvztlwlBMgkwJ8lbwpg=",
-      "dev": true,
-      "requires": {
-        "base64-js": "^1.0.2",
-        "ieee754": "^1.1.4",
-        "isarray": "^1.0.0"
-      }
-    },
-    "buffer-from": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.0.tgz",
-      "integrity": "sha512-c5mRlguI/Pe2dSZmpER62rSCu0ryKmWddzRYsuXc50U2/g8jMOulc31VZMa4mYx31U5xsmSOpDCgH88Vl9cDGQ==",
-      "dev": true
-    },
-    "buffer-xor": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/buffer-xor/-/buffer-xor-1.0.3.tgz",
-      "integrity": "sha1-JuYe0UIvtw3ULm42cp7VHYVf6Nk=",
-      "dev": true
-    },
-    "builtin-modules": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/builtin-modules/-/builtin-modules-1.1.1.tgz",
-      "integrity": "sha1-Jw8HbFpywC9bZaR9+Uxf46J4iS8=",
-      "dev": true
-    },
-    "builtin-status-codes": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/builtin-status-codes/-/builtin-status-codes-3.0.0.tgz",
-      "integrity": "sha1-hZgoeOIbmOHGZCXgPQF0eI9Wnug=",
-      "dev": true
-    },
-    "cacache": {
-      "version": "10.0.4",
-      "resolved": "https://registry.npmjs.org/cacache/-/cacache-10.0.4.tgz",
-      "integrity": "sha512-Dph0MzuH+rTQzGPNT9fAnrPmMmjKfST6trxJeK7NQuHRaVw24VzPRWTmg9MpcwOVQZO0E1FBICUlFeNaKPIfHA==",
-      "dev": true,
-      "requires": {
-        "bluebird": "^3.5.1",
-        "chownr": "^1.0.1",
-        "glob": "^7.1.2",
-        "graceful-fs": "^4.1.11",
-        "lru-cache": "^4.1.1",
-        "mississippi": "^2.0.0",
-        "mkdirp": "^0.5.1",
-        "move-concurrently": "^1.0.1",
-        "promise-inflight": "^1.0.1",
-        "rimraf": "^2.6.2",
-        "ssri": "^5.2.4",
-        "unique-filename": "^1.1.0",
-        "y18n": "^4.0.0"
-      }
-    },
-    "cache-base": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/cache-base/-/cache-base-1.0.1.tgz",
-      "integrity": "sha512-AKcdTnFSWATd5/GCPRxr2ChwIJ85CeyrEyjRHlKxQ56d4XJMGym0uAiKn0xbLOGOl3+yRpOTi484dVCEc5AUzQ==",
-      "dev": true,
-      "requires": {
-        "collection-visit": "^1.0.0",
-        "component-emitter": "^1.2.1",
-        "get-value": "^2.0.6",
-        "has-value": "^1.0.0",
-        "isobject": "^3.0.1",
-        "set-value": "^2.0.0",
-        "to-object-path": "^0.3.0",
-        "union-value": "^1.0.0",
-        "unset-value": "^1.0.0"
-      }
-    },
-    "cacheable-request": {
-      "version": "2.1.4",
-      "resolved": "https://registry.npmjs.org/cacheable-request/-/cacheable-request-2.1.4.tgz",
-      "integrity": "sha1-DYCIAbY0KtM8kd+dC0TcCbkeXD0=",
-      "dev": true,
-      "requires": {
-        "clone-response": "1.0.2",
-        "get-stream": "3.0.0",
-        "http-cache-semantics": "3.8.1",
-        "keyv": "3.0.0",
-        "lowercase-keys": "1.0.0",
-        "normalize-url": "2.0.1",
-        "responselike": "1.0.2"
-      },
-      "dependencies": {
-        "lowercase-keys": {
-          "version": "1.0.0",
-          "resolved": "https://registry.npmjs.org/lowercase-keys/-/lowercase-keys-1.0.0.tgz",
-          "integrity": "sha1-TjNms55/VFfjXxMkvfb4jQv8cwY=",
-          "dev": true
-        }
-      }
-    },
-    "call-me-maybe": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/call-me-maybe/-/call-me-maybe-1.0.1.tgz",
-      "integrity": "sha1-JtII6onje1y95gJQoV8DHBak1ms=",
-      "dev": true
-    },
-    "caller-path": {
-      "version": "0.1.0",
-      "resolved": "https://registry.npmjs.org/caller-path/-/caller-path-0.1.0.tgz",
-      "integrity": "sha1-lAhe9jWB7NPaqSREqP6U6CV3dR8=",
-      "dev": true,
-      "requires": {
-        "callsites": "^0.2.0"
-      }
-    },
-    "callsites": {
-      "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/callsites/-/callsites-0.2.0.tgz",
-      "integrity": "sha1-r6uWJikQp/M8GaV3WCXGnzTjUMo=",
-      "dev": true
-    },
-    "camelcase": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-4.1.0.tgz",
-      "integrity": "sha1-1UVjW+HjPFQmScaRc+Xeas+uNN0=",
-      "dev": true
-    },
-    "chalk": {
-      "version": "2.4.1",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.1.tgz",
-      "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==",
-      "dev": true,
-      "requires": {
-        "ansi-styles": "^3.2.1",
-        "escape-string-regexp": "^1.0.5",
-        "supports-color": "^5.3.0"
-      }
-    },
-    "chardet": {
-      "version": "0.4.2",
-      "resolved": "https://registry.npmjs.org/chardet/-/chardet-0.4.2.tgz",
-      "integrity": "sha1-tUc7M9yXxCTl2Y3IfVXU2KKci/I=",
-      "dev": true
-    },
-    "chokidar": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-2.0.3.tgz",
-      "integrity": "sha512-zW8iXYZtXMx4kux/nuZVXjkLP+CyIK5Al5FHnj1OgTKGZfp4Oy6/ymtMSKFv3GD8DviEmUPmJg9eFdJ/JzudMg==",
-      "dev": true,
-      "requires": {
-        "anymatch": "^2.0.0",
-        "async-each": "^1.0.0",
-        "braces": "^2.3.0",
-        "fsevents": "^1.1.2",
-        "glob-parent": "^3.1.0",
-        "inherits": "^2.0.1",
-        "is-binary-path": "^1.0.0",
-        "is-glob": "^4.0.0",
-        "normalize-path": "^2.1.1",
-        "path-is-absolute": "^1.0.0",
-        "readdirp": "^2.0.0",
-        "upath": "^1.0.0"
-      }
-    },
-    "chownr": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/chownr/-/chownr-1.0.1.tgz",
-      "integrity": "sha1-4qdQQqlVGQi+vSW4Uj1fl2nXkYE=",
-      "dev": true
-    },
-    "chrome-trace-event": {
-      "version": "0.1.3",
-      "resolved": "https://registry.npmjs.org/chrome-trace-event/-/chrome-trace-event-0.1.3.tgz",
-      "integrity": "sha512-sjndyZHrrWiu4RY7AkHgjn80GfAM2ZSzUkZLV/Js59Ldmh6JDThf0SUmOHU53rFu2rVxxfCzJ30Ukcfch3Gb/A==",
-      "dev": true
-    },
-    "cipher-base": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/cipher-base/-/cipher-base-1.0.4.tgz",
-      "integrity": "sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==",
-      "dev": true,
-      "requires": {
-        "inherits": "^2.0.1",
-        "safe-buffer": "^5.0.1"
-      }
-    },
-    "circular-json": {
-      "version": "0.3.3",
-      "resolved": "https://registry.npmjs.org/circular-json/-/circular-json-0.3.3.tgz",
-      "integrity": "sha512-UZK3NBx2Mca+b5LsG7bY183pHWt5Y1xts4P3Pz7ENTwGVnJOUWbRb3ocjvX7hx9tq/yTAdclXm9sZ38gNuem4A==",
-      "dev": true
-    },
-    "class-utils": {
-      "version": "0.3.6",
-      "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
-      "integrity": "sha512-qOhPa/Fj7s6TY8H8esGu5QNpMMQxz79h+urzrNYN6mn+9BnxlDGf5QZ+XeCDsxSjPqsSR56XOZOJmpeurnLMeg==",
-      "dev": true,
-      "requires": {
-        "arr-union": "^3.1.0",
-        "define-property": "^0.2.5",
-        "isobject": "^3.0.0",
-        "static-extend": "^0.1.1"
-      },
-      "dependencies": {
-        "define-property": {
-          "version": "0.2.5",
-          "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz",
-          "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=",
-          "dev": true,
-          "requires": {
-            "is-descriptor": "^0.1.0"
-          }
-        }
-      }
-    },
-    "cli-cursor": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-2.1.0.tgz",
-      "integrity": "sha1-s12sN2R5+sw+lHR9QdDQ9SOP/LU=",
-      "dev": true,
-      "requires": {
-        "restore-cursor": "^2.0.0"
-      }
-    },
-    "cli-spinners": {
-      "version": "0.1.2",
-      "resolved": "https://registry.npmjs.org/cli-spinners/-/cli-spinners-0.1.2.tgz",
-      "integrity": "sha1-u3ZNiOGF+54eaiofGXcjGPYF4xw=",
-      "dev": true
-    },
-    "cli-table": {
-      "version": "0.3.1",
-      "resolved": "https://registry.npmjs.org/cli-table/-/cli-table-0.3.1.tgz",
-      "integrity": "sha1-9TsFJmqLGguTSz0IIebi3FkUriM=",
-      "dev": true,
-      "requires": {
-        "colors": "1.0.3"
-      },
-      "dependencies": {
-        "colors": {
-          "version": "1.0.3",
-          "resolved": "https://registry.npmjs.org/colors/-/colors-1.0.3.tgz",
-          "integrity": "sha1-BDP0TYCWgP3rYO0mDxsMJi6CpAs=",
-          "dev": true
-        }
-      }
-    },
-    "cli-truncate": {
-      "version": "0.2.1",
-      "resolved": "https://registry.npmjs.org/cli-truncate/-/cli-truncate-0.2.1.tgz",
-      "integrity": "sha1-nxXPuwcFAFNpIWxiasfQWrkN1XQ=",
-      "dev": true,
-      "requires": {
-        "slice-ansi": "0.0.4",
-        "string-width": "^1.0.1"
-      },
-      "dependencies": {
-        "ansi-regex": {
-          "version": "2.1.1",
-          "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz",
-          "integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8=",
-          "dev": true
-        },
-        "is-fullwidth-code-point": {
-          "version": "1.0.0",
-          "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz",
-          "integrity": "sha1-754xOG8DGn8NZDr4L95QxFfvAMs=",
-          "dev": true,
-          "requires": {
-            "number-is-nan": "^1.0.0"
-          }
-        },
-        "string-width": {
-          "version": "1.0.2",
-          "resolved": "https://registry.npmjs.org/string-width/-/string-width-1.0.2.tgz",
-          "integrity": "sha1-EYvfW4zcUaKn5w0hHgfisLmxB9M=",
-          "dev": true,
-          "requires": {
-            "code-point-at": "^1.0.0",
-            "is-fullwidth-code-point": "^1.0.0",
-            "strip-ansi": "^3.0.0"
-          }
-        },
-        "strip-ansi": {
-          "version": "3.0.1",
-          "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz",
-          "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=",
-          "dev": true,
-          "requires": {
-            "ansi-regex": "^2.0.0"
-          }
-        }
-      }
-    },
-    "cli-width": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/cli-width/-/cli-width-2.2.0.tgz",
-      "integrity": "sha1-/xnt6Kml5XkyQUewwR8PvLq+1jk=",
-      "dev": true
-    },
-    "cliui": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/cliui/-/cliui-4.1.0.tgz",
-      "integrity": "sha512-4FG+RSG9DL7uEwRUZXZn3SS34DiDPfzP0VOiEwtUWlE+AR2EIg+hSyvrIgUUfhdgR/UkAeW2QHgeP+hWrXs7jQ==",
-      "dev": true,
-      "requires": {
-        "string-width": "^2.1.1",
-        "strip-ansi": "^4.0.0",
-        "wrap-ansi": "^2.0.0"
-      }
-    },
-    "clone": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/clone/-/clone-1.0.4.tgz",
-      "integrity": "sha1-2jCcwmPfFZlMaIypAheco8fNfH4=",
-      "dev": true
-    },
-    "clone-buffer": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/clone-buffer/-/clone-buffer-1.0.0.tgz",
-      "integrity": "sha1-4+JbIHrE5wGvch4staFnksrD3Fg=",
-      "dev": true
-    },
-    "clone-response": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/clone-response/-/clone-response-1.0.2.tgz",
-      "integrity": "sha1-0dyXOSAxTfZ/vrlCI7TuNQI56Ws=",
-      "dev": true,
-      "requires": {
-        "mimic-response": "^1.0.0"
-      }
-    },
-    "clone-stats": {
-      "version": "0.0.1",
-      "resolved": "https://registry.npmjs.org/clone-stats/-/clone-stats-0.0.1.tgz",
-      "integrity": "sha1-uI+UqCzzi4eR1YBG6kAprYjKmdE=",
-      "dev": true
-    },
-    "cloneable-readable": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/cloneable-readable/-/cloneable-readable-1.1.2.tgz",
-      "integrity": "sha512-Bq6+4t+lbM8vhTs/Bef5c5AdEMtapp/iFb6+s4/Hh9MVTt8OLKH7ZOOZSCT+Ys7hsHvqv0GuMPJ1lnQJVHvxpg==",
-      "dev": true,
-      "requires": {
-        "inherits": "^2.0.1",
-        "process-nextick-args": "^2.0.0",
-        "readable-stream": "^2.3.5"
-      }
-    },
-    "co": {
-      "version": "4.6.0",
-      "resolved": "https://registry.npmjs.org/co/-/co-4.6.0.tgz",
-      "integrity": "sha1-bqa989hTrlTMuOR7+gvz+QMfsYQ=",
-      "dev": true
-    },
-    "code-point-at": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/code-point-at/-/code-point-at-1.1.0.tgz",
-      "integrity": "sha1-DQcLTQQ6W+ozovGkDi7bPZpMz3c=",
-      "dev": true
-    },
-    "collection-visit": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/collection-visit/-/collection-visit-1.0.0.tgz",
-      "integrity": "sha1-S8A3PBZLwykbTTaMgpzxqApZ3KA=",
-      "dev": true,
-      "requires": {
-        "map-visit": "^1.0.0",
-        "object-visit": "^1.0.0"
-      }
-    },
-    "color-convert": {
-      "version": "1.9.1",
-      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.1.tgz",
-      "integrity": "sha512-mjGanIiwQJskCC18rPR6OmrZ6fm2Lc7PeGFYwCmy5J34wC6F1PzdGL6xeMfmgicfYcNLGuVFA3WzXtIDCQSZxQ==",
-      "dev": true,
-      "requires": {
-        "color-name": "^1.1.1"
-      }
-    },
-    "color-name": {
-      "version": "1.1.3",
-      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
-      "integrity": "sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=",
-      "dev": true
-    },
-    "colors": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/colors/-/colors-1.3.0.tgz",
-      "integrity": "sha512-EDpX3a7wHMWFA7PUHWPHNWqOxIIRSJetuwl0AS5Oi/5FMV8kWm69RTlgm00GKjBO1xFHMtBbL49yRtMMdticBw==",
-      "dev": true
-    },
-    "commander": {
-      "version": "2.13.0",
-      "resolved": "https://registry.npmjs.org/commander/-/commander-2.13.0.tgz",
-      "integrity": "sha512-MVuS359B+YzaWqjCL/c+22gfryv+mCBPHAv3zyVI2GN8EY6IRP8VwtasXn8jyyhvvq84R4ImN1OKRtcbIasjYA==",
-      "dev": true
-    },
-    "commondir": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/commondir/-/commondir-1.0.1.tgz",
-      "integrity": "sha1-3dgA2gxmEnOTzKWVDqloo6rxJTs=",
-      "dev": true
-    },
-    "component-emitter": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/component-emitter/-/component-emitter-1.2.1.tgz",
-      "integrity": "sha1-E3kY1teCg/ffemt8WmPhQOaUJeY=",
-      "dev": true
-    },
-    "concat-map": {
-      "version": "0.0.1",
-      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
-      "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=",
-      "dev": true
-    },
-    "concat-stream": {
-      "version": "1.6.2",
-      "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-1.6.2.tgz",
-      "integrity": "sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==",
-      "dev": true,
-      "requires": {
-        "buffer-from": "^1.0.0",
-        "inherits": "^2.0.3",
-        "readable-stream": "^2.2.2",
-        "typedarray": "^0.0.6"
-      }
-    },
-    "console-browserify": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/console-browserify/-/console-browserify-1.1.0.tgz",
-      "integrity": "sha1-8CQcRXMKn8YyOyBtvzjtx0HQuxA=",
-      "dev": true,
-      "requires": {
-        "date-now": "^0.1.4"
-      }
-    },
-    "constants-browserify": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/constants-browserify/-/constants-browserify-1.0.0.tgz",
-      "integrity": "sha1-wguW2MYXdIqvHBYCF2DNJ/y4y3U=",
-      "dev": true
-    },
-    "convert-source-map": {
-      "version": "1.5.1",
-      "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.5.1.tgz",
-      "integrity": "sha1-uCeAl7m8IpNl3lxiz1/K7YtVmeU=",
-      "dev": true
-    },
-    "copy-concurrently": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/copy-concurrently/-/copy-concurrently-1.0.5.tgz",
-      "integrity": "sha512-f2domd9fsVDFtaFcbaRZuYXwtdmnzqbADSwhSWYxYB/Q8zsdUUFMXVRwXGDMWmbEzAn1kdRrtI1T/KTFOL4X2A==",
-      "dev": true,
-      "requires": {
-        "aproba": "^1.1.1",
-        "fs-write-stream-atomic": "^1.0.8",
-        "iferr": "^0.1.5",
-        "mkdirp": "^0.5.1",
-        "rimraf": "^2.5.4",
-        "run-queue": "^1.0.0"
-      }
-    },
-    "copy-descriptor": {
-      "version": "0.1.1",
-      "resolved": "https://registry.npmjs.org/copy-descriptor/-/copy-descriptor-0.1.1.tgz",
-      "integrity": "sha1-Z29us8OZl8LuGsOpJP1hJHSPV40=",
-      "dev": true
-    },
-    "core-js": {
-      "version": "2.5.7",
-      "resolved": "https://registry.npmjs.org/core-js/-/core-js-2.5.7.tgz",
-      "integrity": "sha512-RszJCAxg/PP6uzXVXL6BsxSXx/B05oJAQ2vkJRjyjrEcNVycaqOmNb5OTxZPE3xa5gwZduqza6L9JOCenh/Ecw==",
-      "dev": true
-    },
-    "core-util-is": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz",
-      "integrity": "sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=",
-      "dev": true
-    },
-    "create-ecdh": {
-      "version": "4.0.3",
-      "resolved": "https://registry.npmjs.org/create-ecdh/-/create-ecdh-4.0.3.tgz",
-      "integrity": "sha512-GbEHQPMOswGpKXM9kCWVrremUcBmjteUaQ01T9rkKCPDXfUHX0IoP9LpHYo2NPFampa4e+/pFDc3jQdxrxQLaw==",
-      "dev": true,
-      "requires": {
-        "bn.js": "^4.1.0",
-        "elliptic": "^6.0.0"
-      }
-    },
-    "create-hash": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/create-hash/-/create-hash-1.2.0.tgz",
-      "integrity": "sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==",
-      "dev": true,
-      "requires": {
-        "cipher-base": "^1.0.1",
-        "inherits": "^2.0.1",
-        "md5.js": "^1.3.4",
-        "ripemd160": "^2.0.1",
-        "sha.js": "^2.4.0"
-      }
-    },
-    "create-hmac": {
-      "version": "1.1.7",
-      "resolved": "https://registry.npmjs.org/create-hmac/-/create-hmac-1.1.7.tgz",
-      "integrity": "sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg==",
-      "dev": true,
-      "requires": {
-        "cipher-base": "^1.0.3",
-        "create-hash": "^1.1.0",
-        "inherits": "^2.0.1",
-        "ripemd160": "^2.0.0",
-        "safe-buffer": "^5.0.1",
-        "sha.js": "^2.4.8"
-      }
-    },
-    "cross-spawn": {
-      "version": "6.0.5",
-      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-6.0.5.tgz",
-      "integrity": "sha512-eTVLrBSt7fjbDygz805pMnstIs2VTBNkRm0qxZd+M7A5XDdxVRWO5MxGBXZhjY4cqLYLdtrGqRf8mBPmzwSpWQ==",
-      "dev": true,
-      "requires": {
-        "nice-try": "^1.0.4",
-        "path-key": "^2.0.1",
-        "semver": "^5.5.0",
-        "shebang-command": "^1.2.0",
-        "which": "^1.2.9"
-      }
-    },
-    "crypto-browserify": {
-      "version": "3.12.0",
-      "resolved": "https://registry.npmjs.org/crypto-browserify/-/crypto-browserify-3.12.0.tgz",
-      "integrity": "sha512-fz4spIh+znjO2VjL+IdhEpRJ3YN6sMzITSBijk6FK2UvTqruSQW+/cCZTSNsMiZNvUeq0CqurF+dAbyiGOY6Wg==",
-      "dev": true,
-      "requires": {
-        "browserify-cipher": "^1.0.0",
-        "browserify-sign": "^4.0.0",
-        "create-ecdh": "^4.0.0",
-        "create-hash": "^1.1.0",
-        "create-hmac": "^1.1.0",
-        "diffie-hellman": "^5.0.0",
-        "inherits": "^2.0.1",
-        "pbkdf2": "^3.0.3",
-        "public-encrypt": "^4.0.0",
-        "randombytes": "^2.0.0",
-        "randomfill": "^1.0.3"
-      }
-    },
-    "cyclist": {
-      "version": "0.2.2",
-      "resolved": "https://registry.npmjs.org/cyclist/-/cyclist-0.2.2.tgz",
-      "integrity": "sha1-GzN5LhHpFKL9bW7WRHRkRE5fpkA=",
-      "dev": true
-    },
-    "dargs": {
-      "version": "5.1.0",
-      "resolved": "https://registry.npmjs.org/dargs/-/dargs-5.1.0.tgz",
-      "integrity": "sha1-7H6lDHhWTNNsnV7Bj2Yyn63ieCk=",
-      "dev": true
-    },
-    "date-fns": {
-      "version": "1.29.0",
-      "resolved": "https://registry.npmjs.org/date-fns/-/date-fns-1.29.0.tgz",
-      "integrity": "sha512-lbTXWZ6M20cWH8N9S6afb0SBm6tMk+uUg6z3MqHPKE9atmsY3kJkTm8vKe93izJ2B2+q5MV990sM2CHgtAZaOw==",
-      "dev": true
-    },
-    "date-now": {
-      "version": "0.1.4",
-      "resolved": "https://registry.npmjs.org/date-now/-/date-now-0.1.4.tgz",
-      "integrity": "sha1-6vQ5/U1ISK105cx9vvIAZyueNFs=",
-      "dev": true
-    },
-    "dateformat": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/dateformat/-/dateformat-3.0.3.tgz",
-      "integrity": "sha512-jyCETtSl3VMZMWeRo7iY1FL19ges1t55hMo5yaam4Jrsm5EPL89UQkoQRyiI+Yf4k8r2ZpdngkV8hr1lIdjb3Q==",
-      "dev": true
-    },
-    "debug": {
-      "version": "2.6.9",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
-      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
-      "dev": true,
-      "requires": {
-        "ms": "2.0.0"
-      }
-    },
-    "decamelize": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz",
-      "integrity": "sha1-9lNNFRSCabIDUue+4m9QH5oZEpA=",
-      "dev": true
-    },
-    "decode-uri-component": {
-      "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/decode-uri-component/-/decode-uri-component-0.2.0.tgz",
-      "integrity": "sha1-6zkTMzRYd1y4TNGh+uBiEGu4dUU=",
-      "dev": true
-    },
-    "decompress-response": {
-      "version": "3.3.0",
-      "resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-3.3.0.tgz",
-      "integrity": "sha1-gKTdMjdIOEv6JICDYirt7Jgq3/M=",
-      "dev": true,
-      "requires": {
-        "mimic-response": "^1.0.0"
-      }
-    },
-    "deep-extend": {
-      "version": "0.5.1",
-      "resolved": "https://registry.npmjs.org/deep-extend/-/deep-extend-0.5.1.tgz",
-      "integrity": "sha512-N8vBdOa+DF7zkRrDCsaOXoCs/E2fJfx9B9MrKnnSiHNh4ws7eSys6YQE4KvT1cecKmOASYQBhbKjeuDD9lT81w==",
-      "dev": true
-    },
-    "deep-is": {
-      "version": "0.1.3",
-      "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.3.tgz",
-      "integrity": "sha1-s2nW+128E+7PUk+RsHD+7cNXzzQ=",
-      "dev": true
-    },
-    "define-property": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/define-property/-/define-property-2.0.2.tgz",
-      "integrity": "sha512-jwK2UV4cnPpbcG7+VRARKTZPUWowwXA8bzH5NP6ud0oeAxyYPuGZUAC7hMugpCdz4BeSZl2Dl9k66CHJ/46ZYQ==",
-      "dev": true,
-      "requires": {
-        "is-descriptor": "^1.0.2",
-        "isobject": "^3.0.1"
-      },
-      "dependencies": {
-        "is-accessor-descriptor": {
-          "version": "1.0.0",
-          "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz",
-          "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==",
-          "dev": true,
-          "requires": {
-            "kind-of": "^6.0.0"
-          }
-        },
-        "is-data-descriptor": {
-          "version": "1.0.0",
-          "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz",
-          "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==",
-          "dev": true,
-          "requires": {
-            "kind-of": "^6.0.0"
-          }
-        },
-        "is-descriptor": {
-          "version": "1.0.2",
-          "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz",
-          "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==",
-          "dev": true,
-          "requires": {
-            "is-accessor-descriptor": "^1.0.0",
-            "is-data-descriptor": "^1.0.0",
-            "kind-of": "^6.0.2"
-          }
-        }
-      }
-    },
-    "del": {
-      "version": "2.2.2",
-      "resolved": "https://registry.npmjs.org/del/-/del-2.2.2.tgz",
-      "integrity": "sha1-wSyYHQZ4RshLyvhiz/kw2Qf/0ag=",
-      "dev": true,
-      "requires": {
-        "globby": "^5.0.0",
-        "is-path-cwd": "^1.0.0",
-        "is-path-in-cwd": "^1.0.0",
-        "object-assign": "^4.0.1",
-        "pify": "^2.0.0",
-        "pinkie-promise": "^2.0.0",
-        "rimraf": "^2.2.8"
-      },
-      "dependencies": {
-        "globby": {
-          "version": "5.0.0",
-          "resolved": "https://registry.npmjs.org/globby/-/globby-5.0.0.tgz",
-          "integrity": "sha1-69hGZ8oNuzMLmbz8aOrCvFQ3Dg0=",
-          "dev": true,
-          "requires": {
-            "array-union": "^1.0.1",
-            "arrify": "^1.0.0",
-            "glob": "^7.0.3",
-            "object-assign": "^4.0.1",
-            "pify": "^2.0.0",
-            "pinkie-promise": "^2.0.0"
-          }
-        },
-        "pify": {
-          "version": "2.3.0",
-          "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz",
-          "integrity": "sha1-7RQaasBDqEnqWISY59yosVMw6Qw=",
-          "dev": true
-        }
-      }
-    },
-    "des.js": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/des.js/-/des.js-1.0.0.tgz",
-      "integrity": "sha1-wHTS4qpqipoH29YfmhXCzYPsjsw=",
-      "dev": true,
-      "requires": {
-        "inherits": "^2.0.1",
-        "minimalistic-assert": "^1.0.0"
-      }
-    },
-    "detect-conflict": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/detect-conflict/-/detect-conflict-1.0.1.tgz",
-      "integrity": "sha1-CIZXpmqWHAUBnbfEIwiDsca0F24=",
-      "dev": true
-    },
-    "detect-indent": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/detect-indent/-/detect-indent-4.0.0.tgz",
-      "integrity": "sha1-920GQ1LN9Docts5hnE7jqUdd4gg=",
-      "dev": true,
-      "requires": {
-        "repeating": "^2.0.0"
-      }
-    },
-    "diff": {
-      "version": "3.5.0",
-      "resolved": "https://registry.npmjs.org/diff/-/diff-3.5.0.tgz",
-      "integrity": "sha512-A46qtFgd+g7pDZinpnwiRJtxbC1hpgf0uzP3iG89scHk0AUC7A1TGxf5OiiOUv/JMZR8GOt8hL900hV0bOy5xA==",
-      "dev": true
-    },
-    "diffie-hellman": {
-      "version": "5.0.3",
-      "resolved": "https://registry.npmjs.org/diffie-hellman/-/diffie-hellman-5.0.3.tgz",
-      "integrity": "sha512-kqag/Nl+f3GwyK25fhUMYj81BUOrZ9IuJsjIcDE5icNM9FJHAVm3VcUDxdLPoQtTuUylWm6ZIknYJwwaPxsUzg==",
-      "dev": true,
-      "requires": {
-        "bn.js": "^4.1.0",
-        "miller-rabin": "^4.0.0",
-        "randombytes": "^2.0.0"
-      }
-    },
-    "dir-glob": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-2.0.0.tgz",
-      "integrity": "sha512-37qirFDz8cA5fimp9feo43fSuRo2gHwaIn6dXL8Ber1dGwUosDrGZeCCXq57WnIqE4aQ+u3eQZzsk1yOzhdwag==",
-      "dev": true,
-      "requires": {
-        "arrify": "^1.0.1",
-        "path-type": "^3.0.0"
-      }
-    },
-    "doctrine": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-2.1.0.tgz",
-      "integrity": "sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==",
-      "dev": true,
-      "requires": {
-        "esutils": "^2.0.2"
-      }
-    },
-    "domain-browser": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/domain-browser/-/domain-browser-1.2.0.tgz",
-      "integrity": "sha512-jnjyiM6eRyZl2H+W8Q/zLMA481hzi0eszAaBUzIVnmYVDBbnLxVNnfu1HgEBvCbL+71FrxMl3E6lpKH7Ge3OXA==",
-      "dev": true
-    },
-    "duplexer3": {
-      "version": "0.1.4",
-      "resolved": "https://registry.npmjs.org/duplexer3/-/duplexer3-0.1.4.tgz",
-      "integrity": "sha1-7gHdHKwO08vH/b6jfcCo8c4ALOI=",
-      "dev": true
-    },
-    "duplexify": {
-      "version": "3.6.0",
-      "resolved": "https://registry.npmjs.org/duplexify/-/duplexify-3.6.0.tgz",
-      "integrity": "sha512-fO3Di4tBKJpYTFHAxTU00BcfWMY9w24r/x21a6rZRbsD/ToUgGxsMbiGRmB7uVAXeGKXD9MwiLZa5E97EVgIRQ==",
-      "dev": true,
-      "requires": {
-        "end-of-stream": "^1.0.0",
-        "inherits": "^2.0.1",
-        "readable-stream": "^2.0.0",
-        "stream-shift": "^1.0.0"
-      }
-    },
-    "editions": {
-      "version": "1.3.4",
-      "resolved": "https://registry.npmjs.org/editions/-/editions-1.3.4.tgz",
-      "integrity": "sha512-gzao+mxnYDzIysXKMQi/+M1mjy/rjestjg6OPoYTtI+3Izp23oiGZitsl9lPDPiTGXbcSIk1iJWhliSaglxnUg==",
-      "dev": true
-    },
-    "ejs": {
-      "version": "2.6.1",
-      "resolved": "https://registry.npmjs.org/ejs/-/ejs-2.6.1.tgz",
-      "integrity": "sha512-0xy4A/twfrRCnkhfk8ErDi5DqdAsAqeGxht4xkCUrsvhhbQNs7E+4jV0CN7+NKIY0aHE72+XvqtBIXzD31ZbXQ==",
-      "dev": true
-    },
-    "elegant-spinner": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/elegant-spinner/-/elegant-spinner-1.0.1.tgz",
-      "integrity": "sha1-2wQ1IcldfjA/2PNFvtwzSc+wcp4=",
-      "dev": true
-    },
-    "elliptic": {
-      "version": "6.4.0",
-      "resolved": "https://registry.npmjs.org/elliptic/-/elliptic-6.4.0.tgz",
-      "integrity": "sha1-ysmvh2LIWDYYcAPI3+GT5eLq5d8=",
-      "dev": true,
-      "requires": {
-        "bn.js": "^4.4.0",
-        "brorand": "^1.0.1",
-        "hash.js": "^1.0.0",
-        "hmac-drbg": "^1.0.0",
-        "inherits": "^2.0.1",
-        "minimalistic-assert": "^1.0.0",
-        "minimalistic-crypto-utils": "^1.0.0"
-      }
-    },
-    "emojis-list": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/emojis-list/-/emojis-list-2.1.0.tgz",
-      "integrity": "sha1-TapNnbAPmBmIDHn6RXrlsJof04k=",
-      "dev": true
-    },
-    "end-of-stream": {
-      "version": "1.4.1",
-      "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.1.tgz",
-      "integrity": "sha512-1MkrZNvWTKCaigbn+W15elq2BB/L22nqrSY5DKlo3X6+vclJm8Bb5djXJBmEX6fS3+zCh/F4VBK5Z2KxJt4s2Q==",
-      "dev": true,
-      "requires": {
-        "once": "^1.4.0"
-      }
-    },
-    "enhanced-resolve": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-4.0.0.tgz",
-      "integrity": "sha512-jox/62b2GofV1qTUQTMPEJSDIGycS43evqYzD/KVtEb9OCoki9cnacUPxCrZa7JfPzZSYOCZhu9O9luaMxAX8g==",
-      "dev": true,
-      "requires": {
-        "graceful-fs": "^4.1.2",
-        "memory-fs": "^0.4.0",
-        "tapable": "^1.0.0"
-      }
-    },
-    "envinfo": {
-      "version": "5.10.0",
-      "resolved": "https://registry.npmjs.org/envinfo/-/envinfo-5.10.0.tgz",
-      "integrity": "sha512-rXbzXWvnQxy+TcqZlARbWVQwgGVVouVJgFZhLVN5htjLxl1thstrP2ZGi0pXC309AbK7gVOPU+ulz/tmpCI7iw==",
-      "dev": true
-    },
-    "errno": {
-      "version": "0.1.7",
-      "resolved": "https://registry.npmjs.org/errno/-/errno-0.1.7.tgz",
-      "integrity": "sha512-MfrRBDWzIWifgq6tJj60gkAwtLNb6sQPlcFrSOflcP1aFmmruKQ2wRnze/8V6kgyz7H3FF8Npzv78mZ7XLLflg==",
-      "dev": true,
-      "requires": {
-        "prr": "~1.0.1"
-      }
-    },
-    "error": {
-      "version": "7.0.2",
-      "resolved": "https://registry.npmjs.org/error/-/error-7.0.2.tgz",
-      "integrity": "sha1-pfdf/02ZJhJt2sDqXcOOaJFTywI=",
-      "dev": true,
-      "requires": {
-        "string-template": "~0.2.1",
-        "xtend": "~4.0.0"
-      }
-    },
-    "error-ex": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.1.tgz",
-      "integrity": "sha1-+FWobOYa3E6GIcPNoh56dhLDqNw=",
-      "dev": true,
-      "requires": {
-        "is-arrayish": "^0.2.1"
-      }
-    },
-    "escape-string-regexp": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
-      "integrity": "sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=",
-      "dev": true
-    },
-    "eslint": {
-      "version": "4.19.1",
-      "resolved": "https://registry.npmjs.org/eslint/-/eslint-4.19.1.tgz",
-      "integrity": "sha512-bT3/1x1EbZB7phzYu7vCr1v3ONuzDtX8WjuM9c0iYxe+cq+pwcKEoQjl7zd3RpC6YOLgnSy3cTN58M2jcoPDIQ==",
-      "dev": true,
-      "requires": {
-        "ajv": "^5.3.0",
-        "babel-code-frame": "^6.22.0",
-        "chalk": "^2.1.0",
-        "concat-stream": "^1.6.0",
-        "cross-spawn": "^5.1.0",
-        "debug": "^3.1.0",
-        "doctrine": "^2.1.0",
-        "eslint-scope": "^3.7.1",
-        "eslint-visitor-keys": "^1.0.0",
-        "espree": "^3.5.4",
-        "esquery": "^1.0.0",
-        "esutils": "^2.0.2",
-        "file-entry-cache": "^2.0.0",
-        "functional-red-black-tree": "^1.0.1",
-        "glob": "^7.1.2",
-        "globals": "^11.0.1",
-        "ignore": "^3.3.3",
-        "imurmurhash": "^0.1.4",
-        "inquirer": "^3.0.6",
-        "is-resolvable": "^1.0.0",
-        "js-yaml": "^3.9.1",
-        "json-stable-stringify-without-jsonify": "^1.0.1",
-        "levn": "^0.3.0",
-        "lodash": "^4.17.4",
-        "minimatch": "^3.0.2",
-        "mkdirp": "^0.5.1",
-        "natural-compare": "^1.4.0",
-        "optionator": "^0.8.2",
-        "path-is-inside": "^1.0.2",
-        "pluralize": "^7.0.0",
-        "progress": "^2.0.0",
-        "regexpp": "^1.0.1",
-        "require-uncached": "^1.0.3",
-        "semver": "^5.3.0",
-        "strip-ansi": "^4.0.0",
-        "strip-json-comments": "~2.0.1",
-        "table": "4.0.2",
-        "text-table": "~0.2.0"
-      },
-      "dependencies": {
-        "ajv": {
-          "version": "5.5.2",
-          "resolved": "https://registry.npmjs.org/ajv/-/ajv-5.5.2.tgz",
-          "integrity": "sha1-c7Xuyj+rZT49P5Qis0GtQiBdyWU=",
-          "dev": true,
-          "requires": {
-            "co": "^4.6.0",
-            "fast-deep-equal": "^1.0.0",
-            "fast-json-stable-stringify": "^2.0.0",
-            "json-schema-traverse": "^0.3.0"
-          }
-        },
-        "cross-spawn": {
-          "version": "5.1.0",
-          "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-5.1.0.tgz",
-          "integrity": "sha1-6L0O/uWPz/b4+UUQoKVUu/ojVEk=",
-          "dev": true,
-          "requires": {
-            "lru-cache": "^4.0.1",
-            "shebang-command": "^1.2.0",
-            "which": "^1.2.9"
-          }
-        },
-        "debug": {
-          "version": "3.1.0",
-          "resolved": "https://registry.npmjs.org/debug/-/debug-3.1.0.tgz",
-          "integrity": "sha512-OX8XqP7/1a9cqkxYw2yXss15f26NKWBpDXQd0/uK/KPqdQhxbPa994hnzjcE2VqQpDslf55723cKPUOGSmMY3g==",
-          "dev": true,
-          "requires": {
-            "ms": "2.0.0"
-          }
-        },
-        "fast-deep-equal": {
-          "version": "1.1.0",
-          "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-1.1.0.tgz",
-          "integrity": "sha1-wFNHeBfIa1HaqFPIHgWbcz0CNhQ=",
-          "dev": true
-        },
-        "globals": {
-          "version": "11.5.0",
-          "resolved": "https://registry.npmjs.org/globals/-/globals-11.5.0.tgz",
-          "integrity": "sha512-hYyf+kI8dm3nORsiiXUQigOU62hDLfJ9G01uyGMxhc6BKsircrUhC4uJPQPUSuq2GrTmiiEt7ewxlMdBewfmKQ==",
-          "dev": true
-        },
-        "inquirer": {
-          "version": "3.3.0",
-          "resolved": "https://registry.npmjs.org/inquirer/-/inquirer-3.3.0.tgz",
-          "integrity": "sha512-h+xtnyk4EwKvFWHrUYsWErEVR+igKtLdchu+o0Z1RL7VU/jVMFbYir2bp6bAj8efFNxWqHX0dIss6fJQ+/+qeQ==",
-          "dev": true,
-          "requires": {
-            "ansi-escapes": "^3.0.0",
-            "chalk": "^2.0.0",
-            "cli-cursor": "^2.1.0",
-            "cli-width": "^2.0.0",
-            "external-editor": "^2.0.4",
-            "figures": "^2.0.0",
-            "lodash": "^4.3.0",
-            "mute-stream": "0.0.7",
-            "run-async": "^2.2.0",
-            "rx-lite": "^4.0.8",
-            "rx-lite-aggregates": "^4.0.8",
-            "string-width": "^2.1.0",
-            "strip-ansi": "^4.0.0",
-            "through": "^2.3.6"
-          }
-        }
-      }
-    },
-    "eslint-scope": {
-      "version": "3.7.1",
-      "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-3.7.1.tgz",
-      "integrity": "sha1-PWPD7f2gLgbgGkUq2IyqzHzctug=",
-      "dev": true,
-      "requires": {
-        "esrecurse": "^4.1.0",
-        "estraverse": "^4.1.1"
-      }
-    },
-    "eslint-visitor-keys": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-1.0.0.tgz",
-      "integrity": "sha512-qzm/XxIbxm/FHyH341ZrbnMUpe+5Bocte9xkmFMzPMjRaZMcXww+MpBptFvtU+79L362nqiLhekCxCxDPaUMBQ==",
-      "dev": true
-    },
-    "espree": {
-      "version": "3.5.4",
-      "resolved": "https://registry.npmjs.org/espree/-/espree-3.5.4.tgz",
-      "integrity": "sha512-yAcIQxtmMiB/jL32dzEp2enBeidsB7xWPLNiw3IIkpVds1P+h7qF9YwJq1yUNzp2OKXgAprs4F61ih66UsoD1A==",
-      "dev": true,
-      "requires": {
-        "acorn": "^5.5.0",
-        "acorn-jsx": "^3.0.0"
-      }
-    },
-    "esprima": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.0.tgz",
-      "integrity": "sha512-oftTcaMu/EGrEIu904mWteKIv8vMuOgGYo7EhVJJN00R/EED9DCua/xxHRdYnKtcECzVg7xOWhflvJMnqcFZjw==",
-      "dev": true
-    },
-    "esquery": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.0.1.tgz",
-      "integrity": "sha512-SmiyZ5zIWH9VM+SRUReLS5Q8a7GxtRdxEBVZpm98rJM7Sb+A9DVCndXfkeFUd3byderg+EbDkfnevfCwynWaNA==",
-      "dev": true,
-      "requires": {
-        "estraverse": "^4.0.0"
-      }
-    },
-    "esrecurse": {
-      "version": "4.2.1",
-      "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.2.1.tgz",
-      "integrity": "sha512-64RBB++fIOAXPw3P9cy89qfMlvZEXZkqqJkjqqXIvzP5ezRZjW+lPWjw35UX/3EhUPFYbg5ER4JYgDw4007/DQ==",
-      "dev": true,
-      "requires": {
-        "estraverse": "^4.1.0"
-      }
-    },
-    "estraverse": {
-      "version": "4.2.0",
-      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.2.0.tgz",
-      "integrity": "sha1-De4/7TH81GlhjOc0IJn8GvoL2xM=",
-      "dev": true
-    },
-    "esutils": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.2.tgz",
-      "integrity": "sha1-Cr9PHKpbyx96nYrMbepPqqBLrJs=",
-      "dev": true
-    },
-    "events": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/events/-/events-1.1.1.tgz",
-      "integrity": "sha1-nr23Y1rQmccNzEwqH1AEKI6L2SQ=",
-      "dev": true
-    },
-    "evp_bytestokey": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/evp_bytestokey/-/evp_bytestokey-1.0.3.tgz",
-      "integrity": "sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA==",
-      "dev": true,
-      "requires": {
-        "md5.js": "^1.3.4",
-        "safe-buffer": "^5.1.1"
-      }
-    },
-    "execa": {
-      "version": "0.7.0",
-      "resolved": "https://registry.npmjs.org/execa/-/execa-0.7.0.tgz",
-      "integrity": "sha1-lEvs00zEHuMqY6n68nrVpl/Fl3c=",
-      "dev": true,
-      "requires": {
-        "cross-spawn": "^5.0.1",
-        "get-stream": "^3.0.0",
-        "is-stream": "^1.1.0",
-        "npm-run-path": "^2.0.0",
-        "p-finally": "^1.0.0",
-        "signal-exit": "^3.0.0",
-        "strip-eof": "^1.0.0"
-      },
-      "dependencies": {
-        "cross-spawn": {
-          "version": "5.1.0",
-          "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-5.1.0.tgz",
-          "integrity": "sha1-6L0O/uWPz/b4+UUQoKVUu/ojVEk=",
-          "dev": true,
-          "requires": {
-            "lru-cache": "^4.0.1",
-            "shebang-command": "^1.2.0",
-            "which": "^1.2.9"
-          }
-        }
-      }
-    },
-    "exit-hook": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/exit-hook/-/exit-hook-1.1.1.tgz",
-      "integrity": "sha1-8FyiM7SMBdVP/wd2XfhQfpXAL/g=",
-      "dev": true
-    },
-    "expand-brackets": {
-      "version": "2.1.4",
-      "resolved": "https://registry.npmjs.org/expand-brackets/-/expand-brackets-2.1.4.tgz",
-      "integrity": "sha1-t3c14xXOMPa27/D4OwQVGiJEliI=",
-      "dev": true,
-      "requires": {
-        "debug": "^2.3.3",
-        "define-property": "^0.2.5",
-        "extend-shallow": "^2.0.1",
-        "posix-character-classes": "^0.1.0",
-        "regex-not": "^1.0.0",
-        "snapdragon": "^0.8.1",
-        "to-regex": "^3.0.1"
-      },
-      "dependencies": {
-        "define-property": {
-          "version": "0.2.5",
-          "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz",
-          "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=",
-          "dev": true,
-          "requires": {
-            "is-descriptor": "^0.1.0"
-          }
-        },
-        "extend-shallow": {
-          "version": "2.0.1",
-          "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz",
-          "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
-          "dev": true,
-          "requires": {
-            "is-extendable": "^0.1.0"
-          }
-        }
-      }
-    },
-    "expand-range": {
-      "version": "1.8.2",
-      "resolved": "https://registry.npmjs.org/expand-range/-/expand-range-1.8.2.tgz",
-      "integrity": "sha1-opnv/TNf4nIeuujiV+x5ZE/IUzc=",
-      "dev": true,
-      "requires": {
-        "fill-range": "^2.1.0"
-      },
-      "dependencies": {
-        "fill-range": {
-          "version": "2.2.4",
-          "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-2.2.4.tgz",
-          "integrity": "sha512-cnrcCbj01+j2gTG921VZPnHbjmdAf8oQV/iGeV2kZxGSyfYjjTyY79ErsK1WJWMpw6DaApEX72binqJE+/d+5Q==",
-          "dev": true,
-          "requires": {
-            "is-number": "^2.1.0",
-            "isobject": "^2.0.0",
-            "randomatic": "^3.0.0",
-            "repeat-element": "^1.1.2",
-            "repeat-string": "^1.5.2"
-          }
-        },
-        "is-number": {
-          "version": "2.1.0",
-          "resolved": "https://registry.npmjs.org/is-number/-/is-number-2.1.0.tgz",
-          "integrity": "sha1-Afy7s5NGOlSPL0ZszhbezknbkI8=",
-          "dev": true,
-          "requires": {
-            "kind-of": "^3.0.2"
-          }
-        },
-        "isobject": {
-          "version": "2.1.0",
-          "resolved": "https://registry.npmjs.org/isobject/-/isobject-2.1.0.tgz",
-          "integrity": "sha1-8GVWEJaj8dou9GJy+BXIQNh+DIk=",
-          "dev": true,
-          "requires": {
-            "isarray": "1.0.0"
-          }
-        },
-        "kind-of": {
-          "version": "3.2.2",
-          "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz",
-          "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=",
-          "dev": true,
-          "requires": {
-            "is-buffer": "^1.1.5"
-          }
-        }
-      }
-    },
-    "expand-tilde": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/expand-tilde/-/expand-tilde-2.0.2.tgz",
-      "integrity": "sha1-l+gBqgUt8CRU3kawK/YhZCzchQI=",
-      "dev": true,
-      "requires": {
-        "homedir-polyfill": "^1.0.1"
-      }
-    },
-    "extend-shallow": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz",
-      "integrity": "sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg=",
-      "dev": true,
-      "requires": {
-        "assign-symbols": "^1.0.0",
-        "is-extendable": "^1.0.1"
-      },
-      "dependencies": {
-        "is-extendable": {
-          "version": "1.0.1",
-          "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz",
-          "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==",
-          "dev": true,
-          "requires": {
-            "is-plain-object": "^2.0.4"
-          }
-        }
-      }
-    },
-    "external-editor": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/external-editor/-/external-editor-2.2.0.tgz",
-      "integrity": "sha512-bSn6gvGxKt+b7+6TKEv1ZycHleA7aHhRHyAqJyp5pbUFuYYNIzpZnQDk7AsYckyWdEnTeAnay0aCy2aV6iTk9A==",
-      "dev": true,
-      "requires": {
-        "chardet": "^0.4.0",
-        "iconv-lite": "^0.4.17",
-        "tmp": "^0.0.33"
-      }
-    },
-    "extglob": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/extglob/-/extglob-2.0.4.tgz",
-      "integrity": "sha512-Nmb6QXkELsuBr24CJSkilo6UHHgbekK5UiZgfE6UHD3Eb27YC6oD+bhcT+tJ6cl8dmsgdQxnWlcry8ksBIBLpw==",
-      "dev": true,
-      "requires": {
-        "array-unique": "^0.3.2",
-        "define-property": "^1.0.0",
-        "expand-brackets": "^2.1.4",
-        "extend-shallow": "^2.0.1",
-        "fragment-cache": "^0.2.1",
-        "regex-not": "^1.0.0",
-        "snapdragon": "^0.8.1",
-        "to-regex": "^3.0.1"
-      },
-      "dependencies": {
-        "define-property": {
-          "version": "1.0.0",
-          "resolved": "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz",
-          "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=",
-          "dev": true,
-          "requires": {
-            "is-descriptor": "^1.0.0"
-          }
-        },
-        "extend-shallow": {
-          "version": "2.0.1",
-          "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz",
-          "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
-          "dev": true,
-          "requires": {
-            "is-extendable": "^0.1.0"
-          }
-        },
-        "is-accessor-descriptor": {
-          "version": "1.0.0",
-          "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz",
-          "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==",
-          "dev": true,
-          "requires": {
-            "kind-of": "^6.0.0"
-          }
-        },
-        "is-data-descriptor": {
-          "version": "1.0.0",
-          "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz",
-          "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==",
-          "dev": true,
-          "requires": {
-            "kind-of": "^6.0.0"
-          }
-        },
-        "is-descriptor": {
-          "version": "1.0.2",
-          "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz",
-          "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==",
-          "dev": true,
-          "requires": {
-            "is-accessor-descriptor": "^1.0.0",
-            "is-data-descriptor": "^1.0.0",
-            "kind-of": "^6.0.2"
-          }
-        }
-      }
-    },
-    "fast-deep-equal": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-2.0.1.tgz",
-      "integrity": "sha1-ewUhjd+WZ79/Nwv3/bLLFf3Qqkk=",
-      "dev": true
-    },
-    "fast-glob": {
-      "version": "2.2.2",
-      "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-2.2.2.tgz",
-      "integrity": "sha512-TR6zxCKftDQnUAPvkrCWdBgDq/gbqx8A3ApnBrR5rMvpp6+KMJI0Igw7fkWPgeVK0uhRXTXdvO3O+YP0CaUX2g==",
-      "dev": true,
-      "requires": {
-        "@mrmlnc/readdir-enhanced": "^2.2.1",
-        "@nodelib/fs.stat": "^1.0.1",
-        "glob-parent": "^3.1.0",
-        "is-glob": "^4.0.0",
-        "merge2": "^1.2.1",
-        "micromatch": "^3.1.10"
-      }
-    },
-    "fast-json-stable-stringify": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.0.0.tgz",
-      "integrity": "sha1-1RQsDK7msRifh9OnYREGT4bIu/I=",
-      "dev": true
-    },
-    "fast-levenshtein": {
-      "version": "2.0.6",
-      "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
-      "integrity": "sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc=",
-      "dev": true
-    },
-    "figures": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/figures/-/figures-2.0.0.tgz",
-      "integrity": "sha1-OrGi0qYsi/tDGgyUy3l6L84nyWI=",
-      "dev": true,
-      "requires": {
-        "escape-string-regexp": "^1.0.5"
-      }
-    },
-    "file-entry-cache": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-2.0.0.tgz",
-      "integrity": "sha1-w5KZDD5oR4PYOLjISkXYoEhFg2E=",
-      "dev": true,
-      "requires": {
-        "flat-cache": "^1.2.1",
-        "object-assign": "^4.0.1"
-      }
-    },
-    "filename-regex": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/filename-regex/-/filename-regex-2.0.1.tgz",
-      "integrity": "sha1-wcS5vuPglyXdsQa3XB4wH+LxiyY=",
-      "dev": true
-    },
-    "fill-range": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-4.0.0.tgz",
-      "integrity": "sha1-1USBHUKPmOsGpj3EAtJAPDKMOPc=",
-      "dev": true,
-      "requires": {
-        "extend-shallow": "^2.0.1",
-        "is-number": "^3.0.0",
-        "repeat-string": "^1.6.1",
-        "to-regex-range": "^2.1.0"
-      },
-      "dependencies": {
-        "extend-shallow": {
-          "version": "2.0.1",
-          "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz",
-          "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
-          "dev": true,
-          "requires": {
-            "is-extendable": "^0.1.0"
-          }
-        }
-      }
-    },
-    "find-cache-dir": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/find-cache-dir/-/find-cache-dir-1.0.0.tgz",
-      "integrity": "sha1-kojj6ePMN0hxfTnq3hfPcfww7m8=",
-      "dev": true,
-      "requires": {
-        "commondir": "^1.0.1",
-        "make-dir": "^1.0.0",
-        "pkg-dir": "^2.0.0"
-      }
-    },
-    "find-up": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/find-up/-/find-up-2.1.0.tgz",
-      "integrity": "sha1-RdG35QbHF93UgndaK3eSCjwMV6c=",
-      "dev": true,
-      "requires": {
-        "locate-path": "^2.0.0"
-      }
-    },
-    "first-chunk-stream": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/first-chunk-stream/-/first-chunk-stream-2.0.0.tgz",
-      "integrity": "sha1-G97NuOCDwGZLkZRVgVd6Q6nzHXA=",
-      "dev": true,
-      "requires": {
-        "readable-stream": "^2.0.2"
-      }
-    },
-    "flat-cache": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-1.3.0.tgz",
-      "integrity": "sha1-0wMLMrOBVPTjt+nHCfSQ9++XxIE=",
-      "dev": true,
-      "requires": {
-        "circular-json": "^0.3.1",
-        "del": "^2.0.2",
-        "graceful-fs": "^4.1.2",
-        "write": "^0.2.1"
-      }
-    },
-    "flow-parser": {
-      "version": "0.73.0",
-      "resolved": "https://registry.npmjs.org/flow-parser/-/flow-parser-0.73.0.tgz",
-      "integrity": "sha512-9JB+2hrKJ+S1OZ+upIwNTGlaLDRga2iC9KvpqWVFEVNlCxc51pkhNJRmA0PmUcLcEtFAW6IGBmVi70r+j+Qp9A==",
-      "dev": true
-    },
-    "flush-write-stream": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/flush-write-stream/-/flush-write-stream-1.0.3.tgz",
-      "integrity": "sha512-calZMC10u0FMUqoiunI2AiGIIUtUIvifNwkHhNupZH4cbNnW1Itkoh/Nf5HFYmDrwWPjrUxpkZT0KhuCq0jmGw==",
-      "dev": true,
-      "requires": {
-        "inherits": "^2.0.1",
-        "readable-stream": "^2.0.4"
-      }
-    },
-    "for-in": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/for-in/-/for-in-1.0.2.tgz",
-      "integrity": "sha1-gQaNKVqBQuwKxybG4iAMMPttXoA=",
-      "dev": true
-    },
-    "for-own": {
-      "version": "0.1.5",
-      "resolved": "https://registry.npmjs.org/for-own/-/for-own-0.1.5.tgz",
-      "integrity": "sha1-UmXGgaTylNq78XyVCbZ2OqhFEM4=",
-      "dev": true,
-      "requires": {
-        "for-in": "^1.0.1"
-      }
-    },
-    "fragment-cache": {
-      "version": "0.2.1",
-      "resolved": "https://registry.npmjs.org/fragment-cache/-/fragment-cache-0.2.1.tgz",
-      "integrity": "sha1-QpD60n8T6Jvn8zeZxrxaCr//DRk=",
-      "dev": true,
-      "requires": {
-        "map-cache": "^0.2.2"
-      }
-    },
-    "from2": {
-      "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/from2/-/from2-2.3.0.tgz",
-      "integrity": "sha1-i/tVAr3kpNNs/e6gB/zKIdfjgq8=",
-      "dev": true,
-      "requires": {
-        "inherits": "^2.0.1",
-        "readable-stream": "^2.0.0"
-      }
-    },
-    "fs-write-stream-atomic": {
-      "version": "1.0.10",
-      "resolved": "https://registry.npmjs.org/fs-write-stream-atomic/-/fs-write-stream-atomic-1.0.10.tgz",
-      "integrity": "sha1-tH31NJPvkR33VzHnCp3tAYnbQMk=",
-      "dev": true,
-      "requires": {
-        "graceful-fs": "^4.1.2",
-        "iferr": "^0.1.5",
-        "imurmurhash": "^0.1.4",
-        "readable-stream": "1 || 2"
-      }
-    },
-    "fs.realpath": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
-      "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=",
-      "dev": true
-    },
-    "fsevents": {
-      "version": "1.2.4",
-      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-1.2.4.tgz",
-      "integrity": "sha512-z8H8/diyk76B7q5wg+Ud0+CqzcAF3mBBI/bA5ne5zrRUUIvNkJY//D3BqyH571KuAC4Nr7Rw7CjWX4r0y9DvNg==",
-      "dev": true,
-      "optional": true,
-      "requires": {
-        "nan": "^2.9.2",
-        "node-pre-gyp": "^0.10.0"
-      },
-      "dependencies": {
-        "abbrev": {
-          "version": "1.1.1",
-          "bundled": true,
-          "dev": true,
-          "optional": true
-        },
-        "ansi-regex": {
-          "version": "2.1.1",
-          "bundled": true,
-          "dev": true
-        },
-        "aproba": {
-          "version": "1.2.0",
-          "bundled": true,
-          "dev": true,
-          "optional": true
-        },
-        "are-we-there-yet": {
-          "version": "1.1.4",
-          "bundled": true,
-          "dev": true,
-          "optional": true,
-          "requires": {
-            "delegates": "^1.0.0",
-            "readable-stream": "^2.0.6"
-          }
-        },
-        "balanced-match": {
-          "version": "1.0.0",
-          "bundled": true,
-          "dev": true
-        },
-        "brace-expansion": {
-          "version": "1.1.11",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "balanced-match": "^1.0.0",
-            "concat-map": "0.0.1"
-          }
-        },
-        "chownr": {
-          "version": "1.0.1",
-          "bundled": true,
-          "dev": true,
-          "optional": true
-        },
-        "code-point-at": {
-          "version": "1.1.0",
-          "bundled": true,
-          "dev": true
-        },
-        "concat-map": {
-          "version": "0.0.1",
-          "bundled": true,
-          "dev": true
-        },
-        "console-control-strings": {
-          "version": "1.1.0",
-          "bundled": true,
-          "dev": true
-        },
-        "core-util-is": {
-          "version": "1.0.2",
-          "bundled": true,
-          "dev": true,
-          "optional": true
-        },
-        "debug": {
-          "version": "2.6.9",
-          "bundled": true,
-          "dev": true,
-          "optional": true,
-          "requires": {
-            "ms": "2.0.0"
-          }
-        },
-        "deep-extend": {
-          "version": "0.5.1",
-          "bundled": true,
-          "dev": true,
-          "optional": true
-        },
-        "delegates": {
-          "version": "1.0.0",
-          "bundled": true,
-          "dev": true,
-          "optional": true
-        },
-        "detect-libc": {
-          "version": "1.0.3",
-          "bundled": true,
-          "dev": true,
-          "optional": true
-        },
-        "fs-minipass": {
-          "version": "1.2.5",
-          "bundled": true,
-          "dev": true,
-          "optional": true,
-          "requires": {
-            "minipass": "^2.2.1"
-          }
-        },
-        "fs.realpath": {
-          "version": "1.0.0",
-          "bundled": true,
-          "dev": true,
-          "optional": true
-        },
-        "gauge": {
-          "version": "2.7.4",
-          "bundled": true,
-          "dev": true,
-          "optional": true,
-          "requires": {
-            "aproba": "^1.0.3",
-            "console-control-strings": "^1.0.0",
-            "has-unicode": "^2.0.0",
-            "object-assign": "^4.1.0",
-            "signal-exit": "^3.0.0",
-            "string-width": "^1.0.1",
-            "strip-ansi": "^3.0.1",
-            "wide-align": "^1.1.0"
-          }
-        },
-        "glob": {
-          "version": "7.1.2",
-          "bundled": true,
-          "dev": true,
-          "optional": true,
-          "requires": {
-            "fs.realpath": "^1.0.0",
-            "inflight": "^1.0.4",
-            "inherits": "2",
-            "minimatch": "^3.0.4",
-            "once": "^1.3.0",
-            "path-is-absolute": "^1.0.0"
-          }
-        },
-        "has-unicode": {
-          "version": "2.0.1",
-          "bundled": true,
-          "dev": true,
-          "optional": true
-        },
-        "iconv-lite": {
-          "version": "0.4.21",
-          "bundled": true,
-          "dev": true,
-          "optional": true,
-          "requires": {
-            "safer-buffer": "^2.1.0"
-          }
-        },
-        "ignore-walk": {
-          "version": "3.0.1",
-          "bundled": true,
-          "dev": true,
-          "optional": true,
-          "requires": {
-            "minimatch": "^3.0.4"
-          }
-        },
-        "inflight": {
-          "version": "1.0.6",
-          "bundled": true,
-          "dev": true,
-          "optional": true,
-          "requires": {
-            "once": "^1.3.0",
-            "wrappy": "1"
-          }
-        },
-        "inherits": {
-          "version": "2.0.3",
-          "bundled": true,
-          "dev": true
-        },
-        "ini": {
-          "version": "1.3.5",
-          "bundled": true,
-          "dev": true,
-          "optional": true
-        },
-        "is-fullwidth-code-point": {
-          "version": "1.0.0",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "number-is-nan": "^1.0.0"
-          }
-        },
-        "isarray": {
-          "version": "1.0.0",
-          "bundled": true,
-          "dev": true,
-          "optional": true
-        },
-        "minimatch": {
-          "version": "3.0.4",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "brace-expansion": "^1.1.7"
-          }
-        },
-        "minimist": {
-          "version": "0.0.8",
-          "bundled": true,
-          "dev": true
-        },
-        "minipass": {
-          "version": "2.2.4",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "safe-buffer": "^5.1.1",
-            "yallist": "^3.0.0"
-          }
-        },
-        "minizlib": {
-          "version": "1.1.0",
-          "bundled": true,
-          "dev": true,
-          "optional": true,
-          "requires": {
-            "minipass": "^2.2.1"
-          }
-        },
-        "mkdirp": {
-          "version": "0.5.1",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "minimist": "0.0.8"
-          }
-        },
-        "ms": {
-          "version": "2.0.0",
-          "bundled": true,
-          "dev": true,
-          "optional": true
-        },
-        "needle": {
-          "version": "2.2.0",
-          "bundled": true,
-          "dev": true,
-          "optional": true,
-          "requires": {
-            "debug": "^2.1.2",
-            "iconv-lite": "^0.4.4",
-            "sax": "^1.2.4"
-          }
-        },
-        "node-pre-gyp": {
-          "version": "0.10.0",
-          "bundled": true,
-          "dev": true,
-          "optional": true,
-          "requires": {
-            "detect-libc": "^1.0.2",
-            "mkdirp": "^0.5.1",
-            "needle": "^2.2.0",
-            "nopt": "^4.0.1",
-            "npm-packlist": "^1.1.6",
-            "npmlog": "^4.0.2",
-            "rc": "^1.1.7",
-            "rimraf": "^2.6.1",
-            "semver": "^5.3.0",
-            "tar": "^4"
-          }
-        },
-        "nopt": {
-          "version": "4.0.1",
-          "bundled": true,
-          "dev": true,
-          "optional": true,
-          "requires": {
-            "abbrev": "1",
-            "osenv": "^0.1.4"
-          }
-        },
-        "npm-bundled": {
-          "version": "1.0.3",
-          "bundled": true,
-          "dev": true,
-          "optional": true
-        },
-        "npm-packlist": {
-          "version": "1.1.10",
-          "bundled": true,
-          "dev": true,
-          "optional": true,
-          "requires": {
-            "ignore-walk": "^3.0.1",
-            "npm-bundled": "^1.0.1"
-          }
-        },
-        "npmlog": {
-          "version": "4.1.2",
-          "bundled": true,
-          "dev": true,
-          "optional": true,
-          "requires": {
-            "are-we-there-yet": "~1.1.2",
-            "console-control-strings": "~1.1.0",
-            "gauge": "~2.7.3",
-            "set-blocking": "~2.0.0"
-          }
-        },
-        "number-is-nan": {
-          "version": "1.0.1",
-          "bundled": true,
-          "dev": true
-        },
-        "object-assign": {
-          "version": "4.1.1",
-          "bundled": true,
-          "dev": true,
-          "optional": true
-        },
-        "once": {
-          "version": "1.4.0",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "wrappy": "1"
-          }
-        },
-        "os-homedir": {
-          "version": "1.0.2",
-          "bundled": true,
-          "dev": true,
-          "optional": true
-        },
-        "os-tmpdir": {
-          "version": "1.0.2",
-          "bundled": true,
-          "dev": true,
-          "optional": true
-        },
-        "osenv": {
-          "version": "0.1.5",
-          "bundled": true,
-          "dev": true,
-          "optional": true,
-          "requires": {
-            "os-homedir": "^1.0.0",
-            "os-tmpdir": "^1.0.0"
-          }
-        },
-        "path-is-absolute": {
-          "version": "1.0.1",
-          "bundled": true,
-          "dev": true,
-          "optional": true
-        },
-        "process-nextick-args": {
-          "version": "2.0.0",
-          "bundled": true,
-          "dev": true,
-          "optional": true
-        },
-        "rc": {
-          "version": "1.2.7",
-          "bundled": true,
-          "dev": true,
-          "optional": true,
-          "requires": {
-            "deep-extend": "^0.5.1",
-            "ini": "~1.3.0",
-            "minimist": "^1.2.0",
-            "strip-json-comments": "~2.0.1"
-          },
-          "dependencies": {
-            "minimist": {
-              "version": "1.2.0",
-              "bundled": true,
-              "dev": true,
-              "optional": true
-            }
-          }
-        },
-        "readable-stream": {
-          "version": "2.3.6",
-          "bundled": true,
-          "dev": true,
-          "optional": true,
-          "requires": {
-            "core-util-is": "~1.0.0",
-            "inherits": "~2.0.3",
-            "isarray": "~1.0.0",
-            "process-nextick-args": "~2.0.0",
-            "safe-buffer": "~5.1.1",
-            "string_decoder": "~1.1.1",
-            "util-deprecate": "~1.0.1"
-          }
-        },
-        "rimraf": {
-          "version": "2.6.2",
-          "bundled": true,
-          "dev": true,
-          "optional": true,
-          "requires": {
-            "glob": "^7.0.5"
-          }
-        },
-        "safe-buffer": {
-          "version": "5.1.1",
-          "bundled": true,
-          "dev": true
-        },
-        "safer-buffer": {
-          "version": "2.1.2",
-          "bundled": true,
-          "dev": true,
-          "optional": true
-        },
-        "sax": {
-          "version": "1.2.4",
-          "bundled": true,
-          "dev": true,
-          "optional": true
-        },
-        "semver": {
-          "version": "5.5.0",
-          "bundled": true,
-          "dev": true,
-          "optional": true
-        },
-        "set-blocking": {
-          "version": "2.0.0",
-          "bundled": true,
-          "dev": true,
-          "optional": true
-        },
-        "signal-exit": {
-          "version": "3.0.2",
-          "bundled": true,
-          "dev": true,
-          "optional": true
-        },
-        "string-width": {
-          "version": "1.0.2",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "code-point-at": "^1.0.0",
-            "is-fullwidth-code-point": "^1.0.0",
-            "strip-ansi": "^3.0.0"
-          }
-        },
-        "string_decoder": {
-          "version": "1.1.1",
-          "bundled": true,
-          "dev": true,
-          "optional": true,
-          "requires": {
-            "safe-buffer": "~5.1.0"
-          }
-        },
-        "strip-ansi": {
-          "version": "3.0.1",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "ansi-regex": "^2.0.0"
-          }
-        },
-        "strip-json-comments": {
-          "version": "2.0.1",
-          "bundled": true,
-          "dev": true,
-          "optional": true
-        },
-        "tar": {
-          "version": "4.4.1",
-          "bundled": true,
-          "dev": true,
-          "optional": true,
-          "requires": {
-            "chownr": "^1.0.1",
-            "fs-minipass": "^1.2.5",
-            "minipass": "^2.2.4",
-            "minizlib": "^1.1.0",
-            "mkdirp": "^0.5.0",
-            "safe-buffer": "^5.1.1",
-            "yallist": "^3.0.2"
-          }
-        },
-        "util-deprecate": {
-          "version": "1.0.2",
-          "bundled": true,
-          "dev": true,
-          "optional": true
-        },
-        "wide-align": {
-          "version": "1.1.2",
-          "bundled": true,
-          "dev": true,
-          "optional": true,
-          "requires": {
-            "string-width": "^1.0.2"
-          }
-        },
-        "wrappy": {
-          "version": "1.0.2",
-          "bundled": true,
-          "dev": true
-        },
-        "yallist": {
-          "version": "3.0.2",
-          "bundled": true,
-          "dev": true
-        }
-      }
-    },
-    "functional-red-black-tree": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz",
-      "integrity": "sha1-GwqzvVU7Kg1jmdKcDj6gslIHgyc=",
-      "dev": true
-    },
-    "get-caller-file": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-1.0.2.tgz",
-      "integrity": "sha1-9wLmMSfn4jHBYKgMFVSstw1QR+U=",
-      "dev": true
-    },
-    "get-stream": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-3.0.0.tgz",
-      "integrity": "sha1-jpQ9E1jcN1VQVOy+LtsFqhdO3hQ=",
-      "dev": true
-    },
-    "get-value": {
-      "version": "2.0.6",
-      "resolved": "https://registry.npmjs.org/get-value/-/get-value-2.0.6.tgz",
-      "integrity": "sha1-3BXKHGcjh8p2vTesCjlbogQqLCg=",
-      "dev": true
-    },
-    "gh-got": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/gh-got/-/gh-got-6.0.0.tgz",
-      "integrity": "sha512-F/mS+fsWQMo1zfgG9MD8KWvTWPPzzhuVwY++fhQ5Ggd+0P+CAMHtzMZhNxG+TqGfHDChJKsbh6otfMGqO2AKBw==",
-      "dev": true,
-      "requires": {
-        "got": "^7.0.0",
-        "is-plain-obj": "^1.1.0"
-      },
-      "dependencies": {
-        "got": {
-          "version": "7.1.0",
-          "resolved": "https://registry.npmjs.org/got/-/got-7.1.0.tgz",
-          "integrity": "sha512-Y5WMo7xKKq1muPsxD+KmrR8DH5auG7fBdDVueZwETwV6VytKyU9OX/ddpq2/1hp1vIPvVb4T81dKQz3BivkNLw==",
-          "dev": true,
-          "requires": {
-            "decompress-response": "^3.2.0",
-            "duplexer3": "^0.1.4",
-            "get-stream": "^3.0.0",
-            "is-plain-obj": "^1.1.0",
-            "is-retry-allowed": "^1.0.0",
-            "is-stream": "^1.0.0",
-            "isurl": "^1.0.0-alpha5",
-            "lowercase-keys": "^1.0.0",
-            "p-cancelable": "^0.3.0",
-            "p-timeout": "^1.1.1",
-            "safe-buffer": "^5.0.1",
-            "timed-out": "^4.0.0",
-            "url-parse-lax": "^1.0.0",
-            "url-to-options": "^1.0.1"
-          }
-        },
-        "p-cancelable": {
-          "version": "0.3.0",
-          "resolved": "https://registry.npmjs.org/p-cancelable/-/p-cancelable-0.3.0.tgz",
-          "integrity": "sha512-RVbZPLso8+jFeq1MfNvgXtCRED2raz/dKpacfTNxsx6pLEpEomM7gah6VeHSYV3+vo0OAi4MkArtQcWWXuQoyw==",
-          "dev": true
-        },
-        "p-timeout": {
-          "version": "1.2.1",
-          "resolved": "https://registry.npmjs.org/p-timeout/-/p-timeout-1.2.1.tgz",
-          "integrity": "sha1-XrOzU7f86Z8QGhA4iAuwVOu+o4Y=",
-          "dev": true,
-          "requires": {
-            "p-finally": "^1.0.0"
-          }
-        },
-        "prepend-http": {
-          "version": "1.0.4",
-          "resolved": "https://registry.npmjs.org/prepend-http/-/prepend-http-1.0.4.tgz",
-          "integrity": "sha1-1PRWKwzjaW5BrFLQ4ALlemNdxtw=",
-          "dev": true
-        },
-        "url-parse-lax": {
-          "version": "1.0.0",
-          "resolved": "https://registry.npmjs.org/url-parse-lax/-/url-parse-lax-1.0.0.tgz",
-          "integrity": "sha1-evjzA2Rem9eaJy56FKxovAYJ2nM=",
-          "dev": true,
-          "requires": {
-            "prepend-http": "^1.0.1"
-          }
-        }
-      }
-    },
-    "github-username": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/github-username/-/github-username-4.1.0.tgz",
-      "integrity": "sha1-y+KABBiDIG2kISrp5LXxacML9Bc=",
-      "dev": true,
-      "requires": {
-        "gh-got": "^6.0.0"
-      }
-    },
-    "glob": {
-      "version": "7.1.2",
-      "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.2.tgz",
-      "integrity": "sha512-MJTUg1kjuLeQCJ+ccE4Vpa6kKVXkPYJ2mOCQyUuKLcLQsdrMCpBPUi8qVE6+YuaJkozeA9NusTAw3hLr8Xe5EQ==",
-      "dev": true,
-      "requires": {
-        "fs.realpath": "^1.0.0",
-        "inflight": "^1.0.4",
-        "inherits": "2",
-        "minimatch": "^3.0.4",
-        "once": "^1.3.0",
-        "path-is-absolute": "^1.0.0"
-      }
-    },
-    "glob-all": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/glob-all/-/glob-all-3.1.0.tgz",
-      "integrity": "sha1-iRPd+17hrHgSZWJBsD1SF8ZLAqs=",
-      "dev": true,
-      "requires": {
-        "glob": "^7.0.5",
-        "yargs": "~1.2.6"
-      },
-      "dependencies": {
-        "minimist": {
-          "version": "0.1.0",
-          "resolved": "https://registry.npmjs.org/minimist/-/minimist-0.1.0.tgz",
-          "integrity": "sha1-md9lelJXTCHJBXSX33QnkLK0wN4=",
-          "dev": true
-        },
-        "yargs": {
-          "version": "1.2.6",
-          "resolved": "https://registry.npmjs.org/yargs/-/yargs-1.2.6.tgz",
-          "integrity": "sha1-nHtKgv1dWVsr8Xq23MQxNUMv40s=",
-          "dev": true,
-          "requires": {
-            "minimist": "^0.1.0"
-          }
-        }
-      }
-    },
-    "glob-base": {
-      "version": "0.3.0",
-      "resolved": "https://registry.npmjs.org/glob-base/-/glob-base-0.3.0.tgz",
-      "integrity": "sha1-27Fk9iIbHAscz4Kuoyi0l98Oo8Q=",
-      "dev": true,
-      "requires": {
-        "glob-parent": "^2.0.0",
-        "is-glob": "^2.0.0"
-      },
-      "dependencies": {
-        "glob-parent": {
-          "version": "2.0.0",
-          "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-2.0.0.tgz",
-          "integrity": "sha1-gTg9ctsFT8zPUzbaqQLxgvbtuyg=",
-          "dev": true,
-          "requires": {
-            "is-glob": "^2.0.0"
-          }
-        },
-        "is-extglob": {
-          "version": "1.0.0",
-          "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-1.0.0.tgz",
-          "integrity": "sha1-rEaBd8SUNAWgkvyPKXYMb/xiBsA=",
-          "dev": true
-        },
-        "is-glob": {
-          "version": "2.0.1",
-          "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-2.0.1.tgz",
-          "integrity": "sha1-0Jb5JqPe1WAPP9/ZEZjLCIjC2GM=",
-          "dev": true,
-          "requires": {
-            "is-extglob": "^1.0.0"
-          }
-        }
-      }
-    },
-    "glob-parent": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-3.1.0.tgz",
-      "integrity": "sha1-nmr2KZ2NO9K9QEMIMr0RPfkGxa4=",
-      "dev": true,
-      "requires": {
-        "is-glob": "^3.1.0",
-        "path-dirname": "^1.0.0"
-      },
-      "dependencies": {
-        "is-glob": {
-          "version": "3.1.0",
-          "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-3.1.0.tgz",
-          "integrity": "sha1-e6WuJCF4BKxwcHuWkiVnSGzD6Eo=",
-          "dev": true,
-          "requires": {
-            "is-extglob": "^2.1.0"
-          }
-        }
-      }
-    },
-    "glob-to-regexp": {
-      "version": "0.3.0",
-      "resolved": "https://registry.npmjs.org/glob-to-regexp/-/glob-to-regexp-0.3.0.tgz",
-      "integrity": "sha1-jFoUlNIGbFcMw7/kSWF1rMTVAqs=",
-      "dev": true
-    },
-    "global-modules": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/global-modules/-/global-modules-1.0.0.tgz",
-      "integrity": "sha512-sKzpEkf11GpOFuw0Zzjzmt4B4UZwjOcG757PPvrfhxcLFbq0wpsgpOqxpxtxFiCG4DtG93M6XRVbF2oGdev7bg==",
-      "dev": true,
-      "requires": {
-        "global-prefix": "^1.0.1",
-        "is-windows": "^1.0.1",
-        "resolve-dir": "^1.0.0"
-      }
-    },
-    "global-prefix": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/global-prefix/-/global-prefix-1.0.2.tgz",
-      "integrity": "sha1-2/dDxsFJklk8ZVVoy2btMsASLr4=",
-      "dev": true,
-      "requires": {
-        "expand-tilde": "^2.0.2",
-        "homedir-polyfill": "^1.0.1",
-        "ini": "^1.3.4",
-        "is-windows": "^1.0.1",
-        "which": "^1.2.14"
-      }
-    },
-    "globals": {
-      "version": "9.18.0",
-      "resolved": "https://registry.npmjs.org/globals/-/globals-9.18.0.tgz",
-      "integrity": "sha512-S0nG3CLEQiY/ILxqtztTWH/3iRRdyBLw6KMDxnKMchrtbj2OFmehVh0WUCfW3DUrIgx/qFrJPICrq4Z4sTR9UQ==",
-      "dev": true
-    },
-    "globby": {
-      "version": "8.0.1",
-      "resolved": "https://registry.npmjs.org/globby/-/globby-8.0.1.tgz",
-      "integrity": "sha512-oMrYrJERnKBLXNLVTqhm3vPEdJ/b2ZE28xN4YARiix1NOIOBPEpOUnm844K1iu/BkphCaf2WNFwMszv8Soi1pw==",
-      "dev": true,
-      "requires": {
-        "array-union": "^1.0.1",
-        "dir-glob": "^2.0.0",
-        "fast-glob": "^2.0.2",
-        "glob": "^7.1.2",
-        "ignore": "^3.3.5",
-        "pify": "^3.0.0",
-        "slash": "^1.0.0"
-      }
-    },
-    "got": {
-      "version": "8.3.1",
-      "resolved": "https://registry.npmjs.org/got/-/got-8.3.1.tgz",
-      "integrity": "sha512-tiLX+bnYm5A56T5N/n9Xo89vMaO1mrS9qoDqj3u/anVooqGozvY/HbXzEpDfbNeKsHCBpK40gSbz8wGYSp3i1w==",
-      "dev": true,
-      "requires": {
-        "@sindresorhus/is": "^0.7.0",
-        "cacheable-request": "^2.1.1",
-        "decompress-response": "^3.3.0",
-        "duplexer3": "^0.1.4",
-        "get-stream": "^3.0.0",
-        "into-stream": "^3.1.0",
-        "is-retry-allowed": "^1.1.0",
-        "isurl": "^1.0.0-alpha5",
-        "lowercase-keys": "^1.0.0",
-        "mimic-response": "^1.0.0",
-        "p-cancelable": "^0.4.0",
-        "p-timeout": "^2.0.1",
-        "pify": "^3.0.0",
-        "safe-buffer": "^5.1.1",
-        "timed-out": "^4.0.1",
-        "url-parse-lax": "^3.0.0",
-        "url-to-options": "^1.0.1"
-      }
-    },
-    "graceful-fs": {
-      "version": "4.1.11",
-      "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.1.11.tgz",
-      "integrity": "sha1-Dovf5NHduIVNZOBOp8AOKgJuVlg=",
-      "dev": true
-    },
-    "grouped-queue": {
-      "version": "0.3.3",
-      "resolved": "https://registry.npmjs.org/grouped-queue/-/grouped-queue-0.3.3.tgz",
-      "integrity": "sha1-wWfSpTGcWg4JZO9qJbfC34mWyFw=",
-      "dev": true,
-      "requires": {
-        "lodash": "^4.17.2"
-      }
-    },
-    "has-ansi": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/has-ansi/-/has-ansi-2.0.0.tgz",
-      "integrity": "sha1-NPUEnOHs3ysGSa8+8k5F7TVBbZE=",
-      "dev": true,
-      "requires": {
-        "ansi-regex": "^2.0.0"
-      },
-      "dependencies": {
-        "ansi-regex": {
-          "version": "2.1.1",
-          "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz",
-          "integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8=",
-          "dev": true
-        }
-      }
-    },
-    "has-color": {
-      "version": "0.1.7",
-      "resolved": "https://registry.npmjs.org/has-color/-/has-color-0.1.7.tgz",
-      "integrity": "sha1-ZxRKUmDDT8PMpnfQQdr1L+e3iy8=",
-      "dev": true
-    },
-    "has-flag": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
-      "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=",
-      "dev": true
-    },
-    "has-symbol-support-x": {
-      "version": "1.4.2",
-      "resolved": "https://registry.npmjs.org/has-symbol-support-x/-/has-symbol-support-x-1.4.2.tgz",
-      "integrity": "sha512-3ToOva++HaW+eCpgqZrCfN51IPB+7bJNVT6CUATzueB5Heb8o6Nam0V3HG5dlDvZU1Gn5QLcbahiKw/XVk5JJw==",
-      "dev": true
-    },
-    "has-to-string-tag-x": {
-      "version": "1.4.1",
-      "resolved": "https://registry.npmjs.org/has-to-string-tag-x/-/has-to-string-tag-x-1.4.1.tgz",
-      "integrity": "sha512-vdbKfmw+3LoOYVr+mtxHaX5a96+0f3DljYd8JOqvOLsf5mw2Otda2qCDT9qRqLAhrjyQ0h7ual5nOiASpsGNFw==",
-      "dev": true,
-      "requires": {
-        "has-symbol-support-x": "^1.4.1"
-      }
-    },
-    "has-value": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/has-value/-/has-value-1.0.0.tgz",
-      "integrity": "sha1-GLKB2lhbHFxR3vJMkw7SmgvmsXc=",
-      "dev": true,
-      "requires": {
-        "get-value": "^2.0.6",
-        "has-values": "^1.0.0",
-        "isobject": "^3.0.0"
-      }
-    },
-    "has-values": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/has-values/-/has-values-1.0.0.tgz",
-      "integrity": "sha1-lbC2P+whRmGab+V/51Yo1aOe/k8=",
-      "dev": true,
-      "requires": {
-        "is-number": "^3.0.0",
-        "kind-of": "^4.0.0"
-      },
-      "dependencies": {
-        "kind-of": {
-          "version": "4.0.0",
-          "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-4.0.0.tgz",
-          "integrity": "sha1-IIE989cSkosgc3hpGkUGb65y3Vc=",
-          "dev": true,
-          "requires": {
-            "is-buffer": "^1.1.5"
-          }
-        }
-      }
-    },
-    "hash-base": {
-      "version": "3.0.4",
-      "resolved": "https://registry.npmjs.org/hash-base/-/hash-base-3.0.4.tgz",
-      "integrity": "sha1-X8hoaEfs1zSZQDMZprCj8/auSRg=",
-      "dev": true,
-      "requires": {
-        "inherits": "^2.0.1",
-        "safe-buffer": "^5.0.1"
-      }
-    },
-    "hash.js": {
-      "version": "1.1.3",
-      "resolved": "https://registry.npmjs.org/hash.js/-/hash.js-1.1.3.tgz",
-      "integrity": "sha512-/UETyP0W22QILqS+6HowevwhEFJ3MBJnwTf75Qob9Wz9t0DPuisL8kW8YZMK62dHAKE1c1p+gY1TtOLY+USEHA==",
-      "dev": true,
-      "requires": {
-        "inherits": "^2.0.3",
-        "minimalistic-assert": "^1.0.0"
-      }
-    },
-    "hmac-drbg": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/hmac-drbg/-/hmac-drbg-1.0.1.tgz",
-      "integrity": "sha1-0nRXAQJabHdabFRXk+1QL8DGSaE=",
-      "dev": true,
-      "requires": {
-        "hash.js": "^1.0.3",
-        "minimalistic-assert": "^1.0.0",
-        "minimalistic-crypto-utils": "^1.0.1"
-      }
-    },
-    "home-or-tmp": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/home-or-tmp/-/home-or-tmp-2.0.0.tgz",
-      "integrity": "sha1-42w/LSyufXRqhX440Y1fMqeILbg=",
-      "dev": true,
-      "requires": {
-        "os-homedir": "^1.0.0",
-        "os-tmpdir": "^1.0.1"
-      }
-    },
-    "homedir-polyfill": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/homedir-polyfill/-/homedir-polyfill-1.0.1.tgz",
-      "integrity": "sha1-TCu8inWJmP7r9e1oWA921GdotLw=",
-      "dev": true,
-      "requires": {
-        "parse-passwd": "^1.0.0"
-      }
-    },
-    "hosted-git-info": {
-      "version": "2.6.0",
-      "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.6.0.tgz",
-      "integrity": "sha512-lIbgIIQA3lz5XaB6vxakj6sDHADJiZadYEJB+FgA+C4nubM1NwcuvUr9EJPmnH1skZqpqUzWborWo8EIUi0Sdw==",
-      "dev": true
-    },
-    "http-cache-semantics": {
-      "version": "3.8.1",
-      "resolved": "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-3.8.1.tgz",
-      "integrity": "sha512-5ai2iksyV8ZXmnZhHH4rWPoxxistEexSi5936zIQ1bnNTW5VnA85B6P/VpXiRM017IgRvb2kKo1a//y+0wSp3w==",
-      "dev": true
-    },
-    "https-browserify": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/https-browserify/-/https-browserify-1.0.0.tgz",
-      "integrity": "sha1-7AbBDgo0wPL68Zn3/X/Hj//QPHM=",
-      "dev": true
-    },
-    "iconv-lite": {
-      "version": "0.4.23",
-      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.23.tgz",
-      "integrity": "sha512-neyTUVFtahjf0mB3dZT77u+8O0QB89jFdnBkd5P1JgYPbPaia3gXXOVL2fq8VyU2gMMD7SaN7QukTB/pmXYvDA==",
-      "dev": true,
-      "requires": {
-        "safer-buffer": ">= 2.1.2 < 3"
-      }
-    },
-    "ieee754": {
-      "version": "1.1.11",
-      "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.1.11.tgz",
-      "integrity": "sha512-VhDzCKN7K8ufStx/CLj5/PDTMgph+qwN5Pkd5i0sGnVwk56zJ0lkT8Qzi1xqWLS0Wp29DgDtNeS7v8/wMoZeHg==",
-      "dev": true
-    },
-    "iferr": {
-      "version": "0.1.5",
-      "resolved": "https://registry.npmjs.org/iferr/-/iferr-0.1.5.tgz",
-      "integrity": "sha1-xg7taebY/bazEEofy8ocGS3FtQE=",
-      "dev": true
-    },
-    "ignore": {
-      "version": "3.3.8",
-      "resolved": "https://registry.npmjs.org/ignore/-/ignore-3.3.8.tgz",
-      "integrity": "sha512-pUh+xUQQhQzevjRHHFqqcTy0/dP/kS9I8HSrUydhihjuD09W6ldVWFtIrwhXdUJHis3i2rZNqEHpZH/cbinFbg==",
-      "dev": true
-    },
-    "import-local": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/import-local/-/import-local-1.0.0.tgz",
-      "integrity": "sha512-vAaZHieK9qjGo58agRBg+bhHX3hoTZU/Oa3GESWLz7t1U62fk63aHuDJJEteXoDeTCcPmUT+z38gkHPZkkmpmQ==",
-      "dev": true,
-      "requires": {
-        "pkg-dir": "^2.0.0",
-        "resolve-cwd": "^2.0.0"
-      }
-    },
-    "imurmurhash": {
-      "version": "0.1.4",
-      "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
-      "integrity": "sha1-khi5srkoojixPcT7a21XbyMUU+o=",
-      "dev": true
-    },
-    "indent-string": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-2.1.0.tgz",
-      "integrity": "sha1-ji1INIdCEhtKghi3oTfppSBJ3IA=",
-      "dev": true,
-      "requires": {
-        "repeating": "^2.0.0"
-      }
-    },
-    "indexof": {
-      "version": "0.0.1",
-      "resolved": "https://registry.npmjs.org/indexof/-/indexof-0.0.1.tgz",
-      "integrity": "sha1-gtwzbSMrkGIXnQWrMpOmYFn9Q10=",
-      "dev": true
-    },
-    "inflight": {
-      "version": "1.0.6",
-      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
-      "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=",
-      "dev": true,
-      "requires": {
-        "once": "^1.3.0",
-        "wrappy": "1"
-      }
-    },
-    "inherits": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz",
-      "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4=",
-      "dev": true
-    },
-    "ini": {
-      "version": "1.3.5",
-      "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.5.tgz",
-      "integrity": "sha512-RZY5huIKCMRWDUqZlEi72f/lmXKMvuszcMBduliQ3nnWbx9X/ZBQO7DijMEYS9EhHBb2qacRUMtC7svLwe0lcw==",
-      "dev": true
-    },
-    "inquirer": {
-      "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/inquirer/-/inquirer-5.2.0.tgz",
-      "integrity": "sha512-E9BmnJbAKLPGonz0HeWHtbKf+EeSP93paWO3ZYoUpq/aowXvYGjjCSuashhXPpzbArIjBbji39THkxTz9ZeEUQ==",
-      "dev": true,
-      "requires": {
-        "ansi-escapes": "^3.0.0",
-        "chalk": "^2.0.0",
-        "cli-cursor": "^2.1.0",
-        "cli-width": "^2.0.0",
-        "external-editor": "^2.1.0",
-        "figures": "^2.0.0",
-        "lodash": "^4.3.0",
-        "mute-stream": "0.0.7",
-        "run-async": "^2.2.0",
-        "rxjs": "^5.5.2",
-        "string-width": "^2.1.0",
-        "strip-ansi": "^4.0.0",
-        "through": "^2.3.6"
-      }
-    },
-    "interpret": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/interpret/-/interpret-1.1.0.tgz",
-      "integrity": "sha1-ftGxQQxqDg94z5XTuEQMY/eLhhQ=",
-      "dev": true
-    },
-    "into-stream": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/into-stream/-/into-stream-3.1.0.tgz",
-      "integrity": "sha1-lvsKk2wSur1v8XUqF9BWFqvQlMY=",
-      "dev": true,
-      "requires": {
-        "from2": "^2.1.1",
-        "p-is-promise": "^1.1.0"
-      }
-    },
-    "invariant": {
-      "version": "2.2.4",
-      "resolved": "https://registry.npmjs.org/invariant/-/invariant-2.2.4.tgz",
-      "integrity": "sha512-phJfQVBuaJM5raOpJjSfkiD6BpbCE4Ns//LaXl6wGYtUBY83nWS6Rf9tXm2e8VaK60JEjYldbPif/A2B1C2gNA==",
-      "dev": true,
-      "requires": {
-        "loose-envify": "^1.0.0"
-      }
-    },
-    "invert-kv": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/invert-kv/-/invert-kv-1.0.0.tgz",
-      "integrity": "sha1-EEqOSqym09jNFXqO+L+rLXo//bY=",
-      "dev": true
-    },
-    "is-accessor-descriptor": {
-      "version": "0.1.6",
-      "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-0.1.6.tgz",
-      "integrity": "sha1-qeEss66Nh2cn7u84Q/igiXtcmNY=",
-      "dev": true,
-      "requires": {
-        "kind-of": "^3.0.2"
-      },
-      "dependencies": {
-        "kind-of": {
-          "version": "3.2.2",
-          "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz",
-          "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=",
-          "dev": true,
-          "requires": {
-            "is-buffer": "^1.1.5"
-          }
-        }
-      }
-    },
-    "is-arrayish": {
-      "version": "0.2.1",
-      "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz",
-      "integrity": "sha1-d8mYQFJ6qOyxqLppe4BkWnqSap0=",
-      "dev": true
-    },
-    "is-binary-path": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-1.0.1.tgz",
-      "integrity": "sha1-dfFmQrSA8YenEcgUFh/TpKdlWJg=",
-      "dev": true,
-      "requires": {
-        "binary-extensions": "^1.0.0"
-      }
-    },
-    "is-buffer": {
-      "version": "1.1.6",
-      "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-1.1.6.tgz",
-      "integrity": "sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==",
-      "dev": true
-    },
-    "is-builtin-module": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/is-builtin-module/-/is-builtin-module-1.0.0.tgz",
-      "integrity": "sha1-VAVy0096wxGfj3bDDLwbHgN6/74=",
-      "dev": true,
-      "requires": {
-        "builtin-modules": "^1.0.0"
-      }
-    },
-    "is-data-descriptor": {
-      "version": "0.1.4",
-      "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-0.1.4.tgz",
-      "integrity": "sha1-C17mSDiOLIYCgueT8YVv7D8wG1Y=",
-      "dev": true,
-      "requires": {
-        "kind-of": "^3.0.2"
-      },
-      "dependencies": {
-        "kind-of": {
-          "version": "3.2.2",
-          "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz",
-          "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=",
-          "dev": true,
-          "requires": {
-            "is-buffer": "^1.1.5"
-          }
-        }
-      }
-    },
-    "is-descriptor": {
-      "version": "0.1.6",
-      "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-0.1.6.tgz",
-      "integrity": "sha512-avDYr0SB3DwO9zsMov0gKCESFYqCnE4hq/4z3TdUlukEy5t9C0YRq7HLrsN52NAcqXKaepeCD0n+B0arnVG3Hg==",
-      "dev": true,
-      "requires": {
-        "is-accessor-descriptor": "^0.1.6",
-        "is-data-descriptor": "^0.1.4",
-        "kind-of": "^5.0.0"
-      },
-      "dependencies": {
-        "kind-of": {
-          "version": "5.1.0",
-          "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-5.1.0.tgz",
-          "integrity": "sha512-NGEErnH6F2vUuXDh+OlbcKW7/wOcfdRHaZ7VWtqCztfHri/++YKmP51OdWeGPuqCOba6kk2OTe5d02VmTB80Pw==",
-          "dev": true
-        }
-      }
-    },
-    "is-dotfile": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/is-dotfile/-/is-dotfile-1.0.3.tgz",
-      "integrity": "sha1-pqLzL/0t+wT1yiXs0Pa4PPeYoeE=",
-      "dev": true
-    },
-    "is-equal-shallow": {
-      "version": "0.1.3",
-      "resolved": "https://registry.npmjs.org/is-equal-shallow/-/is-equal-shallow-0.1.3.tgz",
-      "integrity": "sha1-IjgJj8Ih3gvPpdnqxMRdY4qhxTQ=",
-      "dev": true,
-      "requires": {
-        "is-primitive": "^2.0.0"
-      }
-    },
-    "is-extendable": {
-      "version": "0.1.1",
-      "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz",
-      "integrity": "sha1-YrEQ4omkcUGOPsNqYX1HLjAd/Ik=",
-      "dev": true
-    },
-    "is-extglob": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
-      "integrity": "sha1-qIwCU1eR8C7TfHahueqXc8gz+MI=",
-      "dev": true
-    },
-    "is-finite": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/is-finite/-/is-finite-1.0.2.tgz",
-      "integrity": "sha1-zGZ3aVYCvlUO8R6LSqYwU0K20Ko=",
-      "dev": true,
-      "requires": {
-        "number-is-nan": "^1.0.0"
-      }
-    },
-    "is-fullwidth-code-point": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz",
-      "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=",
-      "dev": true
-    },
-    "is-glob": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.0.tgz",
-      "integrity": "sha1-lSHHaEXMJhCoUgPd8ICpWML/q8A=",
-      "dev": true,
-      "requires": {
-        "is-extglob": "^2.1.1"
-      }
-    },
-    "is-number": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/is-number/-/is-number-3.0.0.tgz",
-      "integrity": "sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=",
-      "dev": true,
-      "requires": {
-        "kind-of": "^3.0.2"
-      },
-      "dependencies": {
-        "kind-of": {
-          "version": "3.2.2",
-          "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz",
-          "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=",
-          "dev": true,
-          "requires": {
-            "is-buffer": "^1.1.5"
-          }
-        }
-      }
-    },
-    "is-object": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/is-object/-/is-object-1.0.1.tgz",
-      "integrity": "sha1-iVJojF7C/9awPsyF52ngKQMINHA=",
-      "dev": true
-    },
-    "is-observable": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/is-observable/-/is-observable-1.1.0.tgz",
-      "integrity": "sha512-NqCa4Sa2d+u7BWc6CukaObG3Fh+CU9bvixbpcXYhy2VvYS7vVGIdAgnIS5Ks3A/cqk4rebLJ9s8zBstT2aKnIA==",
-      "dev": true,
-      "requires": {
-        "symbol-observable": "^1.1.0"
-      },
-      "dependencies": {
-        "symbol-observable": {
-          "version": "1.2.0",
-          "resolved": "https://registry.npmjs.org/symbol-observable/-/symbol-observable-1.2.0.tgz",
-          "integrity": "sha512-e900nM8RRtGhlV36KGEU9k65K3mPb1WV70OdjfxlG2EAuM1noi/E/BaW/uMhL7bPEssK8QV57vN3esixjUvcXQ==",
-          "dev": true
-        }
-      }
-    },
-    "is-odd": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/is-odd/-/is-odd-2.0.0.tgz",
-      "integrity": "sha512-OTiixgpZAT1M4NHgS5IguFp/Vz2VI3U7Goh4/HA1adtwyLtSBrxYlcSYkhpAE07s4fKEcjrFxyvtQBND4vFQyQ==",
-      "dev": true,
-      "requires": {
-        "is-number": "^4.0.0"
-      },
-      "dependencies": {
-        "is-number": {
-          "version": "4.0.0",
-          "resolved": "https://registry.npmjs.org/is-number/-/is-number-4.0.0.tgz",
-          "integrity": "sha512-rSklcAIlf1OmFdyAqbnWTLVelsQ58uvZ66S/ZyawjWqIviTWCjg2PzVGw8WUA+nNuPTqb4wgA+NszrJ+08LlgQ==",
-          "dev": true
-        }
-      }
-    },
-    "is-path-cwd": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/is-path-cwd/-/is-path-cwd-1.0.0.tgz",
-      "integrity": "sha1-0iXsIxMuie3Tj9p2dHLmLmXxEG0=",
-      "dev": true
-    },
-    "is-path-in-cwd": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/is-path-in-cwd/-/is-path-in-cwd-1.0.1.tgz",
-      "integrity": "sha512-FjV1RTW48E7CWM7eE/J2NJvAEEVektecDBVBE5Hh3nM1Jd0kvhHtX68Pr3xsDf857xt3Y4AkwVULK1Vku62aaQ==",
-      "dev": true,
-      "requires": {
-        "is-path-inside": "^1.0.0"
-      }
-    },
-    "is-path-inside": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-1.0.1.tgz",
-      "integrity": "sha1-jvW33lBDej/cprToZe96pVy0gDY=",
-      "dev": true,
-      "requires": {
-        "path-is-inside": "^1.0.1"
-      }
-    },
-    "is-plain-obj": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-1.1.0.tgz",
-      "integrity": "sha1-caUMhCnfync8kqOQpKA7OfzVHT4=",
-      "dev": true
-    },
-    "is-plain-object": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz",
-      "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==",
-      "dev": true,
-      "requires": {
-        "isobject": "^3.0.1"
-      }
-    },
-    "is-posix-bracket": {
-      "version": "0.1.1",
-      "resolved": "https://registry.npmjs.org/is-posix-bracket/-/is-posix-bracket-0.1.1.tgz",
-      "integrity": "sha1-MzTceXdDaOkvAW5vvAqI9c1ua8Q=",
-      "dev": true
-    },
-    "is-primitive": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/is-primitive/-/is-primitive-2.0.0.tgz",
-      "integrity": "sha1-IHurkWOEmcB7Kt8kCkGochADRXU=",
-      "dev": true
-    },
-    "is-promise": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/is-promise/-/is-promise-2.1.0.tgz",
-      "integrity": "sha1-eaKp7OfwlugPNtKy87wWwf9L8/o=",
-      "dev": true
-    },
-    "is-resolvable": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/is-resolvable/-/is-resolvable-1.1.0.tgz",
-      "integrity": "sha512-qgDYXFSR5WvEfuS5dMj6oTMEbrrSaM0CrFk2Yiq/gXnBvD9pMa2jGXxyhGLfvhZpuMZe18CJpFxAt3CRs42NMg==",
-      "dev": true
-    },
-    "is-retry-allowed": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/is-retry-allowed/-/is-retry-allowed-1.1.0.tgz",
-      "integrity": "sha1-EaBgVotnM5REAz0BJaYaINVk+zQ=",
-      "dev": true
-    },
-    "is-scoped": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/is-scoped/-/is-scoped-1.0.0.tgz",
-      "integrity": "sha1-RJypgpnnEwOCViieyytUDcQ3yzA=",
-      "dev": true,
-      "requires": {
-        "scoped-regex": "^1.0.0"
-      }
-    },
-    "is-stream": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-1.1.0.tgz",
-      "integrity": "sha1-EtSj3U5o4Lec6428hBc66A2RykQ=",
-      "dev": true
-    },
-    "is-utf8": {
-      "version": "0.2.1",
-      "resolved": "https://registry.npmjs.org/is-utf8/-/is-utf8-0.2.1.tgz",
-      "integrity": "sha1-Sw2hRCEE0bM2NA6AeX6GXPOffXI=",
-      "dev": true
-    },
-    "is-windows": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/is-windows/-/is-windows-1.0.2.tgz",
-      "integrity": "sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==",
-      "dev": true
-    },
-    "isarray": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
-      "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=",
-      "dev": true
-    },
-    "isbinaryfile": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/isbinaryfile/-/isbinaryfile-3.0.2.tgz",
-      "integrity": "sha1-Sj6XTsDLqQBNP8bN5yCeppNopiE=",
-      "dev": true
-    },
-    "isexe": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
-      "integrity": "sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=",
-      "dev": true
-    },
-    "isobject": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz",
-      "integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=",
-      "dev": true
-    },
-    "istextorbinary": {
-      "version": "2.2.1",
-      "resolved": "https://registry.npmjs.org/istextorbinary/-/istextorbinary-2.2.1.tgz",
-      "integrity": "sha512-TS+hoFl8Z5FAFMK38nhBkdLt44CclNRgDHWeMgsV8ko3nDlr/9UI2Sf839sW7enijf8oKsZYXRvM8g0it9Zmcw==",
-      "dev": true,
-      "requires": {
-        "binaryextensions": "2",
-        "editions": "^1.3.3",
-        "textextensions": "2"
-      }
-    },
-    "isurl": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/isurl/-/isurl-1.0.0.tgz",
-      "integrity": "sha512-1P/yWsxPlDtn7QeRD+ULKQPaIaN6yF368GZ2vDfv0AL0NwpStafjWCDDdn0k8wgFMWpVAqG7oJhxHnlud42i9w==",
-      "dev": true,
-      "requires": {
-        "has-to-string-tag-x": "^1.2.0",
-        "is-object": "^1.0.1"
-      }
-    },
-    "js-tokens": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-3.0.2.tgz",
-      "integrity": "sha1-mGbfOVECEw449/mWvOtlRDIJwls=",
-      "dev": true
-    },
-    "js-yaml": {
-      "version": "3.12.0",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.12.0.tgz",
-      "integrity": "sha512-PIt2cnwmPfL4hKNwqeiuz4bKfnzHTBv6HyVgjahA6mPLwPDzjDWrplJBMjHUFxku/N3FlmrbyPclad+I+4mJ3A==",
-      "dev": true,
-      "requires": {
-        "argparse": "^1.0.7",
-        "esprima": "^4.0.0"
-      }
-    },
-    "jscodeshift": {
-      "version": "0.5.1",
-      "resolved": "https://registry.npmjs.org/jscodeshift/-/jscodeshift-0.5.1.tgz",
-      "integrity": "sha512-sRMollbhbmSDrR79JMAnhEjyZJlQQVozeeY9A6/KNuV26DNcuB3mGSCWXp0hks9dcwRNOELbNOiwraZaXXRk5Q==",
-      "dev": true,
-      "requires": {
-        "babel-plugin-transform-flow-strip-types": "^6.8.0",
-        "babel-preset-es2015": "^6.9.0",
-        "babel-preset-stage-1": "^6.5.0",
-        "babel-register": "^6.9.0",
-        "babylon": "^7.0.0-beta.47",
-        "colors": "^1.1.2",
-        "flow-parser": "^0.*",
-        "lodash": "^4.13.1",
-        "micromatch": "^2.3.7",
-        "neo-async": "^2.5.0",
-        "node-dir": "0.1.8",
-        "nomnom": "^1.8.1",
-        "recast": "^0.15.0",
-        "temp": "^0.8.1",
-        "write-file-atomic": "^1.2.0"
-      },
-      "dependencies": {
-        "arr-diff": {
-          "version": "2.0.0",
-          "resolved": "https://registry.npmjs.org/arr-diff/-/arr-diff-2.0.0.tgz",
-          "integrity": "sha1-jzuCf5Vai9ZpaX5KQlasPOrjVs8=",
-          "dev": true,
-          "requires": {
-            "arr-flatten": "^1.0.1"
-          }
-        },
-        "array-unique": {
-          "version": "0.2.1",
-          "resolved": "https://registry.npmjs.org/array-unique/-/array-unique-0.2.1.tgz",
-          "integrity": "sha1-odl8yvy8JiXMcPrc6zalDFiwGlM=",
-          "dev": true
-        },
-        "braces": {
-          "version": "1.8.5",
-          "resolved": "https://registry.npmjs.org/braces/-/braces-1.8.5.tgz",
-          "integrity": "sha1-uneWLhLf+WnWt2cR6RS3N4V79qc=",
-          "dev": true,
-          "requires": {
-            "expand-range": "^1.8.1",
-            "preserve": "^0.2.0",
-            "repeat-element": "^1.1.2"
-          }
-        },
-        "expand-brackets": {
-          "version": "0.1.5",
-          "resolved": "https://registry.npmjs.org/expand-brackets/-/expand-brackets-0.1.5.tgz",
-          "integrity": "sha1-3wcoTjQqgHzXM6xa9yQR5YHRF3s=",
-          "dev": true,
-          "requires": {
-            "is-posix-bracket": "^0.1.0"
-          }
-        },
-        "extglob": {
-          "version": "0.3.2",
-          "resolved": "https://registry.npmjs.org/extglob/-/extglob-0.3.2.tgz",
-          "integrity": "sha1-Lhj/PS9JqydlzskCPwEdqo2DSaE=",
-          "dev": true,
-          "requires": {
-            "is-extglob": "^1.0.0"
-          }
-        },
-        "is-extglob": {
-          "version": "1.0.0",
-          "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-1.0.0.tgz",
-          "integrity": "sha1-rEaBd8SUNAWgkvyPKXYMb/xiBsA=",
-          "dev": true
-        },
-        "is-glob": {
-          "version": "2.0.1",
-          "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-2.0.1.tgz",
-          "integrity": "sha1-0Jb5JqPe1WAPP9/ZEZjLCIjC2GM=",
-          "dev": true,
-          "requires": {
-            "is-extglob": "^1.0.0"
-          }
-        },
-        "kind-of": {
-          "version": "3.2.2",
-          "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz",
-          "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=",
-          "dev": true,
-          "requires": {
-            "is-buffer": "^1.1.5"
-          }
-        },
-        "micromatch": {
-          "version": "2.3.11",
-          "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-2.3.11.tgz",
-          "integrity": "sha1-hmd8l9FyCzY0MdBNDRUpO9OMFWU=",
-          "dev": true,
-          "requires": {
-            "arr-diff": "^2.0.0",
-            "array-unique": "^0.2.1",
-            "braces": "^1.8.2",
-            "expand-brackets": "^0.1.4",
-            "extglob": "^0.3.1",
-            "filename-regex": "^2.0.0",
-            "is-extglob": "^1.0.0",
-            "is-glob": "^2.0.1",
-            "kind-of": "^3.0.2",
-            "normalize-path": "^2.0.1",
-            "object.omit": "^2.0.0",
-            "parse-glob": "^3.0.4",
-            "regex-cache": "^0.4.2"
-          }
-        }
-      }
-    },
-    "jsesc": {
-      "version": "0.5.0",
-      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-0.5.0.tgz",
-      "integrity": "sha1-597mbjXW/Bb3EP6R1c9p9w8IkR0=",
-      "dev": true
-    },
-    "json-buffer": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.0.tgz",
-      "integrity": "sha1-Wx85evx11ne96Lz8Dkfh+aPZqJg=",
-      "dev": true
-    },
-    "json-parse-better-errors": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/json-parse-better-errors/-/json-parse-better-errors-1.0.2.tgz",
-      "integrity": "sha512-mrqyZKfX5EhL7hvqcV6WG1yYjnjeuYDzDhhcAAUrq8Po85NBQBJP+ZDUT75qZQ98IkUoBqdkExkukOU7Ts2wrw==",
-      "dev": true
-    },
-    "json-schema-traverse": {
-      "version": "0.3.1",
-      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.3.1.tgz",
-      "integrity": "sha1-NJptRMU6Ud6JtAgFxdXlm0F9M0A=",
-      "dev": true
-    },
-    "json-stable-stringify-without-jsonify": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz",
-      "integrity": "sha1-nbe1lJatPzz+8wp1FC0tkwrXJlE=",
-      "dev": true
-    },
-    "json5": {
-      "version": "0.5.1",
-      "resolved": "https://registry.npmjs.org/json5/-/json5-0.5.1.tgz",
-      "integrity": "sha1-Hq3nrMASA0rYTiOWdn6tn6VJWCE=",
-      "dev": true
-    },
-    "keyv": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/keyv/-/keyv-3.0.0.tgz",
-      "integrity": "sha512-eguHnq22OE3uVoSYG0LVWNP+4ppamWr9+zWBe1bsNcovIMy6huUJFPgy4mGwCd/rnl3vOLGW1MTlu4c57CT1xA==",
-      "dev": true,
-      "requires": {
-        "json-buffer": "3.0.0"
-      }
-    },
-    "kind-of": {
-      "version": "6.0.2",
-      "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.2.tgz",
-      "integrity": "sha512-s5kLOcnH0XqDO+FvuaLX8DDjZ18CGFk7VygH40QoKPUQhW4e2rvM0rwUq0t8IQDOwYSeLK01U90OjzBTme2QqA==",
-      "dev": true
-    },
-    "lcid": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/lcid/-/lcid-1.0.0.tgz",
-      "integrity": "sha1-MIrMr6C8SDo4Z7S28rlQYlHRuDU=",
-      "dev": true,
-      "requires": {
-        "invert-kv": "^1.0.0"
-      }
-    },
-    "leb": {
-      "version": "0.3.0",
-      "resolved": "https://registry.npmjs.org/leb/-/leb-0.3.0.tgz",
-      "integrity": "sha1-Mr7p+tFoMo1q6oUi2DP0GA7tHaM=",
-      "dev": true
-    },
-    "levn": {
-      "version": "0.3.0",
-      "resolved": "https://registry.npmjs.org/levn/-/levn-0.3.0.tgz",
-      "integrity": "sha1-OwmSTt+fCDwEkP3UwLxEIeBHZO4=",
-      "dev": true,
-      "requires": {
-        "prelude-ls": "~1.1.2",
-        "type-check": "~0.3.2"
-      }
-    },
-    "listr": {
-      "version": "0.14.1",
-      "resolved": "https://registry.npmjs.org/listr/-/listr-0.14.1.tgz",
-      "integrity": "sha512-MSMUUVN1f8aRnPi4034RkOqdiUlpYW+FqwFE3aL0uYNPRavkt2S2SsSpDDofn8BDpqv2RNnsdOcCHWsChcq77A==",
-      "dev": true,
-      "requires": {
-        "@samverschueren/stream-to-observable": "^0.3.0",
-        "cli-truncate": "^0.2.1",
-        "figures": "^1.7.0",
-        "indent-string": "^2.1.0",
-        "is-observable": "^1.1.0",
-        "is-promise": "^2.1.0",
-        "is-stream": "^1.1.0",
-        "listr-silent-renderer": "^1.1.1",
-        "listr-update-renderer": "^0.4.0",
-        "listr-verbose-renderer": "^0.4.0",
-        "log-symbols": "^1.0.2",
-        "log-update": "^1.0.2",
-        "ora": "^0.2.3",
-        "p-map": "^1.1.1",
-        "rxjs": "^6.1.0",
-        "strip-ansi": "^3.0.1"
-      },
-      "dependencies": {
-        "ansi-regex": {
-          "version": "2.1.1",
-          "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz",
-          "integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8=",
-          "dev": true
-        },
-        "ansi-styles": {
-          "version": "2.2.1",
-          "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-2.2.1.tgz",
-          "integrity": "sha1-tDLdM1i2NM914eRmQ2gkBTPB3b4=",
-          "dev": true
-        },
-        "chalk": {
-          "version": "1.1.3",
-          "resolved": "https://registry.npmjs.org/chalk/-/chalk-1.1.3.tgz",
-          "integrity": "sha1-qBFcVeSnAv5NFQq9OHKCKn4J/Jg=",
-          "dev": true,
-          "requires": {
-            "ansi-styles": "^2.2.1",
-            "escape-string-regexp": "^1.0.2",
-            "has-ansi": "^2.0.0",
-            "strip-ansi": "^3.0.0",
-            "supports-color": "^2.0.0"
-          }
-        },
-        "figures": {
-          "version": "1.7.0",
-          "resolved": "https://registry.npmjs.org/figures/-/figures-1.7.0.tgz",
-          "integrity": "sha1-y+Hjr/zxzUS4DK3+0o3Hk6lwHS4=",
-          "dev": true,
-          "requires": {
-            "escape-string-regexp": "^1.0.5",
-            "object-assign": "^4.1.0"
-          }
-        },
-        "log-symbols": {
-          "version": "1.0.2",
-          "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-1.0.2.tgz",
-          "integrity": "sha1-N2/3tY6jCGoPCfrMdGF+ylAeGhg=",
-          "dev": true,
-          "requires": {
-            "chalk": "^1.0.0"
-          }
-        },
-        "rxjs": {
-          "version": "6.2.0",
-          "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-6.2.0.tgz",
-          "integrity": "sha512-qBzf5uu6eOKiCZuAE0SgZ0/Qp+l54oeVxFfC2t+mJ2SFI6IB8gmMdJHs5DUMu5kqifqcCtsKS2XHjhZu6RKvAw==",
-          "dev": true,
-          "requires": {
-            "tslib": "^1.9.0"
-          }
-        },
-        "strip-ansi": {
-          "version": "3.0.1",
-          "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz",
-          "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=",
-          "dev": true,
-          "requires": {
-            "ansi-regex": "^2.0.0"
-          }
-        },
-        "supports-color": {
-          "version": "2.0.0",
-          "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-2.0.0.tgz",
-          "integrity": "sha1-U10EXOa2Nj+kARcIRimZXp3zJMc=",
-          "dev": true
-        }
-      }
-    },
-    "listr-silent-renderer": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/listr-silent-renderer/-/listr-silent-renderer-1.1.1.tgz",
-      "integrity": "sha1-kktaN1cVN3C/Go4/v3S4u/P5JC4=",
-      "dev": true
-    },
-    "listr-update-renderer": {
-      "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/listr-update-renderer/-/listr-update-renderer-0.4.0.tgz",
-      "integrity": "sha1-NE2YDaLKLosUW6MFkI8yrj9MyKc=",
-      "dev": true,
-      "requires": {
-        "chalk": "^1.1.3",
-        "cli-truncate": "^0.2.1",
-        "elegant-spinner": "^1.0.1",
-        "figures": "^1.7.0",
-        "indent-string": "^3.0.0",
-        "log-symbols": "^1.0.2",
-        "log-update": "^1.0.2",
-        "strip-ansi": "^3.0.1"
-      },
-      "dependencies": {
-        "ansi-regex": {
-          "version": "2.1.1",
-          "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz",
-          "integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8=",
-          "dev": true
-        },
-        "ansi-styles": {
-          "version": "2.2.1",
-          "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-2.2.1.tgz",
-          "integrity": "sha1-tDLdM1i2NM914eRmQ2gkBTPB3b4=",
-          "dev": true
-        },
-        "chalk": {
-          "version": "1.1.3",
-          "resolved": "https://registry.npmjs.org/chalk/-/chalk-1.1.3.tgz",
-          "integrity": "sha1-qBFcVeSnAv5NFQq9OHKCKn4J/Jg=",
-          "dev": true,
-          "requires": {
-            "ansi-styles": "^2.2.1",
-            "escape-string-regexp": "^1.0.2",
-            "has-ansi": "^2.0.0",
-            "strip-ansi": "^3.0.0",
-            "supports-color": "^2.0.0"
-          }
-        },
-        "figures": {
-          "version": "1.7.0",
-          "resolved": "https://registry.npmjs.org/figures/-/figures-1.7.0.tgz",
-          "integrity": "sha1-y+Hjr/zxzUS4DK3+0o3Hk6lwHS4=",
-          "dev": true,
-          "requires": {
-            "escape-string-regexp": "^1.0.5",
-            "object-assign": "^4.1.0"
-          }
-        },
-        "indent-string": {
-          "version": "3.2.0",
-          "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-3.2.0.tgz",
-          "integrity": "sha1-Sl/W0nzDMvN+VBmlBNu4NxBckok=",
-          "dev": true
-        },
-        "log-symbols": {
-          "version": "1.0.2",
-          "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-1.0.2.tgz",
-          "integrity": "sha1-N2/3tY6jCGoPCfrMdGF+ylAeGhg=",
-          "dev": true,
-          "requires": {
-            "chalk": "^1.0.0"
-          }
-        },
-        "strip-ansi": {
-          "version": "3.0.1",
-          "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz",
-          "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=",
-          "dev": true,
-          "requires": {
-            "ansi-regex": "^2.0.0"
-          }
-        },
-        "supports-color": {
-          "version": "2.0.0",
-          "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-2.0.0.tgz",
-          "integrity": "sha1-U10EXOa2Nj+kARcIRimZXp3zJMc=",
-          "dev": true
-        }
-      }
-    },
-    "listr-verbose-renderer": {
-      "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/listr-verbose-renderer/-/listr-verbose-renderer-0.4.1.tgz",
-      "integrity": "sha1-ggb0z21S3cWCfl/RSYng6WWTOjU=",
-      "dev": true,
-      "requires": {
-        "chalk": "^1.1.3",
-        "cli-cursor": "^1.0.2",
-        "date-fns": "^1.27.2",
-        "figures": "^1.7.0"
-      },
-      "dependencies": {
-        "ansi-regex": {
-          "version": "2.1.1",
-          "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz",
-          "integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8=",
-          "dev": true
-        },
-        "ansi-styles": {
-          "version": "2.2.1",
-          "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-2.2.1.tgz",
-          "integrity": "sha1-tDLdM1i2NM914eRmQ2gkBTPB3b4=",
-          "dev": true
-        },
-        "chalk": {
-          "version": "1.1.3",
-          "resolved": "https://registry.npmjs.org/chalk/-/chalk-1.1.3.tgz",
-          "integrity": "sha1-qBFcVeSnAv5NFQq9OHKCKn4J/Jg=",
-          "dev": true,
-          "requires": {
-            "ansi-styles": "^2.2.1",
-            "escape-string-regexp": "^1.0.2",
-            "has-ansi": "^2.0.0",
-            "strip-ansi": "^3.0.0",
-            "supports-color": "^2.0.0"
-          }
-        },
-        "cli-cursor": {
-          "version": "1.0.2",
-          "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-1.0.2.tgz",
-          "integrity": "sha1-ZNo/fValRBLll5S9Ytw1KV6PKYc=",
-          "dev": true,
-          "requires": {
-            "restore-cursor": "^1.0.1"
-          }
-        },
-        "figures": {
-          "version": "1.7.0",
-          "resolved": "https://registry.npmjs.org/figures/-/figures-1.7.0.tgz",
-          "integrity": "sha1-y+Hjr/zxzUS4DK3+0o3Hk6lwHS4=",
-          "dev": true,
-          "requires": {
-            "escape-string-regexp": "^1.0.5",
-            "object-assign": "^4.1.0"
-          }
-        },
-        "onetime": {
-          "version": "1.1.0",
-          "resolved": "http://registry.npmjs.org/onetime/-/onetime-1.1.0.tgz",
-          "integrity": "sha1-ofeDj4MUxRbwXs78vEzP4EtO14k=",
-          "dev": true
-        },
-        "restore-cursor": {
-          "version": "1.0.1",
-          "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-1.0.1.tgz",
-          "integrity": "sha1-NGYfRohjJ/7SmRR5FSJS35LapUE=",
-          "dev": true,
-          "requires": {
-            "exit-hook": "^1.0.0",
-            "onetime": "^1.0.0"
-          }
-        },
-        "strip-ansi": {
-          "version": "3.0.1",
-          "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz",
-          "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=",
-          "dev": true,
-          "requires": {
-            "ansi-regex": "^2.0.0"
-          }
-        },
-        "supports-color": {
-          "version": "2.0.0",
-          "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-2.0.0.tgz",
-          "integrity": "sha1-U10EXOa2Nj+kARcIRimZXp3zJMc=",
-          "dev": true
-        }
-      }
-    },
-    "load-json-file": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/load-json-file/-/load-json-file-4.0.0.tgz",
-      "integrity": "sha1-L19Fq5HjMhYjT9U62rZo607AmTs=",
-      "dev": true,
-      "requires": {
-        "graceful-fs": "^4.1.2",
-        "parse-json": "^4.0.0",
-        "pify": "^3.0.0",
-        "strip-bom": "^3.0.0"
-      },
-      "dependencies": {
-        "strip-bom": {
-          "version": "3.0.0",
-          "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz",
-          "integrity": "sha1-IzTBjpx1n3vdVv3vfprj1YjmjtM=",
-          "dev": true
-        }
-      }
-    },
-    "loader-runner": {
-      "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/loader-runner/-/loader-runner-2.3.0.tgz",
-      "integrity": "sha1-9IKuqC1UPgeSFwDVpG7yb9rGuKI=",
-      "dev": true
-    },
-    "loader-utils": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/loader-utils/-/loader-utils-1.1.0.tgz",
-      "integrity": "sha1-yYrvSIvM7aL/teLeZG1qdUQp9c0=",
-      "dev": true,
-      "requires": {
-        "big.js": "^3.1.3",
-        "emojis-list": "^2.0.0",
-        "json5": "^0.5.0"
-      }
-    },
-    "locate-path": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-2.0.0.tgz",
-      "integrity": "sha1-K1aLJl7slExtnA3pw9u7ygNUzY4=",
-      "dev": true,
-      "requires": {
-        "p-locate": "^2.0.0",
-        "path-exists": "^3.0.0"
-      }
-    },
-    "lodash": {
-      "version": "4.17.10",
-      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.10.tgz",
-      "integrity": "sha512-UejweD1pDoXu+AD825lWwp4ZGtSwgnpZxb3JDViD7StjQz+Nb/6l093lx4OQ0foGWNRoc19mWy7BzL+UAK2iVg==",
-      "dev": true
-    },
-    "log-symbols": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-2.2.0.tgz",
-      "integrity": "sha512-VeIAFslyIerEJLXHziedo2basKbMKtTw3vfn5IzG0XTjhAVEJyNHnL2p7vc+wBDSdQuUpNw3M2u6xb9QsAY5Eg==",
-      "dev": true,
-      "requires": {
-        "chalk": "^2.0.1"
-      }
-    },
-    "log-update": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/log-update/-/log-update-1.0.2.tgz",
-      "integrity": "sha1-GZKfZMQJPS0ucHWh2tivWcKWuNE=",
-      "dev": true,
-      "requires": {
-        "ansi-escapes": "^1.0.0",
-        "cli-cursor": "^1.0.2"
-      },
-      "dependencies": {
-        "ansi-escapes": {
-          "version": "1.4.0",
-          "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-1.4.0.tgz",
-          "integrity": "sha1-06ioOzGapneTZisT52HHkRQiMG4=",
-          "dev": true
-        },
-        "cli-cursor": {
-          "version": "1.0.2",
-          "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-1.0.2.tgz",
-          "integrity": "sha1-ZNo/fValRBLll5S9Ytw1KV6PKYc=",
-          "dev": true,
-          "requires": {
-            "restore-cursor": "^1.0.1"
-          }
-        },
-        "onetime": {
-          "version": "1.1.0",
-          "resolved": "http://registry.npmjs.org/onetime/-/onetime-1.1.0.tgz",
-          "integrity": "sha1-ofeDj4MUxRbwXs78vEzP4EtO14k=",
-          "dev": true
-        },
-        "restore-cursor": {
-          "version": "1.0.1",
-          "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-1.0.1.tgz",
-          "integrity": "sha1-NGYfRohjJ/7SmRR5FSJS35LapUE=",
-          "dev": true,
-          "requires": {
-            "exit-hook": "^1.0.0",
-            "onetime": "^1.0.0"
-          }
-        }
-      }
-    },
-    "long": {
-      "version": "3.2.0",
-      "resolved": "https://registry.npmjs.org/long/-/long-3.2.0.tgz",
-      "integrity": "sha1-2CG3E4yhy1gcFymQ7xTbIAtcR0s=",
-      "dev": true
-    },
-    "loose-envify": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.3.1.tgz",
-      "integrity": "sha1-0aitM/qc4OcT1l/dCsi3SNR4yEg=",
-      "dev": true,
-      "requires": {
-        "js-tokens": "^3.0.0"
-      }
-    },
-    "lowercase-keys": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/lowercase-keys/-/lowercase-keys-1.0.1.tgz",
-      "integrity": "sha512-G2Lj61tXDnVFFOi8VZds+SoQjtQC3dgokKdDG2mTm1tx4m50NUHBOZSBwQQHyy0V12A0JTG4icfZQH+xPyh8VA==",
-      "dev": true
-    },
-    "lru-cache": {
-      "version": "4.1.3",
-      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-4.1.3.tgz",
-      "integrity": "sha512-fFEhvcgzuIoJVUF8fYr5KR0YqxD238zgObTps31YdADwPPAp82a4M8TrckkWyx7ekNlf9aBcVn81cFwwXngrJA==",
-      "dev": true,
-      "requires": {
-        "pseudomap": "^1.0.2",
-        "yallist": "^2.1.2"
-      }
-    },
-    "make-dir": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-1.3.0.tgz",
-      "integrity": "sha512-2w31R7SJtieJJnQtGc7RVL2StM2vGYVfqUOvUDxH6bC6aJTxPxTF0GnIgCyu7tjockiUWAYQRbxa7vKn34s5sQ==",
-      "dev": true,
-      "requires": {
-        "pify": "^3.0.0"
-      }
-    },
-    "mamacro": {
-      "version": "0.0.3",
-      "resolved": "https://registry.npmjs.org/mamacro/-/mamacro-0.0.3.tgz",
-      "integrity": "sha512-qMEwh+UujcQ+kbz3T6V+wAmO2U8veoq2w+3wY8MquqwVA3jChfwY+Tk52GZKDfACEPjuZ7r2oJLejwpt8jtwTA==",
-      "dev": true
-    },
-    "map-cache": {
-      "version": "0.2.2",
-      "resolved": "https://registry.npmjs.org/map-cache/-/map-cache-0.2.2.tgz",
-      "integrity": "sha1-wyq9C9ZSXZsFFkW7TyasXcmKDb8=",
-      "dev": true
-    },
-    "map-visit": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/map-visit/-/map-visit-1.0.0.tgz",
-      "integrity": "sha1-7Nyo8TFE5mDxtb1B8S80edmN+48=",
-      "dev": true,
-      "requires": {
-        "object-visit": "^1.0.0"
-      }
-    },
-    "math-random": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/math-random/-/math-random-1.0.1.tgz",
-      "integrity": "sha1-izqsWIuKZuSXXjzepn97sylgH6w=",
-      "dev": true
-    },
-    "md5.js": {
-      "version": "1.3.4",
-      "resolved": "https://registry.npmjs.org/md5.js/-/md5.js-1.3.4.tgz",
-      "integrity": "sha1-6b296UogpawYsENA/Fdk1bCdkB0=",
-      "dev": true,
-      "requires": {
-        "hash-base": "^3.0.0",
-        "inherits": "^2.0.1"
-      }
-    },
-    "mem": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/mem/-/mem-1.1.0.tgz",
-      "integrity": "sha1-Xt1StIXKHZAP5kiVUFOZoN+kX3Y=",
-      "dev": true,
-      "requires": {
-        "mimic-fn": "^1.0.0"
-      }
-    },
-    "mem-fs": {
-      "version": "1.1.3",
-      "resolved": "https://registry.npmjs.org/mem-fs/-/mem-fs-1.1.3.tgz",
-      "integrity": "sha1-uK6NLj/Lb10/kWXBLUVRoGXZicw=",
-      "dev": true,
-      "requires": {
-        "through2": "^2.0.0",
-        "vinyl": "^1.1.0",
-        "vinyl-file": "^2.0.0"
-      }
-    },
-    "mem-fs-editor": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/mem-fs-editor/-/mem-fs-editor-4.0.2.tgz",
-      "integrity": "sha512-QHvdXLLNmwJXxKdf7x27aNUren6IoPxwcM8Sfd+S6/ddQQMcYdEtVKsh6ilpqMrU18VQuKZEaH0aCGt3JDbA0g==",
-      "dev": true,
-      "requires": {
-        "commondir": "^1.0.1",
-        "deep-extend": "^0.5.1",
-        "ejs": "^2.5.9",
-        "glob": "^7.0.3",
-        "globby": "^8.0.0",
-        "isbinaryfile": "^3.0.2",
-        "mkdirp": "^0.5.0",
-        "multimatch": "^2.0.0",
-        "rimraf": "^2.2.8",
-        "through2": "^2.0.0",
-        "vinyl": "^2.0.1"
-      },
-      "dependencies": {
-        "clone": {
-          "version": "2.1.1",
-          "resolved": "https://registry.npmjs.org/clone/-/clone-2.1.1.tgz",
-          "integrity": "sha1-0hfR6WERjjrJpLi7oyhVU79kfNs=",
-          "dev": true
-        },
-        "clone-stats": {
-          "version": "1.0.0",
-          "resolved": "https://registry.npmjs.org/clone-stats/-/clone-stats-1.0.0.tgz",
-          "integrity": "sha1-s3gt/4u1R04Yuba/D9/ngvh3doA=",
-          "dev": true
-        },
-        "replace-ext": {
-          "version": "1.0.0",
-          "resolved": "https://registry.npmjs.org/replace-ext/-/replace-ext-1.0.0.tgz",
-          "integrity": "sha1-3mMSg3P8v3w8z6TeWkgMRaZ5WOs=",
-          "dev": true
-        },
-        "vinyl": {
-          "version": "2.1.0",
-          "resolved": "https://registry.npmjs.org/vinyl/-/vinyl-2.1.0.tgz",
-          "integrity": "sha1-Ah+cLPlR1rk5lDyJ617lrdT9kkw=",
-          "dev": true,
-          "requires": {
-            "clone": "^2.1.1",
-            "clone-buffer": "^1.0.0",
-            "clone-stats": "^1.0.0",
-            "cloneable-readable": "^1.0.0",
-            "remove-trailing-separator": "^1.0.1",
-            "replace-ext": "^1.0.0"
-          }
-        }
-      }
-    },
-    "memory-fs": {
-      "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/memory-fs/-/memory-fs-0.4.1.tgz",
-      "integrity": "sha1-OpoguEYlI+RHz7x+i7gO1me/xVI=",
-      "dev": true,
-      "requires": {
-        "errno": "^0.1.3",
-        "readable-stream": "^2.0.1"
-      }
-    },
-    "merge2": {
-      "version": "1.2.2",
-      "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.2.2.tgz",
-      "integrity": "sha512-bgM8twH86rWni21thii6WCMQMRMmwqqdW3sGWi9IipnVAszdLXRjwDwAnyrVXo6DuP3AjRMMttZKUB48QWIFGg==",
-      "dev": true
-    },
-    "micromatch": {
-      "version": "3.1.10",
-      "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-3.1.10.tgz",
-      "integrity": "sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg==",
-      "dev": true,
-      "requires": {
-        "arr-diff": "^4.0.0",
-        "array-unique": "^0.3.2",
-        "braces": "^2.3.1",
-        "define-property": "^2.0.2",
-        "extend-shallow": "^3.0.2",
-        "extglob": "^2.0.4",
-        "fragment-cache": "^0.2.1",
-        "kind-of": "^6.0.2",
-        "nanomatch": "^1.2.9",
-        "object.pick": "^1.3.0",
-        "regex-not": "^1.0.0",
-        "snapdragon": "^0.8.1",
-        "to-regex": "^3.0.2"
-      }
-    },
-    "miller-rabin": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/miller-rabin/-/miller-rabin-4.0.1.tgz",
-      "integrity": "sha512-115fLhvZVqWwHPbClyntxEVfVDfl9DLLTuJvq3g2O/Oxi8AiNouAHvDSzHS0viUJc+V5vm3eq91Xwqn9dp4jRA==",
-      "dev": true,
-      "requires": {
-        "bn.js": "^4.0.0",
-        "brorand": "^1.0.1"
-      }
-    },
-    "mimic-fn": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-1.2.0.tgz",
-      "integrity": "sha512-jf84uxzwiuiIVKiOLpfYk7N46TSy8ubTonmneY9vrpHNAnp0QBt2BxWV9dO3/j+BoVAb+a5G6YDPW3M5HOdMWQ==",
-      "dev": true
-    },
-    "mimic-response": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-1.0.0.tgz",
-      "integrity": "sha1-3z02Uqc/3ta5sLJBRub9BSNTRY4=",
-      "dev": true
-    },
-    "minimalistic-assert": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz",
-      "integrity": "sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==",
-      "dev": true
-    },
-    "minimalistic-crypto-utils": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/minimalistic-crypto-utils/-/minimalistic-crypto-utils-1.0.1.tgz",
-      "integrity": "sha1-9sAMHAsIIkblxNmd+4x8CDsrWCo=",
-      "dev": true
-    },
-    "minimatch": {
-      "version": "3.0.4",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz",
-      "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==",
-      "dev": true,
-      "requires": {
-        "brace-expansion": "^1.1.7"
-      }
-    },
-    "minimist": {
-      "version": "0.0.8",
-      "resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.8.tgz",
-      "integrity": "sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0=",
-      "dev": true
-    },
-    "mississippi": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/mississippi/-/mississippi-2.0.0.tgz",
-      "integrity": "sha512-zHo8v+otD1J10j/tC+VNoGK9keCuByhKovAvdn74dmxJl9+mWHnx6EMsDN4lgRoMI/eYo2nchAxniIbUPb5onw==",
-      "dev": true,
-      "requires": {
-        "concat-stream": "^1.5.0",
-        "duplexify": "^3.4.2",
-        "end-of-stream": "^1.1.0",
-        "flush-write-stream": "^1.0.0",
-        "from2": "^2.1.0",
-        "parallel-transform": "^1.1.0",
-        "pump": "^2.0.1",
-        "pumpify": "^1.3.3",
-        "stream-each": "^1.1.0",
-        "through2": "^2.0.0"
-      }
-    },
-    "mixin-deep": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/mixin-deep/-/mixin-deep-1.3.1.tgz",
-      "integrity": "sha512-8ZItLHeEgaqEvd5lYBXfm4EZSFCX29Jb9K+lAHhDKzReKBQKj3R+7NOF6tjqYi9t4oI8VUfaWITJQm86wnXGNQ==",
-      "dev": true,
-      "requires": {
-        "for-in": "^1.0.2",
-        "is-extendable": "^1.0.1"
-      },
-      "dependencies": {
-        "is-extendable": {
-          "version": "1.0.1",
-          "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz",
-          "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==",
-          "dev": true,
-          "requires": {
-            "is-plain-object": "^2.0.4"
-          }
-        }
-      }
-    },
-    "mkdirp": {
-      "version": "0.5.1",
-      "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.1.tgz",
-      "integrity": "sha1-MAV0OOrGz3+MR2fzhkjWaX11yQM=",
-      "dev": true,
-      "requires": {
-        "minimist": "0.0.8"
-      }
-    },
-    "move-concurrently": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/move-concurrently/-/move-concurrently-1.0.1.tgz",
-      "integrity": "sha1-viwAX9oy4LKa8fBdfEszIUxwH5I=",
-      "dev": true,
-      "requires": {
-        "aproba": "^1.1.1",
-        "copy-concurrently": "^1.0.0",
-        "fs-write-stream-atomic": "^1.0.8",
-        "mkdirp": "^0.5.1",
-        "rimraf": "^2.5.4",
-        "run-queue": "^1.0.3"
-      }
-    },
-    "ms": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
-      "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=",
-      "dev": true
-    },
-    "multimatch": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/multimatch/-/multimatch-2.1.0.tgz",
-      "integrity": "sha1-nHkGoi+0wCkZ4vX3UWG0zb1LKis=",
-      "dev": true,
-      "requires": {
-        "array-differ": "^1.0.0",
-        "array-union": "^1.0.1",
-        "arrify": "^1.0.0",
-        "minimatch": "^3.0.0"
-      }
-    },
-    "mute-stream": {
-      "version": "0.0.7",
-      "resolved": "https://registry.npmjs.org/mute-stream/-/mute-stream-0.0.7.tgz",
-      "integrity": "sha1-MHXOk7whuPq0PhvE2n6BFe0ee6s=",
-      "dev": true
-    },
-    "nan": {
-      "version": "2.10.0",
-      "resolved": "https://registry.npmjs.org/nan/-/nan-2.10.0.tgz",
-      "integrity": "sha512-bAdJv7fBLhWC+/Bls0Oza+mvTaNQtP+1RyhhhvD95pgUJz6XM5IzgmxOkItJ9tkoCiplvAnXI1tNmmUD/eScyA==",
-      "dev": true,
-      "optional": true
-    },
-    "nanomatch": {
-      "version": "1.2.9",
-      "resolved": "https://registry.npmjs.org/nanomatch/-/nanomatch-1.2.9.tgz",
-      "integrity": "sha512-n8R9bS8yQ6eSXaV6jHUpKzD8gLsin02w1HSFiegwrs9E098Ylhw5jdyKPaYqvHknHaSCKTPp7C8dGCQ0q9koXA==",
-      "dev": true,
-      "requires": {
-        "arr-diff": "^4.0.0",
-        "array-unique": "^0.3.2",
-        "define-property": "^2.0.2",
-        "extend-shallow": "^3.0.2",
-        "fragment-cache": "^0.2.1",
-        "is-odd": "^2.0.0",
-        "is-windows": "^1.0.2",
-        "kind-of": "^6.0.2",
-        "object.pick": "^1.3.0",
-        "regex-not": "^1.0.0",
-        "snapdragon": "^0.8.1",
-        "to-regex": "^3.0.1"
-      }
-    },
-    "natural-compare": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
-      "integrity": "sha1-Sr6/7tdUHywnrPspvbvRXI1bpPc=",
-      "dev": true
-    },
-    "neo-async": {
-      "version": "2.5.1",
-      "resolved": "https://registry.npmjs.org/neo-async/-/neo-async-2.5.1.tgz",
-      "integrity": "sha512-3KL3fvuRkZ7s4IFOMfztb7zJp3QaVWnBeGoJlgB38XnCRPj/0tLzzLG5IB8NYOHbJ8g8UGrgZv44GLDk6CxTxA==",
-      "dev": true
-    },
-    "nice-try": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/nice-try/-/nice-try-1.0.4.tgz",
-      "integrity": "sha512-2NpiFHqC87y/zFke0fC0spBXL3bBsoh/p5H1EFhshxjCR5+0g2d6BiXbUFz9v1sAcxsk2htp2eQnNIci2dIYcA==",
-      "dev": true
-    },
-    "node-dir": {
-      "version": "0.1.8",
-      "resolved": "https://registry.npmjs.org/node-dir/-/node-dir-0.1.8.tgz",
-      "integrity": "sha1-VfuN62mQcHB/tn+RpGDwRIKUx30=",
-      "dev": true
-    },
-    "node-libs-browser": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/node-libs-browser/-/node-libs-browser-2.1.0.tgz",
-      "integrity": "sha512-5AzFzdoIMb89hBGMZglEegffzgRg+ZFoUmisQ8HI4j1KDdpx13J0taNp2y9xPbur6W61gepGDDotGBVQ7mfUCg==",
-      "dev": true,
-      "requires": {
-        "assert": "^1.1.1",
-        "browserify-zlib": "^0.2.0",
-        "buffer": "^4.3.0",
-        "console-browserify": "^1.1.0",
-        "constants-browserify": "^1.0.0",
-        "crypto-browserify": "^3.11.0",
-        "domain-browser": "^1.1.1",
-        "events": "^1.0.0",
-        "https-browserify": "^1.0.0",
-        "os-browserify": "^0.3.0",
-        "path-browserify": "0.0.0",
-        "process": "^0.11.10",
-        "punycode": "^1.2.4",
-        "querystring-es3": "^0.2.0",
-        "readable-stream": "^2.3.3",
-        "stream-browserify": "^2.0.1",
-        "stream-http": "^2.7.2",
-        "string_decoder": "^1.0.0",
-        "timers-browserify": "^2.0.4",
-        "tty-browserify": "0.0.0",
-        "url": "^0.11.0",
-        "util": "^0.10.3",
-        "vm-browserify": "0.0.4"
-      },
-      "dependencies": {
-        "punycode": {
-          "version": "1.4.1",
-          "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.4.1.tgz",
-          "integrity": "sha1-wNWmOycYgArY4esPpSachN1BhF4=",
-          "dev": true
-        }
-      }
-    },
-    "nomnom": {
-      "version": "1.8.1",
-      "resolved": "https://registry.npmjs.org/nomnom/-/nomnom-1.8.1.tgz",
-      "integrity": "sha1-IVH3Ikcrp55Qp2/BJbuMjy5Nwqc=",
-      "dev": true,
-      "requires": {
-        "chalk": "~0.4.0",
-        "underscore": "~1.6.0"
-      },
-      "dependencies": {
-        "ansi-styles": {
-          "version": "1.0.0",
-          "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-1.0.0.tgz",
-          "integrity": "sha1-yxAt8cVvUSPquLZ817mAJ6AnkXg=",
-          "dev": true
-        },
-        "chalk": {
-          "version": "0.4.0",
-          "resolved": "https://registry.npmjs.org/chalk/-/chalk-0.4.0.tgz",
-          "integrity": "sha1-UZmj3c0MHv4jvAjBsCewYXbgxk8=",
-          "dev": true,
-          "requires": {
-            "ansi-styles": "~1.0.0",
-            "has-color": "~0.1.0",
-            "strip-ansi": "~0.1.0"
-          }
-        },
-        "strip-ansi": {
-          "version": "0.1.1",
-          "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-0.1.1.tgz",
-          "integrity": "sha1-OeipjQRNFQZgq+SmgIrPcLt7yZE=",
-          "dev": true
-        }
-      }
-    },
-    "normalize-package-data": {
-      "version": "2.4.0",
-      "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.4.0.tgz",
-      "integrity": "sha512-9jjUFbTPfEy3R/ad/2oNbKtW9Hgovl5O1FvFWKkKblNXoN/Oou6+9+KKohPK13Yc3/TyunyWhJp6gvRNR/PPAw==",
-      "dev": true,
-      "requires": {
-        "hosted-git-info": "^2.1.4",
-        "is-builtin-module": "^1.0.0",
-        "semver": "2 || 3 || 4 || 5",
-        "validate-npm-package-license": "^3.0.1"
-      }
-    },
-    "normalize-path": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-2.1.1.tgz",
-      "integrity": "sha1-GrKLVW4Zg2Oowab35vogE3/mrtk=",
-      "dev": true,
-      "requires": {
-        "remove-trailing-separator": "^1.0.1"
-      }
-    },
-    "normalize-url": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/normalize-url/-/normalize-url-2.0.1.tgz",
-      "integrity": "sha512-D6MUW4K/VzoJ4rJ01JFKxDrtY1v9wrgzCX5f2qj/lzH1m/lW6MhUZFKerVsnyjOhOsYzI9Kqqak+10l4LvLpMw==",
-      "dev": true,
-      "requires": {
-        "prepend-http": "^2.0.0",
-        "query-string": "^5.0.1",
-        "sort-keys": "^2.0.0"
-      }
-    },
-    "npm-run-path": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-2.0.2.tgz",
-      "integrity": "sha1-NakjLfo11wZ7TLLd8jV7GHFTbF8=",
-      "dev": true,
-      "requires": {
-        "path-key": "^2.0.0"
-      }
-    },
-    "number-is-nan": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/number-is-nan/-/number-is-nan-1.0.1.tgz",
-      "integrity": "sha1-CXtgK1NCKlIsGvuHkDGDNpQaAR0=",
-      "dev": true
-    },
-    "object-assign": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
-      "integrity": "sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=",
-      "dev": true
-    },
-    "object-copy": {
-      "version": "0.1.0",
-      "resolved": "https://registry.npmjs.org/object-copy/-/object-copy-0.1.0.tgz",
-      "integrity": "sha1-fn2Fi3gb18mRpBupde04EnVOmYw=",
-      "dev": true,
-      "requires": {
-        "copy-descriptor": "^0.1.0",
-        "define-property": "^0.2.5",
-        "kind-of": "^3.0.3"
-      },
-      "dependencies": {
-        "define-property": {
-          "version": "0.2.5",
-          "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz",
-          "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=",
-          "dev": true,
-          "requires": {
-            "is-descriptor": "^0.1.0"
-          }
-        },
-        "kind-of": {
-          "version": "3.2.2",
-          "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz",
-          "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=",
-          "dev": true,
-          "requires": {
-            "is-buffer": "^1.1.5"
-          }
-        }
-      }
-    },
-    "object-visit": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/object-visit/-/object-visit-1.0.1.tgz",
-      "integrity": "sha1-95xEk68MU3e1n+OdOV5BBC3QRbs=",
-      "dev": true,
-      "requires": {
-        "isobject": "^3.0.0"
-      }
-    },
-    "object.omit": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/object.omit/-/object.omit-2.0.1.tgz",
-      "integrity": "sha1-Gpx0SCnznbuFjHbKNXmuKlTr0fo=",
-      "dev": true,
-      "requires": {
-        "for-own": "^0.1.4",
-        "is-extendable": "^0.1.1"
-      }
-    },
-    "object.pick": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/object.pick/-/object.pick-1.3.0.tgz",
-      "integrity": "sha1-h6EKxMFpS9Lhy/U1kaZhQftd10c=",
-      "dev": true,
-      "requires": {
-        "isobject": "^3.0.1"
-      }
-    },
-    "once": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
-      "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=",
-      "dev": true,
-      "requires": {
-        "wrappy": "1"
-      }
-    },
-    "onetime": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/onetime/-/onetime-2.0.1.tgz",
-      "integrity": "sha1-BnQoIw/WdEOyeUsiu6UotoZ5YtQ=",
-      "dev": true,
-      "requires": {
-        "mimic-fn": "^1.0.0"
-      }
-    },
-    "optionator": {
-      "version": "0.8.2",
-      "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.8.2.tgz",
-      "integrity": "sha1-NkxeQJ0/TWMB1sC0wFu6UBgK62Q=",
-      "dev": true,
-      "requires": {
-        "deep-is": "~0.1.3",
-        "fast-levenshtein": "~2.0.4",
-        "levn": "~0.3.0",
-        "prelude-ls": "~1.1.2",
-        "type-check": "~0.3.2",
-        "wordwrap": "~1.0.0"
-      }
-    },
-    "ora": {
-      "version": "0.2.3",
-      "resolved": "https://registry.npmjs.org/ora/-/ora-0.2.3.tgz",
-      "integrity": "sha1-N1J9Igrc1Tw5tzVx11QVbV22V6Q=",
-      "dev": true,
-      "requires": {
-        "chalk": "^1.1.1",
-        "cli-cursor": "^1.0.2",
-        "cli-spinners": "^0.1.2",
-        "object-assign": "^4.0.1"
-      },
-      "dependencies": {
-        "ansi-regex": {
-          "version": "2.1.1",
-          "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz",
-          "integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8=",
-          "dev": true
-        },
-        "ansi-styles": {
-          "version": "2.2.1",
-          "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-2.2.1.tgz",
-          "integrity": "sha1-tDLdM1i2NM914eRmQ2gkBTPB3b4=",
-          "dev": true
-        },
-        "chalk": {
-          "version": "1.1.3",
-          "resolved": "https://registry.npmjs.org/chalk/-/chalk-1.1.3.tgz",
-          "integrity": "sha1-qBFcVeSnAv5NFQq9OHKCKn4J/Jg=",
-          "dev": true,
-          "requires": {
-            "ansi-styles": "^2.2.1",
-            "escape-string-regexp": "^1.0.2",
-            "has-ansi": "^2.0.0",
-            "strip-ansi": "^3.0.0",
-            "supports-color": "^2.0.0"
-          }
-        },
-        "cli-cursor": {
-          "version": "1.0.2",
-          "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-1.0.2.tgz",
-          "integrity": "sha1-ZNo/fValRBLll5S9Ytw1KV6PKYc=",
-          "dev": true,
-          "requires": {
-            "restore-cursor": "^1.0.1"
-          }
-        },
-        "onetime": {
-          "version": "1.1.0",
-          "resolved": "http://registry.npmjs.org/onetime/-/onetime-1.1.0.tgz",
-          "integrity": "sha1-ofeDj4MUxRbwXs78vEzP4EtO14k=",
-          "dev": true
-        },
-        "restore-cursor": {
-          "version": "1.0.1",
-          "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-1.0.1.tgz",
-          "integrity": "sha1-NGYfRohjJ/7SmRR5FSJS35LapUE=",
-          "dev": true,
-          "requires": {
-            "exit-hook": "^1.0.0",
-            "onetime": "^1.0.0"
-          }
-        },
-        "strip-ansi": {
-          "version": "3.0.1",
-          "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz",
-          "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=",
-          "dev": true,
-          "requires": {
-            "ansi-regex": "^2.0.0"
-          }
-        },
-        "supports-color": {
-          "version": "2.0.0",
-          "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-2.0.0.tgz",
-          "integrity": "sha1-U10EXOa2Nj+kARcIRimZXp3zJMc=",
-          "dev": true
-        }
-      }
-    },
-    "os-browserify": {
-      "version": "0.3.0",
-      "resolved": "https://registry.npmjs.org/os-browserify/-/os-browserify-0.3.0.tgz",
-      "integrity": "sha1-hUNzx/XCMVkU/Jv8a9gjj92h7Cc=",
-      "dev": true
-    },
-    "os-homedir": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/os-homedir/-/os-homedir-1.0.2.tgz",
-      "integrity": "sha1-/7xJiDNuDoM94MFox+8VISGqf7M=",
-      "dev": true
-    },
-    "os-locale": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/os-locale/-/os-locale-2.1.0.tgz",
-      "integrity": "sha512-3sslG3zJbEYcaC4YVAvDorjGxc7tv6KVATnLPZONiljsUncvihe9BQoVCEs0RZ1kmf4Hk9OBqlZfJZWI4GanKA==",
-      "dev": true,
-      "requires": {
-        "execa": "^0.7.0",
-        "lcid": "^1.0.0",
-        "mem": "^1.1.0"
-      }
-    },
-    "os-tmpdir": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/os-tmpdir/-/os-tmpdir-1.0.2.tgz",
-      "integrity": "sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ=",
-      "dev": true
-    },
-    "p-cancelable": {
-      "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/p-cancelable/-/p-cancelable-0.4.1.tgz",
-      "integrity": "sha512-HNa1A8LvB1kie7cERyy21VNeHb2CWJJYqyyC2o3klWFfMGlFmWv2Z7sFgZH8ZiaYL95ydToKTFVXgMV/Os0bBQ==",
-      "dev": true
-    },
-    "p-each-series": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/p-each-series/-/p-each-series-1.0.0.tgz",
-      "integrity": "sha1-kw89Et0fUOdDRFeiLNbwSsatf3E=",
-      "dev": true,
-      "requires": {
-        "p-reduce": "^1.0.0"
-      }
-    },
-    "p-finally": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/p-finally/-/p-finally-1.0.0.tgz",
-      "integrity": "sha1-P7z7FbiZpEEjs0ttzBi3JDNqLK4=",
-      "dev": true
-    },
-    "p-is-promise": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/p-is-promise/-/p-is-promise-1.1.0.tgz",
-      "integrity": "sha1-nJRWmJ6fZYgBewQ01WCXZ1w9oF4=",
-      "dev": true
-    },
-    "p-lazy": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/p-lazy/-/p-lazy-1.0.0.tgz",
-      "integrity": "sha1-7FPIAvLuOsKPFmzILQsrAt4nqDU=",
-      "dev": true
-    },
-    "p-limit": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-1.2.0.tgz",
-      "integrity": "sha512-Y/OtIaXtUPr4/YpMv1pCL5L5ed0rumAaAeBSj12F+bSlMdys7i8oQF/GUJmfpTS/QoaRrS/k6pma29haJpsMng==",
-      "dev": true,
-      "requires": {
-        "p-try": "^1.0.0"
-      }
-    },
-    "p-locate": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-2.0.0.tgz",
-      "integrity": "sha1-IKAQOyIqcMj9OcwuWAaA893l7EM=",
-      "dev": true,
-      "requires": {
-        "p-limit": "^1.1.0"
-      }
-    },
-    "p-map": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/p-map/-/p-map-1.2.0.tgz",
-      "integrity": "sha512-r6zKACMNhjPJMTl8KcFH4li//gkrXWfbD6feV8l6doRHlzljFWGJ2AP6iKaCJXyZmAUMOPtvbW7EXkbWO/pLEA==",
-      "dev": true
-    },
-    "p-reduce": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/p-reduce/-/p-reduce-1.0.0.tgz",
-      "integrity": "sha1-GMKw3ZNqRpClKfgjH1ig/bakffo=",
-      "dev": true
-    },
-    "p-timeout": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/p-timeout/-/p-timeout-2.0.1.tgz",
-      "integrity": "sha512-88em58dDVB/KzPEx1X0N3LwFfYZPyDc4B6eF38M1rk9VTZMbxXXgjugz8mmwpS9Ox4BDZ+t6t3QP5+/gazweIA==",
-      "dev": true,
-      "requires": {
-        "p-finally": "^1.0.0"
-      }
-    },
-    "p-try": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/p-try/-/p-try-1.0.0.tgz",
-      "integrity": "sha1-y8ec26+P1CKOE/Yh8rGiN8GyB7M=",
-      "dev": true
-    },
-    "pako": {
-      "version": "1.0.6",
-      "resolved": "https://registry.npmjs.org/pako/-/pako-1.0.6.tgz",
-      "integrity": "sha512-lQe48YPsMJAig+yngZ87Lus+NF+3mtu7DVOBu6b/gHO1YpKwIj5AWjZ/TOS7i46HD/UixzWb1zeWDZfGZ3iYcg==",
-      "dev": true
-    },
-    "parallel-transform": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/parallel-transform/-/parallel-transform-1.1.0.tgz",
-      "integrity": "sha1-1BDwZbBdojCB/NEPKIVMKb2jOwY=",
-      "dev": true,
-      "requires": {
-        "cyclist": "~0.2.2",
-        "inherits": "^2.0.3",
-        "readable-stream": "^2.1.5"
-      }
-    },
-    "parse-asn1": {
-      "version": "5.1.1",
-      "resolved": "https://registry.npmjs.org/parse-asn1/-/parse-asn1-5.1.1.tgz",
-      "integrity": "sha512-KPx7flKXg775zZpnp9SxJlz00gTd4BmJ2yJufSc44gMCRrRQ7NSzAcSJQfifuOLgW6bEi+ftrALtsgALeB2Adw==",
-      "dev": true,
-      "requires": {
-        "asn1.js": "^4.0.0",
-        "browserify-aes": "^1.0.0",
-        "create-hash": "^1.1.0",
-        "evp_bytestokey": "^1.0.0",
-        "pbkdf2": "^3.0.3"
-      }
-    },
-    "parse-glob": {
-      "version": "3.0.4",
-      "resolved": "https://registry.npmjs.org/parse-glob/-/parse-glob-3.0.4.tgz",
-      "integrity": "sha1-ssN2z7EfNVE7rdFz7wu246OIORw=",
-      "dev": true,
-      "requires": {
-        "glob-base": "^0.3.0",
-        "is-dotfile": "^1.0.0",
-        "is-extglob": "^1.0.0",
-        "is-glob": "^2.0.0"
-      },
-      "dependencies": {
-        "is-extglob": {
-          "version": "1.0.0",
-          "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-1.0.0.tgz",
-          "integrity": "sha1-rEaBd8SUNAWgkvyPKXYMb/xiBsA=",
-          "dev": true
-        },
-        "is-glob": {
-          "version": "2.0.1",
-          "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-2.0.1.tgz",
-          "integrity": "sha1-0Jb5JqPe1WAPP9/ZEZjLCIjC2GM=",
-          "dev": true,
-          "requires": {
-            "is-extglob": "^1.0.0"
-          }
-        }
-      }
-    },
-    "parse-json": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-4.0.0.tgz",
-      "integrity": "sha1-vjX1Qlvh9/bHRxhPmKeIy5lHfuA=",
-      "dev": true,
-      "requires": {
-        "error-ex": "^1.3.1",
-        "json-parse-better-errors": "^1.0.1"
-      }
-    },
-    "parse-passwd": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/parse-passwd/-/parse-passwd-1.0.0.tgz",
-      "integrity": "sha1-bVuTSkVpk7I9N/QKOC1vFmao5cY=",
-      "dev": true
-    },
-    "pascalcase": {
-      "version": "0.1.1",
-      "resolved": "https://registry.npmjs.org/pascalcase/-/pascalcase-0.1.1.tgz",
-      "integrity": "sha1-s2PlXoAGym/iF4TS2yK9FdeRfxQ=",
-      "dev": true
-    },
-    "path-browserify": {
-      "version": "0.0.0",
-      "resolved": "https://registry.npmjs.org/path-browserify/-/path-browserify-0.0.0.tgz",
-      "integrity": "sha1-oLhwcpquIUAFt9UDLsLLuw+0RRo=",
-      "dev": true
-    },
-    "path-dirname": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/path-dirname/-/path-dirname-1.0.2.tgz",
-      "integrity": "sha1-zDPSTVJeCZpTiMAzbG4yuRYGCeA=",
-      "dev": true
-    },
-    "path-exists": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-3.0.0.tgz",
-      "integrity": "sha1-zg6+ql94yxiSXqfYENe1mwEP1RU=",
-      "dev": true
-    },
-    "path-is-absolute": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
-      "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=",
-      "dev": true
-    },
-    "path-is-inside": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/path-is-inside/-/path-is-inside-1.0.2.tgz",
-      "integrity": "sha1-NlQX3t5EQw0cEa9hAn+s8HS9/FM=",
-      "dev": true
-    },
-    "path-key": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/path-key/-/path-key-2.0.1.tgz",
-      "integrity": "sha1-QRyttXTFoUDTpLGRDUDYDMn0C0A=",
-      "dev": true
-    },
-    "path-parse": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.5.tgz",
-      "integrity": "sha1-PBrfhx6pzWyUMbbqK9dKD/BVxME=",
-      "dev": true
-    },
-    "path-type": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/path-type/-/path-type-3.0.0.tgz",
-      "integrity": "sha512-T2ZUsdZFHgA3u4e5PfPbjd7HDDpxPnQb5jN0SrDsjNSuVXHJqtwTnWqG0B1jZrgmJ/7lj1EmVIByWt1gxGkWvg==",
-      "dev": true,
-      "requires": {
-        "pify": "^3.0.0"
-      }
-    },
-    "pbkdf2": {
-      "version": "3.0.16",
-      "resolved": "https://registry.npmjs.org/pbkdf2/-/pbkdf2-3.0.16.tgz",
-      "integrity": "sha512-y4CXP3thSxqf7c0qmOF+9UeOTrifiVTIM+u7NWlq+PRsHbr7r7dpCmvzrZxa96JJUNi0Y5w9VqG5ZNeCVMoDcA==",
-      "dev": true,
-      "requires": {
-        "create-hash": "^1.1.2",
-        "create-hmac": "^1.1.4",
-        "ripemd160": "^2.0.1",
-        "safe-buffer": "^5.0.1",
-        "sha.js": "^2.4.8"
-      }
-    },
-    "pify": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/pify/-/pify-3.0.0.tgz",
-      "integrity": "sha1-5aSs0sEB/fPZpNB/DbxNtJ3SgXY=",
-      "dev": true
-    },
-    "pinkie": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/pinkie/-/pinkie-2.0.4.tgz",
-      "integrity": "sha1-clVrgM+g1IqXToDnckjoDtT3+HA=",
-      "dev": true
-    },
-    "pinkie-promise": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/pinkie-promise/-/pinkie-promise-2.0.1.tgz",
-      "integrity": "sha1-ITXW36ejWMBprJsXh3YogihFD/o=",
-      "dev": true,
-      "requires": {
-        "pinkie": "^2.0.0"
-      }
-    },
-    "pkg-dir": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/pkg-dir/-/pkg-dir-2.0.0.tgz",
-      "integrity": "sha1-9tXREJ4Z1j7fQo4L1X4Sd3YVM0s=",
-      "dev": true,
-      "requires": {
-        "find-up": "^2.1.0"
-      }
-    },
-    "pluralize": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/pluralize/-/pluralize-7.0.0.tgz",
-      "integrity": "sha512-ARhBOdzS3e41FbkW/XWrTEtukqqLoK5+Z/4UeDaLuSW+39JPeFgs4gCGqsrJHVZX0fUrx//4OF0K1CUGwlIFow==",
-      "dev": true
-    },
-    "posix-character-classes": {
-      "version": "0.1.1",
-      "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
-      "integrity": "sha1-AerA/jta9xoqbAL+q7jB/vfgDqs=",
-      "dev": true
-    },
-    "prelude-ls": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.1.2.tgz",
-      "integrity": "sha1-IZMqVJ9eUv/ZqCf1cOBL5iqX2lQ=",
-      "dev": true
-    },
-    "prepend-http": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/prepend-http/-/prepend-http-2.0.0.tgz",
-      "integrity": "sha1-6SQ0v6XqjBn0HN/UAddBo8gZ2Jc=",
-      "dev": true
-    },
-    "preserve": {
-      "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/preserve/-/preserve-0.2.0.tgz",
-      "integrity": "sha1-gV7R9uvGWSb4ZbMQwHE7yzMVzks=",
-      "dev": true
-    },
-    "prettier": {
-      "version": "1.13.4",
-      "resolved": "https://registry.npmjs.org/prettier/-/prettier-1.13.4.tgz",
-      "integrity": "sha512-emsEZ2bAigL1lq6ssgkpPm1MIBqgeTvcp90NxOP5XDqprub/V/WS2Hfgih3mS7/1dqTUvhG+sxx1Dv8crnVexA==",
-      "dev": true
-    },
-    "pretty-bytes": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/pretty-bytes/-/pretty-bytes-4.0.2.tgz",
-      "integrity": "sha1-sr+C5zUNZcbDOqlaqlpPYyf2HNk=",
-      "dev": true
-    },
-    "private": {
-      "version": "0.1.8",
-      "resolved": "https://registry.npmjs.org/private/-/private-0.1.8.tgz",
-      "integrity": "sha512-VvivMrbvd2nKkiG38qjULzlc+4Vx4wm/whI9pQD35YrARNnhxeiRktSOhSukRLFNlzg6Br/cJPet5J/u19r/mg==",
-      "dev": true
-    },
-    "process": {
-      "version": "0.11.10",
-      "resolved": "https://registry.npmjs.org/process/-/process-0.11.10.tgz",
-      "integrity": "sha1-czIwDoQBYb2j5podHZGn1LwW8YI=",
-      "dev": true
-    },
-    "process-nextick-args": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.0.tgz",
-      "integrity": "sha512-MtEC1TqN0EU5nephaJ4rAtThHtC86dNN9qCuEhtshvpVBkAW5ZO7BASN9REnF9eoXGcRub+pFuKEpOHE+HbEMw==",
-      "dev": true
-    },
-    "progress": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/progress/-/progress-2.0.0.tgz",
-      "integrity": "sha1-ihvjZr+Pwj2yvSPxDG/pILQ4nR8=",
-      "dev": true
-    },
-    "promise-inflight": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/promise-inflight/-/promise-inflight-1.0.1.tgz",
-      "integrity": "sha1-mEcocL8igTL8vdhoEputEsPAKeM=",
-      "dev": true
-    },
-    "prr": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/prr/-/prr-1.0.1.tgz",
-      "integrity": "sha1-0/wRS6BplaRexok/SEzrHXj19HY=",
-      "dev": true
-    },
-    "pseudomap": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/pseudomap/-/pseudomap-1.0.2.tgz",
-      "integrity": "sha1-8FKijacOYYkX7wqKw0wa5aaChrM=",
-      "dev": true
-    },
-    "public-encrypt": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/public-encrypt/-/public-encrypt-4.0.2.tgz",
-      "integrity": "sha512-4kJ5Esocg8X3h8YgJsKAuoesBgB7mqH3eowiDzMUPKiRDDE7E/BqqZD1hnTByIaAFiwAw246YEltSq7tdrOH0Q==",
-      "dev": true,
-      "requires": {
-        "bn.js": "^4.1.0",
-        "browserify-rsa": "^4.0.0",
-        "create-hash": "^1.1.0",
-        "parse-asn1": "^5.0.0",
-        "randombytes": "^2.0.1"
-      }
-    },
-    "pump": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/pump/-/pump-2.0.1.tgz",
-      "integrity": "sha512-ruPMNRkN3MHP1cWJc9OWr+T/xDP0jhXYCLfJcBuX54hhfIBnaQmAUMfDcG4DM5UMWByBbJY69QSphm3jtDKIkA==",
-      "dev": true,
-      "requires": {
-        "end-of-stream": "^1.1.0",
-        "once": "^1.3.1"
-      }
-    },
-    "pumpify": {
-      "version": "1.5.1",
-      "resolved": "https://registry.npmjs.org/pumpify/-/pumpify-1.5.1.tgz",
-      "integrity": "sha512-oClZI37HvuUJJxSKKrC17bZ9Cu0ZYhEAGPsPUy9KlMUmv9dKX2o77RUmq7f3XjIxbwyGwYzbzQ1L2Ks8sIradQ==",
-      "dev": true,
-      "requires": {
-        "duplexify": "^3.6.0",
-        "inherits": "^2.0.3",
-        "pump": "^2.0.0"
-      }
-    },
-    "punycode": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.1.1.tgz",
-      "integrity": "sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==",
-      "dev": true
-    },
-    "query-string": {
-      "version": "5.1.1",
-      "resolved": "https://registry.npmjs.org/query-string/-/query-string-5.1.1.tgz",
-      "integrity": "sha512-gjWOsm2SoGlgLEdAGt7a6slVOk9mGiXmPFMqrEhLQ68rhQuBnpfs3+EmlvqKyxnCo9/PPlF+9MtY02S1aFg+Jw==",
-      "dev": true,
-      "requires": {
-        "decode-uri-component": "^0.2.0",
-        "object-assign": "^4.1.0",
-        "strict-uri-encode": "^1.0.0"
-      }
-    },
-    "querystring": {
-      "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/querystring/-/querystring-0.2.0.tgz",
-      "integrity": "sha1-sgmEkgO7Jd+CDadW50cAWHhSFiA=",
-      "dev": true
-    },
-    "querystring-es3": {
-      "version": "0.2.1",
-      "resolved": "https://registry.npmjs.org/querystring-es3/-/querystring-es3-0.2.1.tgz",
-      "integrity": "sha1-nsYfeQSYdXB9aUFFlv2Qek1xHnM=",
-      "dev": true
-    },
-    "randomatic": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/randomatic/-/randomatic-3.0.0.tgz",
-      "integrity": "sha512-VdxFOIEY3mNO5PtSRkkle/hPJDHvQhK21oa73K4yAc9qmp6N429gAyF1gZMOTMeS0/AYzaV/2Trcef+NaIonSA==",
-      "dev": true,
-      "requires": {
-        "is-number": "^4.0.0",
-        "kind-of": "^6.0.0",
-        "math-random": "^1.0.1"
-      },
-      "dependencies": {
-        "is-number": {
-          "version": "4.0.0",
-          "resolved": "https://registry.npmjs.org/is-number/-/is-number-4.0.0.tgz",
-          "integrity": "sha512-rSklcAIlf1OmFdyAqbnWTLVelsQ58uvZ66S/ZyawjWqIviTWCjg2PzVGw8WUA+nNuPTqb4wgA+NszrJ+08LlgQ==",
-          "dev": true
-        }
-      }
-    },
-    "randombytes": {
-      "version": "2.0.6",
-      "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.0.6.tgz",
-      "integrity": "sha512-CIQ5OFxf4Jou6uOKe9t1AOgqpeU5fd70A8NPdHSGeYXqXsPe6peOwI0cUl88RWZ6sP1vPMV3avd/R6cZ5/sP1A==",
-      "dev": true,
-      "requires": {
-        "safe-buffer": "^5.1.0"
-      }
-    },
-    "randomfill": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/randomfill/-/randomfill-1.0.4.tgz",
-      "integrity": "sha512-87lcbR8+MhcWcUiQ+9e+Rwx8MyR2P7qnt15ynUlbm3TU/fjbgz4GsvfSUDTemtCCtVCqb4ZcEFlyPNTh9bBTLw==",
-      "dev": true,
-      "requires": {
-        "randombytes": "^2.0.5",
-        "safe-buffer": "^5.1.0"
-      }
-    },
-    "read-chunk": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/read-chunk/-/read-chunk-2.1.0.tgz",
-      "integrity": "sha1-agTAkoAF7Z1C4aasVgDhnLx/9lU=",
-      "dev": true,
-      "requires": {
-        "pify": "^3.0.0",
-        "safe-buffer": "^5.1.1"
-      }
-    },
-    "read-pkg": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-3.0.0.tgz",
-      "integrity": "sha1-nLxoaXj+5l0WwA4rGcI3/Pbjg4k=",
-      "dev": true,
-      "requires": {
-        "load-json-file": "^4.0.0",
-        "normalize-package-data": "^2.3.2",
-        "path-type": "^3.0.0"
-      }
-    },
-    "read-pkg-up": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-3.0.0.tgz",
-      "integrity": "sha1-PtSWaF26D4/hGNBpHcUfSh/5bwc=",
-      "dev": true,
-      "requires": {
-        "find-up": "^2.0.0",
-        "read-pkg": "^3.0.0"
-      }
-    },
-    "readable-stream": {
-      "version": "2.3.6",
-      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.6.tgz",
-      "integrity": "sha512-tQtKA9WIAhBF3+VLAseyMqZeBjW0AHJoxOtYqSUZNJxauErmLbVm2FW1y+J/YA9dUrAC39ITejlZWhVIwawkKw==",
-      "dev": true,
-      "requires": {
-        "core-util-is": "~1.0.0",
-        "inherits": "~2.0.3",
-        "isarray": "~1.0.0",
-        "process-nextick-args": "~2.0.0",
-        "safe-buffer": "~5.1.1",
-        "string_decoder": "~1.1.1",
-        "util-deprecate": "~1.0.1"
-      }
-    },
-    "readdirp": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-2.1.0.tgz",
-      "integrity": "sha1-TtCtBg3zBzMAxIRANz9y0cxkLXg=",
-      "dev": true,
-      "requires": {
-        "graceful-fs": "^4.1.2",
-        "minimatch": "^3.0.2",
-        "readable-stream": "^2.0.2",
-        "set-immediate-shim": "^1.0.1"
-      }
-    },
-    "recast": {
-      "version": "0.15.0",
-      "resolved": "https://registry.npmjs.org/recast/-/recast-0.15.0.tgz",
-      "integrity": "sha512-47C2mIxQYvFICrTNuV4+xGgBa1nAoq42ANN5oDTSBIJ50NX7jcki7gAC6HWYptnQgHmqIRTHJq8OKdi3fwgyNQ==",
-      "dev": true,
-      "requires": {
-        "ast-types": "0.11.5",
-        "esprima": "~4.0.0",
-        "private": "~0.1.5",
-        "source-map": "~0.6.1"
-      },
-      "dependencies": {
-        "source-map": {
-          "version": "0.6.1",
-          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
-          "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
-          "dev": true
-        }
-      }
-    },
-    "rechoir": {
-      "version": "0.6.2",
-      "resolved": "https://registry.npmjs.org/rechoir/-/rechoir-0.6.2.tgz",
-      "integrity": "sha1-hSBLVNuoLVdC4oyWdW70OvUOM4Q=",
-      "dev": true,
-      "requires": {
-        "resolve": "^1.1.6"
-      }
-    },
-    "regenerate": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/regenerate/-/regenerate-1.4.0.tgz",
-      "integrity": "sha512-1G6jJVDWrt0rK99kBjvEtziZNCICAuvIPkSiUFIQxVP06RCVpq3dmDo2oi6ABpYaDYaTRr67BEhL8r1wgEZZKg==",
-      "dev": true
-    },
-    "regenerator-runtime": {
-      "version": "0.11.1",
-      "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.11.1.tgz",
-      "integrity": "sha512-MguG95oij0fC3QV3URf4V2SDYGJhJnJGqvIIgdECeODCT98wSWDAJ94SSuVpYQUoTcGUIL6L4yNB7j1DFFHSBg==",
-      "dev": true
-    },
-    "regenerator-transform": {
-      "version": "0.10.1",
-      "resolved": "https://registry.npmjs.org/regenerator-transform/-/regenerator-transform-0.10.1.tgz",
-      "integrity": "sha512-PJepbvDbuK1xgIgnau7Y90cwaAmO/LCLMI2mPvaXq2heGMR3aWW5/BQvYrhJ8jgmQjXewXvBjzfqKcVOmhjZ6Q==",
-      "dev": true,
-      "requires": {
-        "babel-runtime": "^6.18.0",
-        "babel-types": "^6.19.0",
-        "private": "^0.1.6"
-      }
-    },
-    "regex-cache": {
-      "version": "0.4.4",
-      "resolved": "https://registry.npmjs.org/regex-cache/-/regex-cache-0.4.4.tgz",
-      "integrity": "sha512-nVIZwtCjkC9YgvWkpM55B5rBhBYRZhAaJbgcFYXXsHnbZ9UZI9nnVWYZpBlCqv9ho2eZryPnWrZGsOdPwVWXWQ==",
-      "dev": true,
-      "requires": {
-        "is-equal-shallow": "^0.1.3"
-      }
-    },
-    "regex-not": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/regex-not/-/regex-not-1.0.2.tgz",
-      "integrity": "sha512-J6SDjUgDxQj5NusnOtdFxDwN/+HWykR8GELwctJ7mdqhcyy1xEc4SRFHUXvxTp661YaVKAjfRLZ9cCqS6tn32A==",
-      "dev": true,
-      "requires": {
-        "extend-shallow": "^3.0.2",
-        "safe-regex": "^1.1.0"
-      }
-    },
-    "regexpp": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/regexpp/-/regexpp-1.1.0.tgz",
-      "integrity": "sha512-LOPw8FpgdQF9etWMaAfG/WRthIdXJGYp4mJ2Jgn/2lpkbod9jPn0t9UqN7AxBOKNfzRbYyVfgc7Vk4t/MpnXgw==",
-      "dev": true
-    },
-    "regexpu-core": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/regexpu-core/-/regexpu-core-2.0.0.tgz",
-      "integrity": "sha1-SdA4g3uNz4v6W5pCE5k45uoq4kA=",
-      "dev": true,
-      "requires": {
-        "regenerate": "^1.2.1",
-        "regjsgen": "^0.2.0",
-        "regjsparser": "^0.1.4"
-      }
-    },
-    "regjsgen": {
-      "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/regjsgen/-/regjsgen-0.2.0.tgz",
-      "integrity": "sha1-bAFq3qxVT3WCP+N6wFuS1aTtsfc=",
-      "dev": true
-    },
-    "regjsparser": {
-      "version": "0.1.5",
-      "resolved": "https://registry.npmjs.org/regjsparser/-/regjsparser-0.1.5.tgz",
-      "integrity": "sha1-fuj4Tcb6eS0/0K4ijSS9lJ6tIFw=",
-      "dev": true,
-      "requires": {
-        "jsesc": "~0.5.0"
-      }
-    },
-    "remove-trailing-separator": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/remove-trailing-separator/-/remove-trailing-separator-1.1.0.tgz",
-      "integrity": "sha1-wkvOKig62tW8P1jg1IJJuSN52O8=",
-      "dev": true
-    },
-    "repeat-element": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/repeat-element/-/repeat-element-1.1.2.tgz",
-      "integrity": "sha1-7wiaF40Ug7quTZPrmLT55OEdmQo=",
-      "dev": true
-    },
-    "repeat-string": {
-      "version": "1.6.1",
-      "resolved": "https://registry.npmjs.org/repeat-string/-/repeat-string-1.6.1.tgz",
-      "integrity": "sha1-jcrkcOHIirwtYA//Sndihtp15jc=",
-      "dev": true
-    },
-    "repeating": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/repeating/-/repeating-2.0.1.tgz",
-      "integrity": "sha1-UhTFOpJtNVJwdSf7q0FdvAjQbdo=",
-      "dev": true,
-      "requires": {
-        "is-finite": "^1.0.0"
-      }
-    },
-    "replace-ext": {
-      "version": "0.0.1",
-      "resolved": "https://registry.npmjs.org/replace-ext/-/replace-ext-0.0.1.tgz",
-      "integrity": "sha1-KbvZIHinOfC8zitO5B6DeVNSKSQ=",
-      "dev": true
-    },
-    "require-directory": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
-      "integrity": "sha1-jGStX9MNqxyXbiNE/+f3kqam30I=",
-      "dev": true
-    },
-    "require-main-filename": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/require-main-filename/-/require-main-filename-1.0.1.tgz",
-      "integrity": "sha1-l/cXtp1IeE9fUmpsWqj/3aBVpNE=",
-      "dev": true
-    },
-    "require-uncached": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/require-uncached/-/require-uncached-1.0.3.tgz",
-      "integrity": "sha1-Tg1W1slmL9MeQwEcS5WqSZVUIdM=",
-      "dev": true,
-      "requires": {
-        "caller-path": "^0.1.0",
-        "resolve-from": "^1.0.0"
-      },
-      "dependencies": {
-        "resolve-from": {
-          "version": "1.0.1",
-          "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-1.0.1.tgz",
-          "integrity": "sha1-Jsv+k10a7uq7Kbw/5a6wHpPUQiY=",
-          "dev": true
-        }
-      }
-    },
-    "resolve": {
-      "version": "1.7.1",
-      "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.7.1.tgz",
-      "integrity": "sha512-c7rwLofp8g1U+h1KNyHL/jicrKg1Ek4q+Lr33AL65uZTinUZHe30D5HlyN5V9NW0JX1D5dXQ4jqW5l7Sy/kGfw==",
-      "dev": true,
-      "requires": {
-        "path-parse": "^1.0.5"
-      }
-    },
-    "resolve-cwd": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/resolve-cwd/-/resolve-cwd-2.0.0.tgz",
-      "integrity": "sha1-AKn3OHVW4nA46uIyyqNypqWbZlo=",
-      "dev": true,
-      "requires": {
-        "resolve-from": "^3.0.0"
-      }
-    },
-    "resolve-dir": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/resolve-dir/-/resolve-dir-1.0.1.tgz",
-      "integrity": "sha1-eaQGRMNivoLybv/nOcm7U4IEb0M=",
-      "dev": true,
-      "requires": {
-        "expand-tilde": "^2.0.0",
-        "global-modules": "^1.0.0"
-      }
-    },
-    "resolve-from": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-3.0.0.tgz",
-      "integrity": "sha1-six699nWiBvItuZTM17rywoYh0g=",
-      "dev": true
-    },
-    "resolve-url": {
-      "version": "0.2.1",
-      "resolved": "https://registry.npmjs.org/resolve-url/-/resolve-url-0.2.1.tgz",
-      "integrity": "sha1-LGN/53yJOv0qZj/iGqkIAGjiBSo=",
-      "dev": true
-    },
-    "responselike": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/responselike/-/responselike-1.0.2.tgz",
-      "integrity": "sha1-kYcg7ztjHFZCvgaPFa3lpG9Loec=",
-      "dev": true,
-      "requires": {
-        "lowercase-keys": "^1.0.0"
-      }
-    },
-    "restore-cursor": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-2.0.0.tgz",
-      "integrity": "sha1-n37ih/gv0ybU/RYpI9YhKe7g368=",
-      "dev": true,
-      "requires": {
-        "onetime": "^2.0.0",
-        "signal-exit": "^3.0.2"
-      }
-    },
-    "ret": {
-      "version": "0.1.15",
-      "resolved": "https://registry.npmjs.org/ret/-/ret-0.1.15.tgz",
-      "integrity": "sha512-TTlYpa+OL+vMMNG24xSlQGEJ3B/RzEfUlLct7b5G/ytav+wPrplCpVMFuwzXbkecJrb6IYo1iFb0S9v37754mg==",
-      "dev": true
-    },
-    "rimraf": {
-      "version": "2.6.2",
-      "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.2.tgz",
-      "integrity": "sha512-lreewLK/BlghmxtfH36YYVg1i8IAce4TI7oao75I1g245+6BctqTVQiBP3YUJ9C6DQOXJmkYR9X9fCLtCOJc5w==",
-      "dev": true,
-      "requires": {
-        "glob": "^7.0.5"
-      }
-    },
-    "ripemd160": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/ripemd160/-/ripemd160-2.0.2.tgz",
-      "integrity": "sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA==",
-      "dev": true,
-      "requires": {
-        "hash-base": "^3.0.0",
-        "inherits": "^2.0.1"
-      }
-    },
-    "run-async": {
-      "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/run-async/-/run-async-2.3.0.tgz",
-      "integrity": "sha1-A3GrSuC91yDUFm19/aZP96RFpsA=",
-      "dev": true,
-      "requires": {
-        "is-promise": "^2.1.0"
-      }
-    },
-    "run-queue": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/run-queue/-/run-queue-1.0.3.tgz",
-      "integrity": "sha1-6Eg5bwV9Ij8kOGkkYY4laUFh7Ec=",
-      "dev": true,
-      "requires": {
-        "aproba": "^1.1.1"
-      }
-    },
-    "rx-lite": {
-      "version": "4.0.8",
-      "resolved": "https://registry.npmjs.org/rx-lite/-/rx-lite-4.0.8.tgz",
-      "integrity": "sha1-Cx4Rr4vESDbwSmQH6S2kJGe3lEQ=",
-      "dev": true
-    },
-    "rx-lite-aggregates": {
-      "version": "4.0.8",
-      "resolved": "https://registry.npmjs.org/rx-lite-aggregates/-/rx-lite-aggregates-4.0.8.tgz",
-      "integrity": "sha1-dTuHqJoRyVRnxKwWJsTvxOBcZ74=",
-      "dev": true,
-      "requires": {
-        "rx-lite": "*"
-      }
-    },
-    "rxjs": {
-      "version": "5.5.11",
-      "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-5.5.11.tgz",
-      "integrity": "sha512-3bjO7UwWfA2CV7lmwYMBzj4fQ6Cq+ftHc2MvUe+WMS7wcdJ1LosDWmdjPQanYp2dBRj572p7PeU81JUxHKOcBA==",
-      "dev": true,
-      "requires": {
-        "symbol-observable": "1.0.1"
-      }
-    },
-    "safe-buffer": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
-      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
-      "dev": true
-    },
-    "safe-regex": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/safe-regex/-/safe-regex-1.1.0.tgz",
-      "integrity": "sha1-QKNmnzsHfR6UPURinhV91IAjvy4=",
-      "dev": true,
-      "requires": {
-        "ret": "~0.1.10"
-      }
-    },
-    "safer-buffer": {
-      "version": "2.1.2",
-      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
-      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
-      "dev": true
-    },
-    "schema-utils": {
-      "version": "0.4.5",
-      "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-0.4.5.tgz",
-      "integrity": "sha512-yYrjb9TX2k/J1Y5UNy3KYdZq10xhYcF8nMpAW6o3hy6Q8WSIEf9lJHG/ePnOBfziPM3fvQwfOwa13U/Fh8qTfA==",
-      "dev": true,
-      "requires": {
-        "ajv": "^6.1.0",
-        "ajv-keywords": "^3.1.0"
-      }
-    },
-    "scoped-regex": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/scoped-regex/-/scoped-regex-1.0.0.tgz",
-      "integrity": "sha1-o0a7Gs1CB65wvXwMfKnlZra63bg=",
-      "dev": true
-    },
-    "semver": {
-      "version": "5.5.0",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-5.5.0.tgz",
-      "integrity": "sha512-4SJ3dm0WAwWy/NVeioZh5AntkdJoWKxHxcmyP622fOkgHa4z3R0TdBJICINyaSDE6uNwVc8gZr+ZinwZAH4xIA==",
-      "dev": true
-    },
-    "serialize-javascript": {
-      "version": "1.5.0",
-      "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-1.5.0.tgz",
-      "integrity": "sha512-Ga8c8NjAAp46Br4+0oZ2WxJCwIzwP60Gq1YPgU+39PiTVxyed/iKE/zyZI6+UlVYH5Q4PaQdHhcegIFPZTUfoQ==",
-      "dev": true
-    },
-    "set-blocking": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz",
-      "integrity": "sha1-BF+XgtARrppoA93TgrJDkrPYkPc=",
-      "dev": true
-    },
-    "set-immediate-shim": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/set-immediate-shim/-/set-immediate-shim-1.0.1.tgz",
-      "integrity": "sha1-SysbJ+uAip+NzEgaWOXlb1mfP2E=",
-      "dev": true
-    },
-    "set-value": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/set-value/-/set-value-2.0.0.tgz",
-      "integrity": "sha512-hw0yxk9GT/Hr5yJEYnHNKYXkIA8mVJgd9ditYZCe16ZczcaELYYcfvaXesNACk2O8O0nTiPQcQhGUQj8JLzeeg==",
-      "dev": true,
-      "requires": {
-        "extend-shallow": "^2.0.1",
-        "is-extendable": "^0.1.1",
-        "is-plain-object": "^2.0.3",
-        "split-string": "^3.0.1"
-      },
-      "dependencies": {
-        "extend-shallow": {
-          "version": "2.0.1",
-          "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz",
-          "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
-          "dev": true,
-          "requires": {
-            "is-extendable": "^0.1.0"
-          }
-        }
-      }
-    },
-    "setimmediate": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/setimmediate/-/setimmediate-1.0.5.tgz",
-      "integrity": "sha1-KQy7Iy4waULX1+qbg3Mqt4VvgoU=",
-      "dev": true
-    },
-    "sha.js": {
-      "version": "2.4.11",
-      "resolved": "https://registry.npmjs.org/sha.js/-/sha.js-2.4.11.tgz",
-      "integrity": "sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ==",
-      "dev": true,
-      "requires": {
-        "inherits": "^2.0.1",
-        "safe-buffer": "^5.0.1"
-      }
-    },
-    "shebang-command": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-1.2.0.tgz",
-      "integrity": "sha1-RKrGW2lbAzmJaMOfNj/uXer98eo=",
-      "dev": true,
-      "requires": {
-        "shebang-regex": "^1.0.0"
-      }
-    },
-    "shebang-regex": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-1.0.0.tgz",
-      "integrity": "sha1-2kL0l0DAtC2yypcoVxyxkMmO/qM=",
-      "dev": true
-    },
-    "shelljs": {
-      "version": "0.8.2",
-      "resolved": "https://registry.npmjs.org/shelljs/-/shelljs-0.8.2.tgz",
-      "integrity": "sha512-pRXeNrCA2Wd9itwhvLp5LZQvPJ0wU6bcjaTMywHHGX5XWhVN2nzSu7WV0q+oUY7mGK3mgSkDDzP3MgjqdyIgbQ==",
-      "dev": true,
-      "requires": {
-        "glob": "^7.0.0",
-        "interpret": "^1.0.0",
-        "rechoir": "^0.6.2"
-      }
-    },
-    "signal-exit": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.2.tgz",
-      "integrity": "sha1-tf3AjxKH6hF4Yo5BXiUTK3NkbG0=",
-      "dev": true
-    },
-    "slash": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/slash/-/slash-1.0.0.tgz",
-      "integrity": "sha1-xB8vbDn8FtHNF61LXYlhFK5HDVU=",
-      "dev": true
-    },
-    "slice-ansi": {
-      "version": "0.0.4",
-      "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-0.0.4.tgz",
-      "integrity": "sha1-7b+JA/ZvfOL46v1s7tZeJkyDGzU=",
-      "dev": true
-    },
-    "slide": {
-      "version": "1.1.6",
-      "resolved": "https://registry.npmjs.org/slide/-/slide-1.1.6.tgz",
-      "integrity": "sha1-VusCfWW00tzmyy4tMsTUr8nh1wc=",
-      "dev": true
-    },
-    "snapdragon": {
-      "version": "0.8.2",
-      "resolved": "https://registry.npmjs.org/snapdragon/-/snapdragon-0.8.2.tgz",
-      "integrity": "sha512-FtyOnWN/wCHTVXOMwvSv26d+ko5vWlIDD6zoUJ7LW8vh+ZBC8QdljveRP+crNrtBwioEUWy/4dMtbBjA4ioNlg==",
-      "dev": true,
-      "requires": {
-        "base": "^0.11.1",
-        "debug": "^2.2.0",
-        "define-property": "^0.2.5",
-        "extend-shallow": "^2.0.1",
-        "map-cache": "^0.2.2",
-        "source-map": "^0.5.6",
-        "source-map-resolve": "^0.5.0",
-        "use": "^3.1.0"
-      },
-      "dependencies": {
-        "define-property": {
-          "version": "0.2.5",
-          "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz",
-          "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=",
-          "dev": true,
-          "requires": {
-            "is-descriptor": "^0.1.0"
-          }
-        },
-        "extend-shallow": {
-          "version": "2.0.1",
-          "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz",
-          "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
-          "dev": true,
-          "requires": {
-            "is-extendable": "^0.1.0"
-          }
-        }
-      }
-    },
-    "snapdragon-node": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/snapdragon-node/-/snapdragon-node-2.1.1.tgz",
-      "integrity": "sha512-O27l4xaMYt/RSQ5TR3vpWCAB5Kb/czIcqUFOM/C4fYcLnbZUc1PkjTAMjof2pBWaSTwOUd6qUHcFGVGj7aIwnw==",
-      "dev": true,
-      "requires": {
-        "define-property": "^1.0.0",
-        "isobject": "^3.0.0",
-        "snapdragon-util": "^3.0.1"
-      },
-      "dependencies": {
-        "define-property": {
-          "version": "1.0.0",
-          "resolved": "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz",
-          "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=",
-          "dev": true,
-          "requires": {
-            "is-descriptor": "^1.0.0"
-          }
-        },
-        "is-accessor-descriptor": {
-          "version": "1.0.0",
-          "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz",
-          "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==",
-          "dev": true,
-          "requires": {
-            "kind-of": "^6.0.0"
-          }
-        },
-        "is-data-descriptor": {
-          "version": "1.0.0",
-          "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz",
-          "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==",
-          "dev": true,
-          "requires": {
-            "kind-of": "^6.0.0"
-          }
-        },
-        "is-descriptor": {
-          "version": "1.0.2",
-          "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz",
-          "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==",
-          "dev": true,
-          "requires": {
-            "is-accessor-descriptor": "^1.0.0",
-            "is-data-descriptor": "^1.0.0",
-            "kind-of": "^6.0.2"
-          }
-        }
-      }
-    },
-    "snapdragon-util": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/snapdragon-util/-/snapdragon-util-3.0.1.tgz",
-      "integrity": "sha512-mbKkMdQKsjX4BAL4bRYTj21edOf8cN7XHdYUJEe+Zn99hVEYcMvKPct1IqNe7+AZPirn8BCDOQBHQZknqmKlZQ==",
-      "dev": true,
-      "requires": {
-        "kind-of": "^3.2.0"
-      },
-      "dependencies": {
-        "kind-of": {
-          "version": "3.2.2",
-          "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz",
-          "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=",
-          "dev": true,
-          "requires": {
-            "is-buffer": "^1.1.5"
-          }
-        }
-      }
-    },
-    "sort-keys": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/sort-keys/-/sort-keys-2.0.0.tgz",
-      "integrity": "sha1-ZYU1WEhh7JfXMNbPQYIuH1ZoQSg=",
-      "dev": true,
-      "requires": {
-        "is-plain-obj": "^1.0.0"
-      }
-    },
-    "source-list-map": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/source-list-map/-/source-list-map-2.0.0.tgz",
-      "integrity": "sha512-I2UmuJSRr/T8jisiROLU3A3ltr+swpniSmNPI4Ml3ZCX6tVnDsuZzK7F2hl5jTqbZBWCEKlj5HRQiPExXLgE8A==",
-      "dev": true
-    },
-    "source-map": {
-      "version": "0.5.7",
-      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz",
-      "integrity": "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=",
-      "dev": true
-    },
-    "source-map-resolve": {
-      "version": "0.5.2",
-      "resolved": "https://registry.npmjs.org/source-map-resolve/-/source-map-resolve-0.5.2.tgz",
-      "integrity": "sha512-MjqsvNwyz1s0k81Goz/9vRBe9SZdB09Bdw+/zYyO+3CuPk6fouTaxscHkgtE8jKvf01kVfl8riHzERQ/kefaSA==",
-      "dev": true,
-      "requires": {
-        "atob": "^2.1.1",
-        "decode-uri-component": "^0.2.0",
-        "resolve-url": "^0.2.1",
-        "source-map-url": "^0.4.0",
-        "urix": "^0.1.0"
-      }
-    },
-    "source-map-support": {
-      "version": "0.4.18",
-      "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.4.18.tgz",
-      "integrity": "sha512-try0/JqxPLF9nOjvSta7tVondkP5dwgyLDjVoyMDlmjugT2lRZ1OfsrYTkCd2hkDnJTKRbO/Rl3orm8vlsUzbA==",
-      "dev": true,
-      "requires": {
-        "source-map": "^0.5.6"
-      }
-    },
-    "source-map-url": {
-      "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/source-map-url/-/source-map-url-0.4.0.tgz",
-      "integrity": "sha1-PpNdfd1zYxuXZZlW1VEo6HtQhKM=",
-      "dev": true
-    },
-    "spdx-correct": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.0.0.tgz",
-      "integrity": "sha512-N19o9z5cEyc8yQQPukRCZ9EUmb4HUpnrmaL/fxS2pBo2jbfcFRVuFZ/oFC+vZz0MNNk0h80iMn5/S6qGZOL5+g==",
-      "dev": true,
-      "requires": {
-        "spdx-expression-parse": "^3.0.0",
-        "spdx-license-ids": "^3.0.0"
-      }
-    },
-    "spdx-exceptions": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.1.0.tgz",
-      "integrity": "sha512-4K1NsmrlCU1JJgUrtgEeTVyfx8VaYea9J9LvARxhbHtVtohPs/gFGG5yy49beySjlIMhhXZ4QqujIZEfS4l6Cg==",
-      "dev": true
-    },
-    "spdx-expression-parse": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.0.tgz",
-      "integrity": "sha512-Yg6D3XpRD4kkOmTpdgbUiEJFKghJH03fiC1OPll5h/0sO6neh2jqRDVHOQ4o/LMea0tgCkbMgea5ip/e+MkWyg==",
-      "dev": true,
-      "requires": {
-        "spdx-exceptions": "^2.1.0",
-        "spdx-license-ids": "^3.0.0"
-      }
-    },
-    "spdx-license-ids": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.0.tgz",
-      "integrity": "sha512-2+EPwgbnmOIl8HjGBXXMd9NAu02vLjOO1nWw4kmeRDFyHn+M/ETfHxQUK0oXg8ctgVnl9t3rosNVsZ1jG61nDA==",
-      "dev": true
-    },
-    "split-string": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/split-string/-/split-string-3.1.0.tgz",
-      "integrity": "sha512-NzNVhJDYpwceVVii8/Hu6DKfD2G+NrQHlS/V/qgv763EYudVwEcMQNxd2lh+0VrUByXN/oJkl5grOhYWvQUYiw==",
-      "dev": true,
-      "requires": {
-        "extend-shallow": "^3.0.0"
-      }
-    },
-    "sprintf-js": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz",
-      "integrity": "sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw=",
-      "dev": true
-    },
-    "ssri": {
-      "version": "5.3.0",
-      "resolved": "https://registry.npmjs.org/ssri/-/ssri-5.3.0.tgz",
-      "integrity": "sha512-XRSIPqLij52MtgoQavH/x/dU1qVKtWUAAZeOHsR9c2Ddi4XerFy3mc1alf+dLJKl9EUIm/Ht+EowFkTUOA6GAQ==",
-      "dev": true,
-      "requires": {
-        "safe-buffer": "^5.1.1"
-      }
-    },
-    "static-extend": {
-      "version": "0.1.2",
-      "resolved": "https://registry.npmjs.org/static-extend/-/static-extend-0.1.2.tgz",
-      "integrity": "sha1-YICcOcv/VTNyJv1eC1IPNB8ftcY=",
-      "dev": true,
-      "requires": {
-        "define-property": "^0.2.5",
-        "object-copy": "^0.1.0"
-      },
-      "dependencies": {
-        "define-property": {
-          "version": "0.2.5",
-          "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz",
-          "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=",
-          "dev": true,
-          "requires": {
-            "is-descriptor": "^0.1.0"
-          }
-        }
-      }
-    },
-    "stream-browserify": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/stream-browserify/-/stream-browserify-2.0.1.tgz",
-      "integrity": "sha1-ZiZu5fm9uZQKTkUUyvtDu3Hlyds=",
-      "dev": true,
-      "requires": {
-        "inherits": "~2.0.1",
-        "readable-stream": "^2.0.2"
-      }
-    },
-    "stream-each": {
-      "version": "1.2.2",
-      "resolved": "https://registry.npmjs.org/stream-each/-/stream-each-1.2.2.tgz",
-      "integrity": "sha512-mc1dbFhGBxvTM3bIWmAAINbqiuAk9TATcfIQC8P+/+HJefgaiTlMn2dHvkX8qlI12KeYKSQ1Ua9RrIqrn1VPoA==",
-      "dev": true,
-      "requires": {
-        "end-of-stream": "^1.1.0",
-        "stream-shift": "^1.0.0"
-      }
-    },
-    "stream-http": {
-      "version": "2.8.3",
-      "resolved": "https://registry.npmjs.org/stream-http/-/stream-http-2.8.3.tgz",
-      "integrity": "sha512-+TSkfINHDo4J+ZobQLWiMouQYB+UVYFttRA94FpEzzJ7ZdqcL4uUUQ7WkdkI4DSozGmgBUE/a47L+38PenXhUw==",
-      "dev": true,
-      "requires": {
-        "builtin-status-codes": "^3.0.0",
-        "inherits": "^2.0.1",
-        "readable-stream": "^2.3.6",
-        "to-arraybuffer": "^1.0.0",
-        "xtend": "^4.0.0"
-      }
-    },
-    "stream-shift": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/stream-shift/-/stream-shift-1.0.0.tgz",
-      "integrity": "sha1-1cdSgl5TZ+eG944Y5EXqIjoVWVI=",
-      "dev": true
-    },
-    "strict-uri-encode": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/strict-uri-encode/-/strict-uri-encode-1.1.0.tgz",
-      "integrity": "sha1-J5siXfHVgrH1TmWt3UNS4Y+qBxM=",
-      "dev": true
-    },
-    "string-template": {
-      "version": "0.2.1",
-      "resolved": "https://registry.npmjs.org/string-template/-/string-template-0.2.1.tgz",
-      "integrity": "sha1-QpMuWYo1LQH8IuwzZ9nYTuxsmt0=",
-      "dev": true
-    },
-    "string-width": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz",
-      "integrity": "sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==",
-      "dev": true,
-      "requires": {
-        "is-fullwidth-code-point": "^2.0.0",
-        "strip-ansi": "^4.0.0"
-      }
-    },
-    "string_decoder": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
-      "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
-      "dev": true,
-      "requires": {
-        "safe-buffer": "~5.1.0"
-      }
-    },
-    "strip-ansi": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz",
-      "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=",
-      "dev": true,
-      "requires": {
-        "ansi-regex": "^3.0.0"
-      }
-    },
-    "strip-bom": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-2.0.0.tgz",
-      "integrity": "sha1-YhmoVhZSBJHzV4i9vxRHqZx+aw4=",
-      "dev": true,
-      "requires": {
-        "is-utf8": "^0.2.0"
-      }
-    },
-    "strip-bom-stream": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/strip-bom-stream/-/strip-bom-stream-2.0.0.tgz",
-      "integrity": "sha1-+H217yYT9paKpUWr/h7HKLaoKco=",
-      "dev": true,
-      "requires": {
-        "first-chunk-stream": "^2.0.0",
-        "strip-bom": "^2.0.0"
-      }
-    },
-    "strip-eof": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/strip-eof/-/strip-eof-1.0.0.tgz",
-      "integrity": "sha1-u0P/VZim6wXYm1n80SnJgzE2Br8=",
-      "dev": true
-    },
-    "strip-json-comments": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz",
-      "integrity": "sha1-PFMZQukIwml8DsNEhYwobHygpgo=",
-      "dev": true
-    },
-    "supports-color": {
-      "version": "5.4.0",
-      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.4.0.tgz",
-      "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==",
-      "dev": true,
-      "requires": {
-        "has-flag": "^3.0.0"
-      }
-    },
-    "symbol-observable": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/symbol-observable/-/symbol-observable-1.0.1.tgz",
-      "integrity": "sha1-g0D8RwLDEi310iKI+IKD9RPT/dQ=",
-      "dev": true
-    },
-    "table": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/table/-/table-4.0.2.tgz",
-      "integrity": "sha512-UUkEAPdSGxtRpiV9ozJ5cMTtYiqz7Ni1OGqLXRCynrvzdtR1p+cfOWe2RJLwvUG8hNanaSRjecIqwOjqeatDsA==",
-      "dev": true,
-      "requires": {
-        "ajv": "^5.2.3",
-        "ajv-keywords": "^2.1.0",
-        "chalk": "^2.1.0",
-        "lodash": "^4.17.4",
-        "slice-ansi": "1.0.0",
-        "string-width": "^2.1.1"
-      },
-      "dependencies": {
-        "ajv": {
-          "version": "5.5.2",
-          "resolved": "https://registry.npmjs.org/ajv/-/ajv-5.5.2.tgz",
-          "integrity": "sha1-c7Xuyj+rZT49P5Qis0GtQiBdyWU=",
-          "dev": true,
-          "requires": {
-            "co": "^4.6.0",
-            "fast-deep-equal": "^1.0.0",
-            "fast-json-stable-stringify": "^2.0.0",
-            "json-schema-traverse": "^0.3.0"
-          }
-        },
-        "ajv-keywords": {
-          "version": "2.1.1",
-          "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-2.1.1.tgz",
-          "integrity": "sha1-YXmX/F9gV2iUxDX5QNgZ4TW4B2I=",
-          "dev": true
-        },
-        "fast-deep-equal": {
-          "version": "1.1.0",
-          "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-1.1.0.tgz",
-          "integrity": "sha1-wFNHeBfIa1HaqFPIHgWbcz0CNhQ=",
-          "dev": true
-        },
-        "slice-ansi": {
-          "version": "1.0.0",
-          "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-1.0.0.tgz",
-          "integrity": "sha512-POqxBK6Lb3q6s047D/XsDVNPnF9Dl8JSaqe9h9lURl0OdNqy/ujDrOiIHtsqXMGbWWTIomRzAMaTyawAU//Reg==",
-          "dev": true,
-          "requires": {
-            "is-fullwidth-code-point": "^2.0.0"
-          }
-        }
-      }
-    },
-    "tapable": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/tapable/-/tapable-1.0.0.tgz",
-      "integrity": "sha512-dQRhbNQkRnaqauC7WqSJ21EEksgT0fYZX2lqXzGkpo8JNig9zGZTYoMGvyI2nWmXlE2VSVXVDu7wLVGu/mQEsg==",
-      "dev": true
-    },
-    "temp": {
-      "version": "0.8.3",
-      "resolved": "https://registry.npmjs.org/temp/-/temp-0.8.3.tgz",
-      "integrity": "sha1-4Ma8TSa5AxJEEOT+2BEDAU38H1k=",
-      "dev": true,
-      "requires": {
-        "os-tmpdir": "^1.0.0",
-        "rimraf": "~2.2.6"
-      },
-      "dependencies": {
-        "rimraf": {
-          "version": "2.2.8",
-          "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.2.8.tgz",
-          "integrity": "sha1-5Dm+Kq7jJzIZUnMPmaiSnk/FBYI=",
-          "dev": true
-        }
-      }
-    },
-    "text-table": {
-      "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz",
-      "integrity": "sha1-f17oI66AUgfACvLfSoTsP8+lcLQ=",
-      "dev": true
-    },
-    "textextensions": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/textextensions/-/textextensions-2.2.0.tgz",
-      "integrity": "sha512-j5EMxnryTvKxwH2Cq+Pb43tsf6sdEgw6Pdwxk83mPaq0ToeFJt6WE4J3s5BqY7vmjlLgkgXvhtXUxo80FyBhCA==",
-      "dev": true
-    },
-    "through": {
-      "version": "2.3.8",
-      "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz",
-      "integrity": "sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=",
-      "dev": true
-    },
-    "through2": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/through2/-/through2-2.0.3.tgz",
-      "integrity": "sha1-AARWmzfHx0ujnEPzzteNGtlBQL4=",
-      "dev": true,
-      "requires": {
-        "readable-stream": "^2.1.5",
-        "xtend": "~4.0.1"
-      }
-    },
-    "timed-out": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/timed-out/-/timed-out-4.0.1.tgz",
-      "integrity": "sha1-8y6srFoXW+ol1/q1Zas+2HQe9W8=",
-      "dev": true
-    },
-    "timers-browserify": {
-      "version": "2.0.10",
-      "resolved": "https://registry.npmjs.org/timers-browserify/-/timers-browserify-2.0.10.tgz",
-      "integrity": "sha512-YvC1SV1XdOUaL6gx5CoGroT3Gu49pK9+TZ38ErPldOWW4j49GI1HKs9DV+KGq/w6y+LZ72W1c8cKz2vzY+qpzg==",
-      "dev": true,
-      "requires": {
-        "setimmediate": "^1.0.4"
-      }
-    },
-    "tmp": {
-      "version": "0.0.33",
-      "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.0.33.tgz",
-      "integrity": "sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==",
-      "dev": true,
-      "requires": {
-        "os-tmpdir": "~1.0.2"
-      }
-    },
-    "to-arraybuffer": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/to-arraybuffer/-/to-arraybuffer-1.0.1.tgz",
-      "integrity": "sha1-fSKbH8xjfkZsoIEYCDanqr/4P0M=",
-      "dev": true
-    },
-    "to-fast-properties": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-1.0.3.tgz",
-      "integrity": "sha1-uDVx+k2MJbguIxsG46MFXeTKGkc=",
-      "dev": true
-    },
-    "to-object-path": {
-      "version": "0.3.0",
-      "resolved": "https://registry.npmjs.org/to-object-path/-/to-object-path-0.3.0.tgz",
-      "integrity": "sha1-KXWIt7Dn4KwI4E5nL4XB9JmeF68=",
-      "dev": true,
-      "requires": {
-        "kind-of": "^3.0.2"
-      },
-      "dependencies": {
-        "kind-of": {
-          "version": "3.2.2",
-          "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz",
-          "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=",
-          "dev": true,
-          "requires": {
-            "is-buffer": "^1.1.5"
-          }
-        }
-      }
-    },
-    "to-regex": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/to-regex/-/to-regex-3.0.2.tgz",
-      "integrity": "sha512-FWtleNAtZ/Ki2qtqej2CXTOayOH9bHDQF+Q48VpWyDXjbYxA4Yz8iDB31zXOBUlOHHKidDbqGVrTUvQMPmBGBw==",
-      "dev": true,
-      "requires": {
-        "define-property": "^2.0.2",
-        "extend-shallow": "^3.0.2",
-        "regex-not": "^1.0.2",
-        "safe-regex": "^1.1.0"
-      }
-    },
-    "to-regex-range": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-2.1.1.tgz",
-      "integrity": "sha1-fIDBe53+vlmeJzZ+DU3VWQFB2zg=",
-      "dev": true,
-      "requires": {
-        "is-number": "^3.0.0",
-        "repeat-string": "^1.6.1"
-      }
-    },
-    "trim-right": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/trim-right/-/trim-right-1.0.1.tgz",
-      "integrity": "sha1-yy4SAwZ+DI3h9hQJS5/kVwTqYAM=",
-      "dev": true
-    },
-    "ts-loader": {
-      "version": "4.3.1",
-      "resolved": "https://registry.npmjs.org/ts-loader/-/ts-loader-4.3.1.tgz",
-      "integrity": "sha512-ra304bebnyxd9nIJoKjQoeQLOENqrDG7vfppS+DkCnqOEv29GuiiWMvgebuCqFko0AkMFpoubRLeFM7YmlkL3w==",
-      "dev": true,
-      "requires": {
-        "chalk": "^2.3.0",
-        "enhanced-resolve": "^4.0.0",
-        "loader-utils": "^1.0.2",
-        "micromatch": "^3.1.4",
-        "semver": "^5.0.1"
-      }
-    },
-    "tslib": {
-      "version": "1.9.2",
-      "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.9.2.tgz",
-      "integrity": "sha512-AVP5Xol3WivEr7hnssHDsaM+lVrVXWUvd1cfXTRkTj80b//6g2wIFEH6hZG0muGZRnHGrfttpdzRk3YlBkWjKw==",
-      "dev": true
-    },
-    "tty-browserify": {
-      "version": "0.0.0",
-      "resolved": "https://registry.npmjs.org/tty-browserify/-/tty-browserify-0.0.0.tgz",
-      "integrity": "sha1-oVe6QC2iTpv5V/mqadUk7tQpAaY=",
-      "dev": true
-    },
-    "type-check": {
-      "version": "0.3.2",
-      "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.3.2.tgz",
-      "integrity": "sha1-WITKtRLPHTVeP7eE8wgEsrUg23I=",
-      "dev": true,
-      "requires": {
-        "prelude-ls": "~1.1.2"
-      }
-    },
-    "typedarray": {
-      "version": "0.0.6",
-      "resolved": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz",
-      "integrity": "sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=",
-      "dev": true
-    },
-    "typescript": {
-      "version": "2.9.1",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-2.9.1.tgz",
-      "integrity": "sha512-h6pM2f/GDchCFlldnriOhs1QHuwbnmj6/v7499eMHqPeW4V2G0elua2eIc2nu8v2NdHV0Gm+tzX83Hr6nUFjQA==",
-      "dev": true
-    },
-    "uglify-es": {
-      "version": "3.3.9",
-      "resolved": "https://registry.npmjs.org/uglify-es/-/uglify-es-3.3.9.tgz",
-      "integrity": "sha512-r+MU0rfv4L/0eeW3xZrd16t4NZfK8Ld4SWVglYBb7ez5uXFWHuVRs6xCTrf1yirs9a4j4Y27nn7SRfO6v67XsQ==",
-      "dev": true,
-      "requires": {
-        "commander": "~2.13.0",
-        "source-map": "~0.6.1"
-      },
-      "dependencies": {
-        "source-map": {
-          "version": "0.6.1",
-          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
-          "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
-          "dev": true
-        }
-      }
-    },
-    "uglifyjs-webpack-plugin": {
-      "version": "1.2.5",
-      "resolved": "https://registry.npmjs.org/uglifyjs-webpack-plugin/-/uglifyjs-webpack-plugin-1.2.5.tgz",
-      "integrity": "sha512-hIQJ1yxAPhEA2yW/i7Fr+SXZVMp+VEI3d42RTHBgQd2yhp/1UdBcR3QEWPV5ahBxlqQDMEMTuTEvDHSFINfwSw==",
-      "dev": true,
-      "requires": {
-        "cacache": "^10.0.4",
-        "find-cache-dir": "^1.0.0",
-        "schema-utils": "^0.4.5",
-        "serialize-javascript": "^1.4.0",
-        "source-map": "^0.6.1",
-        "uglify-es": "^3.3.4",
-        "webpack-sources": "^1.1.0",
-        "worker-farm": "^1.5.2"
-      },
-      "dependencies": {
-        "source-map": {
-          "version": "0.6.1",
-          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
-          "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
-          "dev": true
-        }
-      }
-    },
-    "underscore": {
-      "version": "1.6.0",
-      "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.6.0.tgz",
-      "integrity": "sha1-izixDKze9jM3uLJOT/htRa6lKag=",
-      "dev": true
-    },
-    "union-value": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/union-value/-/union-value-1.0.0.tgz",
-      "integrity": "sha1-XHHDTLW61dzr4+oM0IIHulqhrqQ=",
-      "dev": true,
-      "requires": {
-        "arr-union": "^3.1.0",
-        "get-value": "^2.0.6",
-        "is-extendable": "^0.1.1",
-        "set-value": "^0.4.3"
-      },
-      "dependencies": {
-        "extend-shallow": {
-          "version": "2.0.1",
-          "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz",
-          "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
-          "dev": true,
-          "requires": {
-            "is-extendable": "^0.1.0"
-          }
-        },
-        "set-value": {
-          "version": "0.4.3",
-          "resolved": "https://registry.npmjs.org/set-value/-/set-value-0.4.3.tgz",
-          "integrity": "sha1-fbCPnT0i3H945Trzw79GZuzfzPE=",
-          "dev": true,
-          "requires": {
-            "extend-shallow": "^2.0.1",
-            "is-extendable": "^0.1.1",
-            "is-plain-object": "^2.0.1",
-            "to-object-path": "^0.3.0"
-          }
-        }
-      }
-    },
-    "unique-filename": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/unique-filename/-/unique-filename-1.1.0.tgz",
-      "integrity": "sha1-0F8v5AMlYIcfMOk8vnNe6iAVFPM=",
-      "dev": true,
-      "requires": {
-        "unique-slug": "^2.0.0"
-      }
-    },
-    "unique-slug": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/unique-slug/-/unique-slug-2.0.0.tgz",
-      "integrity": "sha1-22Z258fMBimHj/GWCXx4hVrp9Ks=",
-      "dev": true,
-      "requires": {
-        "imurmurhash": "^0.1.4"
-      }
-    },
-    "unset-value": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/unset-value/-/unset-value-1.0.0.tgz",
-      "integrity": "sha1-g3aHP30jNRef+x5vw6jtDfyKtVk=",
-      "dev": true,
-      "requires": {
-        "has-value": "^0.3.1",
-        "isobject": "^3.0.0"
-      },
-      "dependencies": {
-        "has-value": {
-          "version": "0.3.1",
-          "resolved": "https://registry.npmjs.org/has-value/-/has-value-0.3.1.tgz",
-          "integrity": "sha1-ex9YutpiyoJ+wKIHgCVlSEWZXh8=",
-          "dev": true,
-          "requires": {
-            "get-value": "^2.0.3",
-            "has-values": "^0.1.4",
-            "isobject": "^2.0.0"
-          },
-          "dependencies": {
-            "isobject": {
-              "version": "2.1.0",
-              "resolved": "https://registry.npmjs.org/isobject/-/isobject-2.1.0.tgz",
-              "integrity": "sha1-8GVWEJaj8dou9GJy+BXIQNh+DIk=",
-              "dev": true,
-              "requires": {
-                "isarray": "1.0.0"
-              }
-            }
-          }
-        },
-        "has-values": {
-          "version": "0.1.4",
-          "resolved": "https://registry.npmjs.org/has-values/-/has-values-0.1.4.tgz",
-          "integrity": "sha1-bWHeldkd/Km5oCCJrThL/49it3E=",
-          "dev": true
-        }
-      }
-    },
-    "untildify": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/untildify/-/untildify-3.0.3.tgz",
-      "integrity": "sha512-iSk/J8efr8uPT/Z4eSUywnqyrQU7DSdMfdqK4iWEaUVVmcP5JcnpRqmVMwcwcnmI1ATFNgC5V90u09tBynNFKA==",
-      "dev": true
-    },
-    "upath": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/upath/-/upath-1.1.0.tgz",
-      "integrity": "sha512-bzpH/oBhoS/QI/YtbkqCg6VEiPYjSZtrHQM6/QnJS6OL9pKUFLqb3aFh4Scvwm45+7iAgiMkLhSbaZxUqmrprw==",
-      "dev": true
-    },
-    "uri-js": {
-      "version": "4.2.2",
-      "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.2.2.tgz",
-      "integrity": "sha512-KY9Frmirql91X2Qgjry0Wd4Y+YTdrdZheS8TFwvkbLWf/G5KNJDCh6pKL5OZctEW4+0Baa5idK2ZQuELRwPznQ==",
-      "dev": true,
-      "requires": {
-        "punycode": "^2.1.0"
-      }
-    },
-    "urix": {
-      "version": "0.1.0",
-      "resolved": "https://registry.npmjs.org/urix/-/urix-0.1.0.tgz",
-      "integrity": "sha1-2pN/emLiH+wf0Y1Js1wpNQZ6bHI=",
-      "dev": true
-    },
-    "url": {
-      "version": "0.11.0",
-      "resolved": "https://registry.npmjs.org/url/-/url-0.11.0.tgz",
-      "integrity": "sha1-ODjpfPxgUh63PFJajlW/3Z4uKPE=",
-      "dev": true,
-      "requires": {
-        "punycode": "1.3.2",
-        "querystring": "0.2.0"
-      },
-      "dependencies": {
-        "punycode": {
-          "version": "1.3.2",
-          "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.3.2.tgz",
-          "integrity": "sha1-llOgNvt8HuQjQvIyXM7v6jkmxI0=",
-          "dev": true
-        }
-      }
-    },
-    "url-parse-lax": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/url-parse-lax/-/url-parse-lax-3.0.0.tgz",
-      "integrity": "sha1-FrXK/Afb42dsGxmZF3gj1lA6yww=",
-      "dev": true,
-      "requires": {
-        "prepend-http": "^2.0.0"
-      }
-    },
-    "url-to-options": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/url-to-options/-/url-to-options-1.0.1.tgz",
-      "integrity": "sha1-FQWgOiiaSMvXpDTvuu7FBV9WM6k=",
-      "dev": true
-    },
-    "use": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/use/-/use-3.1.0.tgz",
-      "integrity": "sha512-6UJEQM/L+mzC3ZJNM56Q4DFGLX/evKGRg15UJHGB9X5j5Z3AFbgZvjUh2yq/UJUY4U5dh7Fal++XbNg1uzpRAw==",
-      "dev": true,
-      "requires": {
-        "kind-of": "^6.0.2"
-      }
-    },
-    "util": {
-      "version": "0.10.4",
-      "resolved": "https://registry.npmjs.org/util/-/util-0.10.4.tgz",
-      "integrity": "sha512-0Pm9hTQ3se5ll1XihRic3FDIku70C+iHUdT/W926rSgHV5QgXsYbKZN8MSC3tJtSkhuROzvsQjAaFENRXr+19A==",
-      "dev": true,
-      "requires": {
-        "inherits": "2.0.3"
-      }
-    },
-    "util-deprecate": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
-      "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=",
-      "dev": true
-    },
-    "v8-compile-cache": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/v8-compile-cache/-/v8-compile-cache-2.0.0.tgz",
-      "integrity": "sha512-qNdTUMaCjPs4eEnM3W9H94R3sU70YCuT+/ST7nUf+id1bVOrdjrpUaeZLqPBPRph3hsgn4a4BvwpxhHZx+oSDg==",
-      "dev": true
-    },
-    "validate-npm-package-license": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.3.tgz",
-      "integrity": "sha512-63ZOUnL4SIXj4L0NixR3L1lcjO38crAbgrTpl28t8jjrfuiOBL5Iygm+60qPs/KsZGzPNg6Smnc/oY16QTjF0g==",
-      "dev": true,
-      "requires": {
-        "spdx-correct": "^3.0.0",
-        "spdx-expression-parse": "^3.0.0"
-      }
-    },
-    "vinyl": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/vinyl/-/vinyl-1.2.0.tgz",
-      "integrity": "sha1-XIgDbPVl5d8FVYv8kR+GVt8hiIQ=",
-      "dev": true,
-      "requires": {
-        "clone": "^1.0.0",
-        "clone-stats": "^0.0.1",
-        "replace-ext": "0.0.1"
-      }
-    },
-    "vinyl-file": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/vinyl-file/-/vinyl-file-2.0.0.tgz",
-      "integrity": "sha1-p+v1/779obfRjRQPyweyI++2dRo=",
-      "dev": true,
-      "requires": {
-        "graceful-fs": "^4.1.2",
-        "pify": "^2.3.0",
-        "pinkie-promise": "^2.0.0",
-        "strip-bom": "^2.0.0",
-        "strip-bom-stream": "^2.0.0",
-        "vinyl": "^1.1.0"
-      },
-      "dependencies": {
-        "pify": {
-          "version": "2.3.0",
-          "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz",
-          "integrity": "sha1-7RQaasBDqEnqWISY59yosVMw6Qw=",
-          "dev": true
-        }
-      }
-    },
-    "vm-browserify": {
-      "version": "0.0.4",
-      "resolved": "https://registry.npmjs.org/vm-browserify/-/vm-browserify-0.0.4.tgz",
-      "integrity": "sha1-XX6kW7755Kb/ZflUOOCofDV9WnM=",
-      "dev": true,
-      "requires": {
-        "indexof": "0.0.1"
-      }
-    },
-    "watchpack": {
-      "version": "1.6.0",
-      "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-1.6.0.tgz",
-      "integrity": "sha512-i6dHe3EyLjMmDlU1/bGQpEw25XSjkJULPuAVKCbNRefQVq48yXKUpwg538F7AZTf9kyr57zj++pQFltUa5H7yA==",
-      "dev": true,
-      "requires": {
-        "chokidar": "^2.0.2",
-        "graceful-fs": "^4.1.2",
-        "neo-async": "^2.5.0"
-      }
-    },
-    "webpack": {
-      "version": "4.11.1",
-      "resolved": "https://registry.npmjs.org/webpack/-/webpack-4.11.1.tgz",
-      "integrity": "sha512-8HGSxsLm9LTVgYiyfjY849c3Rgtb0bI0fPpdQsMmO6Hg8JXUOCudGD3j6sPfo6DaAdti1icUUZNh8XpY3igHqQ==",
-      "dev": true,
-      "requires": {
-        "@webassemblyjs/ast": "1.5.10",
-        "@webassemblyjs/helper-module-context": "1.5.10",
-        "@webassemblyjs/wasm-edit": "1.5.10",
-        "@webassemblyjs/wasm-opt": "1.5.10",
-        "@webassemblyjs/wasm-parser": "1.5.10",
-        "acorn": "^5.0.0",
-        "acorn-dynamic-import": "^3.0.0",
-        "ajv": "^6.1.0",
-        "ajv-keywords": "^3.1.0",
-        "chrome-trace-event": "^0.1.1",
-        "enhanced-resolve": "^4.0.0",
-        "eslint-scope": "^3.7.1",
-        "json-parse-better-errors": "^1.0.2",
-        "loader-runner": "^2.3.0",
-        "loader-utils": "^1.1.0",
-        "memory-fs": "~0.4.1",
-        "micromatch": "^3.1.8",
-        "mkdirp": "~0.5.0",
-        "neo-async": "^2.5.0",
-        "node-libs-browser": "^2.0.0",
-        "schema-utils": "^0.4.4",
-        "tapable": "^1.0.0",
-        "uglifyjs-webpack-plugin": "^1.2.4",
-        "watchpack": "^1.5.0",
-        "webpack-sources": "^1.0.1"
-      }
-    },
-    "webpack-addons": {
-      "version": "1.1.5",
-      "resolved": "https://registry.npmjs.org/webpack-addons/-/webpack-addons-1.1.5.tgz",
-      "integrity": "sha512-MGO0nVniCLFAQz1qv22zM02QPjcpAoJdy7ED0i3Zy7SY1IecgXCm460ib7H/Wq7e9oL5VL6S2BxaObxwIcag0g==",
-      "dev": true,
-      "requires": {
-        "jscodeshift": "^0.4.0"
-      },
-      "dependencies": {
-        "arr-diff": {
-          "version": "2.0.0",
-          "resolved": "https://registry.npmjs.org/arr-diff/-/arr-diff-2.0.0.tgz",
-          "integrity": "sha1-jzuCf5Vai9ZpaX5KQlasPOrjVs8=",
-          "dev": true,
-          "requires": {
-            "arr-flatten": "^1.0.1"
-          }
-        },
-        "array-unique": {
-          "version": "0.2.1",
-          "resolved": "https://registry.npmjs.org/array-unique/-/array-unique-0.2.1.tgz",
-          "integrity": "sha1-odl8yvy8JiXMcPrc6zalDFiwGlM=",
-          "dev": true
-        },
-        "ast-types": {
-          "version": "0.10.1",
-          "resolved": "https://registry.npmjs.org/ast-types/-/ast-types-0.10.1.tgz",
-          "integrity": "sha512-UY7+9DPzlJ9VM8eY0b2TUZcZvF+1pO0hzMtAyjBYKhOmnvRlqYNYnWdtsMj0V16CGaMlpL0G1jnLbLo4AyotuQ==",
-          "dev": true
-        },
-        "babylon": {
-          "version": "6.18.0",
-          "resolved": "https://registry.npmjs.org/babylon/-/babylon-6.18.0.tgz",
-          "integrity": "sha512-q/UEjfGJ2Cm3oKV71DJz9d25TPnq5rhBVL2Q4fA5wcC3jcrdn7+SssEybFIxwAvvP+YCsCYNKughoF33GxgycQ==",
-          "dev": true
-        },
-        "braces": {
-          "version": "1.8.5",
-          "resolved": "https://registry.npmjs.org/braces/-/braces-1.8.5.tgz",
-          "integrity": "sha1-uneWLhLf+WnWt2cR6RS3N4V79qc=",
-          "dev": true,
-          "requires": {
-            "expand-range": "^1.8.1",
-            "preserve": "^0.2.0",
-            "repeat-element": "^1.1.2"
-          }
-        },
-        "expand-brackets": {
-          "version": "0.1.5",
-          "resolved": "https://registry.npmjs.org/expand-brackets/-/expand-brackets-0.1.5.tgz",
-          "integrity": "sha1-3wcoTjQqgHzXM6xa9yQR5YHRF3s=",
-          "dev": true,
-          "requires": {
-            "is-posix-bracket": "^0.1.0"
-          }
-        },
-        "extglob": {
-          "version": "0.3.2",
-          "resolved": "https://registry.npmjs.org/extglob/-/extglob-0.3.2.tgz",
-          "integrity": "sha1-Lhj/PS9JqydlzskCPwEdqo2DSaE=",
-          "dev": true,
-          "requires": {
-            "is-extglob": "^1.0.0"
-          }
-        },
-        "is-extglob": {
-          "version": "1.0.0",
-          "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-1.0.0.tgz",
-          "integrity": "sha1-rEaBd8SUNAWgkvyPKXYMb/xiBsA=",
-          "dev": true
-        },
-        "is-glob": {
-          "version": "2.0.1",
-          "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-2.0.1.tgz",
-          "integrity": "sha1-0Jb5JqPe1WAPP9/ZEZjLCIjC2GM=",
-          "dev": true,
-          "requires": {
-            "is-extglob": "^1.0.0"
-          }
-        },
-        "jscodeshift": {
-          "version": "0.4.1",
-          "resolved": "https://registry.npmjs.org/jscodeshift/-/jscodeshift-0.4.1.tgz",
-          "integrity": "sha512-iOX6If+hsw0q99V3n31t4f5VlD1TQZddH08xbT65ZqA7T4Vkx68emrDZMUOLVvCEAJ6NpAk7DECe3fjC/t52AQ==",
-          "dev": true,
-          "requires": {
-            "async": "^1.5.0",
-            "babel-plugin-transform-flow-strip-types": "^6.8.0",
-            "babel-preset-es2015": "^6.9.0",
-            "babel-preset-stage-1": "^6.5.0",
-            "babel-register": "^6.9.0",
-            "babylon": "^6.17.3",
-            "colors": "^1.1.2",
-            "flow-parser": "^0.*",
-            "lodash": "^4.13.1",
-            "micromatch": "^2.3.7",
-            "node-dir": "0.1.8",
-            "nomnom": "^1.8.1",
-            "recast": "^0.12.5",
-            "temp": "^0.8.1",
-            "write-file-atomic": "^1.2.0"
-          }
-        },
-        "kind-of": {
-          "version": "3.2.2",
-          "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz",
-          "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=",
-          "dev": true,
-          "requires": {
-            "is-buffer": "^1.1.5"
-          }
-        },
-        "micromatch": {
-          "version": "2.3.11",
-          "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-2.3.11.tgz",
-          "integrity": "sha1-hmd8l9FyCzY0MdBNDRUpO9OMFWU=",
-          "dev": true,
-          "requires": {
-            "arr-diff": "^2.0.0",
-            "array-unique": "^0.2.1",
-            "braces": "^1.8.2",
-            "expand-brackets": "^0.1.4",
-            "extglob": "^0.3.1",
-            "filename-regex": "^2.0.0",
-            "is-extglob": "^1.0.0",
-            "is-glob": "^2.0.1",
-            "kind-of": "^3.0.2",
-            "normalize-path": "^2.0.1",
-            "object.omit": "^2.0.0",
-            "parse-glob": "^3.0.4",
-            "regex-cache": "^0.4.2"
-          }
-        },
-        "recast": {
-          "version": "0.12.9",
-          "resolved": "https://registry.npmjs.org/recast/-/recast-0.12.9.tgz",
-          "integrity": "sha512-y7ANxCWmMW8xLOaiopiRDlyjQ9ajKRENBH+2wjntIbk3A6ZR1+BLQttkmSHMY7Arl+AAZFwJ10grg2T6f1WI8A==",
-          "dev": true,
-          "requires": {
-            "ast-types": "0.10.1",
-            "core-js": "^2.4.1",
-            "esprima": "~4.0.0",
-            "private": "~0.1.5",
-            "source-map": "~0.6.1"
-          }
-        },
-        "source-map": {
-          "version": "0.6.1",
-          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
-          "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
-          "dev": true
-        }
-      }
-    },
-    "webpack-cli": {
-      "version": "2.1.5",
-      "resolved": "https://registry.npmjs.org/webpack-cli/-/webpack-cli-2.1.5.tgz",
-      "integrity": "sha512-CiWQR+1JS77rmyiO6y1q8Kt/O+e8nUUC9YfJ25JtSmzDwbqJV7vIsh3+QKRHVTbTCa0DaVh8iY1LBiagUIDB3g==",
-      "dev": true,
-      "requires": {
-        "chalk": "^2.4.1",
-        "cross-spawn": "^6.0.5",
-        "diff": "^3.5.0",
-        "enhanced-resolve": "^4.0.0",
-        "envinfo": "^5.7.0",
-        "glob-all": "^3.1.0",
-        "global-modules": "^1.0.0",
-        "got": "^8.3.1",
-        "import-local": "^1.0.0",
-        "inquirer": "^5.2.0",
-        "interpret": "^1.1.0",
-        "jscodeshift": "^0.5.0",
-        "listr": "^0.14.1",
-        "loader-utils": "^1.1.0",
-        "lodash": "^4.17.10",
-        "log-symbols": "^2.2.0",
-        "mkdirp": "^0.5.1",
-        "p-each-series": "^1.0.0",
-        "p-lazy": "^1.0.0",
-        "prettier": "^1.12.1",
-        "supports-color": "^5.4.0",
-        "v8-compile-cache": "^2.0.0",
-        "webpack-addons": "^1.1.5",
-        "yargs": "^11.1.0",
-        "yeoman-environment": "^2.1.1",
-        "yeoman-generator": "^2.0.5"
-      }
-    },
-    "webpack-sources": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/webpack-sources/-/webpack-sources-1.1.0.tgz",
-      "integrity": "sha512-aqYp18kPphgoO5c/+NaUvEeACtZjMESmDChuD3NBciVpah3XpMEU9VAAtIaB1BsfJWWTSdv8Vv1m3T0aRk2dUw==",
-      "dev": true,
-      "requires": {
-        "source-list-map": "^2.0.0",
-        "source-map": "~0.6.1"
-      },
-      "dependencies": {
-        "source-map": {
-          "version": "0.6.1",
-          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
-          "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
-          "dev": true
-        }
-      }
-    },
-    "which": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/which/-/which-1.3.1.tgz",
-      "integrity": "sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==",
-      "dev": true,
-      "requires": {
-        "isexe": "^2.0.0"
-      }
-    },
-    "which-module": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/which-module/-/which-module-2.0.0.tgz",
-      "integrity": "sha1-2e8H3Od7mQK4o6j6SzHD4/fm6Ho=",
-      "dev": true
-    },
-    "wordwrap": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-1.0.0.tgz",
-      "integrity": "sha1-J1hIEIkUVqQXHI0CJkQa3pDLyus=",
-      "dev": true
-    },
-    "worker-farm": {
-      "version": "1.6.0",
-      "resolved": "https://registry.npmjs.org/worker-farm/-/worker-farm-1.6.0.tgz",
-      "integrity": "sha512-6w+3tHbM87WnSWnENBUvA2pxJPLhQUg5LKwUQHq3r+XPhIM+Gh2R5ycbwPCyuGbNg+lPgdcnQUhuC02kJCvffQ==",
-      "dev": true,
-      "requires": {
-        "errno": "~0.1.7"
-      }
-    },
-    "wrap-ansi": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-2.1.0.tgz",
-      "integrity": "sha1-2Pw9KE3QV5T+hJc8rs3Rz4JP3YU=",
-      "dev": true,
-      "requires": {
-        "string-width": "^1.0.1",
-        "strip-ansi": "^3.0.1"
-      },
-      "dependencies": {
-        "ansi-regex": {
-          "version": "2.1.1",
-          "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz",
-          "integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8=",
-          "dev": true
-        },
-        "is-fullwidth-code-point": {
-          "version": "1.0.0",
-          "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz",
-          "integrity": "sha1-754xOG8DGn8NZDr4L95QxFfvAMs=",
-          "dev": true,
-          "requires": {
-            "number-is-nan": "^1.0.0"
-          }
-        },
-        "string-width": {
-          "version": "1.0.2",
-          "resolved": "https://registry.npmjs.org/string-width/-/string-width-1.0.2.tgz",
-          "integrity": "sha1-EYvfW4zcUaKn5w0hHgfisLmxB9M=",
-          "dev": true,
-          "requires": {
-            "code-point-at": "^1.0.0",
-            "is-fullwidth-code-point": "^1.0.0",
-            "strip-ansi": "^3.0.0"
-          }
-        },
-        "strip-ansi": {
-          "version": "3.0.1",
-          "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz",
-          "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=",
-          "dev": true,
-          "requires": {
-            "ansi-regex": "^2.0.0"
-          }
-        }
-      }
-    },
-    "wrappy": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
-      "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=",
-      "dev": true
-    },
-    "write": {
-      "version": "0.2.1",
-      "resolved": "https://registry.npmjs.org/write/-/write-0.2.1.tgz",
-      "integrity": "sha1-X8A4KOJkzqP+kUVUdvejxWbLB1c=",
-      "dev": true,
-      "requires": {
-        "mkdirp": "^0.5.1"
-      }
-    },
-    "write-file-atomic": {
-      "version": "1.3.4",
-      "resolved": "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-1.3.4.tgz",
-      "integrity": "sha1-+Aek8LHZ6ROuekgRLmzDrxmRtF8=",
-      "dev": true,
-      "requires": {
-        "graceful-fs": "^4.1.11",
-        "imurmurhash": "^0.1.4",
-        "slide": "^1.1.5"
-      }
-    },
-    "xtend": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.1.tgz",
-      "integrity": "sha1-pcbVMr5lbiPbgg77lDofBJmNY68=",
-      "dev": true
-    },
-    "y18n": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/y18n/-/y18n-4.0.0.tgz",
-      "integrity": "sha512-r9S/ZyXu/Xu9q1tYlpsLIsa3EeLXXk0VwlxqTcFRfg9EhMW+17kbt9G0NrgCmhGb5vT2hyhJZLfDGx+7+5Uj/w==",
-      "dev": true
-    },
-    "yallist": {
-      "version": "2.1.2",
-      "resolved": "https://registry.npmjs.org/yallist/-/yallist-2.1.2.tgz",
-      "integrity": "sha1-HBH5IY8HYImkfdUS+TxmmaaoHVI=",
-      "dev": true
-    },
-    "yargs": {
-      "version": "11.1.0",
-      "resolved": "https://registry.npmjs.org/yargs/-/yargs-11.1.0.tgz",
-      "integrity": "sha512-NwW69J42EsCSanF8kyn5upxvjp5ds+t3+udGBeTbFnERA+lF541DDpMawzo4z6W/QrzNM18D+BPMiOBibnFV5A==",
-      "dev": true,
-      "requires": {
-        "cliui": "^4.0.0",
-        "decamelize": "^1.1.1",
-        "find-up": "^2.1.0",
-        "get-caller-file": "^1.0.1",
-        "os-locale": "^2.0.0",
-        "require-directory": "^2.1.1",
-        "require-main-filename": "^1.0.1",
-        "set-blocking": "^2.0.0",
-        "string-width": "^2.0.0",
-        "which-module": "^2.0.0",
-        "y18n": "^3.2.1",
-        "yargs-parser": "^9.0.2"
-      },
-      "dependencies": {
-        "y18n": {
-          "version": "3.2.1",
-          "resolved": "https://registry.npmjs.org/y18n/-/y18n-3.2.1.tgz",
-          "integrity": "sha1-bRX7qITAhnnA136I53WegR4H+kE=",
-          "dev": true
-        }
-      }
-    },
-    "yargs-parser": {
-      "version": "9.0.2",
-      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-9.0.2.tgz",
-      "integrity": "sha1-nM9qQ0YP5O1Aqbto9I1DuKaMwHc=",
-      "dev": true,
-      "requires": {
-        "camelcase": "^4.1.0"
-      }
-    },
-    "yeoman-environment": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/yeoman-environment/-/yeoman-environment-2.2.0.tgz",
-      "integrity": "sha512-gQ+hIW8QRlUo4jGBDCm++qg01SXaIVJ7VyLrtSwk2jQG4vtvluWpsGIl7V8DqT2jGiqukdec0uEyffVEyQgaZA==",
-      "dev": true,
-      "requires": {
-        "chalk": "^2.1.0",
-        "cross-spawn": "^6.0.5",
-        "debug": "^3.1.0",
-        "diff": "^3.3.1",
-        "escape-string-regexp": "^1.0.2",
-        "globby": "^8.0.1",
-        "grouped-queue": "^0.3.3",
-        "inquirer": "^5.2.0",
-        "is-scoped": "^1.0.0",
-        "lodash": "^4.17.10",
-        "log-symbols": "^2.1.0",
-        "mem-fs": "^1.1.0",
-        "strip-ansi": "^4.0.0",
-        "text-table": "^0.2.0",
-        "untildify": "^3.0.2"
-      },
-      "dependencies": {
-        "debug": {
-          "version": "3.1.0",
-          "resolved": "https://registry.npmjs.org/debug/-/debug-3.1.0.tgz",
-          "integrity": "sha512-OX8XqP7/1a9cqkxYw2yXss15f26NKWBpDXQd0/uK/KPqdQhxbPa994hnzjcE2VqQpDslf55723cKPUOGSmMY3g==",
-          "dev": true,
-          "requires": {
-            "ms": "2.0.0"
-          }
-        }
-      }
-    },
-    "yeoman-generator": {
-      "version": "2.0.5",
-      "resolved": "https://registry.npmjs.org/yeoman-generator/-/yeoman-generator-2.0.5.tgz",
-      "integrity": "sha512-rV6tJ8oYzm4mmdF2T3wjY+Q42jKF2YiiD0VKfJ8/0ZYwmhCKC9Xs2346HVLPj/xE13i68psnFJv7iS6gWRkeAg==",
-      "dev": true,
-      "requires": {
-        "async": "^2.6.0",
-        "chalk": "^2.3.0",
-        "cli-table": "^0.3.1",
-        "cross-spawn": "^6.0.5",
-        "dargs": "^5.1.0",
-        "dateformat": "^3.0.3",
-        "debug": "^3.1.0",
-        "detect-conflict": "^1.0.0",
-        "error": "^7.0.2",
-        "find-up": "^2.1.0",
-        "github-username": "^4.0.0",
-        "istextorbinary": "^2.2.1",
-        "lodash": "^4.17.10",
-        "make-dir": "^1.1.0",
-        "mem-fs-editor": "^4.0.0",
-        "minimist": "^1.2.0",
-        "pretty-bytes": "^4.0.2",
-        "read-chunk": "^2.1.0",
-        "read-pkg-up": "^3.0.0",
-        "rimraf": "^2.6.2",
-        "run-async": "^2.0.0",
-        "shelljs": "^0.8.0",
-        "text-table": "^0.2.0",
-        "through2": "^2.0.0",
-        "yeoman-environment": "^2.0.5"
-      },
-      "dependencies": {
-        "async": {
-          "version": "2.6.1",
-          "resolved": "https://registry.npmjs.org/async/-/async-2.6.1.tgz",
-          "integrity": "sha512-fNEiL2+AZt6AlAw/29Cr0UDe4sRAHCpEHh54WMz+Bb7QfNcFw4h3loofyJpLeQs4Yx7yuqu/2dLgM5hKOs6HlQ==",
-          "dev": true,
-          "requires": {
-            "lodash": "^4.17.10"
-          }
-        },
-        "debug": {
-          "version": "3.1.0",
-          "resolved": "https://registry.npmjs.org/debug/-/debug-3.1.0.tgz",
-          "integrity": "sha512-OX8XqP7/1a9cqkxYw2yXss15f26NKWBpDXQd0/uK/KPqdQhxbPa994hnzjcE2VqQpDslf55723cKPUOGSmMY3g==",
-          "dev": true,
-          "requires": {
-            "ms": "2.0.0"
-          }
-        },
-        "minimist": {
-          "version": "1.2.0",
-          "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz",
-          "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=",
-          "dev": true
-        }
-      }
-    }
-  }
-}
diff --git a/package.json b/package.json
index 7ecfd84c..60e2f84f 100644
--- a/package.json
+++ b/package.json
@@ -1,14 +1,20 @@
 {
   "license": "MIT",
   "scripts": {
-    "run-webpack": "webpack"
+    "run-webpack": "webpack",
+    "run-webpack-dev-server": "webpack-dev-server",
+    "run-geckodriver": "geckodriver"
   },
   "devDependencies": {
     "@types/node": "^9.4.6",
+    "eslint": "^5.0.1",
+    "geckodriver": "^1.11.0",
+    "selenium-webdriver": "^4.0.0-alpha.1",
     "ts-loader": "^4.0.1",
     "typescript": "^2.7.2",
     "webpack": "^4.11.1",
     "webpack-cli": "^2.0.10",
-    "eslint": "^4.19.1"
+    "webpack-dev-server": "^3.1.4",
+    "babel-eslint": "^8.2.5"
   }
 }
diff --git a/src/js.rs b/src/js.rs
index 1de3d662..61d6860a 100644
--- a/src/js.rs
+++ b/src/js.rs
@@ -51,7 +51,7 @@ extern "C" {
 
     /// The decodeURIComponent() function decodes a Uniform Resource Identifier (URI) component
     /// previously created by encodeURIComponent or by a similar routine.
-    /// 
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/decodeURIComponent
     #[wasm_bindgen(catch, js_name = decodeURIComponent)]
     pub fn decode_uri_component(encoded: &str) -> Result<JsString, JsValue>;
@@ -70,7 +70,7 @@ extern "C" {
     /// by replacing each instance of certain characters by one, two, three, or four escape sequences
     /// representing the UTF-8 encoding of the character
     /// (will only be four escape sequences for characters composed of two "surrogate" characters).
-    /// 
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent
     #[wasm_bindgen(js_name = encodeURIComponent)]
     pub fn encode_uri_component(decoded: &str) -> JsString;
@@ -141,6 +141,13 @@ extern "C" {
     #[wasm_bindgen(method)]
     pub fn filter(this: &Array, predicate: &mut FnMut(JsValue, u32, Array) -> bool) -> Array;
 
+    /// The `find()` method returns the value of the first element in the array that satisfies
+    ///  the provided testing function. Otherwise `undefined` is returned.
+    ///
+    /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find
+    #[wasm_bindgen(method)]
+    pub fn find(this: &Array, predicate: &mut FnMut(JsValue, u32, Array) -> bool) -> JsValue;
+
     /// The includes() method determines whether an array includes a certain
     /// element, returning true or false as appropriate.
     ///
@@ -254,6 +261,45 @@ extern "C" {
     pub fn unshift(this: &Array, value: JsValue) -> u32;
 }
 
+// ArrayBuffer
+#[wasm_bindgen]
+extern "C" {
+    pub type ArrayBuffer;
+
+    /// The `ArrayBuffer` object is used to represent a generic,
+    /// fixed-length raw binary data buffer. You cannot directly
+    /// manipulate the contents of an `ArrayBuffer`; instead, you
+    /// create one of the typed array objects or a `DataView` object
+    /// which represents the buffer in a specific format, and use that
+    /// to read and write the contents of the buffer.
+    ///
+    /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer
+    #[wasm_bindgen(constructor)]
+    pub fn new(length: u32) -> ArrayBuffer;
+
+    /// The `slice()` method returns a new `ArrayBuffer` whose contents
+    /// are a copy of this `ArrayBuffer`'s bytes from begin, inclusive,
+    /// up to end, exclusive.
+    ///
+    /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/isView
+    #[wasm_bindgen(static_method_of = ArrayBuffer, js_name = isView)]
+    pub fn is_view(value: JsValue) -> bool;
+
+    /// The `slice()` method returns a new `ArrayBuffer` whose contents
+    /// are a copy of this `ArrayBuffer`'s bytes from begin, inclusive,
+    /// up to end, exclusive.
+    ///
+    /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/slice
+    #[wasm_bindgen(method)]
+    pub fn slice(this: &ArrayBuffer, begin: u32) -> ArrayBuffer;
+
+    /// Like `slice()` but with the `end` argument.
+    ///
+    /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/slice
+    #[wasm_bindgen(method, js_name = slice)]
+    pub fn slice_with_end(this: &ArrayBuffer, begin: u32, end: u32) -> ArrayBuffer;
+}
+
 // Array Iterator
 #[wasm_bindgen]
 extern "C" {
@@ -301,7 +347,7 @@ extern "C" {
     /// Instances of Error objects are thrown when runtime errors occur.
     /// The Error object can also be used as a base object for user-defined exceptions.
     /// See below for standard built-in error types.
-    /// 
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error
     #[wasm_bindgen(constructor)]
     pub fn new(message: &JsString) -> Error;
@@ -343,7 +389,7 @@ extern "C" {
 
     /// The bind() method creates a new function that, when called, has its this keyword set to the provided value,
     /// with a given sequence of arguments preceding any provided when the new function is called.
-    /// 
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind
     #[wasm_bindgen(method)]
     pub fn bind(this: &Function, context: &JsValue) -> Function;
@@ -382,14 +428,14 @@ extern {
     pub fn next(this: &Generator, value: &JsValue) -> Result<JsValue, JsValue>;
 
     /// The return() method returns the given value and finishes the generator.
-    /// 
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Generator/return
     #[wasm_bindgen(method, structural, js_name = return)]
     pub fn return_(this: &Generator, value: &JsValue) -> JsValue;
 
     /// The throw() method resumes the execution of a generator by throwing an error into it
     /// and returns an object with two properties done and value.
-    /// 
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Generator/throw
     #[wasm_bindgen(method, structural, catch)]
     pub fn throw(this: &Generator, error: &Error) -> Result<JsValue, JsValue>;
@@ -401,51 +447,51 @@ extern {
     pub type Map;
 
     /// The clear() method removes all elements from a Map object.
-    /// 
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/clear
     #[wasm_bindgen(method)]
     pub fn clear(this: &Map);
 
     /// The delete() method removes the specified element from a Map object.
-    /// 
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/delete
     #[wasm_bindgen(method)]
     pub fn delete(this: &Map, key: &str) -> bool;
 
     /// The get() method returns a specified element from a Map object.
-    /// 
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/get
     #[wasm_bindgen(method)]
     pub fn get(this: &Map, key: &JsValue) -> JsValue;
 
-    /// The has() method returns a boolean indicating whether an element with 
+    /// The has() method returns a boolean indicating whether an element with
     /// the specified key exists or not.
-    /// 
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/has
     #[wasm_bindgen(method)]
     pub fn has(this: &Map, key: &JsValue) -> bool;
 
-    /// The Map object holds key-value pairs. Any value (both objects and 
+    /// The Map object holds key-value pairs. Any value (both objects and
     /// primitive values) maybe used as either a key or a value.
-    /// 
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map
     #[wasm_bindgen(constructor)]
     pub fn new() -> Map;
 
-    /// The set() method adds or updates an element with a specified key 
+    /// The set() method adds or updates an element with a specified key
     /// and value to a Map object.
-    /// 
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/set
     #[wasm_bindgen(method)]
     pub fn set(this: &Map, key: &JsValue, value: &JsValue) -> Map;
 
-    /// The value of size is an integer representing how many entries 
-    /// the Map object has. A set accessor function for size is undefined; 
+    /// The value of size is an integer representing how many entries
+    /// the Map object has. A set accessor function for size is undefined;
     /// you can not change this property.
-    /// 
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/size
     #[wasm_bindgen(method, getter, structural)]
-    pub fn size(this: &Map) -> Number;
+    pub fn size(this: &Map) -> u32;
 }
 
 // Map Iterator
@@ -453,22 +499,22 @@ extern {
 extern {
     pub type MapIterator;
 
-    /// The entries() method returns a new Iterator object that contains 
-    /// the [key, value] pairs for each element in the Map object in 
+    /// The entries() method returns a new Iterator object that contains
+    /// the [key, value] pairs for each element in the Map object in
     /// insertion order.
     ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/entries
     #[wasm_bindgen(method)]
     pub fn entries(this: &Map) -> MapIterator;
 
-    /// The keys() method returns a new Iterator object that contains the 
+    /// The keys() method returns a new Iterator object that contains the
     /// keys for each element in the Map object in insertion order.
     ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/keys
     #[wasm_bindgen(method)]
     pub fn keys(this: &Map) -> MapIterator;
 
-    /// The values() method returns a new Iterator object that contains the 
+    /// The values() method returns a new Iterator object that contains the
     /// values for each element in the Map object in insertion order.
     ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/values
@@ -480,12 +526,13 @@ extern {
 #[wasm_bindgen]
 extern "C" {
     pub type Math;
+
     /// The Math.abs() function returns the absolute value of a number, that is
     /// Math.abs(x) = |x|
     ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/abs
     #[wasm_bindgen(static_method_of = Math)]
-    pub fn abs(x: f64) -> Number;
+    pub fn abs(x: f64) -> f64;
 
     /// The Math.acos() function returns the arccosine (in radians) of a
     /// number, that is ∀x∊[-1;1]
@@ -493,7 +540,7 @@ extern "C" {
     ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/acos
     #[wasm_bindgen(static_method_of = Math)]
-    pub fn acos(x: f64) -> Number;
+    pub fn acos(x: f64) -> f64;
 
     /// The Math.acosh() function returns the hyperbolic arc-cosine of a
     /// number, that is ∀x ≥ 1
@@ -501,7 +548,7 @@ extern "C" {
     ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/acosh
     #[wasm_bindgen(static_method_of = Math)]
-    pub fn acosh(x: f64) -> Number;
+    pub fn acosh(x: f64) -> f64;
 
     /// The Math.asin() function returns the arcsine (in radians) of a
     /// number, that is ∀x ∊ [-1;1]
@@ -509,27 +556,27 @@ extern "C" {
     ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/asin
     #[wasm_bindgen(static_method_of = Math)]
-    pub fn asin(x: f64) -> Number;
+    pub fn asin(x: f64) -> f64;
 
     /// The Math.asinh() function returns the hyperbolic arcsine of a
     /// number, that is Math.asinh(x) = arsinh(x) = the unique y such that sinh(y) = x
     ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/asinh
     #[wasm_bindgen(static_method_of = Math)]
-    pub fn asinh(x: f64) -> Number;
+    pub fn asinh(x: f64) -> f64;
 
     /// The Math.atan() function returns the arctangent (in radians) of a
     /// number, that is Math.atan(x) = arctan(x) = the unique y ∊ [-π2;π2]such that
     /// tan(y) = x
     #[wasm_bindgen(static_method_of = Math)]
-    pub fn atan(x: f64) -> Number;
+    pub fn atan(x: f64) -> f64;
 
     /// The Math.atan2() function returns the arctangent of the quotient of
     /// its arguments.
     ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/atan2
     #[wasm_bindgen(static_method_of = Math)]
-    pub fn atan2(y: f64, x: f64) -> Number;
+    pub fn atan2(y: f64, x: f64) -> f64;
 
     /// The Math.atanh() function returns the hyperbolic arctangent of a number,
     /// that is ∀x ∊ (-1,1), Math.atanh(x) = arctanh(x) = the unique y such that
@@ -537,35 +584,35 @@ extern "C" {
     ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/atanh
     #[wasm_bindgen(static_method_of = Math)]
-    pub fn atanh(x: f64) -> Number;
+    pub fn atanh(x: f64) -> f64;
 
     /// The Math.cbrt() function returns the cube root of a number, that is
     /// Math.cbrt(x) = x^3 = the unique y such that y^3 = x
     ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/cbrt
     #[wasm_bindgen(static_method_of = Math)]
-    pub fn cbrt(x: f64) -> Number;
+    pub fn cbrt(x: f64) -> f64;
 
     /// The Math.ceil() function returns the smallest integer greater than
     /// or equal to a given number.
     ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/ceil
     #[wasm_bindgen(static_method_of = Math)]
-    pub fn ceil(x: f64) -> Number;
+    pub fn ceil(x: f64) -> i32;
 
     /// The Math.clz32() function returns the number of leading zero bits in
     /// the 32-bit binary representation of a number.
     ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32
     #[wasm_bindgen(static_method_of = Math)]
-    pub fn clz32(x: i32) -> Number;
+    pub fn clz32(x: i32) -> u32;
 
     /// The Math.cos() static function returns the cosine of the specified angle,
     /// which must be specified in radians. This value is length(adjacent)/length(hypotenuse).
     ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/cos
     #[wasm_bindgen(static_method_of = Math)]
-    pub fn cos(x: f64) -> Number;
+    pub fn cos(x: f64) -> f64;
 
 
     /// The Math.cosh() function returns the hyperbolic cosine of a number,
@@ -573,125 +620,125 @@ extern "C" {
     ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/cosh
     #[wasm_bindgen(static_method_of = Math)]
-    pub fn cosh(x: f64) -> Number;
+    pub fn cosh(x: f64) -> f64;
 
     /// The Math.exp() function returns e^x, where x is the argument, and e is Euler's number
     /// (also known as Napier's constant), the base of the natural logarithms.
     ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/exp
     #[wasm_bindgen(static_method_of = Math)]
-    pub fn exp(x: f64) -> Number;
+    pub fn exp(x: f64) -> f64;
 
     /// The Math.expm1() function returns e^x - 1, where x is the argument, and e the base of the
     /// natural logarithms.
     ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/expm1
     #[wasm_bindgen(static_method_of = Math)]
-    pub fn expm1(x: f64) -> Number;
+    pub fn expm1(x: f64) -> f64;
 
     /// The Math.floor() function returns the largest integer less than or
     /// equal to a given number.
     ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/floor
     #[wasm_bindgen(static_method_of = Math)]
-    pub fn floor(x: f64) -> Number;
+    pub fn floor(x: f64) -> i32;
 
     /// The Math.fround() function returns the nearest 32-bit single precision float representation
     /// of a Number.
     ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/fround
     #[wasm_bindgen(static_method_of = Math)]
-    pub fn fround(x: f64) -> Number;
+    pub fn fround(x: f64) -> f32;
 
     /// The Math.imul() function returns the result of the C-like 32-bit multiplication of the
     /// two parameters.
     ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul
     #[wasm_bindgen(static_method_of = Math)]
-    pub fn imul(x: i32, y: i32) -> Number;
+    pub fn imul(x: i32, y: i32) -> i32;
 
     /// The Math.log() function returns the natural logarithm (base e) of a number.
     /// The JavaScript Math.log() function is equivalent to ln(x) in mathematics.
     ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/log
     #[wasm_bindgen(static_method_of = Math)]
-    pub fn log(x: f64) -> Number;
+    pub fn log(x: f64) -> f64;
 
     /// The Math.log10() function returns the base 10 logarithm of a number.
     ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/log10
     #[wasm_bindgen(static_method_of = Math)]
-    pub fn log10(x: f64) -> Number;
+    pub fn log10(x: f64) -> f64;
 
     /// The Math.log1p() function returns the natural logarithm (base e) of 1 + a number.
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/log1p
     #[wasm_bindgen(static_method_of = Math)]
-    pub fn log1p(x: f64) -> Number;
+    pub fn log1p(x: f64) -> f64;
 
     /// The Math.log2() function returns the base 2 logarithm of a number.
     ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/log2
     #[wasm_bindgen(static_method_of = Math)]
-    pub fn log2(x: f64) -> Number;
+    pub fn log2(x: f64) -> f64;
 
     /// The Math.pow() function returns the base to the exponent power, that is, base^exponent.
-    /// 
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/pow
     #[wasm_bindgen(static_method_of = Math)]
-    pub fn pow(base: f64, exponent: f64) -> Number;
+    pub fn pow(base: f64, exponent: f64) -> f64;
 
     /// The Math.round() function returns the value of a number rounded to the nearest integer.
-    /// 
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round
     #[wasm_bindgen(static_method_of = Math)]
-    pub fn round(x: f64) -> Number;
+    pub fn round(x: f64) -> i32;
 
     /// The Math.sign() function returns the sign of a number, indicating whether the number is
     /// positive, negative or zero.
-    /// 
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sign
     #[wasm_bindgen(static_method_of = Math)]
-    pub fn sign(x: f64) -> Number;
+    pub fn sign(x: f64) -> f64;
 
     /// The Math.sin() function returns the sine of a number.
-    /// 
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sin
     #[wasm_bindgen(static_method_of = Math)]
-    pub fn sin(x: f64) -> Number;
+    pub fn sin(x: f64) -> f64;
 
     /// The Math.sinh() function returns the hyperbolic sine of a number, that can be expressed
     /// using the constant e: Math.sinh(x) = (e^x - e^-x)/2
-    /// 
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sinh
     #[wasm_bindgen(static_method_of = Math)]
-    pub fn sinh(x: f64) -> Number;
+    pub fn sinh(x: f64) -> f64;
 
     /// The Math.sqrt() function returns the square root of a number, that is
     /// ∀x ≥ 0, Math.sqrt(x) = √x = the unique y ≥ 0 such that y^2 = x
-    /// 
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sqrt
     #[wasm_bindgen(static_method_of = Math)]
-    pub fn sqrt(x: f64) -> Number;
+    pub fn sqrt(x: f64) -> f64;
 
     /// The Math.tan() function returns the tangent of a number.
-    /// 
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/tan
     #[wasm_bindgen(static_method_of = Math)]
-    pub fn tan(x: f64) -> Number;
+    pub fn tan(x: f64) -> f64;
 
     /// The Math.tanh() function returns the hyperbolic tangent of a number, that is
     /// tanh x = sinh x / cosh x = (e^x - e^-x)/(e^x + e^-x) = (e^2x - 1)/(e^2x + 1)
-    /// 
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/tanh
     #[wasm_bindgen(static_method_of = Math)]
-    pub fn tanh(x: f64) -> Number;
+    pub fn tanh(x: f64) -> f64;
 
     /// The Math.trunc() function returns the integer part of a number by removing any fractional
     /// digits.
-    /// 
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc
     #[wasm_bindgen(static_method_of = Math)]
-    pub fn trunc(x: f64) -> Number;
+    pub fn trunc(x: f64) -> i32;
 }
 
 // Number.
@@ -699,6 +746,12 @@ extern "C" {
 extern "C" {
     pub type Number;
 
+    /// The Number.isInteger() method determines whether the passed value is an integer.
+    ///
+    /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger
+    #[wasm_bindgen(static_method_of = Number, js_name = isInteger)]
+    pub fn is_integer(object: &Object) -> bool;
+
     /// The `Number` JavaScript object is a wrapper object allowing
     /// you to work with numerical values. A `Number` object is
     /// created using the `Number()` constructor.
@@ -747,7 +800,7 @@ extern "C" {
     ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/valueOf
     #[wasm_bindgen(method, js_name = valueOf)]
-    pub fn value_of(this: &Number) -> Number;
+    pub fn value_of(this: &Number) -> f64;
 }
 
 // Date.
@@ -755,6 +808,26 @@ extern "C" {
 extern "C" {
     pub type Date;
 
+    /// The getDate() method returns the day of the month for the
+    /// specified date according to local time.
+    ///
+    /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getDate
+    #[wasm_bindgen(method, js_name = getDate)]
+    pub fn get_date(this: &Date) -> u32;
+
+    /// The getDay() method returns the day of the week for the specified date according to local time,
+    /// where 0 represents Sunday. For the day of the month see getDate().
+    ///
+    /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getDay
+    #[wasm_bindgen(method, js_name = getDay)]
+    pub fn get_day(this: &Date) -> u32;
+
+    /// The getFullYear() method returns the year of the specified date according to local time.
+    ///
+    /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getFullYear
+    #[wasm_bindgen(method, js_name = getFullYear)]
+    pub fn get_full_year(this: &Date) -> u32;
+
     /// Creates a JavaScript Date instance that represents
     /// a single moment in time. Date objects are based on a time value that is
     /// the number of milliseconds since 1 January 1970 UTC.
@@ -880,19 +953,19 @@ extern "C" {
 
     /// The Object.isExtensible() method determines if an object is extensible
     /// (whether it can have new properties added to it).
-    /// 
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isExtensible
     #[wasm_bindgen(static_method_of = Object, js_name = isExtensible)]
     pub fn is_extensible(object: &Object) -> bool;
 
     /// The Object.isFrozen() determines if an object is frozen.
-    /// 
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isFrozen
     #[wasm_bindgen(static_method_of = Object, js_name = isFrozen)]
     pub fn is_frozen(object: &Object) -> bool;
 
     /// The Object.isSealed() method determines if an object is sealed.
-    /// 
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isSealed
     #[wasm_bindgen(static_method_of = Object, js_name = isSealed)]
     pub fn is_sealed(object: &Object) -> bool;
@@ -920,7 +993,7 @@ extern "C" {
     /// The Object.preventExtensions() method prevents
     /// new properties from ever being added to an object
     /// (i.e. prevents future extensions to the object).
-    /// 
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/preventExtensions
     #[wasm_bindgen(static_method_of = Object, js_name = preventExtensions)]
     pub fn prevent_extensions(object: &Object);
@@ -942,7 +1015,7 @@ extern "C" {
 
     /// The Object.setPrototypeOf() method sets the prototype (i.e., the internal
     /// [[Prototype]] property) of a specified object to another object or null.
-    /// 
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/setPrototypeOf
     #[wasm_bindgen(static_method_of = Object, js_name = setPrototypeOf)]
     pub fn set_prototype_of(object: &Object, prototype: &Object) -> Object;
@@ -972,12 +1045,32 @@ extern "C" {
     /// own enumerable property values, in the same order as that provided
     /// by a for...in loop (the difference being that a for-in loop
     /// enumerates properties in the prototype chain as well).
-    /// 
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/values
     #[wasm_bindgen(static_method_of = Object)]
     pub fn values(object: &Object) -> Array;
 }
 
+// Proxy
+#[wasm_bindgen]
+extern {
+    pub type Proxy;
+
+    /// The Proxy object is used to define custom behavior for fundamental
+    /// operations (e.g. property lookup, assignment, enumeration, function
+    /// invocation, etc).
+    ///
+    /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy
+    #[wasm_bindgen(constructor)]
+    pub fn new(target: &JsValue, handler: &Object) -> Proxy;
+
+    /// The Proxy.revocable() method is used to create a revocable Proxy object.
+    ///
+    /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/revocable
+    #[wasm_bindgen(static_method_of = Proxy)]
+    pub fn revocable(target: &JsValue, handler: &Object) -> Object;
+}
+
 // Reflect
 #[wasm_bindgen]
 extern "C" {
@@ -1091,44 +1184,44 @@ extern "C" {
 extern {
     pub type Set;
 
-    /// The add() method appends a new element with a specified value to the 
+    /// The add() method appends a new element with a specified value to the
     /// end of a Set object.
-    /// 
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/add
     #[wasm_bindgen(method)]
     pub fn add(this: &Set, value: &JsValue) -> Set;
 
     /// The clear() method removes all elements from a Set object.
-    /// 
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/clear
     #[wasm_bindgen(method)]
     pub fn clear(this: &Set);
 
     /// The delete() method removes the specified element from a Set object.
-    /// 
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/delete
     #[wasm_bindgen(method)]
     pub fn delete(this: &Set, value: &JsValue) -> bool;
 
-    /// The has() method returns a boolean indicating whether an element 
+    /// The has() method returns a boolean indicating whether an element
     /// with the specified value exists in a Set object or not.
-    /// 
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/has
     #[wasm_bindgen(method)]
     pub fn has(this: &Set, value: &JsValue) -> bool;
 
-    /// The Set object lets you store unique values of any type, whether primitive 
+    /// The Set object lets you store unique values of any type, whether primitive
     /// values or object references.
-    /// 
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set
     #[wasm_bindgen(constructor)]
     pub fn new() -> Set;
 
     /// The size accessor property returns the number of elements in a Set object.
-    /// 
+    ///
     /// https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Global_Objects/Set/size
     #[wasm_bindgen(method, getter, structural)]
-    pub fn size(this: &Set) -> Number;
+    pub fn size(this: &Set) -> u32;
 }
 
 // SetIterator
@@ -1136,28 +1229,28 @@ extern {
 extern {
     pub type SetIterator;
 
-    /// The entries() method returns a new Iterator object that contains 
-    /// an array of [value, value] for each element in the Set object, 
-    /// in insertion order. For Set objects there is no key like in 
+    /// The entries() method returns a new Iterator object that contains
+    /// an array of [value, value] for each element in the Set object,
+    /// in insertion order. For Set objects there is no key like in
     /// Map objects. However, to keep the API similar to the Map object,
-    /// each entry has the same value for its key and value here, so that 
+    /// each entry has the same value for its key and value here, so that
     /// an array [value, value] is returned.
-    /// 
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/entries
     #[wasm_bindgen(method)]
     pub fn entries(set: &Set) -> SetIterator;
 
-    /// The keys() method is an alias for this method (for similarity with 
-    /// Map objects); it behaves exactly the same and returns values 
+    /// The keys() method is an alias for this method (for similarity with
+    /// Map objects); it behaves exactly the same and returns values
     /// of Set elements.
-    /// 
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/values
     #[wasm_bindgen(method)]
     pub fn keys(set: &Set) -> SetIterator;
 
-    /// The values() method returns a new Iterator object that contains the 
+    /// The values() method returns a new Iterator object that contains the
     /// values for each element in the Set object in insertion order.
-    /// 
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/values
     #[wasm_bindgen(method)]
     pub fn values(set: &Set) -> SetIterator;
@@ -1168,7 +1261,7 @@ extern {
 extern "C" {
     pub type WeakMap;
 
-    /// The WeakMap object is a collection of key/value pairs in which the keys are weakly referenced.  
+    /// The WeakMap object is a collection of key/value pairs in which the keys are weakly referenced.
     /// The keys must be objects and the values can be arbitrary values.
     ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap
@@ -1259,9 +1352,11 @@ extern "C" {
     /// code points not representable in a single UTF-16 code unit, e.g. Unicode code points > 0x10000).
     /// If you want the entire code point value, use codePointAt().
     ///
+    /// Returns `NaN` if index is out of range.
+    ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/charCodeAt
     #[wasm_bindgen(method, js_class = "String", js_name = charCodeAt)]
-    pub fn char_code_at(this: &JsString, index: u32) -> Number;
+    pub fn char_code_at(this: &JsString, index: u32) -> f64;
 
     /// The codePointAt() method returns a non-negative integer that is the Unicode code point value.
     ///
@@ -1408,3 +1503,17 @@ if_std! {
         }
     }
 }
+
+// Symbol
+#[wasm_bindgen]
+extern "C" {
+    pub type Symbol;
+
+    /// The Symbol.hasInstance well-known symbol is used to determine
+    /// if a constructor object recognizes an object as its instance.
+    /// The instanceof operator's behavior can be customized by this symbol.
+    ///
+    /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/hasInstance
+    #[wasm_bindgen(static_method_of = Symbol, getter, structural, js_name = hasInstance)]
+    pub fn has_instance() -> Symbol;
+}
diff --git a/tests/all/api.rs b/tests/all/api.rs
index 87f8d133..8f9a7c4e 100644
--- a/tests/all/api.rs
+++ b/tests/all/api.rs
@@ -6,144 +6,144 @@ fn works() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section)]
+                #![feature(proc_macro, wasm_custom_section)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen]
-            pub fn foo() -> JsValue {
-                JsValue::from("foo")
-            }
+                #[wasm_bindgen]
+                pub fn foo() -> JsValue {
+                    JsValue::from("foo")
+                }
 
-            #[wasm_bindgen]
-            pub fn bar(s: &str) -> JsValue {
-                JsValue::from(s)
-            }
+                #[wasm_bindgen]
+                pub fn bar(s: &str) -> JsValue {
+                    JsValue::from(s)
+                }
 
-            #[wasm_bindgen]
-            pub fn baz() -> JsValue {
-                JsValue::from(1.0)
-            }
+                #[wasm_bindgen]
+                pub fn baz() -> JsValue {
+                    JsValue::from(1.0)
+                }
 
-            #[wasm_bindgen]
-            pub fn baz2(a: &JsValue, b: &JsValue) {
-                assert_eq!(a.as_f64(), Some(2.0));
-                assert_eq!(b.as_f64(), None);
-            }
+                #[wasm_bindgen]
+                pub fn baz2(a: &JsValue, b: &JsValue) {
+                    assert_eq!(a.as_f64(), Some(2.0));
+                    assert_eq!(b.as_f64(), None);
+                }
 
-            #[wasm_bindgen]
-            pub fn js_null() -> JsValue {
-                JsValue::null()
-            }
+                #[wasm_bindgen]
+                pub fn js_null() -> JsValue {
+                    JsValue::null()
+                }
 
-            #[wasm_bindgen]
-            pub fn js_undefined() -> JsValue {
-                JsValue::undefined()
-            }
+                #[wasm_bindgen]
+                pub fn js_undefined() -> JsValue {
+                    JsValue::undefined()
+                }
 
-            #[wasm_bindgen]
-            pub fn test_is_null_undefined(
-                a: &JsValue,
-                b: &JsValue,
-                c: &JsValue,
-            ) {
-                assert!(a.is_null());
-                assert!(!a.is_undefined());
+                #[wasm_bindgen]
+                pub fn test_is_null_undefined(
+                    a: &JsValue,
+                    b: &JsValue,
+                    c: &JsValue,
+                ) {
+                    assert!(a.is_null());
+                    assert!(!a.is_undefined());
 
-                assert!(!b.is_null());
-                assert!(b.is_undefined());
+                    assert!(!b.is_null());
+                    assert!(b.is_undefined());
 
-                assert!(!c.is_null());
-                assert!(!c.is_undefined());
-            }
+                    assert!(!c.is_null());
+                    assert!(!c.is_undefined());
+                }
 
-            #[wasm_bindgen]
-            pub fn get_true() -> JsValue {
-                JsValue::from(true)
-            }
+                #[wasm_bindgen]
+                pub fn get_true() -> JsValue {
+                    JsValue::from(true)
+                }
 
-            #[wasm_bindgen]
-            pub fn get_false() -> JsValue {
-                JsValue::from(false)
-            }
+                #[wasm_bindgen]
+                pub fn get_false() -> JsValue {
+                    JsValue::from(false)
+                }
 
-            #[wasm_bindgen]
-            pub fn test_bool(
-                a: &JsValue,
-                b: &JsValue,
-                c: &JsValue,
-            ) {
-                assert_eq!(a.as_bool(), Some(true));
-                assert_eq!(b.as_bool(), Some(false));
-                assert_eq!(c.as_bool(), None);
-            }
+                #[wasm_bindgen]
+                pub fn test_bool(
+                    a: &JsValue,
+                    b: &JsValue,
+                    c: &JsValue,
+                ) {
+                    assert_eq!(a.as_bool(), Some(true));
+                    assert_eq!(b.as_bool(), Some(false));
+                    assert_eq!(c.as_bool(), None);
+                }
 
-            #[wasm_bindgen]
-            pub fn mk_symbol() -> JsValue {
-                let a = JsValue::symbol(None);
-                assert!(a.is_symbol());
-                return a
-            }
+                #[wasm_bindgen]
+                pub fn mk_symbol() -> JsValue {
+                    let a = JsValue::symbol(None);
+                    assert!(a.is_symbol());
+                    return a
+                }
 
-            #[wasm_bindgen]
-            pub fn mk_symbol2(s: &str) -> JsValue {
-                let a = JsValue::symbol(Some(s));
-                assert!(a.is_symbol());
-                return a
-            }
+                #[wasm_bindgen]
+                pub fn mk_symbol2(s: &str) -> JsValue {
+                    let a = JsValue::symbol(Some(s));
+                    assert!(a.is_symbol());
+                    return a
+                }
 
-            #[wasm_bindgen]
-            pub fn assert_symbols(a: &JsValue, b: &JsValue) {
-                assert!(a.is_symbol());
-                assert!(!b.is_symbol());
-            }
+                #[wasm_bindgen]
+                pub fn assert_symbols(a: &JsValue, b: &JsValue) {
+                    assert!(a.is_symbol());
+                    assert!(!b.is_symbol());
+                }
 
-            #[wasm_bindgen]
-            pub fn acquire_string(a: &JsValue, b: &JsValue) {
-                assert_eq!(a.as_string().unwrap(), "foo");
-                assert_eq!(b.as_string(), None);
-            }
+                #[wasm_bindgen]
+                pub fn acquire_string(a: &JsValue, b: &JsValue) {
+                    assert_eq!(a.as_string().unwrap(), "foo");
+                    assert_eq!(b.as_string(), None);
+                }
 
-            #[wasm_bindgen]
-            pub fn acquire_string2(a: &JsValue) -> String {
-                a.as_string().unwrap_or("wrong".to_string())
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn acquire_string2(a: &JsValue) -> String {
+                    a.as_string().unwrap_or("wrong".to_string())
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import * as assert from "assert";
-            import * as wasm from "./out";
+                import * as assert from "assert";
+                import * as wasm from "./out";
 
-            export function test() {
-                assert.strictEqual(wasm.foo(), 'foo');
-                assert.strictEqual(wasm.bar('a'), 'a');
-                assert.strictEqual(wasm.baz(), 1);
-                wasm.baz2(2, 'a');
+                export function test() {
+                    assert.strictEqual(wasm.foo(), 'foo');
+                    assert.strictEqual(wasm.bar('a'), 'a');
+                    assert.strictEqual(wasm.baz(), 1);
+                    wasm.baz2(2, 'a');
 
-                assert.strictEqual(wasm.js_null(), null);
-                assert.strictEqual(wasm.js_undefined(), undefined);
+                    assert.strictEqual(wasm.js_null(), null);
+                    assert.strictEqual(wasm.js_undefined(), undefined);
 
-                wasm.test_is_null_undefined(null, undefined, 1.0);
+                    wasm.test_is_null_undefined(null, undefined, 1.0);
 
-                assert.strictEqual(wasm.get_true(), true);
-                assert.strictEqual(wasm.get_false(), false);
-                wasm.test_bool(true, false, 1.0);
+                    assert.strictEqual(wasm.get_true(), true);
+                    assert.strictEqual(wasm.get_false(), false);
+                    wasm.test_bool(true, false, 1.0);
 
-                assert.strictEqual(typeof(wasm.mk_symbol()), 'symbol');
-                assert.strictEqual(typeof(wasm.mk_symbol2('a')), 'symbol');
-                assert.strictEqual((Symbol as any).keyFor(wasm.mk_symbol()), undefined);
-                assert.strictEqual((Symbol as any).keyFor(wasm.mk_symbol2('b')), undefined);
+                    assert.strictEqual(typeof(wasm.mk_symbol()), 'symbol');
+                    assert.strictEqual(typeof(wasm.mk_symbol2('a')), 'symbol');
+                    assert.strictEqual(Symbol.keyFor(wasm.mk_symbol()), undefined);
+                    assert.strictEqual(Symbol.keyFor(wasm.mk_symbol2('b')), undefined);
 
-                wasm.assert_symbols((Symbol as any)(), 'a');
-                wasm.acquire_string('foo', null)
-                assert.strictEqual(wasm.acquire_string2(''), '');
-                assert.strictEqual(wasm.acquire_string2('a'), 'a');
-            }
-        "#,
+                    wasm.assert_symbols(Symbol(), 'a');
+                    wasm.acquire_string('foo', null)
+                    assert.strictEqual(wasm.acquire_string2(''), '');
+                    assert.strictEqual(wasm.acquire_string2('a'), 'a');
+                }
+            "#,
         )
         .test();
 }
@@ -172,22 +172,22 @@ fn eq_works() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import * as assert from "assert";
-            import * as wasm from "./out";
+                import * as assert from "assert";
+                import * as wasm from "./out";
 
-            export function test() {
-                assert.strictEqual(wasm.test('a', 'a'), true);
-                assert.strictEqual(wasm.test('a', 'b'), false);
-                assert.strictEqual(wasm.test(NaN, NaN), false);
-                assert.strictEqual(wasm.test({a: 'a'}, {a: 'a'}), false);
-                assert.strictEqual(wasm.test1(NaN), false);
-                let x = {a: 'a'};
-                assert.strictEqual(wasm.test(x, x), true);
-                assert.strictEqual(wasm.test1(x), true);
-            }
-        "#,
+                export function test() {
+                    assert.strictEqual(wasm.test('a', 'a'), true);
+                    assert.strictEqual(wasm.test('a', 'b'), false);
+                    assert.strictEqual(wasm.test(NaN, NaN), false);
+                    assert.strictEqual(wasm.test({a: 'a'}, {a: 'a'}), false);
+                    assert.strictEqual(wasm.test1(NaN), false);
+                    let x = {a: 'a'};
+                    assert.strictEqual(wasm.test(x, x), true);
+                    assert.strictEqual(wasm.test1(x), true);
+                }
+            "#,
         )
         .test();
 }
diff --git a/tests/all/classes.rs b/tests/all/classes.rs
index 1abb6bf1..1abc54eb 100644
--- a/tests/all/classes.rs
+++ b/tests/all/classes.rs
@@ -40,7 +40,7 @@ fn simple() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import { Foo } from "./out";
@@ -115,7 +115,7 @@ fn strings() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import { Foo } from "./out";
@@ -139,70 +139,64 @@ fn exceptions() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen]
-            pub struct A {
-            }
-
-            #[wasm_bindgen]
-            impl A {
-                pub fn new() -> A {
-                    A {}
+                #[wasm_bindgen]
+                pub struct A {
                 }
 
-                pub fn foo(&self, _: &A) {
+                #[wasm_bindgen]
+                impl A {
+                    pub fn new() -> A {
+                        A {}
+                    }
+
+                    pub fn foo(&self, _: &A) {
+                    }
+
+                    pub fn bar(&mut self, _: &mut A) {
+                    }
                 }
 
-                pub fn bar(&mut self, _: &mut A) {
+                #[wasm_bindgen]
+                pub struct B {
                 }
-            }
 
-            #[wasm_bindgen]
-            pub struct B {
-            }
-
-            #[wasm_bindgen]
-            impl B {
-                pub fn new() -> B {
-                    B {}
+                #[wasm_bindgen]
+                impl B {
+                    pub fn new() -> B {
+                        B {}
+                    }
                 }
-            }
-        "#,
+            "#,
         )
         .file(
             "test.js",
             r#"
-            import * as assert from "assert";
-            import { A, B } from "./out";
+                import * as assert from "assert";
+                import { A, B } from "./out";
 
-            export function test() {
-                assert.throws(() => new A(), /cannot invoke `new` directly/);
-                let a = A.new();
-                a.free();
-                assert.throws(() => a.free(), /null pointer passed to rust/);
+                export function test() {
+                    assert.throws(() => new A(), /cannot invoke `new` directly/);
+                    let a = A.new();
+                    a.free();
+                    assert.throws(() => a.free(), /null pointer passed to rust/);
 
-                let b = A.new();
-                b.foo(b);
-                assert.throws(() => b.bar(b), /recursive use of an object/);
+                    let b = A.new();
+                    b.foo(b);
+                    assert.throws(() => b.bar(b), /recursive use of an object/);
 
-                let c = A.new();
-                let d = B.new();
-                assert.throws(() => c.foo(d), /expected instance of A/);
-                d.free();
-                c.free();
-            };
-        "#,
-        )
-        .file(
-            "test.d.ts",
-            r#"
-            export function test(): void;
-        "#,
+                    let c = A.new();
+                    let d = B.new();
+                    assert.throws(() => c.foo(d), /expected instance of A/);
+                    d.free();
+                    c.free();
+                };
+            "#,
         )
         .test();
 }
@@ -247,7 +241,7 @@ fn pass_one_to_another() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import { A, B } from "./out";
 
@@ -269,49 +263,49 @@ fn pass_into_js() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen]
-            pub struct Foo(i32);
+                #[wasm_bindgen]
+                pub struct Foo(i32);
 
-            #[wasm_bindgen]
-            impl Foo {
-                pub fn inner(&self) -> i32 {
-                    self.0
+                #[wasm_bindgen]
+                impl Foo {
+                    pub fn inner(&self) -> i32 {
+                        self.0
+                    }
                 }
-            }
 
-            #[wasm_bindgen(module = "./test")]
-            extern {
-                fn take_foo(foo: Foo);
-            }
+                #[wasm_bindgen(module = "./test")]
+                extern {
+                    fn take_foo(foo: Foo);
+                }
 
-            #[wasm_bindgen]
-            pub fn run() {
-                take_foo(Foo(13));
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn run() {
+                    take_foo(Foo(13));
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import { run, Foo } from "./out";
-            import * as assert from "assert";
+                import { run, Foo } from "./out";
+                import * as assert from "assert";
 
-            export function take_foo(foo: Foo) {
-                assert.strictEqual(foo.inner(), 13);
-                foo.free();
-                assert.throws(() => foo.free(), /null pointer passed to rust/);
-            }
+                export function take_foo(foo) {
+                    assert.strictEqual(foo.inner(), 13);
+                    foo.free();
+                    assert.throws(() => foo.free(), /null pointer passed to rust/);
+                }
 
-            export function test() {
-                run();
-            }
-        "#,
+                export function test() {
+                    run();
+                }
+            "#,
         )
         .test();
 }
@@ -353,7 +347,7 @@ fn issue_27() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import { context } from "./out";
 
@@ -399,21 +393,21 @@ fn pass_into_js_as_js_class() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import { run, Foo } from "./out";
-            import * as assert from "assert";
+                import { run, Foo } from "./out";
+                import * as assert from "assert";
 
-            export function take_foo(foo: any) {
-                assert(foo instanceof Foo);
-                assert.strictEqual(foo.inner(), 13);
-                foo.free();
-            }
+                export function take_foo(foo) {
+                    assert.ok(foo instanceof Foo);
+                    assert.strictEqual(foo.inner(), 13);
+                    foo.free();
+                }
 
-            export function test() {
-                run();
-            }
-        "#,
+                export function test() {
+                    run();
+                }
+            "#,
         )
         .test();
 }
@@ -472,31 +466,31 @@ fn constructors() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import * as assert from "assert";
-            import { Foo, Bar, cross_item_construction } from "./out";
+                import * as assert from "assert";
+                import { Foo, Bar, cross_item_construction } from "./out";
 
-            export function test() {
-                const foo = new Foo(1);
-                assert.strictEqual(foo.get_number(), 1);
-                foo.free();
+                export function test() {
+                    const foo = new Foo(1);
+                    assert.strictEqual(foo.get_number(), 1);
+                    foo.free();
 
-                const foo2 = Foo.new(2);
-                assert.strictEqual(foo2.get_number(), 2);
-                foo2.free();
+                    const foo2 = Foo.new(2);
+                    assert.strictEqual(foo2.get_number(), 2);
+                    foo2.free();
 
-                const bar = new Bar(3, 4);
-                assert.strictEqual(bar.get_sum(), 7);
-                bar.free();
+                    const bar = new Bar(3, 4);
+                    assert.strictEqual(bar.get_sum(), 7);
+                    bar.free();
 
-                const bar2 = Bar.other_name(5, 6);
-                assert.strictEqual(bar2.get_sum(), 11);
-                bar2.free();
+                    const bar2 = Bar.other_name(5, 6);
+                    assert.strictEqual(bar2.get_sum(), 11);
+                    bar2.free();
 
-                assert.strictEqual(cross_item_construction().get_sum(), 15);
-            }
-        "#,
+                    assert.strictEqual(cross_item_construction().get_sum(), 15);
+                }
+            "#,
         )
         .test();
 }
@@ -525,14 +519,14 @@ fn empty_structs() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import { Other } from "./out";
+                import { Other } from "./out";
 
-            export function test() {
-                Other.return_a_value();
-            }
-        "#,
+                export function test() {
+                    Other.return_a_value();
+                }
+            "#,
         )
         .test();
 }
@@ -568,7 +562,7 @@ fn public_fields() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import { Foo } from "./out";
             import * as assert from "assert";
@@ -622,7 +616,7 @@ fn using_self() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import { Foo } from "./out";
 
@@ -641,40 +635,40 @@ fn readonly_fields() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen]
-            #[derive(Default)]
-            pub struct Foo {
-                #[wasm_bindgen(readonly)]
-                pub a: u32,
-            }
-
-            #[wasm_bindgen]
-            impl Foo {
-                pub fn new() -> Foo {
-                    Foo::default()
+                #[wasm_bindgen]
+                #[derive(Default)]
+                pub struct Foo {
+                    #[wasm_bindgen(readonly)]
+                    pub a: u32,
                 }
-            }
-        "#,
+
+                #[wasm_bindgen]
+                impl Foo {
+                    pub fn new() -> Foo {
+                        Foo::default()
+                    }
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import { Foo } from "./out";
-            import * as assert from "assert";
+                import { Foo } from "./out";
+                import * as assert from "assert";
 
-            export function test() {
-                const a = Foo.new();
-                assert.strictEqual(a.a, 0);
-                assert.throws(() => (a as any).a = 3, /has only a getter/);
-                a.free();
-            }
-        "#,
+                export function test() {
+                    const a = Foo.new();
+                    assert.strictEqual(a.a, 0);
+                    assert.throws(() => a.a = 3, /has only a getter/);
+                    a.free();
+                }
+            "#,
         )
         .test();
 }
@@ -704,7 +698,7 @@ fn double_consume() {
                 }
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import { Foo } from "./out";
 
diff --git a/tests/all/closures.rs b/tests/all/closures.rs
index a85ba9bd..209b184e 100644
--- a/tests/all/closures.rs
+++ b/tests/all/closures.rs
@@ -6,46 +6,46 @@ fn works() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use std::cell::Cell;
-            use wasm_bindgen::prelude::*;
+                use std::cell::Cell;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen(module = "./test")]
-            extern {
-                fn call(a: &Fn());
-                fn thread(a: &Fn(u32) -> u32) -> u32;
-            }
+                #[wasm_bindgen(module = "./test")]
+                extern {
+                    fn call(a: &Fn());
+                    fn thread(a: &Fn(u32) -> u32) -> u32;
+                }
 
-            #[wasm_bindgen]
-            pub fn run() {
-                let a = Cell::new(false);
-                call(&|| a.set(true));
-                assert!(a.get());
+                #[wasm_bindgen]
+                pub fn run() {
+                    let a = Cell::new(false);
+                    call(&|| a.set(true));
+                    assert!(a.get());
 
-                assert_eq!(thread(&|a| a + 1), 3);
-            }
-        "#,
+                    assert_eq!(thread(&|a| a + 1), 3);
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import { run } from "./out";
+                import { run } from "./out";
 
-            export function call(a: any) {
-                a();
-            }
+                export function call(a) {
+                    a();
+                }
 
-            export function thread(a: any) {
-                return a(2);
-            }
+                export function thread(a) {
+                    return a(2);
+                }
 
-            export function test() {
-                run();
-            }
-        "#,
+                export function test() {
+                    run();
+                }
+            "#,
         )
         .test();
 }
@@ -56,34 +56,34 @@ fn cannot_reuse() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen(module = "./test")]
-            extern {
-                fn call(a: &Fn());
-                #[wasm_bindgen(catch)]
-                fn call_again() -> Result<(), JsValue>;
-            }
+                #[wasm_bindgen(module = "./test")]
+                extern {
+                    fn call(a: &Fn());
+                    #[wasm_bindgen(catch)]
+                    fn call_again() -> Result<(), JsValue>;
+                }
 
-            #[wasm_bindgen]
-            pub fn run() {
-                call(&|| {});
-                assert!(call_again().is_err());
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn run() {
+                    call(&|| {});
+                    assert!(call_again().is_err());
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import { run } from "./out";
 
-            let CACHE: any = null;
+            let CACHE = null;
 
-            export function call(a: any) {
+            export function call(a) {
                 CACHE = a;
             }
 
@@ -142,15 +142,15 @@ fn long_lived() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import { run } from "./out";
 
-            export function call1(a: any) {
+            export function call1(a) {
                 a();
             }
 
-            export function call2(a: any) {
+            export function call2(a) {
                 return a(2);
             }
 
@@ -242,18 +242,18 @@ fn many_arity() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import { run } from "./out";
 
-            export function call1(a: any) { a() }
-            export function call2(a: any) { a(1) }
-            export function call3(a: any) { a(1, 2) }
-            export function call4(a: any) { a(1, 2, 3) }
-            export function call5(a: any) { a(1, 2, 3, 4) }
-            export function call6(a: any) { a(1, 2, 3, 4, 5) }
-            export function call7(a: any) { a(1, 2, 3, 4, 5, 6) }
-            export function call8(a: any) { a(1, 2, 3, 4, 5, 6, 7) }
+            export function call1(a) { a() }
+            export function call2(a) { a(1) }
+            export function call3(a) { a(1, 2) }
+            export function call4(a) { a(1, 2, 3) }
+            export function call5(a) { a(1, 2, 3, 4) }
+            export function call6(a) { a(1, 2, 3, 4, 5) }
+            export function call7(a) { a(1, 2, 3, 4, 5, 6) }
+            export function call8(a) { a(1, 2, 3, 4, 5, 6, 7) }
 
             export function test() {
                 run();
@@ -299,13 +299,13 @@ fn long_lived_dropping() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import { run } from "./out";
 
-            let CACHE: any = null;
+            let CACHE = null;
 
-            export function cache(a: any) { CACHE = a; }
+            export function cache(a) { CACHE = a; }
             export function call() { CACHE() }
 
             export function test() {
@@ -346,13 +346,13 @@ fn long_fnmut_recursive() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import { run } from "./out";
 
-            let CACHE: any = null;
+            let CACHE = null;
 
-            export function cache(a: any) { CACHE = a; }
+            export function cache(a) { CACHE = a; }
             export function call() { CACHE() }
 
             export function test() {
@@ -397,15 +397,15 @@ fn fnmut() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import { run } from "./out";
 
-            export function call(a: any) {
+            export function call(a) {
                 a();
             }
 
-            export function thread(a: any) {
+            export function thread(a) {
                 return a(2);
             }
 
@@ -455,18 +455,18 @@ fn fnmut_bad() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import { run } from "./out";
 
-            let F: any = null;
+            let F = null;
 
-            export function call(a: any) {
+            export function call(a) {
                 F = a;
                 a();
             }
 
-            export function again(x: boolean) {
+            export function again(x) {
                 if (x) F();
             }
 
@@ -507,18 +507,18 @@ fn string_arguments() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import { run } from "./out";
+                import { run } from "./out";
 
-            export function call(a: any) {
-                a("foo")
-            }
+                export function call(a) {
+                    a("foo")
+                }
 
-            export function test() {
-                run();
-            }
-        "#,
+                export function test() {
+                    run();
+                }
+            "#,
         )
         .test();
 }
@@ -529,45 +529,45 @@ fn string_ret() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen(module = "./test")]
-            extern {
-                fn call(a: &mut FnMut(String) -> String);
-            }
+                #[wasm_bindgen(module = "./test")]
+                extern {
+                    fn call(a: &mut FnMut(String) -> String);
+                }
 
-            #[wasm_bindgen]
-            pub fn run() {
-                let mut x = false;
-                call(&mut |mut s| {
-                    assert_eq!(s, "foo");
-                    s.push_str("bar");
-                    x = true;
-                    s
-                });
-                assert!(x);
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn run() {
+                    let mut x = false;
+                    call(&mut |mut s| {
+                        assert_eq!(s, "foo");
+                        s.push_str("bar");
+                        x = true;
+                        s
+                    });
+                    assert!(x);
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import { run } from "./out";
-            import * as assert from "assert";
+                import { run } from "./out";
+                import * as assert from "assert";
 
-            export function call(a: any) {
-                const s = a("foo");
-                assert.strictEqual(s, "foobar");
-            }
+                export function call(a) {
+                    const s = a("foo");
+                    assert.strictEqual(s, "foobar");
+                }
 
-            export function test() {
-                run();
-            }
-        "#,
+                export function test() {
+                    run();
+                }
+            "#,
         )
         .test();
 }
diff --git a/tests/all/comments.rs b/tests/all/comments.rs
index 89956337..30ceb7c2 100644
--- a/tests/all/comments.rs
+++ b/tests/all/comments.rs
@@ -38,12 +38,12 @@ fn works() {
         "#,
     );
 
-    let (root, target) = p.cargo_build();
-    p.gen_bindings(&root, &target);
+    p.gen_bindings();
     let js = p.read_js();
     let comments = extract_doc_comments(&js);
     assert!(comments.iter().all(|c| c == "This comment should exist"));
 }
+
 /// Pull out all lines in a js string that start with
 /// '* ', all other lines will either be comment start, comment
 /// end or actual js lines.
diff --git a/tests/all/dependencies.rs b/tests/all/dependencies.rs
index 6c8ec4f4..a56571c8 100644
--- a/tests/all/dependencies.rs
+++ b/tests/all/dependencies.rs
@@ -6,87 +6,87 @@ fn dependencies_work() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
-            extern crate wasm_bindgen;
-            extern crate dependency;
-            use wasm_bindgen::prelude::*;
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                extern crate wasm_bindgen;
+                extern crate dependency;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen]
-            pub fn return_dep_ty(x: f64) -> dependency::Foo {
-                dependency::Foo(x)
-            }
+                #[wasm_bindgen]
+                pub fn return_dep_ty(x: f64) -> dependency::Foo {
+                    dependency::Foo(x)
+                }
 
-            #[wasm_bindgen]
-            pub fn takes_own_dep_ty(foo: dependency::Foo) -> f64 {
-                foo.0
-            }
+                #[wasm_bindgen]
+                pub fn takes_own_dep_ty(foo: dependency::Foo) -> f64 {
+                    foo.0
+                }
 
-            #[wasm_bindgen]
-            pub fn takes_ref_dep_ty(foo: &dependency::Foo) -> f64 {
-                foo.0
-            }
+                #[wasm_bindgen]
+                pub fn takes_ref_dep_ty(foo: &dependency::Foo) -> f64 {
+                    foo.0
+                }
 
-            #[wasm_bindgen]
-            pub fn takes_mut_dep_ty(foo: &mut dependency::Foo, x: f64) {
-                foo.0 = x;
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn takes_mut_dep_ty(foo: &mut dependency::Foo, x: f64) {
+                    foo.0 = x;
+                }
+            "#,
         )
         .add_local_dependency("dependency", "vendor/dependency")
         .file(
             "vendor/dependency/Cargo.toml",
             &format!(
                 r#"
-                [package]
-                name = "dependency"
-                version = "0.0.1"
-                authors = []
+                    [package]
+                    name = "dependency"
+                    version = "0.0.1"
+                    authors = []
 
-                [dependencies]
-                wasm-bindgen = {{ path = '{}' }}
-        "#,
+                    [dependencies]
+                    wasm-bindgen = {{ path = '{}' }}
+            "#,
                 env!("CARGO_MANIFEST_DIR")
             ),
         )
         .file(
             "vendor/dependency/src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
-            extern crate wasm_bindgen;
-            use wasm_bindgen::prelude::*;
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                extern crate wasm_bindgen;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen]
-            pub struct Foo(pub f64);
+                #[wasm_bindgen]
+                pub struct Foo(pub f64);
 
-            #[wasm_bindgen]
-            impl Foo {
-                pub fn new(x: f64) -> Foo { Foo(x) }
-                pub fn get(&self) -> f64 { self.0 }
-            }
-        "#,
+                #[wasm_bindgen]
+                impl Foo {
+                    pub fn new(x: f64) -> Foo { Foo(x) }
+                    pub fn get(&self) -> f64 { self.0 }
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import * as assert from "assert";
-            import * as wasm from "./out";
+                import * as assert from "assert";
+                import * as wasm from "./out";
 
-            export function test() {
-                const foo = wasm.return_dep_ty(42);
-                assert.strictEqual(foo.get(), 42);
+                export function test() {
+                    const foo = wasm.return_dep_ty(42);
+                    assert.strictEqual(foo.get(), 42);
 
-                const x = wasm.takes_ref_dep_ty(foo);
-                assert.strictEqual(x, 42);
+                    const x = wasm.takes_ref_dep_ty(foo);
+                    assert.strictEqual(x, 42);
 
-                const y = 1337;
-                wasm.takes_mut_dep_ty(foo, y);
-                assert.strictEqual(foo.get(), y);
+                    const y = 1337;
+                    wasm.takes_mut_dep_ty(foo, y);
+                    assert.strictEqual(foo.get(), y);
 
-                const z = wasm.takes_own_dep_ty(foo);
-                assert.strictEqual(z, y);
-                assert.strictEqual((foo as any).ptr, 0);
-            }
-        "#,
+                    const z = wasm.takes_own_dep_ty(foo);
+                    assert.strictEqual(z, y);
+                    assert.strictEqual(foo.ptr, 0);
+                }
+            "#,
         )
         .test();
 }
diff --git a/tests/all/enums.rs b/tests/all/enums.rs
index 0ad10fd4..5723eee7 100644
--- a/tests/all/enums.rs
+++ b/tests/all/enums.rs
@@ -6,44 +6,44 @@ fn c_style_enum() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section)]
+                #![feature(proc_macro, wasm_custom_section)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen]
-            pub enum Color {
-                Green,
-                Yellow,
-                Red,
-            }
-
-            #[wasm_bindgen]
-            pub fn cycle(color: Color) -> Color {
-                match color {
-                    Color::Green => Color::Yellow,
-                    Color::Yellow => Color::Red,
-                    Color::Red => Color::Green,
+                #[wasm_bindgen]
+                pub enum Color {
+                    Green,
+                    Yellow,
+                    Red,
                 }
-            }
-        "#,
+
+                #[wasm_bindgen]
+                pub fn cycle(color: Color) -> Color {
+                    match color {
+                        Color::Green => Color::Yellow,
+                        Color::Yellow => Color::Red,
+                        Color::Red => Color::Green,
+                    }
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import * as assert from "assert";
-            import * as wasm from "./out";
+                import * as assert from "assert";
+                import * as wasm from "./out";
 
-            export function test() {
-                assert.strictEqual(wasm.Color.Green, 0);
-                assert.strictEqual(wasm.Color.Yellow, 1);
-                assert.strictEqual(wasm.Color.Red, 2);
-                assert.strictEqual(Object.keys(wasm.Color).length, 3);
+                export function test() {
+                    assert.strictEqual(wasm.Color.Green, 0);
+                    assert.strictEqual(wasm.Color.Yellow, 1);
+                    assert.strictEqual(wasm.Color.Red, 2);
+                    assert.strictEqual(Object.keys(wasm.Color).length, 3);
 
-                assert.strictEqual(wasm.cycle(wasm.Color.Green), wasm.Color.Yellow);
-            }
-        "#,
+                    assert.strictEqual(wasm.cycle(wasm.Color.Green), wasm.Color.Yellow);
+                }
+            "#,
         )
         .test();
 }
@@ -54,50 +54,50 @@ fn c_style_enum_with_custom_values() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section)]
+                #![feature(proc_macro, wasm_custom_section)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
-
-            pub mod inner {
                 use wasm_bindgen::prelude::*;
 
+                pub mod inner {
+                    use wasm_bindgen::prelude::*;
+
+                    #[wasm_bindgen]
+                    pub enum Color {
+                        Green = 21,
+                        Yellow = 34,
+                        Red,
+                    }
+                }
+
+                use inner::Color;
+
                 #[wasm_bindgen]
-                pub enum Color {
-                    Green = 21,
-                    Yellow = 34,
-                    Red,
+                pub fn cycle(color: Color) -> Color {
+                    match color {
+                        Color::Green => Color::Yellow,
+                        Color::Yellow => Color::Red,
+                        Color::Red => Color::Green,
+                    }
                 }
-            }
-
-            use inner::Color;
-
-            #[wasm_bindgen]
-            pub fn cycle(color: Color) -> Color {
-                match color {
-                    Color::Green => Color::Yellow,
-                    Color::Yellow => Color::Red,
-                    Color::Red => Color::Green,
-                }
-            }
-        "#,
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import * as assert from "assert";
-            import * as wasm from "./out";
+                import * as assert from "assert";
+                import * as wasm from "./out";
 
-            export function test() {
-                assert.strictEqual(wasm.Color.Green, 21);
-                assert.strictEqual(wasm.Color.Yellow, 34);
-                assert.strictEqual(wasm.Color.Red, 2);
-                assert.strictEqual(Object.keys(wasm.Color).length, 3);
+                export function test() {
+                    assert.strictEqual(wasm.Color.Green, 21);
+                    assert.strictEqual(wasm.Color.Yellow, 34);
+                    assert.strictEqual(wasm.Color.Red, 2);
+                    assert.strictEqual(Object.keys(wasm.Color).length, 3);
 
-                assert.strictEqual(wasm.cycle(wasm.Color.Green), wasm.Color.Yellow);
-            }
-        "#,
+                    assert.strictEqual(wasm.cycle(wasm.Color.Green), wasm.Color.Yellow);
+                }
+            "#,
         )
         .test();
 }
diff --git a/tests/all/import_class.rs b/tests/all/import_class.rs
index b0b7d010..0f5ec9ab 100644
--- a/tests/all/import_class.rs
+++ b/tests/all/import_class.rs
@@ -6,42 +6,42 @@ fn simple() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen]
-            pub fn get_random() -> f64 {
-                random()
-            }
+                #[wasm_bindgen]
+                pub fn get_random() -> f64 {
+                    random()
+                }
 
-            #[wasm_bindgen]
-            pub fn do_log(a: f64) -> f64 {
-                log(a)
-            }
+                #[wasm_bindgen]
+                pub fn do_log(a: f64) -> f64 {
+                    log(a)
+                }
 
-            #[wasm_bindgen]
-            extern {
-                #[wasm_bindgen(js_namespace = Math)]
-                fn random() -> f64;
-                #[wasm_bindgen(js_namespace = Math)]
-                fn log(a: f64) -> f64;
-            }
-        "#,
+                #[wasm_bindgen]
+                extern {
+                    #[wasm_bindgen(js_namespace = Math)]
+                    fn random() -> f64;
+                    #[wasm_bindgen(js_namespace = Math)]
+                    fn log(a: f64) -> f64;
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import * as wasm from "./out";
-            import * as assert from "assert";
+                import * as wasm from "./out";
+                import * as assert from "assert";
 
-            export function test() {
-                wasm.get_random();
-                assert.strictEqual(wasm.do_log(1.0), Math.log(1.0));
-            }
-        "#,
+                export function test() {
+                    wasm.get_random();
+                    assert.strictEqual(wasm.do_log(1.0), Math.log(1.0));
+                }
+            "#,
         )
         .test();
 }
@@ -52,48 +52,48 @@ fn import_class() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen(module = "./another")]
-            extern {
-                #[wasm_bindgen(js_namespace = Foo)]
-                fn bar();
-            }
-
-            #[wasm_bindgen]
-            pub fn baz() {
-                bar();
-            }
-        "#,
-        )
-        .file(
-            "test.ts",
-            r#"
-            import { baz } from "./out";
-            import { called } from "./another";
-            import * as assert from "assert";
-
-            export function test() {
-                baz();
-                assert.strictEqual(called, true);
-            }
-        "#,
-        )
-        .file(
-            "another.ts",
-            r#"
-            export let called = false;
-
-            export class Foo {
-                static bar() {
-                    called = true;
+                #[wasm_bindgen(module = "./another")]
+                extern {
+                    #[wasm_bindgen(js_namespace = Foo)]
+                    fn bar();
                 }
-            }
-        "#,
+
+                #[wasm_bindgen]
+                pub fn baz() {
+                    bar();
+                }
+            "#,
+        )
+        .file(
+            "test.js",
+            r#"
+                import { baz } from "./out";
+                import { called } from "./another";
+                import * as assert from "assert";
+
+                export function test() {
+                    baz();
+                    assert.strictEqual(called, true);
+                }
+            "#,
+        )
+        .file(
+            "another.js",
+            r#"
+                export let called = false;
+
+                export class Foo {
+                    static bar() {
+                        called = true;
+                    }
+                }
+            "#,
         )
         .test();
 }
@@ -104,77 +104,79 @@ fn construct() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen(module = "./another")]
-            extern {
-                type Foo;
-                #[wasm_bindgen(js_namespace = Foo)]
-                fn create() -> Foo;
-                #[wasm_bindgen(method)]
-                fn get_internal_string(this: &Foo) -> String;
-                #[wasm_bindgen(method)]
-                fn append_to_internal_string(this: &Foo, s: &str);
-                #[wasm_bindgen(method)]
-                fn assert_internal_string(this: &Foo, s: &str);
-            }
+                #[wasm_bindgen(module = "./another")]
+                extern {
+                    #[derive(Clone)]
+                    type Foo;
+                    #[wasm_bindgen(js_namespace = Foo)]
+                    fn create() -> Foo;
+                    #[wasm_bindgen(method)]
+                    fn get_internal_string(this: &Foo) -> String;
+                    #[wasm_bindgen(method)]
+                    fn append_to_internal_string(this: &Foo, s: &str);
+                    #[wasm_bindgen(method)]
+                    fn assert_internal_string(this: &Foo, s: &str);
+                }
 
-            #[wasm_bindgen]
-            pub fn run() {
-                let f = Foo::create();
-                assert_eq!(f.get_internal_string(), "this");
-                f.append_to_internal_string(" foo");
-                f.assert_internal_string("this foo");
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn run() {
+                    let f = Foo::create();
+                    assert_eq!(f.get_internal_string(), "this");
+                    assert_eq!(f.clone().get_internal_string(), "this");
+                    f.append_to_internal_string(" foo");
+                    f.assert_internal_string("this foo");
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import { run } from "./out";
-            import { called } from "./another";
-            import * as assert from "assert";
+                import { run } from "./out";
+                import { called } from "./another";
+                import * as assert from "assert";
 
-            export function test() {
-                run();
-                assert.strictEqual(called, true);
-            }
-        "#,
+                export function test() {
+                    run();
+                    assert.strictEqual(called, true);
+                }
+            "#,
         )
         .file(
-            "another.ts",
+            "another.js",
             r#"
-            import * as assert from "assert";
+                import * as assert from "assert";
 
-            export let called = false;
+                export let called = false;
 
-            export class Foo {
-                private internal_string: string = '';
+                export class Foo {
+                    static create() {
+                        const ret = new Foo();
+                        ret.internal_string = 'this';
+                        return ret;
+                    }
 
-                static create() {
-                    const ret = new Foo();
-                    ret.internal_string = 'this';
-                    return ret;
+                    get_internal_string() {
+                        return this.internal_string;
+                    }
+
+                    append_to_internal_string(s) {
+                        this.internal_string += s;
+                    }
+
+                    assert_internal_string(s) {
+                        assert.strictEqual(this.internal_string, s);
+                        called = true;
+                    }
                 }
 
-                get_internal_string() {
-                    return this.internal_string;
-                }
-
-                append_to_internal_string(s: string) {
-                    this.internal_string += s;
-                }
-
-                assert_internal_string(s: string) {
-                    assert.strictEqual(this.internal_string, s);
-                    called = true;
-                }
-            }
-        "#,
+                Foo.internal_string = '';
+            "#,
         )
         .test();
 }
@@ -185,50 +187,51 @@ fn new_constructors() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen(module = "./another")]
-            extern {
-                type Foo;
-                #[wasm_bindgen(constructor)]
-                fn new(arg: i32) -> Foo;
-                #[wasm_bindgen(method)]
-                fn get(this: &Foo) -> i32;
-            }
-
-            #[wasm_bindgen]
-            pub fn run() {
-                let f = Foo::new(1);
-                assert_eq!(f.get(), 2);
-            }
-        "#,
-        )
-        .file(
-            "test.ts",
-            r#"
-            import { run } from "./out";
-
-            export function test() {
-                run();
-            }
-        "#,
-        )
-        .file(
-            "another.ts",
-            r#"
-            export class Foo {
-                constructor(private field: number) {
+                #[wasm_bindgen(module = "./another")]
+                extern {
+                    type Foo;
+                    #[wasm_bindgen(constructor)]
+                    fn new(arg: i32) -> Foo;
+                    #[wasm_bindgen(method)]
+                    fn get(this: &Foo) -> i32;
                 }
 
-                get() {
-                    return this.field + 1;
+                #[wasm_bindgen]
+                pub fn run() {
+                    let f = Foo::new(1);
+                    assert_eq!(f.get(), 2);
                 }
-            }
-        "#,
+            "#,
+        )
+        .file(
+            "test.js",
+            r#"
+                import { run } from "./out";
+
+                export function test() {
+                    run();
+                }
+            "#,
+        )
+        .file(
+            "another.js",
+            r#"
+                export class Foo {
+                    constructor(field) {
+                        this.field = field;
+                    }
+
+                    get() {
+                        return this.field + 1;
+                    }
+                }
+            "#,
         )
         .test();
 }
@@ -239,84 +242,84 @@ fn switch_methods() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen(module = "./another")]
-            extern {
-                type Foo;
+                #[wasm_bindgen(module = "./another")]
+                extern {
+                    type Foo;
 
-                #[wasm_bindgen(constructor)]
-                fn new() -> Foo;
+                    #[wasm_bindgen(constructor)]
+                    fn new() -> Foo;
 
-                #[wasm_bindgen(js_namespace = Foo)]
-                fn a();
+                    #[wasm_bindgen(js_namespace = Foo)]
+                    fn a();
 
-                #[wasm_bindgen(method)]
-                fn b(this: &Foo);
-            }
+                    #[wasm_bindgen(method)]
+                    fn b(this: &Foo);
+                }
 
-            #[wasm_bindgen]
-            pub fn a() {
-                Foo::a();
-            }
+                #[wasm_bindgen]
+                pub fn a() {
+                    Foo::a();
+                }
 
-            #[wasm_bindgen]
-            pub fn b() {
-                Foo::new().b();
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn b() {
+                    Foo::new().b();
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import { a, b } from "./out";
-            import { Foo, called } from "./another";
-            import * as assert from "assert";
+                import { a, b } from "./out";
+                import { Foo, called } from "./another";
+                import * as assert from "assert";
 
-            export function test() {
-                assert.strictEqual(called.a, false);
-                a();
-                assert.strictEqual(called.a, true);
-                called.a = false;
-                Foo.a = function() {};
-                assert.strictEqual(called.a, false);
-                a();
-                assert.strictEqual(called.a, true);
+                export function test() {
+                    assert.strictEqual(called.a, false);
+                    a();
+                    assert.strictEqual(called.a, true);
+                    called.a = false;
+                    Foo.a = function() {};
+                    assert.strictEqual(called.a, false);
+                    a();
+                    assert.strictEqual(called.a, true);
 
-                called.a = false;
-                assert.strictEqual(called.a, false);
-                b();
-                assert.strictEqual(called.a, true);
-                called.a = false;
-                Foo.prototype.b = function() {};
-                assert.strictEqual(called.a, false);
-                b();
-                assert.strictEqual(called.a, true);
-            }
-        "#,
+                    called.a = false;
+                    assert.strictEqual(called.a, false);
+                    b();
+                    assert.strictEqual(called.a, true);
+                    called.a = false;
+                    Foo.prototype.b = function() {};
+                    assert.strictEqual(called.a, false);
+                    b();
+                    assert.strictEqual(called.a, true);
+                }
+            "#,
         )
         .file(
-            "another.ts",
+            "another.js",
             r#"
-            export let called = { a: false };
+                export let called = { a: false };
 
-            export class Foo {
-                constructor() {
-                }
+                export class Foo {
+                    constructor() {
+                    }
 
-                static a() {
-                    called.a = true;
-                }
+                    static a() {
+                        called.a = true;
+                    }
 
-                b() {
-                    called.a = true;
+                    b() {
+                        called.a = true;
+                    }
                 }
-            }
-        "#,
+            "#,
         )
         .test();
 }
@@ -327,62 +330,62 @@ fn properties() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen(module = "./another")]
-            extern {
-                type Foo;
+                #[wasm_bindgen(module = "./another")]
+                extern {
+                    type Foo;
 
-                #[wasm_bindgen(constructor)]
-                fn new() -> Foo;
+                    #[wasm_bindgen(constructor)]
+                    fn new() -> Foo;
 
-                #[wasm_bindgen(getter, method)]
-                fn a(this: &Foo) -> i32;
+                    #[wasm_bindgen(getter, method)]
+                    fn a(this: &Foo) -> i32;
 
-                #[wasm_bindgen(setter, method)]
-                fn set_a(this: &Foo, a: i32);
-            }
+                    #[wasm_bindgen(setter, method)]
+                    fn set_a(this: &Foo, a: i32);
+                }
 
-            #[wasm_bindgen]
-            pub fn run() {
-                let a = Foo::new();
-                assert_eq!(a.a(), 1);
-                a.set_a(2);
-                assert_eq!(a.a(), 2);
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn run() {
+                    let a = Foo::new();
+                    assert_eq!(a.a(), 1);
+                    a.set_a(2);
+                    assert_eq!(a.a(), 2);
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import { run } from "./out";
+                import { run } from "./out";
 
-            export function test() {
-                run();
-            }
-        "#,
+                export function test() {
+                    run();
+                }
+            "#,
         )
         .file(
-            "another.ts",
+            "another.js",
             r#"
-            export class Foo {
-                constructor(private num: number) {
-                    this.num = 1;
-                }
+                export class Foo {
+                    constructor() {
+                        this.num = 1;
+                    }
 
-                get a() {
-                    return this.num;
-                }
+                    get a() {
+                        return this.num;
+                    }
 
-                set a(val) {
-                    this.num = val;
+                    set a(val) {
+                        this.num = val;
+                    }
                 }
-            }
-        "#,
+            "#,
         )
         .test();
 }
@@ -393,62 +396,62 @@ fn rename_setter_getter() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen(module = "./another")]
-            extern {
-                type Foo;
+                #[wasm_bindgen(module = "./another")]
+                extern {
+                    type Foo;
 
-                #[wasm_bindgen(constructor)]
-                fn new() -> Foo;
+                    #[wasm_bindgen(constructor)]
+                    fn new() -> Foo;
 
-                #[wasm_bindgen(getter = a, method)]
-                fn test(this: &Foo) -> i32;
+                    #[wasm_bindgen(getter = a, method)]
+                    fn test(this: &Foo) -> i32;
 
-                #[wasm_bindgen(setter = a, method)]
-                fn another(this: &Foo, a: i32);
-            }
+                    #[wasm_bindgen(setter = a, method)]
+                    fn another(this: &Foo, a: i32);
+                }
 
-            #[wasm_bindgen]
-            pub fn run() {
-                let a = Foo::new();
-                assert_eq!(a.test(), 1);
-                a.another(2);
-                assert_eq!(a.test(), 2);
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn run() {
+                    let a = Foo::new();
+                    assert_eq!(a.test(), 1);
+                    a.another(2);
+                    assert_eq!(a.test(), 2);
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import { run } from "./out";
+                import { run } from "./out";
 
-            export function test() {
-                run();
-            }
-        "#,
+                export function test() {
+                    run();
+                }
+            "#,
         )
         .file(
-            "another.ts",
+            "another.js",
             r#"
-            export class Foo {
-                constructor(private num: number) {
-                    this.num = 1;
-                }
+                export class Foo {
+                    constructor() {
+                        this.num = 1;
+                    }
 
-                get a() {
-                    return this.num;
-                }
+                    get a() {
+                        return this.num;
+                    }
 
-                set a(val) {
-                    this.num = val;
+                    set a(val) {
+                        this.num = val;
+                    }
                 }
-            }
-        "#,
+            "#,
         )
         .test();
 }
diff --git a/tests/all/imports.rs b/tests/all/imports.rs
index 9094bcdf..96b80771 100644
--- a/tests/all/imports.rs
+++ b/tests/all/imports.rs
@@ -6,84 +6,84 @@ fn simple() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen(module = "./test")]
-            extern {
-                fn foo(s: &str);
-                fn another(a: u32) -> i32;
-                fn take_and_return_bool(a: bool) -> bool;
-                fn return_object() -> JsValue;
-            }
+                #[wasm_bindgen(module = "./test")]
+                extern {
+                    fn foo(s: &str);
+                    fn another(a: u32) -> i32;
+                    fn take_and_return_bool(a: bool) -> bool;
+                    fn return_object() -> JsValue;
+                }
 
-            #[wasm_bindgen]
-            pub fn bar(s: &str) {
-                foo(s);
-            }
+                #[wasm_bindgen]
+                pub fn bar(s: &str) {
+                    foo(s);
+                }
 
-            #[wasm_bindgen]
-            pub fn another_thunk(a: u32) -> i32 {
-                another(a)
-            }
+                #[wasm_bindgen]
+                pub fn another_thunk(a: u32) -> i32 {
+                    another(a)
+                }
 
-            #[wasm_bindgen]
-            pub fn bool_thunk(a: bool) -> bool {
-                take_and_return_bool(a)
-            }
+                #[wasm_bindgen]
+                pub fn bool_thunk(a: bool) -> bool {
+                    take_and_return_bool(a)
+                }
 
-            #[wasm_bindgen]
-            pub fn get_the_object() -> JsValue {
-                return_object()
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn get_the_object() -> JsValue {
+                    return_object()
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import * as wasm from "./out";
-            import * as assert from "assert";
+                import * as wasm from "./out";
+                import * as assert from "assert";
 
-            let ARG: string | null = null;
-            let ANOTHER_ARG: number | null = null;
-            let SYM = (Symbol as any)('a');
+                let ARG = null;
+                let ANOTHER_ARG = null;
+                let SYM = Symbol('a');
 
-            export function foo(s: string): void {
-                assert.strictEqual(ARG, null);
-                assert.strictEqual(s, "foo");
-                ARG = s;
-            }
-            export function another(s: number): number {
-                assert.strictEqual(ANOTHER_ARG, null);
-                assert.strictEqual(s, 21);
-                ANOTHER_ARG = s;
-                return 35;
-            }
-            export function take_and_return_bool(s: boolean): boolean {
-                return s;
-            }
-            export function return_object(): any {
-                return SYM;
-            }
+                export function foo(s) {
+                    assert.strictEqual(ARG, null);
+                    assert.strictEqual(s, "foo");
+                    ARG = s;
+                }
+                export function another(s) {
+                    assert.strictEqual(ANOTHER_ARG, null);
+                    assert.strictEqual(s, 21);
+                    ANOTHER_ARG = s;
+                    return 35;
+                }
+                export function take_and_return_bool(s) {
+                    return s;
+                }
+                export function return_object() {
+                    return SYM;
+                }
 
-            export function test() {
-                assert.strictEqual(ARG, null);
-                wasm.bar("foo");
-                assert.strictEqual(ARG, "foo");
+                export function test() {
+                    assert.strictEqual(ARG, null);
+                    wasm.bar("foo");
+                    assert.strictEqual(ARG, "foo");
 
-                assert.strictEqual(ANOTHER_ARG, null);
-                assert.strictEqual(wasm.another_thunk(21), 35);
-                assert.strictEqual(ANOTHER_ARG, 21);
+                    assert.strictEqual(ANOTHER_ARG, null);
+                    assert.strictEqual(wasm.another_thunk(21), 35);
+                    assert.strictEqual(ANOTHER_ARG, 21);
 
-                assert.strictEqual(wasm.bool_thunk(true), true);
-                assert.strictEqual(wasm.bool_thunk(false), false);
+                    assert.strictEqual(wasm.bool_thunk(true), true);
+                    assert.strictEqual(wasm.bool_thunk(false), false);
 
-                assert.strictEqual(wasm.get_the_object(), SYM);
-            }
-        "#,
+                    assert.strictEqual(wasm.get_the_object(), SYM);
+                }
+            "#,
         )
         .test();
 }
@@ -94,33 +94,33 @@ fn unused() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
-            #![allow(dead_code)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![allow(dead_code)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen(module = "./test")]
-            extern {
-                fn debug_print(s: &str);
-            }
+                #[wasm_bindgen(module = "./test")]
+                extern {
+                    fn debug_print(s: &str);
+                }
 
-            #[wasm_bindgen]
-            pub fn bar() {}
-        "#,
+                #[wasm_bindgen]
+                pub fn bar() {}
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import * as wasm from "./out";
+                import * as wasm from "./out";
 
-            export function debug_print() {}
+                export function debug_print() {}
 
-            export function test() {
-                wasm.bar();
-            }
-        "#,
+                export function test() {
+                    wasm.bar();
+                }
+            "#,
         )
         .test();
 }
@@ -131,36 +131,36 @@ fn string_ret() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen(module = "./test")]
-            extern {
-                fn foo() -> String;
-            }
+                #[wasm_bindgen(module = "./test")]
+                extern {
+                    fn foo() -> String;
+                }
 
-            #[wasm_bindgen]
-            pub fn run() {
-                assert_eq!(foo(), "bar");
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn run() {
+                    assert_eq!(foo(), "bar");
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import * as wasm from "./out";
+                import * as wasm from "./out";
 
-            export function foo(): string {
-                return 'bar';
-            }
+                export function foo() {
+                    return 'bar';
+                }
 
-            export function test() {
-                wasm.run();
-            }
-        "#,
+                export function test() {
+                    wasm.run();
+                }
+            "#,
         )
         .test();
 }
@@ -171,43 +171,43 @@ fn strings() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen(module = "./test")]
-            extern {
-                fn foo(a: String) -> String;
-            }
+                #[wasm_bindgen(module = "./test")]
+                extern {
+                    fn foo(a: String) -> String;
+                }
 
-            #[wasm_bindgen]
-            pub fn bar(a: &str) -> String {
-                foo(a.to_string())
-            }
+                #[wasm_bindgen]
+                pub fn bar(a: &str) -> String {
+                    foo(a.to_string())
+                }
 
-            #[wasm_bindgen]
-            pub fn bar2(a: String) -> String {
-                foo(a)
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn bar2(a: String) -> String {
+                    foo(a)
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import * as wasm from "./out";
-            import * as assert from "assert";
+                import * as wasm from "./out";
+                import * as assert from "assert";
 
-            export function foo(a: string): string {
-                return a + 'b';
-            }
+                export function foo(a) {
+                    return a + 'b';
+                }
 
-            export function test() {
-                assert.strictEqual(wasm.bar('a'), 'ab');
-                assert.strictEqual(wasm.bar2('a'), 'ab');
-            }
-        "#,
+                export function test() {
+                    assert.strictEqual(wasm.bar('a'), 'ab');
+                    assert.strictEqual(wasm.bar2('a'), 'ab');
+                }
+            "#,
         )
         .test();
 }
@@ -218,60 +218,60 @@ fn exceptions() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen(module = "./test")]
-            extern {
-                fn foo();
-                fn bar();
-                #[wasm_bindgen(catch)]
-                fn baz() -> Result<(), JsValue>;
-            }
+                #[wasm_bindgen(module = "./test")]
+                extern {
+                    fn foo();
+                    fn bar();
+                    #[wasm_bindgen(catch)]
+                    fn baz() -> Result<(), JsValue>;
+                }
 
-            #[wasm_bindgen]
-            pub fn run() {
-                foo();
-                bar();
-            }
+                #[wasm_bindgen]
+                pub fn run() {
+                    foo();
+                    bar();
+                }
 
-            #[wasm_bindgen]
-            pub fn run2() {
-                assert!(baz().is_err());
-                bar();
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn run2() {
+                    assert!(baz().is_err());
+                    bar();
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import { run, run2 } from "./out";
-            import * as assert from "assert";
+                import { run, run2 } from "./out";
+                import * as assert from "assert";
 
-            let called = false;
+                let called = false;
 
-            export function foo() {
-                throw new Error('error!');
-            }
+                export function foo() {
+                    throw new Error('error!');
+                }
 
-            export function baz() {
-                throw new Error('error2');
-            }
+                export function baz() {
+                    throw new Error('error2');
+                }
 
-            export function bar() {
-                called = true;
-            }
+                export function bar() {
+                    called = true;
+                }
 
-            export function test() {
-                assert.throws(run, /error!/);
-                assert.strictEqual(called, false);
-                run2();
-                assert.strictEqual(called, true);
-            }
-        "#,
+                export function test() {
+                    assert.throws(run, /error!/);
+                    assert.strictEqual(called, false);
+                    run2();
+                    assert.strictEqual(called, true);
+                }
+            "#,
         )
         .test();
 }
@@ -282,40 +282,40 @@ fn exn_caught() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen(module = "./test")]
-            extern {
-                #[wasm_bindgen(catch)]
-                fn foo() -> Result<(), JsValue>;
-            }
+                #[wasm_bindgen(module = "./test")]
+                extern {
+                    #[wasm_bindgen(catch)]
+                    fn foo() -> Result<(), JsValue>;
+                }
 
-            #[wasm_bindgen]
-            pub fn run() -> JsValue {
-                foo().unwrap_err()
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn run() -> JsValue {
+                    foo().unwrap_err()
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import { run } from "./out";
-            import * as assert from "assert";
+                import { run } from "./out";
+                import * as assert from "assert";
 
-            export function foo() {
-                throw new Error('error!');
-            }
+                export function foo() {
+                    throw new Error('error!');
+                }
 
-            export function test() {
-                const obj = run();
-                assert.strictEqual(obj instanceof Error, true);
-                assert.strictEqual(obj.message, 'error!');
-            }
-        "#,
+                export function test() {
+                    const obj = run();
+                    assert.strictEqual(obj instanceof Error, true);
+                    assert.strictEqual(obj.message, 'error!');
+                }
+            "#,
         )
         .test();
 }
@@ -326,32 +326,32 @@ fn free_imports() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen]
-            extern {
-                fn parseInt(a: &str) -> u32;
-            }
+                #[wasm_bindgen]
+                extern {
+                    fn parseInt(a: &str) -> u32;
+                }
 
-            #[wasm_bindgen]
-            pub fn run() {
-                assert_eq!(parseInt("3"), 3);
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn run() {
+                    assert_eq!(parseInt("3"), 3);
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import { run } from "./out";
+                import { run } from "./out";
 
-            export function test() {
-                run();
-            }
-        "#,
+                export function test() {
+                    run();
+                }
+            "#,
         )
         .test();
 }
@@ -363,34 +363,34 @@ fn import_a_field() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen(module = "./test")]
-            extern {
-                static IMPORT: JsValue;
-            }
+                #[wasm_bindgen(module = "./test")]
+                extern {
+                    static IMPORT: JsValue;
+                }
 
-            #[wasm_bindgen]
-            pub fn run() {
-                assert_eq!(IMPORT.as_f64(), Some(1.0));
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn run() {
+                    assert_eq!(IMPORT.as_f64(), Some(1.0));
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import { run } from "./out";
+                import { run } from "./out";
 
-            export const IMPORT = 1.0;
+                export const IMPORT = 1.0;
 
-            export function test() {
-                run();
-            }
-        "#,
+                export function test() {
+                    run();
+                }
+            "#,
         )
         .test();
 }
@@ -401,41 +401,41 @@ fn rename() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen(module = "./test")]
-            extern {
-                #[wasm_bindgen(js_name = baz)]
-                fn foo();
-            }
+                #[wasm_bindgen(module = "./test")]
+                extern {
+                    #[wasm_bindgen(js_name = baz)]
+                    fn foo();
+                }
 
-            #[wasm_bindgen]
-            pub fn run() {
-                foo();
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn run() {
+                    foo();
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import * as wasm from "./out";
-            import * as assert from "assert";
+                import * as wasm from "./out";
+                import * as assert from "assert";
 
-            let called = false;
+                let called = false;
 
-            export function baz() {
-                called = true;
-            }
+                export function baz() {
+                    called = true;
+                }
 
-            export function test() {
-                wasm.run();
-                assert.strictEqual(called, true);
-            }
-        "#,
+                export function test() {
+                    wasm.run();
+                    assert.strictEqual(called, true);
+                }
+            "#,
         )
         .test();
 }
@@ -443,49 +443,50 @@ fn rename() {
 #[test]
 fn versions() {
     project()
+        .debug(false)
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen(module = "webpack", version = "^0.2.0")]
-            extern {
-                fn foo();
-            }
+                #[wasm_bindgen(module = "webpack", version = "^0.2.0")]
+                extern {
+                    fn foo();
+                }
 
-            #[wasm_bindgen]
-            pub fn run() {
-                foo();
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn run() {
+                    foo();
+                }
+            "#,
         )
         .file(
             "test.js",
             r#"
-            const fs = require("fs");
-            const assert = require("assert");
+                import * as fs from 'fs';
+                import * as assert from 'assert';
 
-            exports.test = function() {
-                const bytes = fs.readFileSync('out_bg.wasm');
-                const m = new WebAssembly.Module(bytes);
-                const name = '__wasm_pack_unstable';
-                const sections = WebAssembly.Module.customSections(m, name);
-                assert.strictEqual(sections.length, 1);
-                const b = new Uint8Array(sections[0]);
-                const buf = new Buffer(b);
-                const map = JSON.parse(buf.toString());
-                assert.deepStrictEqual(map, {
-                    version: '0.0.1',
-                    modules: [
-                        ['webpack', '^0.2.0']
-                    ]
-                });
-            };
-        "#,
+                export function test() {
+                    const bytes = fs.readFileSync('out_bg.wasm');
+                    const m = new WebAssembly.Module(bytes);
+                    const name = '__wasm_pack_unstable';
+                    const sections = WebAssembly.Module.customSections(m, name);
+                    assert.strictEqual(sections.length, 1);
+                    const b = new Uint8Array(sections[0]);
+                    const buf = new Buffer(b);
+                    const map = JSON.parse(buf.toString());
+                    assert.deepStrictEqual(map, {
+                        version: '0.0.1',
+                        modules: [
+                            ['webpack', '^0.2.0']
+                        ]
+                    });
+                };
+            "#,
         )
         .test();
 }
@@ -511,10 +512,10 @@ fn underscore_pattern() {
                 foo(1);
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import { run } from "./out";
 
-            export function foo(_a: number) {
+            export function foo(_a) {
             }
 
             export function test() {
@@ -530,37 +531,37 @@ fn rust_keyword() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen(module = "./test")]
-            extern {
-                #[wasm_bindgen(js_name = self)]
-                fn foo() -> u32;
-            }
+                #[wasm_bindgen(module = "./test")]
+                extern {
+                    #[wasm_bindgen(js_name = self)]
+                    fn foo() -> u32;
+                }
 
-            #[wasm_bindgen]
-            pub fn run() {
-                assert_eq!(foo(), 2);
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn run() {
+                    assert_eq!(foo(), 2);
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import { run } from "./out";
+                import { run } from "./out";
 
-            export function self() {
-                return 2;
-            }
+                export function self() {
+                    return 2;
+                }
 
-            export function test() {
-                run();
-            }
-        "#,
+                export function test() {
+                    run();
+                }
+            "#,
         )
         .test();
 }
@@ -572,38 +573,38 @@ fn rust_keyword2() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen(module = "./test")]
-            extern {
-                pub type bar;
-                #[wasm_bindgen(js_namespace = bar, js_name = foo)]
-                static FOO: JsValue;
-            }
+                #[wasm_bindgen(module = "./test")]
+                extern {
+                    pub type bar;
+                    #[wasm_bindgen(js_namespace = bar, js_name = foo)]
+                    static FOO: JsValue;
+                }
 
-            #[wasm_bindgen]
-            pub fn run() {
-                assert_eq!(FOO.as_f64(), Some(3.0));
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn run() {
+                    assert_eq!(FOO.as_f64(), Some(3.0));
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import { run } from "./out";
+                import { run } from "./out";
 
-            export const bar = {
-                foo: 3,
-            };
+                export const bar = {
+                    foo: 3,
+                };
 
-            export function test() {
-                run();
-            }
-        "#,
+                export function test() {
+                    run();
+                }
+            "#,
         )
         .test();
 }
@@ -645,18 +646,18 @@ fn custom_type() {
                 bad2();
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import { run, Foo, bad } from "./out";
 
-            let VAL: any = null;
+            let VAL = null;
 
-            export function foo(f: Foo): Foo {
+            export function foo(f) {
                 VAL = f;
                 return f;
             }
 
-            export function bad2(): number {
+            export function bad2() {
                 return 2;
             }
 
@@ -691,7 +692,7 @@ fn unused_imports_not_generated() {
             pub fn run() {
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import { run } from "./out";
 
             export function test() {
diff --git a/tests/all/js_globals/Array.rs b/tests/all/js_globals/Array.rs
index 13f13d60..33b01723 100644
--- a/tests/all/js_globals/Array.rs
+++ b/tests/all/js_globals/Array.rs
@@ -22,7 +22,7 @@ fn filter() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -61,7 +61,7 @@ fn index_of() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -104,27 +104,27 @@ fn is_array() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
             export function test() {
-                assert(wasm.is_array([]));
-                assert(wasm.is_array([1]));
-                assert(wasm.is_array(new Array()));
-                assert(wasm.is_array(new Array('a', 'b', 'c', 'd')));
-                assert(wasm.is_array(new Array(3)));
-                assert(wasm.is_array(Array.prototype));
+                assert.ok(wasm.is_array([]));
+                assert.ok(wasm.is_array([1]));
+                assert.ok(wasm.is_array(new Array()));
+                assert.ok(wasm.is_array(new Array('a', 'b', 'c', 'd')));
+                assert.ok(wasm.is_array(new Array(3)));
+                assert.ok(wasm.is_array(Array.prototype));
 
-                assert(!wasm.is_array({}));
-                assert(!wasm.is_array(null));
-                assert(!wasm.is_array(undefined));
-                assert(!wasm.is_array(17));
-                assert(!wasm.is_array('Array'));
-                assert(!wasm.is_array(true));
-                assert(!wasm.is_array(false));
-                assert(!wasm.is_array({ __proto__: Array.prototype }));
+                assert.ok(!wasm.is_array({}));
+                assert.ok(!wasm.is_array(null));
+                assert.ok(!wasm.is_array(undefined));
+                assert.ok(!wasm.is_array(17));
+                assert.ok(!wasm.is_array('Array'));
+                assert.ok(!wasm.is_array(true));
+                assert.ok(!wasm.is_array(false));
+                assert.ok(!wasm.is_array({ __proto__: Array.prototype }));
             }
         "#,
         )
@@ -151,7 +151,7 @@ fn sort() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -183,7 +183,7 @@ fn some() {
             }
 
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -218,7 +218,7 @@ fn last_index_of() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -262,7 +262,7 @@ fn join() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -299,7 +299,7 @@ fn slice() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -335,7 +335,7 @@ fn fill() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -368,7 +368,7 @@ fn copy_within() {
             }
 
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -406,7 +406,7 @@ fn pop() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -442,7 +442,7 @@ fn push() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -478,7 +478,7 @@ fn reverse() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -514,7 +514,7 @@ fn shift() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -551,7 +551,7 @@ fn unshift() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -588,7 +588,7 @@ fn to_string() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -624,7 +624,7 @@ fn includes() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -665,7 +665,7 @@ fn concat() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -702,20 +702,20 @@ fn length() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import * as assert from "assert";
-            import * as wasm from "./out";
+                import * as assert from "assert";
+                import * as wasm from "./out";
 
-            export function test() {
-                let characters = [8, 5, 4, 3, 1, 2]
-                let charactersLength = wasm.array_length(characters);
-                assert.equal(charactersLength, 6);
+                export function test() {
+                    let characters = [8, 5, 4, 3, 1, 2]
+                    let charactersLength = wasm.array_length(characters);
+                    assert.equal(charactersLength, 6);
 
-                var empty : number[] = [];
-                let emptyLength = wasm.array_length(empty);
-                assert.equal(emptyLength, 0);
-            }
+                    var empty = [];
+                    let emptyLength = wasm.array_length(empty);
+                    assert.equal(emptyLength, 0);
+                }
         "#,
         )
         .test()
@@ -727,34 +727,72 @@ fn every() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section)]
+                #![feature(proc_macro, wasm_custom_section)]
 
-            extern crate wasm_bindgen;
-            use wasm_bindgen::prelude::*;
-            use wasm_bindgen::js;
+                extern crate wasm_bindgen;
+                use wasm_bindgen::prelude::*;
+                use wasm_bindgen::js;
 
-            #[wasm_bindgen]
-            pub fn array_every_number_is_even(array: &js::Array) -> bool {
-                array.every(&mut |el, _, _| el.as_f64().unwrap() % 2f64 == 0f64)
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn array_every_number_is_even(array: &js::Array) -> bool {
+                    array.every(&mut |el, _, _| el.as_f64().unwrap() % 2f64 == 0f64)
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import * as assert from "assert";
-            import * as wasm from "./out";
+                import * as assert from "assert";
+                import * as wasm from "./out";
 
-            export function test() {
-                const arrayEven = [2, 4, 6, 8];
-                const arrayOdd = [1, 3, 5, 7];
-                const arrayMixed = [2, 3, 4, 5];
+                export function test() {
+                    const arrayEven = [2, 4, 6, 8];
+                    const arrayOdd = [1, 3, 5, 7];
+                    const arrayMixed = [2, 3, 4, 5];
 
-                assert(wasm.array_every_number_is_even(arrayEven));
-                assert(!wasm.array_every_number_is_even(arrayOdd));
-                assert(!wasm.array_every_number_is_even(arrayMixed));
-            }
-        "#,
+                    assert.ok(wasm.array_every_number_is_even(arrayEven));
+                    assert.ok(!wasm.array_every_number_is_even(arrayOdd));
+                    assert.ok(!wasm.array_every_number_is_even(arrayMixed));
+                }
+            "#,
+        )
+        .test()
+}
+
+#[test]
+fn find() {
+    project()
+        .file(
+            "src/lib.rs",
+            r#"
+                #![feature(proc_macro, wasm_custom_section)]
+
+                extern crate wasm_bindgen;
+                use wasm_bindgen::prelude::*;
+                use wasm_bindgen::js;
+
+                #[wasm_bindgen]
+                pub fn array_find_first_even_number(array: &js::Array) -> JsValue {
+                    array.find(&mut |el, _, _| el.as_f64().unwrap() % 2f64 == 0f64)
+                }
+            "#,
+        )
+        .file(
+            "test.js",
+            r#"
+                import * as assert from "assert";
+                import * as wasm from "./out";
+
+                export function test() {
+                    const arrayEven = [2, 4, 6, 8];
+                    const arrayOdd = [1, 3, 5, 7];
+                    const arrayMixed = [3, 5, 7, 10];
+
+                    assert.equal(wasm.array_find_first_even_number(arrayEven), 2);
+                    assert.equal(wasm.array_find_first_even_number(arrayOdd), undefined);
+                    assert.equal(wasm.array_find_first_even_number(arrayMixed), 10);
+                }
+            "#,
         )
         .test()
 }
diff --git a/tests/all/js_globals/ArrayBuffer.rs b/tests/all/js_globals/ArrayBuffer.rs
new file mode 100644
index 00000000..aa088663
--- /dev/null
+++ b/tests/all/js_globals/ArrayBuffer.rs
@@ -0,0 +1,110 @@
+#![allow(non_snake_case)]
+
+use super::project;
+
+#[test]
+fn new() {
+    project()
+        .file("src/lib.rs", r#"
+            #![feature(proc_macro, wasm_custom_section)]
+
+            extern crate wasm_bindgen;
+            use wasm_bindgen::prelude::*;
+            use wasm_bindgen::js::ArrayBuffer;
+
+            #[wasm_bindgen]
+            pub fn new_arraybuffer() -> ArrayBuffer {
+                ArrayBuffer::new(42)
+            }
+        "#)
+        .file("test.js", r#"
+            import * as assert from "assert";
+            import * as wasm from "./out";
+
+            export function test() {
+                assert.equal(typeof wasm.new_arraybuffer(), "object");
+            }
+        "#)
+        .test()
+}
+
+#[test]
+fn is_view() {
+    project()
+        .file("src/lib.rs", r#"
+            #![feature(proc_macro, wasm_custom_section)]
+
+            extern crate wasm_bindgen;
+            use JsValue;
+            use wasm_bindgen::prelude::*;
+            use wasm_bindgen::js::ArrayBuffer;
+
+            #[wasm_bindgen]
+            pub fn is_view(value: JsValue) -> bool {
+                ArrayBuffer::is_view(value)
+            }
+        "#)
+        .file("test.js", r#"
+            import * as assert from "assert";
+            import * as wasm from "./out";
+
+            export function test() {
+                assert.equal(wasm.is_view(new Uint8Array(42)), true);
+            }
+        "#)
+        .test()
+}
+
+#[test]
+fn slice() {
+    project()
+        .file("src/lib.rs", r#"
+            #![feature(proc_macro, wasm_custom_section)]
+
+            extern crate wasm_bindgen;
+            use wasm_bindgen::prelude::*;
+            use wasm_bindgen::js::ArrayBuffer;
+
+            #[wasm_bindgen]
+            pub fn slice(arraybuffer: &ArrayBuffer, begin: u32) -> ArrayBuffer {
+                arraybuffer.slice(begin)
+            }
+        "#)
+        .file("test.js", r#"
+            import * as assert from "assert";
+            import * as wasm from "./out";
+
+            export function test() {
+                const arraybuffer = new ArrayBuffer(4);
+                assert.equal(typeof wasm.slice(arraybuffer, 2), "object");
+            }
+        "#)
+        .test()
+}
+
+#[test]
+fn slice_with_end() {
+    project()
+        .file("src/lib.rs", r#"
+            #![feature(proc_macro, wasm_custom_section)]
+
+            extern crate wasm_bindgen;
+            use wasm_bindgen::prelude::*;
+            use wasm_bindgen::js::ArrayBuffer;
+
+            #[wasm_bindgen]
+            pub fn slice_with_end(arraybuffer: &ArrayBuffer, begin: u32, end: u32) -> ArrayBuffer {
+                arraybuffer.slice_with_end(begin, end)
+            }
+        "#)
+        .file("test.js", r#"
+            import * as assert from "assert";
+            import * as wasm from "./out";
+
+            export function test() {
+                const arraybuffer = new ArrayBuffer(4);
+                assert.equal(typeof wasm.slice_with_end(arraybuffer, 1, 2), "object");
+            }
+        "#)
+        .test()
+}
diff --git a/tests/all/js_globals/ArrayIterator.rs b/tests/all/js_globals/ArrayIterator.rs
index c31912f6..959e9d9e 100644
--- a/tests/all/js_globals/ArrayIterator.rs
+++ b/tests/all/js_globals/ArrayIterator.rs
@@ -22,7 +22,7 @@ fn keys() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -60,7 +60,7 @@ fn entries() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
diff --git a/tests/all/js_globals/Boolean.rs b/tests/all/js_globals/Boolean.rs
index aea23d36..d48e9010 100644
--- a/tests/all/js_globals/Boolean.rs
+++ b/tests/all/js_globals/Boolean.rs
@@ -21,7 +21,7 @@ fn new_undefined() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -53,7 +53,7 @@ fn new_truely() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
diff --git a/tests/all/js_globals/Date.rs b/tests/all/js_globals/Date.rs
old mode 100644
new mode 100755
index cdabfd9a..9c7dab9a
--- a/tests/all/js_globals/Date.rs
+++ b/tests/all/js_globals/Date.rs
@@ -2,6 +2,110 @@
 
 use super::project;
 
+#[test]
+fn get_date() {
+    project()
+        .file(
+            "src/lib.rs",
+            r#"
+            #![feature(proc_macro, wasm_custom_section)]
+
+            extern crate wasm_bindgen;
+            use wasm_bindgen::prelude::*;
+            use wasm_bindgen::js::Date;
+
+            #[wasm_bindgen]
+            pub fn get_date(this: &Date) -> u32 {
+                this.get_date()
+            }
+        "#,
+        )
+        .file(
+            "test.js",
+            r#"
+            import * as assert from "assert";
+            import * as wasm from "./out";
+
+            export function test() {
+                let date = new Date(1993, 6, 28, 14, 39, 7);
+
+                assert.equal(wasm.get_date(date), 28);
+            }
+        "#,
+        )
+        .test()
+}
+
+#[test]
+fn get_day() {
+    project()
+        .file(
+            "src/lib.rs",
+            r#"
+            #![feature(proc_macro, wasm_custom_section)]
+
+            extern crate wasm_bindgen;
+            use wasm_bindgen::prelude::*;
+            use wasm_bindgen::js::Date;
+
+            #[wasm_bindgen]
+            pub fn get_day(this: &Date) -> u32 {
+                this.get_day()
+            }
+        "#,
+        )
+        .file(
+            "test.js",
+            r#"
+            import * as assert from "assert";
+            import * as wasm from "./out";
+
+            export function test() {
+                let date = new Date('August 19, 1975 23:15:30');
+
+                assert.equal(wasm.get_day(date), 2);
+            }
+        "#,
+        )
+        .test()
+}
+
+#[test]
+fn get_full_year() {
+    project()
+        .file(
+            "src/lib.rs",
+            r#"
+            #![feature(proc_macro, wasm_custom_section)]
+
+            extern crate wasm_bindgen;
+            use wasm_bindgen::prelude::*;
+            use wasm_bindgen::js::Date;
+
+            #[wasm_bindgen]
+            pub fn get_full_year(this: &Date) -> u32 {
+                this.get_full_year()
+            }
+        "#,
+        )
+        .file(
+            "test.js",
+            r#"
+            import * as assert from "assert";
+            import * as wasm from "./out";
+
+            export function test() {
+                let date = new Date('July 20, 1969 00:20:18');
+                let abbrDate = new Date('Thu, 06 Sep 12 00:00:00');
+
+                assert.equal(wasm.get_full_year(date), 1969);
+                assert.equal(wasm.get_full_year(abbrDate), 2012);
+            }
+        "#,
+        )
+        .test()
+}
+
 #[test]
 fn new() {
     project()
@@ -21,7 +125,7 @@ fn new() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -49,7 +153,7 @@ fn now() {
                 Date::now()
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -79,7 +183,7 @@ fn to_date_string() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -113,7 +217,7 @@ fn to_iso_string() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -147,7 +251,7 @@ fn to_json() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -178,7 +282,7 @@ fn to_locale_date_string() {
                 this.to_locale_date_string(locale, options)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -186,7 +290,9 @@ fn to_locale_date_string() {
                 let date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
                 let options = { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' };
 
-                assert.equal(wasm.to_locale_date_string(date, 'de-DE', options), 'Thursday, December 20, 2012');
+                let output = wasm.to_locale_date_string(date, 'de-DE', options)
+                assert.equal(typeof output, 'string');
+                assert.ok(output.length > 0);
             }
         "#)
         .test()
@@ -208,13 +314,15 @@ fn to_locale_string() {
                 this.to_locale_string(locale, options)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
             export function test() {
                 let date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
-                assert.equal(wasm.to_locale_string(date, 'en-GB', { timeZone: 'UTC' }), "12/20/2012, 3:00:00 AM");
+                let output = wasm.to_locale_string(date, 'en-GB', { timeZone: 'UTC' });
+                assert.equal(typeof output, 'string');
+                assert.ok(output.length > 0);
             }
         "#)
         .test()
@@ -239,7 +347,7 @@ fn to_locale_time_string() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -272,7 +380,7 @@ fn to_string() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -305,7 +413,7 @@ fn to_time_string() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -338,7 +446,7 @@ fn to_utc_string() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -367,7 +475,7 @@ fn utc() {
                 Date::utc(2018f64, 6f64)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -397,7 +505,7 @@ fn value_of() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
diff --git a/tests/all/js_globals/Error.rs b/tests/all/js_globals/Error.rs
index bf2918a0..9e2700c1 100644
--- a/tests/all/js_globals/Error.rs
+++ b/tests/all/js_globals/Error.rs
@@ -18,7 +18,7 @@ fn new() {
                 Error::new(message)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -48,7 +48,7 @@ fn message() {
                 this.message()
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -78,7 +78,7 @@ fn set_message() {
                 this.set_message(message);
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -109,7 +109,7 @@ fn name() {
                 this.name()
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -140,7 +140,7 @@ fn set_name() {
                 this.set_name(name);
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -171,7 +171,7 @@ fn to_string() {
                 this.to_string()
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -180,13 +180,13 @@ fn to_string() {
 
                 assert.equal(wasm.error_to_string(error), 'Error: error message 1');
 
-                (error.name as any) = undefined;
+                error.name = undefined;
                 assert.equal(wasm.error_to_string(error), 'Error: error message 1');
 
                 error.name = 'error_name_1';
                 assert.equal(wasm.error_to_string(error), 'error_name_1: error message 1');
 
-                (error.message as any) = undefined;
+                error.message = undefined;
                 assert.equal(wasm.error_to_string(error), 'error_name_1');
 
                 error.name = 'error_name_2';
diff --git a/tests/all/js_globals/Function.rs b/tests/all/js_globals/Function.rs
index b5f32d5b..43f7ba16 100644
--- a/tests/all/js_globals/Function.rs
+++ b/tests/all/js_globals/Function.rs
@@ -21,7 +21,7 @@ fn apply() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -57,7 +57,7 @@ fn bind() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -97,21 +97,21 @@ fn length() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
             export function test() {
                 assert.equal(wasm.fn_length(() => {}), 0);
-                assert.equal(wasm.fn_length((a: string) => console.log(a)), 1);
-                assert.equal(wasm.fn_length((a: string, b: string) => console.log({ a, b })), 2);
+                assert.equal(wasm.fn_length(a => console.log(a)), 1);
+                assert.equal(wasm.fn_length((a, b) => console.log({ a, b })), 2);
 
                 function fn0() {}
-                function fn1(a: string) {
+                function fn1(a) {
                     console.log(a);
                 }
-                function fn2(a: string, b: string) {
+                function fn2(a, b) {
                     console.log({ a, b });
                 }
 
@@ -143,7 +143,7 @@ fn name() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -190,17 +190,17 @@ fn to_string() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
             export function test() {
-                function fn1(a: any, b: any) { return a + b }
-                const fn2 = (a: number) => console.log(a);
+                function fn1(a, b) { return a + b; }
+                const fn2 = a => console.log(a);
 
                 assert.equal(wasm.get_source_code(fn1), 'function fn1(a, b) { return a + b; }');
-                assert.equal(wasm.get_source_code(fn2), 'function (a) { return console.log(a); }');
+                assert.equal(wasm.get_source_code(fn2), 'a => console.log(a)');
             }
         "#,
         )
diff --git a/tests/all/js_globals/Generator.rs b/tests/all/js_globals/Generator.rs
index 315e0e82..1217bd8c 100644
--- a/tests/all/js_globals/Generator.rs
+++ b/tests/all/js_globals/Generator.rs
@@ -8,40 +8,40 @@ fn return_() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section)]
+                #![feature(proc_macro, wasm_custom_section)]
 
-            extern crate wasm_bindgen;
-            use wasm_bindgen::prelude::*;
-            use wasm_bindgen::js;
+                extern crate wasm_bindgen;
+                use wasm_bindgen::prelude::*;
+                use wasm_bindgen::js;
 
-            #[wasm_bindgen]
-            pub fn gen_return(this: &js::Generator, value: &JsValue) -> JsValue {
-                this.return_(value)
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn gen_return(this: &js::Generator, value: &JsValue) -> JsValue {
+                    this.return_(value)
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import * as assert from "assert";
-            import * as wasm from "./out";
+                import * as assert from "assert";
+                import * as wasm from "./out";
 
-            export function test() {
-                function* generator() {
-                    yield 1;
-                    yield 2;
+                export function test() {
+                    function* generator() {
+                        yield 1;
+                        yield 2;
+                    }
+
+                    const gen = generator();
+                    gen.next();
+
+                    const res = wasm.gen_return(gen, 42);
+                    assert.deepEqual(res, { value: 42, done: true });
+
+                    const next = gen.next();
+                    assert.deepEqual(next, { value: undefined, done: true });
                 }
-
-                const gen = generator();
-                gen.next();
-
-                const res = wasm.gen_return(gen, 42);
-                assert.deepEqual(res, { value: 42, done: true });
-
-                const next = gen.next();
-                assert.deepEqual(next, { value: undefined, done: true });
-            }
-        "#,
+            "#,
         )
         .test()
 }
@@ -52,54 +52,54 @@ fn next() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section)]
+                #![feature(proc_macro, wasm_custom_section)]
 
-            extern crate wasm_bindgen;
-            use wasm_bindgen::prelude::*;
-            use wasm_bindgen::js;
+                extern crate wasm_bindgen;
+                use wasm_bindgen::prelude::*;
+                use wasm_bindgen::js;
 
-            #[wasm_bindgen]
-            pub fn next(this: &js::Generator, value: &JsValue) -> JsValue {
-                this.next(value)
-                    .ok()
-                    .expect("generator throws an error")
-            }
+                #[wasm_bindgen]
+                pub fn next(this: &js::Generator, value: &JsValue) -> JsValue {
+                    this.next(value)
+                        .ok()
+                        .expect("generator throws an error")
+                }
 
-            #[wasm_bindgen]
-            pub fn next_throws_error(this: &js::Generator, value: &JsValue) -> bool {
-                this.next(value).is_err()
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn next_throws_error(this: &js::Generator, value: &JsValue) -> bool {
+                    this.next(value).is_err()
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import * as assert from "assert";
-            import * as wasm from "./out";
+                import * as assert from "assert";
+                import * as wasm from "./out";
 
-            export function test() {
-                function* generator() {
-                    const reply = yield '2 * 2';
+                export function test() {
+                    function* generator() {
+                        const reply = yield '2 * 2';
 
-                    return reply === 4;
+                        return reply === 4;
+                    }
+
+                    const gen = generator();
+
+                    const q = wasm.next(gen, undefined);
+                    assert.deepEqual(q, { value: '2 * 2', done: false });
+
+                    const a = wasm.next(gen, 4);
+                    assert.deepEqual(a, { value: true, done: true });
+
+                    function* brokenGenerator() {
+                        throw new Error('Something went wrong');
+                        yield 1;
+                    }
+
+                    assert.ok(wasm.next_throws_error(brokenGenerator(), undefined));
                 }
-
-                const gen = generator();
-
-                const q = wasm.next(gen, undefined);
-                assert.deepEqual(q, { value: '2 * 2', done: false });
-
-                const a = wasm.next(gen, 4);
-                assert.deepEqual(a, { value: true, done: true });
-
-                function* brokenGenerator() {
-                    throw new Error('Something went wrong');
-                    yield 1;
-                }
-
-                assert(wasm.next_throws_error(brokenGenerator(), undefined));
-            }
-        "#,
+            "#,
         )
         .test()
 }
@@ -110,37 +110,37 @@ fn throw() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section)]
+                #![feature(proc_macro, wasm_custom_section)]
 
-            extern crate wasm_bindgen;
-            use wasm_bindgen::prelude::*;
-            use wasm_bindgen::js;
+                extern crate wasm_bindgen;
+                use wasm_bindgen::prelude::*;
+                use wasm_bindgen::js;
 
-            #[wasm_bindgen]
-            pub fn gen_throws_error(this: &js::Generator, error: &js::Error) -> bool {
-                this.throw(error).is_err()
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn gen_throws_error(this: &js::Generator, error: &js::Error) -> bool {
+                    this.throw(error).is_err()
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import * as assert from "assert";
-            import * as wasm from "./out";
+                import * as assert from "assert";
+                import * as wasm from "./out";
 
-            export function test() {
-                function* generator() {
-                    yield 1;
-                    yield 2;
+                export function test() {
+                    function* generator() {
+                        yield 1;
+                        yield 2;
+                    }
+
+                    const gen = generator();
+                    gen.next();
+
+                    assert.ok(wasm.gen_throws_error(gen, new Error('Something went wrong')));
+                    assert.deepEqual(gen.next(), { value: undefined, done: true });
                 }
-
-                const gen = generator();
-                gen.next();
-
-                assert(wasm.gen_throws_error(gen, new Error('Something went wrong')));
-                assert.deepEqual(gen.next(), { value: undefined, done: true });
-            }
-        "#,
+            "#,
         )
         .test()
 }
diff --git a/tests/all/js_globals/JsString.rs b/tests/all/js_globals/JsString.rs
old mode 100644
new mode 100755
index 0c937444..1005a842
--- a/tests/all/js_globals/JsString.rs
+++ b/tests/all/js_globals/JsString.rs
@@ -22,7 +22,7 @@ fn length() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -58,7 +58,7 @@ fn char_at() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -87,13 +87,13 @@ fn char_code_at() {
             use wasm_bindgen::js;
 
             #[wasm_bindgen]
-            pub fn string_char_code_at(this: &js::JsString, index: u32) -> js::Number {
+            pub fn string_char_code_at(this: &js::JsString, index: u32) -> f64 {
                 this.char_code_at(index)
             }
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -101,8 +101,14 @@ fn char_code_at() {
             var anyString = 'Brave new world';
 
             export function test() {
-                assert.equal(wasm.string_char_code_at(anyString, 0), 66);
-                assert.ok(isNaN(wasm.string_char_code_at(anyString, 999)));
+                for (let i = 0; i < anyString.length; i++) {
+                    assert.equal(wasm.string_char_code_at(anyString, i),
+                                 anyString.charCodeAt(i),
+                                 `charCodeAt(${i})`);
+                }
+
+                const outOfBounds = wasm.string_char_code_at(anyString, 999);
+                assert.ok(Number.isNaN(outOfBounds));
             }
         "#,
         )
@@ -128,7 +134,7 @@ fn code_point_at() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -162,7 +168,7 @@ fn concat() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -196,7 +202,7 @@ fn includes() {
                 this.includes(search_value, position)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -231,7 +237,7 @@ fn index_of() {
                 this.index_of(search_value, from_index)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -274,7 +280,7 @@ fn slice() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -305,7 +311,7 @@ fn starts_with() {
                 this.starts_with(search_string, position)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -336,7 +342,7 @@ fn substring() {
                 this.substring(index_start, index_end)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -375,7 +381,7 @@ fn substr() {
                 this.substr(start, length)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -411,7 +417,7 @@ fn to_lower_case() {
                 this.to_lower_case()
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -441,7 +447,7 @@ fn to_string() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -470,7 +476,7 @@ fn to_upper_case() {
                 this.to_upper_case()
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -500,7 +506,7 @@ fn trim() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -539,7 +545,7 @@ fn trim_end_and_trim_right() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -579,7 +585,7 @@ fn trim_start_and_trim_left() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -614,7 +620,7 @@ fn value_of() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
diff --git a/tests/all/js_globals/Map.rs b/tests/all/js_globals/Map.rs
old mode 100644
new mode 100755
index 522e7fde..54edbeae
--- a/tests/all/js_globals/Map.rs
+++ b/tests/all/js_globals/Map.rs
@@ -17,7 +17,7 @@ fn clear() {
                 this.clear();
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -49,7 +49,7 @@ fn delete() {
                 this.delete(key)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -81,7 +81,7 @@ fn get() {
                 this.get(key)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -112,7 +112,7 @@ fn has() {
                 this.has(key)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -141,7 +141,7 @@ fn new() {
                 js::Map::new()
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -169,7 +169,7 @@ fn set() {
                 this.set(key, value)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -194,11 +194,11 @@ fn size() {
             use wasm_bindgen::js;
 
             #[wasm_bindgen]
-            pub fn map_size(this: &js::Map) -> js::Number {
+            pub fn map_size(this: &js::Map) -> u32 {
                 this.size()
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -210,4 +210,4 @@ fn size() {
             }
         "#)
         .test()
-}
\ No newline at end of file
+}
diff --git a/tests/all/js_globals/MapIterator.rs b/tests/all/js_globals/MapIterator.rs
index 0bc79e25..b1805191 100644
--- a/tests/all/js_globals/MapIterator.rs
+++ b/tests/all/js_globals/MapIterator.rs
@@ -18,7 +18,7 @@ fn entries() {
                 this.entries()
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -50,7 +50,7 @@ fn keys() {
                 this.keys()
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -82,7 +82,7 @@ fn values() {
                 this.values()
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -97,4 +97,4 @@ fn values() {
             }
         "#)
         .test()
-}
\ No newline at end of file
+}
diff --git a/tests/all/js_globals/Math.rs b/tests/all/js_globals/Math.rs
old mode 100644
new mode 100755
index 46788cb6..a81e6e09
--- a/tests/all/js_globals/Math.rs
+++ b/tests/all/js_globals/Math.rs
@@ -15,13 +15,13 @@ fn abs() {
             use wasm_bindgen::js;
 
             #[wasm_bindgen]
-            pub fn abs(x: f64) -> js::Number {
+            pub fn abs(x: f64) -> f64 {
                 js::Math::abs(x)
             }
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -49,13 +49,13 @@ fn acos() {
             use wasm_bindgen::js;
 
             #[wasm_bindgen]
-            pub fn acos(x: f64) -> js::Number {
+            pub fn acos(x: f64) -> f64 {
                 js::Math::acos(x)
             }
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -63,7 +63,7 @@ fn acos() {
             export function test() {
                 assert.equal(wasm.acos(-1), Math.PI);
                 assert.equal(wasm.acos(0.5), 1.0471975511965979);
-                assert(Number.isNaN(wasm.acos(2)));
+                assert.ok(Number.isNaN(wasm.acos(2)));
             }
         "#,
         )
@@ -83,13 +83,13 @@ fn acosh() {
             use wasm_bindgen::js;
 
             #[wasm_bindgen]
-            pub fn acosh(x: f64) -> js::Number {
+            pub fn acosh(x: f64) -> f64 {
                 js::Math::acosh(x)
             }
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -97,7 +97,7 @@ fn acosh() {
             export function test() {
                 assert.equal(wasm.acosh(1), 0);
                 assert.equal(wasm.acosh(2), Math.acosh(2));
-                assert(Number.isNaN(wasm.acosh(0.5)));
+                assert.ok(Number.isNaN(wasm.acosh(0.5)));
             }
         "#,
         )
@@ -117,13 +117,13 @@ fn asin() {
             use wasm_bindgen::js;
 
             #[wasm_bindgen]
-            pub fn asin(x: f64) -> js::Number {
+            pub fn asin(x: f64) -> f64 {
                 js::Math::asin(x)
             }
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -131,7 +131,7 @@ fn asin() {
             export function test() {
                 assert.equal(wasm.asin(1), Math.asin(1));
                 assert.equal(wasm.asin(0.5), Math.asin(0.5));
-                assert(Number.isNaN(wasm.asin(2)));
+                assert.ok(Number.isNaN(wasm.asin(2)));
             }
         "#,
         )
@@ -151,13 +151,13 @@ fn asinh() {
             use wasm_bindgen::js;
 
             #[wasm_bindgen]
-            pub fn asinh(x: f64) -> js::Number {
+            pub fn asinh(x: f64) -> f64 {
                 js::Math::asinh(x)
             }
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -184,13 +184,13 @@ fn atan() {
             use wasm_bindgen::js;
 
             #[wasm_bindgen]
-            pub fn atan(x: f64) -> js::Number {
+            pub fn atan(x: f64) -> f64 {
                 js::Math::atan(x)
             }
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -217,13 +217,13 @@ fn atan2() {
             use wasm_bindgen::js;
 
             #[wasm_bindgen]
-            pub fn atan2(y: f64, x: f64) -> js::Number {
+            pub fn atan2(y: f64, x: f64) -> f64 {
                 js::Math::atan2(y, x)
             }
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -250,13 +250,13 @@ fn atanh() {
             use wasm_bindgen::js;
 
             #[wasm_bindgen]
-            pub fn atanh(x: f64) -> js::Number {
+            pub fn atanh(x: f64) -> f64 {
                 js::Math::atanh(x)
             }
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -264,7 +264,7 @@ fn atanh() {
             export function test() {
                 assert.equal(wasm.atanh(1), Math.atanh(1));
                 assert.equal(wasm.atanh(0.5), Math.atanh(0.5));
-                assert(Number.isNaN(wasm.atanh(2)));
+                assert.ok(Number.isNaN(wasm.atanh(2)));
             }
         "#,
         )
@@ -284,13 +284,13 @@ fn cbrt() {
             use wasm_bindgen::js;
 
             #[wasm_bindgen]
-            pub fn cbrt(x: f64) -> js::Number {
+            pub fn cbrt(x: f64) -> f64 {
                 js::Math::cbrt(x)
             }
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -317,13 +317,13 @@ fn ceil() {
             use wasm_bindgen::js;
 
             #[wasm_bindgen]
-            pub fn ceil(x: f64) -> js::Number {
+            pub fn ceil(x: f64) -> i32 {
                 js::Math::ceil(x)
             }
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -350,13 +350,13 @@ fn clz32() {
             use wasm_bindgen::js;
 
             #[wasm_bindgen]
-            pub fn clz32(x: i32) -> js::Number {
+            pub fn clz32(x: i32) -> u32 {
                 js::Math::clz32(x)
             }
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -381,11 +381,11 @@ fn cos() {
             use wasm_bindgen::js;
 
             #[wasm_bindgen]
-            pub fn cos(x: f64) -> js::Number {
+            pub fn cos(x: f64) -> f64 {
                 js::Math::cos(x)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -408,11 +408,11 @@ fn cosh() {
             use wasm_bindgen::js;
 
             #[wasm_bindgen]
-            pub fn cosh(x: f64) -> js::Number {
+            pub fn cosh(x: f64) -> f64 {
                 js::Math::cosh(x)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -435,11 +435,11 @@ fn exp() {
             use wasm_bindgen::js;
 
             #[wasm_bindgen]
-            pub fn exp(x: f64) -> js::Number {
+            pub fn exp(x: f64) -> f64 {
                 js::Math::exp(x)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -463,11 +463,11 @@ fn expm1() {
             use wasm_bindgen::js;
 
             #[wasm_bindgen]
-            pub fn expm1(x: f64) -> js::Number {
+            pub fn expm1(x: f64) -> f64 {
                 js::Math::expm1(x)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -494,13 +494,13 @@ fn floor() {
             use wasm_bindgen::js;
 
             #[wasm_bindgen]
-            pub fn floor(x: f64) -> js::Number {
+            pub fn floor(x: f64) -> i32 {
                 js::Math::floor(x)
             }
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -525,11 +525,11 @@ fn fround() {
             use wasm_bindgen::js;
 
             #[wasm_bindgen]
-            pub fn fround(x: f64) -> js::Number {
+            pub fn fround(x: f64) -> f32 {
                 js::Math::fround(x)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -554,11 +554,11 @@ fn imul() {
             use wasm_bindgen::js;
 
             #[wasm_bindgen]
-            pub fn imul(x: i32, y:i32) -> js::Number {
+            pub fn imul(x: i32, y:i32) -> i32 {
                 js::Math::imul(x, y)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -582,11 +582,11 @@ fn log() {
             use wasm_bindgen::js;
 
             #[wasm_bindgen]
-            pub fn log(x: f64) -> js::Number {
+            pub fn log(x: f64) -> f64 {
                 js::Math::log(x)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -609,11 +609,11 @@ fn log10() {
             use wasm_bindgen::js;
 
             #[wasm_bindgen]
-            pub fn log10(x: f64) -> js::Number {
+            pub fn log10(x: f64) -> f64 {
                 js::Math::log10(x)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -637,11 +637,11 @@ fn log1p() {
             use wasm_bindgen::js;
 
             #[wasm_bindgen]
-            pub fn log1p(x: f64) -> js::Number {
+            pub fn log1p(x: f64) -> f64 {
                 js::Math::log1p(x)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -649,7 +649,7 @@ fn log1p() {
                 assert.equal(wasm.log1p(1), 0.6931471805599453);
                 assert.equal(wasm.log1p(0), 0);
                 assert.equal(wasm.log1p(-1), -Infinity);
-                assert(isNaN(wasm.log1p(-2)));
+                assert.ok(isNaN(wasm.log1p(-2)));
             }
         "#)
         .test()
@@ -666,11 +666,11 @@ fn log2() {
             use wasm_bindgen::js;
 
             #[wasm_bindgen]
-            pub fn log2(x: f64) -> js::Number {
+            pub fn log2(x: f64) -> f64 {
                 js::Math::log2(x)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -695,18 +695,18 @@ fn pow() {
             use wasm_bindgen::js;
 
             #[wasm_bindgen]
-            pub fn pow(base: f64, exponent: f64) -> js::Number {
+            pub fn pow(base: f64, exponent: f64) -> f64 {
                 js::Math::pow(base, exponent)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
             export function test() {
                 assert.equal(wasm.pow(7, 2), 49);
                 assert.equal(wasm.pow(3.8, 0.5), Math.pow(3.8, 0.5));
-                assert(Number.isNaN(wasm.pow(-2, 0.5)));
+                assert.ok(Number.isNaN(wasm.pow(-2, 0.5)));
             }
         "#)
         .test()
@@ -723,11 +723,11 @@ fn round() {
             use wasm_bindgen::js;
 
             #[wasm_bindgen]
-            pub fn round(x: f64) -> js::Number {
+            pub fn round(x: f64) -> i32 {
                 js::Math::round(x)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -753,11 +753,11 @@ fn sign() {
             use wasm_bindgen::js;
 
             #[wasm_bindgen]
-            pub fn sign(x: f64) -> js::Number {
+            pub fn sign(x: f64) -> f64 {
                 js::Math::sign(x)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -766,7 +766,7 @@ fn sign() {
                 assert.equal(wasm.sign(-3), -1);
                 assert.equal(wasm.sign(2.3), 1);
                 assert.equal(wasm.sign(0), 0);
-                assert(Number.isNaN(wasm.sign(NaN)));
+                assert.ok(Number.isNaN(wasm.sign(NaN)));
             }
         "#)
         .test()
@@ -783,11 +783,11 @@ fn sin() {
             use wasm_bindgen::js;
 
             #[wasm_bindgen]
-            pub fn sin(x: f64) -> js::Number {
+            pub fn sin(x: f64) -> f64 {
                 js::Math::sin(x)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -811,11 +811,11 @@ fn sinh() {
             use wasm_bindgen::js;
 
             #[wasm_bindgen]
-            pub fn sinh(x: f64) -> js::Number {
+            pub fn sinh(x: f64) -> f64 {
                 js::Math::sinh(x)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -839,11 +839,11 @@ fn sqrt() {
             use wasm_bindgen::js;
 
             #[wasm_bindgen]
-            pub fn sqrt(x: f64) -> js::Number {
+            pub fn sqrt(x: f64) -> f64 {
                 js::Math::sqrt(x)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -852,7 +852,7 @@ fn sqrt() {
                 assert.equal(wasm.sqrt(2), Math.sqrt(2));
                 assert.equal(wasm.sqrt(42.42), Math.sqrt(42.42));
                 assert.equal(wasm.sqrt(1), 1);
-                assert(Number.isNaN(wasm.sqrt(-1)));
+                assert.ok(Number.isNaN(wasm.sqrt(-1)));
             }
         "#)
         .test()
@@ -869,11 +869,11 @@ fn tan() {
             use wasm_bindgen::js;
 
             #[wasm_bindgen]
-            pub fn tan(x: f64) -> js::Number {
+            pub fn tan(x: f64) -> f64 {
                 js::Math::tan(x)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -897,11 +897,11 @@ fn tanh() {
             use wasm_bindgen::js;
 
             #[wasm_bindgen]
-            pub fn tanh(x: f64) -> js::Number {
+            pub fn tanh(x: f64) -> f64 {
                 js::Math::tanh(x)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -925,11 +925,11 @@ fn trunc() {
             use wasm_bindgen::js;
 
             #[wasm_bindgen]
-            pub fn trunc(x: f64) -> js::Number {
+            pub fn trunc(x: f64) -> i32 {
                 js::Math::trunc(x)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -941,4 +941,4 @@ fn trunc() {
             }
         "#)
         .test()
-}
\ No newline at end of file
+}
diff --git a/tests/all/js_globals/Number.rs b/tests/all/js_globals/Number.rs
old mode 100644
new mode 100755
index e74f7651..11e62ad3
--- a/tests/all/js_globals/Number.rs
+++ b/tests/all/js_globals/Number.rs
@@ -2,6 +2,33 @@
 
 use super::project;
 
+#[test]
+fn is_integer() {
+    project()
+        .file("src/lib.rs", r#"
+            #![feature(proc_macro, wasm_custom_section)]
+
+            extern crate wasm_bindgen;
+            use wasm_bindgen::prelude::*;
+            use wasm_bindgen::js;
+
+            #[wasm_bindgen]
+            pub fn is_integer(obj: &js::Object) -> bool {
+                js::Number::is_integer(&obj)
+            }
+        "#)
+        .file("test.js", r#"
+            import * as assert from "assert";
+            import * as wasm from "./out";
+
+            export function test() {
+                assert.ok(wasm.is_integer(123));
+                assert.ok(!wasm.is_integer(123.45));
+            }
+        "#)
+        .test()
+}
+
 #[test]
 fn new() {
     project()
@@ -17,7 +44,7 @@ fn new() {
                 Number::new(JsValue::from(42))
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -44,7 +71,7 @@ fn to_locale_string() {
                 this.to_locale_string(locale)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -83,7 +110,7 @@ fn to_precision() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -121,7 +148,7 @@ fn to_string() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -150,13 +177,13 @@ fn value_of() {
             use wasm_bindgen::js;
 
             #[wasm_bindgen]
-            pub fn js_value_of(this: &js::Number) -> js::Number {
+            pub fn js_value_of(this: &js::Number) -> f64 {
                 this.value_of()
             }
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -195,7 +222,7 @@ fn to_fixed() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -233,7 +260,7 @@ fn to_exponential() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
diff --git a/tests/all/js_globals/Object.rs b/tests/all/js_globals/Object.rs
index 402e247c..f3897841 100644
--- a/tests/all/js_globals/Object.rs
+++ b/tests/all/js_globals/Object.rs
@@ -21,7 +21,7 @@ fn new() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -53,18 +53,18 @@ fn has_own_property() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
             export function test() {
-                assert(wasm.has_own_foo_property({ foo: 42 }, "foo"));
-                assert(wasm.has_own_foo_property({ 42: "foo" }, 42));
-                assert(!wasm.has_own_foo_property({ foo: 42 }, "bar"));
+                assert.ok(wasm.has_own_foo_property({ foo: 42 }, "foo"));
+                assert.ok(wasm.has_own_foo_property({ 42: "foo" }, 42));
+                assert.ok(!wasm.has_own_foo_property({ foo: 42 }, "bar"));
 
                 const s = Symbol();
-                assert(wasm.has_own_foo_property({ [s]: "foo" }, s));
+                assert.ok(wasm.has_own_foo_property({ [s]: "foo" }, s));
             }
         "#,
         )
@@ -96,7 +96,7 @@ fn to_string() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -125,16 +125,16 @@ fn is_extensible() {
                 js::Object::is_extensible(&obj)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
             export function test() {
                 const object = {};
-                assert(wasm.is_extensible(object));
+                assert.ok(wasm.is_extensible(object));
 
                 Object.preventExtensions(object);
-                assert(!wasm.is_extensible(object));
+                assert.ok(!wasm.is_extensible(object));
             }
         "#)
         .test()
@@ -155,16 +155,16 @@ fn is_frozen() {
                 js::Object::is_frozen(&obj)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
             export function test() {
                 const object = {};
-                assert(!wasm.is_frozen(object));
+                assert.ok(!wasm.is_frozen(object));
 
                 Object.freeze(object);
-                assert(wasm.is_frozen(object));
+                assert.ok(wasm.is_frozen(object));
             }
         "#)
         .test()
@@ -185,16 +185,16 @@ fn is_sealed() {
                 js::Object::is_sealed(&obj)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
             export function test() {
                 const object = {};
-                assert(!wasm.is_sealed(object));
+                assert.ok(!wasm.is_sealed(object));
 
                 Object.seal(object);
-                assert(wasm.is_sealed(object));
+                assert.ok(wasm.is_sealed(object));
             }
         "#)
         .test()
@@ -219,7 +219,7 @@ fn is_prototype_of() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -229,8 +229,8 @@ fn is_prototype_of() {
 
             export function test() {
                 const foo = new Foo();
-                assert(wasm.obj_is_prototype_of_value(Foo.prototype, foo));
-                assert(!wasm.obj_is_prototype_of_value(Bar.prototype, foo));
+                assert.ok(wasm.obj_is_prototype_of_value(Foo.prototype, foo));
+                assert.ok(!wasm.obj_is_prototype_of_value(Bar.prototype, foo));
             }
         "#,
         )
@@ -256,7 +256,7 @@ fn keys() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -285,7 +285,7 @@ fn prevent_extensions() {
                 js::Object::prevent_extensions(obj);
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -293,7 +293,7 @@ fn prevent_extensions() {
                 const object = {};
                 wasm.prevent_extensions(object);
 
-                assert(!Object.isExtensible(object));
+                assert.ok(!Object.isExtensible(object));
                 assert.throws(() => {
                     'use strict';
                     Object.defineProperty(object, 'foo', { value: 42 });
@@ -322,19 +322,19 @@ fn property_is_enumerable() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
             export function test() {
-                assert(wasm.property_is_enumerable({ foo: 42 }, "foo"));
-                assert(wasm.property_is_enumerable({ 42: "foo" }, 42));
-                assert(!wasm.property_is_enumerable({}, 42));
+                assert.ok(wasm.property_is_enumerable({ foo: 42 }, "foo"));
+                assert.ok(wasm.property_is_enumerable({ 42: "foo" }, 42));
+                assert.ok(!wasm.property_is_enumerable({}, 42));
 
                 const obj = {};
                 Object.defineProperty(obj, "foo", { enumerable: false });
-                assert(!wasm.property_is_enumerable(obj, "foo"));
+                assert.ok(!wasm.property_is_enumerable(obj, "foo"));
 
                 const s = Symbol();
                 assert.ok(wasm.property_is_enumerable({ [s]: true }, s));
@@ -359,12 +359,12 @@ fn seal() {
                 js::Object::seal(&value)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
             export function test() {
-                const object: any = { foo: 'bar' };
+                const object = { foo: 'bar' };
                 const sealedObject = wasm.seal(object);
                 assert.strictEqual(object, sealedObject);
                 assert.throws(() => {
@@ -410,7 +410,7 @@ fn set_prototype_of() {
                 js::Object::set_prototype_of(&object, &prototype)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -419,7 +419,7 @@ fn set_prototype_of() {
                 const newPrototype = { bar: 'baz' };
 
                 const modifiedObject = wasm.set_prototype_of(object, newPrototype);
-                assert(newPrototype.isPrototypeOf(modifiedObject));
+                assert.ok(newPrototype.isPrototypeOf(modifiedObject));
             }
         "#)
         .test()
@@ -445,7 +445,7 @@ fn to_locale_string() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -477,7 +477,7 @@ fn value_of() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -507,7 +507,7 @@ fn values() {
                 js::Object::values(&obj)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
diff --git a/tests/all/js_globals/Proxy.rs b/tests/all/js_globals/Proxy.rs
new file mode 100644
index 00000000..dea1d6da
--- /dev/null
+++ b/tests/all/js_globals/Proxy.rs
@@ -0,0 +1,76 @@
+#![allow(non_snake_case)]
+
+use project;
+
+#[test]
+fn new() {
+    project()
+        .file("src/lib.rs", r#"
+            #![feature(proc_macro, wasm_custom_section)]
+
+            extern crate wasm_bindgen;
+            use wasm_bindgen::prelude::*;
+            use wasm_bindgen::js;
+
+            #[wasm_bindgen]
+            pub fn new_proxy(target: JsValue, handler: js::Object) -> js::Proxy {
+                js::Proxy::new(&target, &handler)
+            }
+        "#)
+        .file("test.js", r#"
+            import * as assert from "assert";
+            import * as wasm from "./out";
+
+            export function test() {
+                const target = { a: 100 };
+                const handler = {
+                     get: function(obj, prop) {
+                         return prop in obj ? obj[prop] : 37;
+                     }
+                };
+                const proxy = wasm.new_proxy(target, handler);
+                assert.equal(proxy.a, 100);
+                assert.equal(proxy.b, 37);
+            }
+        "#)
+        .test()
+}
+
+#[test]
+fn revocable() {
+    project()
+        .file("src/lib.rs", r#"
+            #![feature(proc_macro, wasm_custom_section)]
+
+            extern crate wasm_bindgen;
+            use wasm_bindgen::prelude::*;
+            use wasm_bindgen::js;
+
+            #[wasm_bindgen]
+            pub fn new_revocable_proxy(target: JsValue, handler: js::Object) -> js::Object {
+                js::Proxy::revocable(&target, &handler)
+            }
+        "#)
+        .file("test.js", r#"
+            import * as assert from "assert";
+            import * as wasm from "./out";
+
+            export function test() {
+                const target = { a: 100 };
+                const handler = {
+                     get: function(obj, prop) {
+                         return prop in obj ? obj[prop] : 37;
+                     }
+                };
+                const { proxy, revoke } =
+                   wasm.new_revocable_proxy(target, handler);
+                assert.equal(proxy.a, 100);
+                assert.equal(proxy.b, 37);
+                revoke();
+                assert.throws(() => { proxy.a }, TypeError);
+                assert.throws(() => { proxy.b }, TypeError);
+                assert.equal(typeof proxy, "object");
+            }
+        "#)
+        .test()
+}
diff --git a/tests/all/js_globals/Set.rs b/tests/all/js_globals/Set.rs
old mode 100644
new mode 100755
index 8d1bdb15..20dd4c41
--- a/tests/all/js_globals/Set.rs
+++ b/tests/all/js_globals/Set.rs
@@ -18,7 +18,7 @@ fn add() {
             }
 
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -51,7 +51,7 @@ fn clear() {
             }
 
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -81,7 +81,7 @@ fn delete() {
                 this.delete(value)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -110,7 +110,7 @@ fn has() {
                 this.has(value)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -139,7 +139,7 @@ fn new() {
                 js::Set::new()
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -163,12 +163,12 @@ fn size() {
             use wasm_bindgen::js;
 
             #[wasm_bindgen]
-            pub fn size(this: &js::Set) -> js::Number {
+            pub fn size(this: &js::Set) -> u32 {
                 this.size()
             }
 
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -179,4 +179,4 @@ fn size() {
             }
         "#)
         .test()
-}
\ No newline at end of file
+}
diff --git a/tests/all/js_globals/SetIterator.rs b/tests/all/js_globals/SetIterator.rs
index 33e910df..ac820783 100644
--- a/tests/all/js_globals/SetIterator.rs
+++ b/tests/all/js_globals/SetIterator.rs
@@ -18,7 +18,7 @@ fn entries() {
             }
 
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -50,7 +50,7 @@ fn keys() {
             }
 
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -81,7 +81,7 @@ fn values() {
             }
 
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
@@ -94,4 +94,4 @@ fn values() {
             }
         "#)
         .test()
-}
\ No newline at end of file
+}
diff --git a/tests/all/js_globals/Symbol.rs b/tests/all/js_globals/Symbol.rs
new file mode 100644
index 00000000..74003089
--- /dev/null
+++ b/tests/all/js_globals/Symbol.rs
@@ -0,0 +1,42 @@
+#![allow(non_snake_case)]
+
+use project;
+
+#[test]
+fn has_instance() {
+    project()
+        .file(
+            "src/lib.rs",
+            r#"
+            #![feature(proc_macro, wasm_custom_section)]
+
+            extern crate wasm_bindgen;
+            use wasm_bindgen::prelude::*;
+            use wasm_bindgen::js;
+
+            #[wasm_bindgen]
+            pub fn symbol_has_instance() -> js::Symbol {
+                js::Symbol::has_instance()
+            }
+
+        "#,
+        )
+        .file(
+            "test.js",
+            r#"
+            import * as assert from "assert";
+            import * as wasm from "./out";
+            class Array1 {
+                static [wasm.symbol_has_instance()](instance) {
+                    return Array.isArray(instance);
+                }
+            }
+
+            export function test() {
+                assert.equal(typeof wasm.symbol_has_instance(), "symbol");
+                assert.ok([] instanceof Array1);
+            }
+        "#,
+        )
+        .test()
+}
diff --git a/tests/all/js_globals/TypedArray.rs b/tests/all/js_globals/TypedArray.rs
index 618e8e16..97af6071 100644
--- a/tests/all/js_globals/TypedArray.rs
+++ b/tests/all/js_globals/TypedArray.rs
@@ -21,7 +21,7 @@ fn new_undefined() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -53,7 +53,7 @@ fn new_length() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -81,7 +81,7 @@ fn fill() {
                 this.fill(value, start, end)
             }
         "#)
-        .file("test.ts", r#"
+        .file("test.js", r#"
             import * as assert from "assert";
             import * as wasm from "./out";
 
diff --git a/tests/all/js_globals/WeakMap.rs b/tests/all/js_globals/WeakMap.rs
index da189a7c..5bcf9e43 100644
--- a/tests/all/js_globals/WeakMap.rs
+++ b/tests/all/js_globals/WeakMap.rs
@@ -21,7 +21,7 @@ fn new() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -53,7 +53,7 @@ fn get() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -91,7 +91,7 @@ fn set() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -126,7 +126,7 @@ fn has() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -164,7 +164,7 @@ fn delete() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
diff --git a/tests/all/js_globals/WeakSet.rs b/tests/all/js_globals/WeakSet.rs
index 7957e7f9..def77cd3 100644
--- a/tests/all/js_globals/WeakSet.rs
+++ b/tests/all/js_globals/WeakSet.rs
@@ -21,7 +21,7 @@ fn new() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -53,7 +53,7 @@ fn has() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -91,7 +91,7 @@ fn add() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
@@ -132,7 +132,7 @@ fn delete() {
         "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
             import * as assert from "assert";
             import * as wasm from "./out";
diff --git a/tests/all/js_globals/mod.rs b/tests/all/js_globals/mod.rs
index 097d514e..06ba71e9 100644
--- a/tests/all/js_globals/mod.rs
+++ b/tests/all/js_globals/mod.rs
@@ -3,6 +3,7 @@
 use super::project;
 
 mod Array;
+mod ArrayBuffer;
 mod ArrayIterator;
 mod Boolean;
 mod Date;
@@ -15,9 +16,11 @@ mod MapIterator;
 mod Math;
 mod Number;
 mod Object;
+mod Proxy;
 mod Reflect;
 mod Set;
 mod SetIterator;
+mod Symbol;
 mod TypedArray;
 mod WeakMap;
 mod WeakSet;
@@ -29,22 +32,22 @@ fn decode_uri() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section)]
+                #![feature(proc_macro, wasm_custom_section)]
 
-            extern crate wasm_bindgen;
-            use wasm_bindgen::prelude::*;
-            use wasm_bindgen::js;
+                extern crate wasm_bindgen;
+                use wasm_bindgen::prelude::*;
+                use wasm_bindgen::js;
 
-            #[wasm_bindgen]
-            pub fn test() {
-                let x = js::decode_uri("https://mozilla.org/?x=%D1%88%D0%B5%D0%BB%D0%BB%D1%8B")
-                    .ok()
-                    .expect("should decode URI OK");
-                assert_eq!(String::from(x), "https://mozilla.org/?x=шеллы");
+                #[wasm_bindgen]
+                pub fn test() {
+                    let x = js::decode_uri("https://mozilla.org/?x=%D1%88%D0%B5%D0%BB%D0%BB%D1%8B")
+                        .ok()
+                        .expect("should decode URI OK");
+                    assert_eq!(String::from(x), "https://mozilla.org/?x=шеллы");
 
-                assert!(js::decode_uri("%E0%A4%A").is_err());
-            }
-        "#,
+                    assert!(js::decode_uri("%E0%A4%A").is_err());
+                }
+            "#,
         )
         .test();
 }
@@ -55,22 +58,22 @@ fn decode_uri_component() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section)]
+                #![feature(proc_macro, wasm_custom_section)]
 
-            extern crate wasm_bindgen;
-            use wasm_bindgen::prelude::*;
-            use wasm_bindgen::js;
+                extern crate wasm_bindgen;
+                use wasm_bindgen::prelude::*;
+                use wasm_bindgen::js;
 
-            #[wasm_bindgen]
-            pub fn test() {
-                let x = js::decode_uri_component("%3Fx%3Dtest")
-                    .ok()
-                    .expect("should decode URI OK");
-                assert_eq!(String::from(x), "?x=test");
+                #[wasm_bindgen]
+                pub fn test() {
+                    let x = js::decode_uri_component("%3Fx%3Dtest")
+                        .ok()
+                        .expect("should decode URI OK");
+                    assert_eq!(String::from(x), "?x=test");
 
-                assert!(js::decode_uri_component("%E0%A4%A").is_err());
-            }
-        "#,
+                    assert!(js::decode_uri_component("%E0%A4%A").is_err());
+                }
+            "#,
         )
         .test();
 }
@@ -82,18 +85,18 @@ fn encode_uri() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section)]
+                #![feature(proc_macro, wasm_custom_section)]
 
-            extern crate wasm_bindgen;
-            use wasm_bindgen::prelude::*;
-            use wasm_bindgen::js;
+                extern crate wasm_bindgen;
+                use wasm_bindgen::prelude::*;
+                use wasm_bindgen::js;
 
-            #[wasm_bindgen]
-            pub fn test() {
-                let x = js::encode_uri("ABC abc 123");
-                assert_eq!(String::from(x), "ABC%20abc%20123");
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn test() {
+                    let x = js::encode_uri("ABC abc 123");
+                    assert_eq!(String::from(x), "ABC%20abc%20123");
+                }
+            "#,
         )
         .test();
 }
@@ -104,18 +107,18 @@ fn encode_uri_component() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section)]
+                #![feature(proc_macro, wasm_custom_section)]
 
-            extern crate wasm_bindgen;
-            use wasm_bindgen::prelude::*;
-            use wasm_bindgen::js;
+                extern crate wasm_bindgen;
+                use wasm_bindgen::prelude::*;
+                use wasm_bindgen::js;
 
-            #[wasm_bindgen]
-            pub fn test() {
-                let x = js::encode_uri_component("?x=шеллы");
-                assert_eq!(String::from(x), "%3Fx%3D%D1%88%D0%B5%D0%BB%D0%BB%D1%8B");
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn test() {
+                    let x = js::encode_uri_component("?x=шеллы");
+                    assert_eq!(String::from(x), "%3Fx%3D%D1%88%D0%B5%D0%BB%D0%BB%D1%8B");
+                }
+            "#,
         )
         .test();
 }
@@ -126,23 +129,23 @@ fn eval() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section)]
+                #![feature(proc_macro, wasm_custom_section)]
 
-            extern crate wasm_bindgen;
-            use wasm_bindgen::prelude::*;
-            use wasm_bindgen::js;
+                extern crate wasm_bindgen;
+                use wasm_bindgen::prelude::*;
+                use wasm_bindgen::js;
 
-            #[wasm_bindgen]
-            pub fn test() {
-                let x = js::eval("42").ok().expect("should eval OK");
-                assert_eq!(x.as_f64().unwrap(), 42.0);
+                #[wasm_bindgen]
+                pub fn test() {
+                    let x = js::eval("42").ok().expect("should eval OK");
+                    assert_eq!(x.as_f64().unwrap(), 42.0);
 
-                let err = js::eval("(function () { throw 42; }())")
-                    .err()
-                    .expect("eval should throw");
-                assert_eq!(err.as_f64().unwrap(), 42.0);
-            }
-        "#,
+                    let err = js::eval("(function () { throw 42; }())")
+                        .err()
+                        .expect("eval should throw");
+                    assert_eq!(err.as_f64().unwrap(), 42.0);
+                }
+            "#,
         )
         .test();
 }
diff --git a/tests/all/jsobjects.rs b/tests/all/jsobjects.rs
index 3ae8723a..49f59aef 100644
--- a/tests/all/jsobjects.rs
+++ b/tests/all/jsobjects.rs
@@ -6,43 +6,43 @@ fn simple() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen(module = "./test")]
-            extern {
-                fn foo(s: &JsValue);
-            }
+                #[wasm_bindgen(module = "./test")]
+                extern {
+                    fn foo(s: &JsValue);
+                }
 
-            #[wasm_bindgen]
-            pub fn bar(s: &JsValue) {
-                foo(s);
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn bar(s: &JsValue) {
+                    foo(s);
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import * as wasm from "./out";
-            import * as assert from "assert";
+                import * as wasm from "./out";
+                import * as assert from "assert";
 
-            let ARG: string | null = null;
+                let ARG = null;
 
-            export function foo(s: any): void {
-                assert.strictEqual(ARG, null);
-                ARG = s;
-            }
+                export function foo(s) {
+                    assert.strictEqual(ARG, null);
+                    ARG = s;
+                }
 
-            export function test() {
-                assert.strictEqual(ARG, null);
-                let sym = (Symbol as any)('test');
-                wasm.bar(sym);
-                assert.strictEqual(ARG, sym);
-            }
-        "#,
+                export function test() {
+                    assert.strictEqual(ARG, null);
+                    let sym = Symbol('test');
+                    wasm.bar(sym);
+                    assert.strictEqual(ARG, sym);
+                }
+            "#,
         )
         .test();
 }
@@ -53,43 +53,43 @@ fn owned() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen(module = "./test")]
-            extern {
-                fn foo(s: JsValue);
-            }
+                #[wasm_bindgen(module = "./test")]
+                extern {
+                    fn foo(s: JsValue);
+                }
 
-            #[wasm_bindgen]
-            pub fn bar(s: JsValue) {
-                foo(s);
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn bar(s: JsValue) {
+                    foo(s);
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import * as wasm from "./out";
-            import * as assert from "assert";
+                import * as wasm from "./out";
+                import * as assert from "assert";
 
-            let ARG: any = null;
+                let ARG = null;
 
-            export function foo(s: any): void {
-                assert.strictEqual(ARG, null);
-                ARG = s;
-            }
+                export function foo(s) {
+                    assert.strictEqual(ARG, null);
+                    ARG = s;
+                }
 
-            export function test() {
-                assert.strictEqual(ARG, null);
-                let sym = (Symbol as any)('test');
-                wasm.bar(sym);
-                assert.strictEqual(ARG, sym);
-            }
-        "#,
+                export function test() {
+                    assert.strictEqual(ARG, null);
+                    let sym = Symbol('test');
+                    wasm.bar(sym);
+                    assert.strictEqual(ARG, sym);
+                }
+            "#,
         )
         .test();
 }
@@ -100,49 +100,49 @@ fn clone() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen(module = "./test")]
-            extern {
-                fn foo1(s: JsValue);
-                fn foo2(s: &JsValue);
-                fn foo3(s: JsValue);
-                fn foo4(s: &JsValue);
-                fn foo5(s: JsValue);
-            }
+                #[wasm_bindgen(module = "./test")]
+                extern {
+                    fn foo1(s: JsValue);
+                    fn foo2(s: &JsValue);
+                    fn foo3(s: JsValue);
+                    fn foo4(s: &JsValue);
+                    fn foo5(s: JsValue);
+                }
 
-            #[wasm_bindgen]
-            pub fn bar(s: JsValue) {
-                foo1(s.clone());
-                foo2(&s);
-                foo3(s.clone());
-                foo4(&s);
-                foo5(s);
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn bar(s: JsValue) {
+                    foo1(s.clone());
+                    foo2(&s);
+                    foo3(s.clone());
+                    foo4(&s);
+                    foo5(s);
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import * as wasm from "./out";
-            import * as assert from "assert";
+                import * as wasm from "./out";
+                import * as assert from "assert";
 
-            let ARG = (Symbol as any)('test');
+                let ARG = Symbol('test');
 
-            export function foo1(s: any): void { assert.strictEqual(s, ARG); }
-            export function foo2(s: any): void { assert.strictEqual(s, ARG); }
-            export function foo3(s: any): void { assert.strictEqual(s, ARG); }
-            export function foo4(s: any): void { assert.strictEqual(s, ARG); }
-            export function foo5(s: any): void { assert.strictEqual(s, ARG); }
+                export function foo1(s) { assert.strictEqual(s, ARG); }
+                export function foo2(s) { assert.strictEqual(s, ARG); }
+                export function foo3(s) { assert.strictEqual(s, ARG); }
+                export function foo4(s) { assert.strictEqual(s, ARG); }
+                export function foo5(s) { assert.strictEqual(s, ARG); }
 
-            export function test() {
-                wasm.bar(ARG);
-            }
-        "#,
+                export function test() {
+                    wasm.bar(ARG);
+                }
+            "#,
         )
         .test();
 }
@@ -153,46 +153,46 @@ fn promote() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen(module = "./test")]
-            extern {
-                fn foo1(s: &JsValue);
-                fn foo2(s: JsValue);
-                fn foo3(s: &JsValue);
-                fn foo4(s: JsValue);
-            }
+                #[wasm_bindgen(module = "./test")]
+                extern {
+                    fn foo1(s: &JsValue);
+                    fn foo2(s: JsValue);
+                    fn foo3(s: &JsValue);
+                    fn foo4(s: JsValue);
+                }
 
-            #[wasm_bindgen]
-            pub fn bar(s: &JsValue) {
-                foo1(s);
-                foo2(s.clone());
-                foo3(s);
-                foo4(s.clone());
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn bar(s: &JsValue) {
+                    foo1(s);
+                    foo2(s.clone());
+                    foo3(s);
+                    foo4(s.clone());
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import * as wasm from "./out";
-            import * as assert from "assert";
+                import * as wasm from "./out";
+                import * as assert from "assert";
 
-            let ARG = (Symbol as any)('test');
+                let ARG = Symbol('test');
 
-            export function foo1(s: any): void { assert.strictEqual(s, ARG); }
-            export function foo2(s: any): void { assert.strictEqual(s, ARG); }
-            export function foo3(s: any): void { assert.strictEqual(s, ARG); }
-            export function foo4(s: any): void { assert.strictEqual(s, ARG); }
+                export function foo1(s) { assert.strictEqual(s, ARG); }
+                export function foo2(s) { assert.strictEqual(s, ARG); }
+                export function foo3(s) { assert.strictEqual(s, ARG); }
+                export function foo4(s) { assert.strictEqual(s, ARG); }
 
-            export function test() {
-                wasm.bar(ARG);
-            }
-        "#,
+                export function test() {
+                    wasm.bar(ARG);
+                }
+            "#,
         )
         .test();
 }
@@ -203,40 +203,40 @@ fn returning_vector() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen(module = "./test")]
-            extern {
-                fn foo() -> JsValue;
-            }
-
-            #[wasm_bindgen]
-            pub fn bar() -> Vec<JsValue> {
-                let mut res = Vec::new();
-                for _ in 0..10 {
-                    res.push(foo())
+                #[wasm_bindgen(module = "./test")]
+                extern {
+                    fn foo() -> JsValue;
                 }
-                res
-            }
-        "#,
+
+                #[wasm_bindgen]
+                pub fn bar() -> Vec<JsValue> {
+                    let mut res = Vec::new();
+                    for _ in 0..10 {
+                        res.push(foo())
+                    }
+                    res
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import * as wasm from "./out";
-            import * as assert from "assert";
+                import * as wasm from "./out";
+                import * as assert from "assert";
 
-            export function foo(): any { return { "foo": "bar" }; }
+                export function foo() { return { "foo": "bar" }; }
 
-            export function test() {
-                const result = wasm.bar();
-                assert.strictEqual(result.length, 10);
-            }
-        "#,
+                export function test() {
+                    const result = wasm.bar();
+                    assert.strictEqual(result.length, 10);
+                }
+            "#,
         )
         .test();
 }
@@ -247,36 +247,36 @@ fn another_vector_return() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
 
-            #[wasm_bindgen]
-            pub fn get_array() -> Vec<JsValue> {
-                vec![
-                    JsValue::from(1),
-                    JsValue::from(2),
-                    JsValue::from(3),
-                    JsValue::from(4),
-                    JsValue::from(5),
-                    JsValue::from(6),
-                ]
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn get_array() -> Vec<JsValue> {
+                    vec![
+                        JsValue::from(1),
+                        JsValue::from(2),
+                        JsValue::from(3),
+                        JsValue::from(4),
+                        JsValue::from(5),
+                        JsValue::from(6),
+                    ]
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import { get_array } from "./out";
-            import * as assert from "assert";
+                import { get_array } from "./out";
+                import * as assert from "assert";
 
-            export function test() {
-                assert.deepStrictEqual(get_array(), [1, 2, 3, 4, 5, 6]);
-            }
-        "#,
+                export function test() {
+                    assert.deepStrictEqual(get_array(), [1, 2, 3, 4, 5, 6]);
+                }
+            "#,
         )
         .test();
 }
@@ -290,86 +290,86 @@ fn serde() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
-            #[macro_use]
-            extern crate serde_derive;
+                extern crate wasm_bindgen;
+                #[macro_use]
+                extern crate serde_derive;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[derive(Deserialize, Serialize)]
-            pub struct Foo {
-                a: u32,
-                b: String,
-                c: Option<Bar>,
-                d: Bar,
-            }
+                #[derive(Deserialize, Serialize)]
+                pub struct Foo {
+                    a: u32,
+                    b: String,
+                    c: Option<Bar>,
+                    d: Bar,
+                }
 
-            #[derive(Deserialize, Serialize)]
-            pub struct Bar {
-                a: u32,
-            }
+                #[derive(Deserialize, Serialize)]
+                pub struct Bar {
+                    a: u32,
+                }
 
-            #[wasm_bindgen(module = "./test")]
-            extern {
-                fn verify(a: JsValue) -> JsValue;
-            }
+                #[wasm_bindgen(module = "./test")]
+                extern {
+                    fn verify(a: JsValue) -> JsValue;
+                }
 
-            #[wasm_bindgen]
-            pub fn run() {
-                let js = JsValue::from_serde("foo").unwrap();
-                assert_eq!(js.as_string(), Some("foo".to_string()));
+                #[wasm_bindgen]
+                pub fn run() {
+                    let js = JsValue::from_serde("foo").unwrap();
+                    assert_eq!(js.as_string(), Some("foo".to_string()));
 
-                let ret = verify(JsValue::from_serde(&Foo {
-                    a: 0,
-                    b: "foo".to_string(),
-                    c: None,
-                    d: Bar { a: 1 },
-                }).unwrap());
+                    let ret = verify(JsValue::from_serde(&Foo {
+                        a: 0,
+                        b: "foo".to_string(),
+                        c: None,
+                        d: Bar { a: 1 },
+                    }).unwrap());
 
-                let foo = ret.into_serde::<Foo>().unwrap();
-                assert_eq!(foo.a, 2);
-                assert_eq!(foo.b, "bar");
-                assert!(foo.c.is_some());
-                assert_eq!(foo.c.as_ref().unwrap().a, 3);
-                assert_eq!(foo.d.a, 4);
-            }
+                    let foo = ret.into_serde::<Foo>().unwrap();
+                    assert_eq!(foo.a, 2);
+                    assert_eq!(foo.b, "bar");
+                    assert!(foo.c.is_some());
+                    assert_eq!(foo.c.as_ref().unwrap().a, 3);
+                    assert_eq!(foo.d.a, 4);
+                }
 
-            #[wasm_bindgen]
-            pub fn parse(j: &JsValue) {
-                let s = j.into_serde::<String>().unwrap();
-                assert_eq!(s, "bar");
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn parse(j: &JsValue) {
+                    let s = j.into_serde::<String>().unwrap();
+                    assert_eq!(s, "bar");
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import { run, parse } from "./out";
-            import * as assert from "assert";
+                import { run, parse } from "./out";
+                import * as assert from "assert";
 
-            export function verify(a: any) {
-                assert.deepStrictEqual(a, {
-                    a: 0,
-                    b: 'foo',
-                    c: null,
-                    d: { a: 1 }
-                });
+                export function verify(a) {
+                    assert.deepStrictEqual(a, {
+                        a: 0,
+                        b: 'foo',
+                        c: null,
+                        d: { a: 1 }
+                    });
 
-                return {
-                    a: 2,
-                    b: 'bar',
-                    c: { a: 3 },
-                    d: { a: 4 },
+                    return {
+                        a: 2,
+                        b: 'bar',
+                        c: { a: 3 },
+                        d: { a: 4 },
+                    }
                 }
-            }
 
-            export function test() {
-                run();
-                parse('bar');
-            }
-        "#,
+                export function test() {
+                    run();
+                    parse('bar');
+                }
+            "#,
         )
         .test();
 }
diff --git a/tests/all/main.rs b/tests/all/main.rs
index 79100d24..3d06a784 100644
--- a/tests/all/main.rs
+++ b/tests/all/main.rs
@@ -1,544 +1,6 @@
-extern crate wasm_bindgen_cli_support as cli;
+extern crate wasm_bindgen_test_project_builder as project_builder;
 
-use std::env;
-use std::fs::{self, File};
-use std::io::{self, Read, Write};
-use std::path::{Path, PathBuf};
-use std::process::{Command, Stdio};
-use std::sync::atomic::*;
-use std::sync::{Once, ONCE_INIT};
-use std::time::Instant;
-
-static CNT: AtomicUsize = ATOMIC_USIZE_INIT;
-thread_local!(static IDX: usize = CNT.fetch_add(1, Ordering::SeqCst));
-
-struct Project {
-    files: Vec<(String, String)>,
-    debug: bool,
-    node: bool,
-    no_std: bool,
-    serde: bool,
-    rlib: bool,
-    node_args: Vec<String>,
-    deps: Vec<String>,
-}
-
-fn project() -> Project {
-    let dir = Path::new(env!("CARGO_MANIFEST_DIR"));
-    let mut lockfile = String::new();
-    fs::File::open(&dir.join("Cargo.lock"))
-        .unwrap()
-        .read_to_string(&mut lockfile)
-        .unwrap();
-    Project {
-        debug: true,
-        node: false,
-        no_std: false,
-        serde: false,
-        rlib: false,
-        deps: Vec::new(),
-        node_args: Vec::new(),
-        files: vec![
-            ("Cargo.lock".to_string(), lockfile),
-            (
-                "run-node.js".to_string(),
-                r#"require("./test").test();"#.to_string(),
-            ),
-            (
-                "webpack.config.js".to_string(),
-                r#"
-                const path = require('path');
-                const fs = require('fs');
-                
-                let nodeModules = {};
-
-                // Webpack bundles the modules from node_modules.
-                // For node target, we will not have `fs` module 
-                // inside the `node_modules` folder.
-                // This reads the directories in `node_modules`
-                // and give that to externals and webpack ignores 
-                // to bundle the modules listed as external. 
-                fs.readdirSync('node_modules')
-                    .filter(module => module !== '.bin')
-                    .forEach(mod => {
-                        // External however,expects browser environment. 
-                        // To make it work in `node` target we 
-                        // prefix commonjs here.
-                        nodeModules[mod] = 'commonjs ' + mod;
-                    });
-
-                module.exports = {
-                  entry: './run.js',
-                  mode: "development",
-                  devtool: "source-map",
-                  module: {
-                    rules: [
-                      {
-                        test: /\.ts$/,
-                        use: 'ts-loader',
-                        exclude: /node_modules/
-                      }
-                    ]
-                  },
-                  resolve: {
-                    extensions: [ '.ts', '.js', '.wasm' ]
-                  },
-                  output: {
-                    filename: 'bundle.js',
-                    path: path.resolve(__dirname, '.')
-                  },
-                  target: 'node',
-                  externals: nodeModules
-                };
-            "#.to_string(),
-            ),
-            (
-                "tsconfig.json".to_string(),
-                r#"
-                {
-                  "compilerOptions": {
-                    "noEmitOnError": true,
-                    "noImplicitAny": true,
-                    "noImplicitThis": true,
-                    "noUnusedParameters": true,
-                    "noUnusedLocals": true,
-                    "noImplicitReturns": true,
-                    "strictFunctionTypes": true,
-                    "strictNullChecks": true,
-                    "alwaysStrict": true,
-                    "strict": true,
-                    "target": "es5",
-                    "lib": ["es2015"]
-                  }
-                }
-            "#.to_string(),
-            ),
-        ],
-    }
-}
-
-fn root() -> PathBuf {
-    let idx = IDX.with(|x| *x);
-
-    let mut me = env::current_exe().unwrap();
-    me.pop(); // chop off exe name
-    me.pop(); // chop off `deps`
-    me.pop(); // chop off `debug` / `release`
-    me.push("generated-tests");
-    me.push(&format!("test{}", idx));
-    return me;
-}
-
-fn assert_bigint_support() -> Option<&'static str> {
-    static BIGINT_SUPPORED: AtomicUsize = ATOMIC_USIZE_INIT;
-    static INIT: Once = ONCE_INIT;
-
-    INIT.call_once(|| {
-        let mut cmd = Command::new("node");
-        cmd.arg("-e").arg("BigInt");
-        cmd.stdin(Stdio::null())
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped());
-        if cmd.status().unwrap().success() {
-            BIGINT_SUPPORED.store(1, Ordering::SeqCst);
-            return;
-        }
-
-        cmd.arg("--harmony-bigint");
-        if cmd.status().unwrap().success() {
-            BIGINT_SUPPORED.store(2, Ordering::SeqCst);
-            return;
-        }
-    });
-
-    match BIGINT_SUPPORED.load(Ordering::SeqCst) {
-        1 => return None,
-        2 => return Some("--harmony-bigint"),
-        _ => panic!(
-            "the version of node.js that is installed for these tests \
-             does not support `BigInt`, you may wish to try installing \
-             node 10 to fix this"
-        ),
-    }
-}
-
-impl Project {
-    fn file(&mut self, name: &str, contents: &str) -> &mut Project {
-        self.files.push((name.to_string(), contents.to_string()));
-        self
-    }
-
-    fn debug(&mut self, debug: bool) -> &mut Project {
-        self.debug = debug;
-        self
-    }
-
-    fn node(&mut self, node: bool) -> &mut Project {
-        self.node = node;
-        self
-    }
-
-    fn no_std(&mut self, no_std: bool) -> &mut Project {
-        self.no_std = no_std;
-        self
-    }
-
-    fn serde(&mut self, serde: bool) -> &mut Project {
-        self.serde = serde;
-        self
-    }
-
-    fn rlib(&mut self, rlib: bool) -> &mut Project {
-        self.rlib = rlib;
-        self
-    }
-
-    fn depend(&mut self, dep: &str) -> &mut Project {
-        self.deps.push(dep.to_string());
-        self
-    }
-
-    fn add_local_dependency(&mut self, name: &str, path: &str) -> &mut Project {
-        self.deps
-            .push(format!("{} = {{ path = '{}' }}", name, path));
-        self
-    }
-
-    fn crate_name(&self) -> String {
-        format!("test{}", IDX.with(|x| *x))
-    }
-
-    fn requires_bigint(&mut self) -> &mut Project {
-        if let Some(arg) = assert_bigint_support() {
-            self.node_args.push(arg.to_string());
-        }
-        self
-    }
-
-    fn generate_webidl_bindings(&mut self) -> Vec<PathBuf> {
-        let mut res = Vec::new();
-        let mut origpaths = Vec::new();
-
-        for (path, _) in &self.files {
-            let path = Path::new(&path);
-            let extension = path.extension().map(|x| x.to_str().unwrap());
-
-            if extension != Some("webidl") {
-                continue;
-            }
-
-            res.push(path.with_extension("rs"));
-            origpaths.push(path.to_owned());
-        }
-
-        if res.is_empty() {
-            return res;
-        }
-
-        let mut buildrs = r#"
-            extern crate wasm_bindgen_webidl;
-
-            use wasm_bindgen_webidl::compile_file;
-            use std::env;
-            use std::fs::{self, File};
-            use std::io::Write;
-            use std::path::Path;
-
-            fn main() {
-                let dest = env::var("OUT_DIR").unwrap();
-        "#.to_string();
-
-        for (path, origpath) in res.iter().zip(origpaths.iter()) {
-            buildrs.push_str(&format!(
-                r#"
-                fs::create_dir_all("{}").unwrap();
-                File::create(&Path::new(&dest).join("{}"))
-                    .unwrap()
-                    .write_all(
-                        compile_file(Path::new("{}"))
-                            .unwrap()
-                            .as_bytes()
-                    )
-                    .unwrap();
-                "#,
-                path.parent().unwrap().to_str().unwrap(),
-                path.to_str().unwrap(),
-                origpath.to_str().unwrap(),
-            ));
-
-            self.files.push((
-                Path::new("src").join(path).to_str().unwrap().to_string(),
-                format!(
-                    r#"include!(concat!(env!("OUT_DIR"), "/{}"));"#,
-                    path.display()
-                ),
-            ));
-        }
-
-        buildrs.push('}');
-
-        self.files.push(("build.rs".to_string(), buildrs));
-
-        res
-    }
-
-    fn generate_js_entry(&mut self, modules: Vec<PathBuf>) {
-        let mut runjs = r#"
-            import * as process from "process";
-        "#.to_string();
-
-        if !modules.is_empty() {
-            runjs.push_str(r#"Promise.all(["#);
-            for module in &modules {
-                runjs.push_str(&format!(
-                    r#"import('./{}'),"#,
-                    module.with_extension("").to_str().unwrap()
-                ));
-            }
-            runjs.push_str(
-                r#"]).then(results => { results.map(module => Object.assign(global, module));"#,
-            );
-        }
-
-        runjs.push_str(
-            r#"
-            let wasm = import('./out');
-            const test = import('./test');
-            "#,
-        );
-
-        if !modules.is_empty() {
-            runjs.push_str("return ");
-        }
-
-        runjs.push_str(r#"Promise.all([test, wasm])"#);
-
-        if !modules.is_empty() {
-            runjs.push_str("})");
-        }
-
-        runjs.push_str(
-            r#"
-            .then(results => {
-                let [test, wasm] = results;
-                test.test();
-
-                if (wasm.assertStackEmpty)
-                    wasm.assertStackEmpty();
-                if (wasm.assertSlabEmpty)
-                    wasm.assertSlabEmpty();
-            })
-            .catch(error => {
-                  console.error(error);
-                  process.exit(1);
-                });
-            "#,
-        );
-        self.files.push(("run.js".to_string(), runjs));
-    }
-
-    fn ensure_test_entry(&mut self) {
-        if !self
-            .files
-            .iter()
-            .any(|(path, _)| path == "test.ts" || path == "test.js")
-        {
-            self.files.push((
-                "test.ts".to_string(),
-                r#"export {test} from './out';"#.to_string(),
-            ));
-        }
-    }
-    /// build + cargo cmd execution
-    fn cargo_build(&mut self) -> (PathBuf, PathBuf) {
-        let (root, target_dir) = self.build();
-        let mut cmd = Command::new("cargo");
-        cmd.arg("build")
-            .arg("--target")
-            .arg("wasm32-unknown-unknown")
-            .current_dir(&root)
-            .env("CARGO_TARGET_DIR", &target_dir)
-            // Catch any warnings in generated code because we don't want any
-            .env("RUSTFLAGS", "-Dwarnings");
-        run(&mut cmd, "cargo");
-        (root, target_dir)
-    }
-
-    fn build(&mut self) -> (PathBuf, PathBuf) {
-        self.ensure_test_entry();
-
-        let webidl_modules = self.generate_webidl_bindings();
-        self.generate_js_entry(webidl_modules);
-
-        let mut manifest = format!(
-            r#"
-            [package]
-            name = "test{}"
-            version = "0.0.1"
-            authors = []
-
-            [workspace]
-
-            [lib]
-        "#,
-            IDX.with(|x| *x)
-        );
-
-        if !self.rlib {
-            manifest.push_str("crate-type = [\"cdylib\"]\n");
-        }
-
-        manifest.push_str("[build-dependencies]\n");
-        manifest.push_str("wasm-bindgen-webidl = { path = '");
-        manifest.push_str(env!("CARGO_MANIFEST_DIR"));
-        manifest.push_str("/crates/webidl' }\n");
-
-        manifest.push_str("[dependencies]\n");
-        for dep in self.deps.iter() {
-            manifest.push_str(dep);
-            manifest.push_str("\n");
-        }
-        manifest.push_str("wasm-bindgen = { path = '");
-        manifest.push_str(env!("CARGO_MANIFEST_DIR"));
-        manifest.push_str("'");
-        if self.no_std {
-            manifest.push_str(", default-features = false");
-        }
-        if self.serde {
-            manifest.push_str(", features = ['serde-serialize']");
-        }
-        manifest.push_str(" }\n");
-        self.files.push(("Cargo.toml".to_string(), manifest));
-
-        let root = root();
-        drop(fs::remove_dir_all(&root));
-        for &(ref file, ref contents) in self.files.iter() {
-            let dst = root.join(file);
-            fs::create_dir_all(dst.parent().unwrap()).unwrap();
-            fs::File::create(&dst)
-                .unwrap()
-                .write_all(contents.as_ref())
-                .unwrap();
-        }
-        let target_dir = root.parent().unwrap() // chop off test name
-            .parent().unwrap(); // chop off `generated-tests`
-        (root.clone(), target_dir.to_path_buf())
-    }
-
-    fn test(&mut self) {
-        let (root, target_dir) = self.cargo_build();
-
-        self.gen_bindings(&root, &target_dir);
-        let mut wasm = Vec::new();
-        File::open(root.join("out_bg.wasm"))
-            .unwrap()
-            .read_to_end(&mut wasm)
-            .unwrap();
-        let obj = cli::wasm2es6js::Config::new()
-            .base64(true)
-            .generate(&wasm)
-            .expect("failed to convert wasm to js");
-
-        File::create(root.join("out_bg.d.ts"))
-            .unwrap()
-            .write_all(obj.typescript().as_bytes())
-            .unwrap();
-
-        // move files from the root into each test, it looks like this may be
-        // needed for webpack to work well when invoked concurrently.
-        fs::hard_link("package.json", root.join("package.json")).unwrap();
-        if !Path::new("node_modules").exists() {
-            panic!("\n\nfailed to find `node_modules`, have you run `npm install` yet?\n\n");
-        }
-        let cwd = env::current_dir().unwrap();
-        symlink_dir(&cwd.join("node_modules"), &root.join("node_modules")).unwrap();
-
-        if self.node {
-            let mut cmd = Command::new("node");
-            cmd.args(&self.node_args);
-            cmd.arg(root.join("run-node.js")).current_dir(&root);
-            run(&mut cmd, "node");
-        } else {
-            let mut cmd = if cfg!(windows) {
-                let mut c = Command::new("cmd");
-                c.arg("/c");
-                c.arg("npm");
-                c
-            } else {
-                Command::new("npm")
-            };
-            cmd.arg("run").arg("run-webpack").current_dir(&root);
-            run(&mut cmd, "npm");
-
-            let mut cmd = Command::new("node");
-            cmd.args(&self.node_args);
-            cmd.arg(root.join("bundle.js")).current_dir(&root);
-            run(&mut cmd, "node");
-        }
-    }
-    /// execute the cli against the current test .wasm
-    fn gen_bindings(&self, root: &PathBuf, target_dir: &PathBuf) {
-        let idx = IDX.with(|x| *x);
-        let out = target_dir.join(&format!("wasm32-unknown-unknown/debug/test{}.wasm", idx));
-
-        let as_a_module = root.join("out.wasm");
-        fs::copy(&out, &as_a_module).unwrap();
-
-        let res = cli::Bindgen::new()
-            .input_path(&as_a_module)
-            .typescript(true)
-            .nodejs(self.node)
-            .debug(self.debug)
-            .generate(&root);
-        if let Err(e) = res {
-            for e in e.causes() {
-                println!("- {}", e);
-            }
-            panic!("failed");
-        }
-    }
-    fn read_js(&self) -> String {
-        let path = root().join("out.js");
-        println!("js, {:?}", &path);
-        fs::read_to_string(path).expect("Unable to read js")
-    }
-}
-
-#[cfg(unix)]
-fn symlink_dir(a: &Path, b: &Path) -> io::Result<()> {
-    use std::os::unix::fs::symlink;
-    symlink(a, b)
-}
-
-#[cfg(windows)]
-fn symlink_dir(a: &Path, b: &Path) -> io::Result<()> {
-    use std::os::windows::fs::symlink_dir;
-    symlink_dir(a, b)
-}
-
-fn run(cmd: &mut Command, program: &str) {
-    println!("···················································");
-    println!("running {:?}", cmd);
-    let start = Instant::now();
-    let output = match cmd.output() {
-        Ok(output) => output,
-        Err(err) => panic!("failed to spawn `{}`: {}", program, err),
-    };
-    println!("exit: {}", output.status);
-    let dur = start.elapsed();
-    println!(
-        "dur: {}.{:03}ms",
-        dur.as_secs(),
-        dur.subsec_nanos() / 1_000_000
-    );
-    if output.stdout.len() > 0 {
-        println!("stdout ---\n{}", String::from_utf8_lossy(&output.stdout));
-    }
-    if output.stderr.len() > 0 {
-        println!("stderr ---\n{}", String::from_utf8_lossy(&output.stderr));
-    }
-    assert!(output.status.success());
-}
+use project_builder::{project, run};
 
 mod api;
 mod char;
@@ -559,6 +21,7 @@ mod non_wasm;
 mod simple;
 mod slice;
 mod structural;
+mod typescript;
 mod u64;
 mod validate_prt;
 mod webidl;
diff --git a/tests/all/math.rs b/tests/all/math.rs
index 07f5bd9b..99562800 100644
--- a/tests/all/math.rs
+++ b/tests/all/math.rs
@@ -6,77 +6,77 @@ fn auto_bind_math() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section)]
+                #![feature(proc_macro, wasm_custom_section)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen]
-            pub fn math(a: f32, b: f64) -> f64 {
-                b.acos() +
-                    b.asin() +
-                    b.atan() +
-                    b.atan2(b) +
-                    b.cbrt() +
-                    b.cosh() +
-                    b.exp_m1() +
-                    b.ln_1p() +
-                    b.sinh() +
-                    b.tan() +
-                    b.tanh() +
-                    b.hypot(b) +
-                    b.cos() +
-                    b.exp() +
-                    b.exp2() +
-                    b.mul_add(b, b) +
-                    b.ln() +
-                    b.log(b) +
-                    b.log10() +
-                    b.log2() +
-                    b.powi(8) +
-                    b.powf(b) +
-                    b.round() +
-                    b.sin() +
-                    b.abs() +
-                    b.signum() +
-                    b.floor() +
-                    b.ceil() +
-                    b.trunc() +
-                    b.sqrt() +
-                    (b % (a as f64)) +
-                    ((a.cos() +
-                    a.exp() +
-                    a.exp2() +
-                    a.mul_add(a, a) +
-                    a.ln() +
-                    a.log(a) +
-                    a.log10() +
-                    a.log2() +
-                    a.powi(8) +
-                    a.powf(a) +
-                    a.round() +
-                    a.sin() +
-                    a.abs() +
-                    a.signum() +
-                    a.floor() +
-                    a.ceil() +
-                    a.trunc() +
-                    a.sqrt() +
-                    (a % (b as f32))) as f64) +
-                    (b + 2.0f64.powf(a as f64))
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn math(a: f32, b: f64) -> f64 {
+                    b.acos() +
+                        b.asin() +
+                        b.atan() +
+                        b.atan2(b) +
+                        b.cbrt() +
+                        b.cosh() +
+                        b.exp_m1() +
+                        b.ln_1p() +
+                        b.sinh() +
+                        b.tan() +
+                        b.tanh() +
+                        b.hypot(b) +
+                        b.cos() +
+                        b.exp() +
+                        b.exp2() +
+                        b.mul_add(b, b) +
+                        b.ln() +
+                        b.log(b) +
+                        b.log10() +
+                        b.log2() +
+                        b.powi(8) +
+                        b.powf(b) +
+                        b.round() +
+                        b.sin() +
+                        b.abs() +
+                        b.signum() +
+                        b.floor() +
+                        b.ceil() +
+                        b.trunc() +
+                        b.sqrt() +
+                        (b % (a as f64)) +
+                        ((a.cos() +
+                        a.exp() +
+                        a.exp2() +
+                        a.mul_add(a, a) +
+                        a.ln() +
+                        a.log(a) +
+                        a.log10() +
+                        a.log2() +
+                        a.powi(8) +
+                        a.powf(a) +
+                        a.round() +
+                        a.sin() +
+                        a.abs() +
+                        a.signum() +
+                        a.floor() +
+                        a.ceil() +
+                        a.trunc() +
+                        a.sqrt() +
+                        (a % (b as f32))) as f64) +
+                        (b + 2.0f64.powf(a as f64))
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import { math } from "./out";
+                import { math } from "./out";
 
-            export function test() {
-                math(1.0, 2.0);
-            }
-        "#,
+                export function test() {
+                    math(1.0, 2.0);
+                }
+            "#,
         )
         .test();
 }
diff --git a/tests/all/node.rs b/tests/all/node.rs
index 2f98eb35..29b1b4d1 100644
--- a/tests/all/node.rs
+++ b/tests/all/node.rs
@@ -3,158 +3,159 @@ use super::project;
 #[test]
 fn works() {
     project()
-        .node(true)
+        .debug(false)
+        .nodejs_experimental_modules(false)
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen(module = "./test")]
-            extern {
-                static FOO: JsValue;
-                fn hit();
-            }
-
-            #[wasm_bindgen]
-            pub fn run() {
-                hit();
-                assert_eq!(FOO.as_f64(), Some(1.0));
-            }
-
-            #[wasm_bindgen]
-            pub struct Foo {
-                contents: u32,
-            }
-
-            #[wasm_bindgen]
-            impl Foo {
-                pub fn new() -> Foo {
-                    Foo::with_contents(0)
+                #[wasm_bindgen(module = "./test")]
+                extern {
+                    static FOO: JsValue;
+                    fn hit();
                 }
-                pub fn with_contents(a: u32) -> Foo {
-                    Foo { contents: a }
-                }
-                pub fn add(&mut self, amt: u32) -> u32 {
-                    self.contents += amt;
-                    self.contents
-                }
-            }
 
-            #[wasm_bindgen]
-            pub enum Color {
-                Green,
-                Yellow,
-                Red,
-            }
-            #[wasm_bindgen]
-            pub fn cycle(color: Color) -> Color {
-                match color {
-                    Color::Green => Color::Yellow,
-                    Color::Yellow => Color::Red,
-                    Color::Red => Color::Green,
+                #[wasm_bindgen]
+                pub fn run() {
+                    hit();
+                    assert_eq!(FOO.as_f64(), Some(1.0));
                 }
-            }
 
-            #[wasm_bindgen]
-            pub fn math(a: f32, b: f64) -> f64 {
-                b.acos() +
-                    b.asin() +
-                    b.atan() +
-                    b.atan2(b) +
-                    b.cbrt() +
-                    b.cosh() +
-                    b.exp_m1() +
-                    b.ln_1p() +
-                    b.sinh() +
-                    b.tan() +
-                    b.tanh() +
-                    b.hypot(b) +
-                    b.cos() +
-                    b.exp() +
-                    b.exp2() +
-                    b.mul_add(b, b) +
-                    b.ln() +
-                    b.log(b) +
-                    b.log10() +
-                    b.log2() +
-                    b.powi(8) +
-                    b.powf(b) +
-                    b.round() +
-                    b.sin() +
-                    b.abs() +
-                    b.signum() +
-                    b.floor() +
-                    b.ceil() +
-                    b.trunc() +
-                    b.sqrt() +
-                    (b % (a as f64)) +
-                    ((a.cos() +
-                    a.exp() +
-                    a.exp2() +
-                    a.mul_add(a, a) +
-                    a.ln() +
-                    a.log(a) +
-                    a.log10() +
-                    a.log2() +
-                    a.powi(8) +
-                    a.powf(a) +
-                    a.round() +
-                    a.sin() +
-                    a.abs() +
-                    a.signum() +
-                    a.floor() +
-                    a.ceil() +
-                    a.trunc() +
-                    a.sqrt() +
-                    (a % (b as f32))) as f64) +
-                    (b + 2.0f64.powf(a as f64))
-            }
-        "#,
+                #[wasm_bindgen]
+                pub struct Foo {
+                    contents: u32,
+                }
+
+                #[wasm_bindgen]
+                impl Foo {
+                    pub fn new() -> Foo {
+                        Foo::with_contents(0)
+                    }
+                    pub fn with_contents(a: u32) -> Foo {
+                        Foo { contents: a }
+                    }
+                    pub fn add(&mut self, amt: u32) -> u32 {
+                        self.contents += amt;
+                        self.contents
+                    }
+                }
+
+                #[wasm_bindgen]
+                pub enum Color {
+                    Green,
+                    Yellow,
+                    Red,
+                }
+                #[wasm_bindgen]
+                pub fn cycle(color: Color) -> Color {
+                    match color {
+                        Color::Green => Color::Yellow,
+                        Color::Yellow => Color::Red,
+                        Color::Red => Color::Green,
+                    }
+                }
+
+                #[wasm_bindgen]
+                pub fn math(a: f32, b: f64) -> f64 {
+                    b.acos() +
+                        b.asin() +
+                        b.atan() +
+                        b.atan2(b) +
+                        b.cbrt() +
+                        b.cosh() +
+                        b.exp_m1() +
+                        b.ln_1p() +
+                        b.sinh() +
+                        b.tan() +
+                        b.tanh() +
+                        b.hypot(b) +
+                        b.cos() +
+                        b.exp() +
+                        b.exp2() +
+                        b.mul_add(b, b) +
+                        b.ln() +
+                        b.log(b) +
+                        b.log10() +
+                        b.log2() +
+                        b.powi(8) +
+                        b.powf(b) +
+                        b.round() +
+                        b.sin() +
+                        b.abs() +
+                        b.signum() +
+                        b.floor() +
+                        b.ceil() +
+                        b.trunc() +
+                        b.sqrt() +
+                        (b % (a as f64)) +
+                        ((a.cos() +
+                        a.exp() +
+                        a.exp2() +
+                        a.mul_add(a, a) +
+                        a.ln() +
+                        a.log(a) +
+                        a.log10() +
+                        a.log2() +
+                        a.powi(8) +
+                        a.powf(a) +
+                        a.round() +
+                        a.sin() +
+                        a.abs() +
+                        a.signum() +
+                        a.floor() +
+                        a.ceil() +
+                        a.trunc() +
+                        a.sqrt() +
+                        (a % (b as f32))) as f64) +
+                        (b + 2.0f64.powf(a as f64))
+                }
+            "#,
         )
         .file(
             "test.js",
             r#"
-            const assert = require('assert');
+                const assert = require('assert');
 
-            var called = false;
+                var called = false;
 
-            module.exports.hit = function() {
-                called = true;
-            };
-            module.exports.FOO = 1.0;
+                module.exports.hit = function() {
+                    called = true;
+                };
 
-            const { math, run, Foo, Color, cycle } = require('./out');
+                module.exports.FOO = 1.0;
 
-            module.exports.test = function() {
-                run();
-                assert.strictEqual(called, true);
+                const { math, run, Foo, Color, cycle } = require('./out');
 
-                var r = Foo.new();
-                assert.strictEqual(r.add(0), 0);
-                assert.strictEqual(r.add(1), 1);
-                assert.strictEqual(r.add(2), 3);
-                r.free();
+                module.exports.test = function() {
+                    run();
+                    assert.strictEqual(called, true);
 
-                var r2 = Foo.with_contents(10);
-                assert.strictEqual(r2.add(0), 10);
-                assert.strictEqual(r2.add(1), 11);
-                assert.strictEqual(r2.add(2), 13);
-                r2.free();
+                    var r = Foo.new();
+                    assert.strictEqual(r.add(0), 0);
+                    assert.strictEqual(r.add(1), 1);
+                    assert.strictEqual(r.add(2), 3);
+                    r.free();
 
-                assert.strictEqual(Color.Green, 0);
-                assert.strictEqual(Color.Yellow, 1);
-                assert.strictEqual(Color.Red, 2);
-                assert.strictEqual(Object.keys(Color).length, 3);
-                assert.strictEqual(cycle(Color.Green), Color.Yellow);
+                    var r2 = Foo.with_contents(10);
+                    assert.strictEqual(r2.add(0), 10);
+                    assert.strictEqual(r2.add(1), 11);
+                    assert.strictEqual(r2.add(2), 13);
+                    r2.free();
 
-                math(1.0, 2.0);
-            };
+                    assert.strictEqual(Color.Green, 0);
+                    assert.strictEqual(Color.Yellow, 1);
+                    assert.strictEqual(Color.Red, 2);
+                    assert.strictEqual(Object.keys(Color).length, 3);
+                    assert.strictEqual(cycle(Color.Green), Color.Yellow);
 
-        "#,
+                    math(1.0, 2.0);
+                };
+            "#,
         )
         .test();
 }
diff --git a/tests/all/non_debug.rs b/tests/all/non_debug.rs
index c6afd316..4618d2a7 100644
--- a/tests/all/non_debug.rs
+++ b/tests/all/non_debug.rs
@@ -7,42 +7,42 @@ fn works() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen]
-            pub struct A {}
+                #[wasm_bindgen]
+                pub struct A {}
 
-            #[wasm_bindgen]
-            impl A {
-                pub fn new() -> A {
-                    A {}
+                #[wasm_bindgen]
+                impl A {
+                    pub fn new() -> A {
+                        A {}
+                    }
                 }
-            }
 
-            #[wasm_bindgen]
-            pub fn clone(a: &JsValue) -> JsValue {
-                drop(a.clone());
-                a.clone()
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn clone(a: &JsValue) -> JsValue {
+                    drop(a.clone());
+                    a.clone()
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import * as assert from "assert";
-            import * as wasm from "./out";
+                import * as assert from "assert";
+                import * as wasm from "./out";
 
-            export function test() {
-                let sym = (Symbol as any)('a');
-                assert.strictEqual(wasm.clone(sym), sym);
-                let a = wasm.A.new();
-                a.free();
-            }
-        "#,
+                export function test() {
+                    let sym = Symbol('a');
+                    assert.strictEqual(wasm.clone(sym), sym);
+                    let a = wasm.A.new();
+                    a.free();
+                }
+            "#,
         )
         .test();
 }
diff --git a/tests/all/simple.rs b/tests/all/simple.rs
index 69afbf4f..95b5a70c 100644
--- a/tests/all/simple.rs
+++ b/tests/all/simple.rs
@@ -6,55 +6,88 @@ fn add() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section)]
+                #![feature(proc_macro, wasm_custom_section)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen]
-            pub fn add(a: u32, b: u32) -> u32 {
-                a + b
-            }
-
-            #[wasm_bindgen]
-            pub fn add3(a: u32) -> u32 {
-                a + 3
-            }
-
-            #[wasm_bindgen]
-            pub fn get2(_b: bool) -> u32 {
-                2
-            }
-
-            #[wasm_bindgen]
-            pub fn return_and_take_bool(a: bool, b: bool) -> bool {
-                a && b
-            }
-
-            #[wasm_bindgen]
-            pub fn raw_pointers_work(a: *mut u32, b: *const u8) -> *const u32 {
-                unsafe {
-                    (*a) = (*b) as u32;
-                    return a
+                #[wasm_bindgen]
+                pub fn add(a: u32, b: u32) -> u32 {
+                    a + b
                 }
-            }
-        "#,
+
+                #[wasm_bindgen]
+                pub fn add3(a: u32) -> u32 {
+                    a + 3
+                }
+
+                #[wasm_bindgen]
+                pub fn get2(_b: bool) -> u32 {
+                    2
+                }
+
+                #[wasm_bindgen]
+                pub fn return_and_take_bool(a: bool, b: bool) -> bool {
+                    a && b
+                }
+
+                #[wasm_bindgen]
+                pub fn raw_pointers_work(a: *mut u32, b: *const u8) -> *const u32 {
+                    unsafe {
+                        (*a) = (*b) as u32;
+                        return a
+                    }
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import * as assert from "assert";
-            import * as wasm from "./out";
+                import * as assert from "assert";
+                import * as wasm from "./out";
 
-            export function test() {
-                assert.strictEqual(wasm.add(1, 2), 3);
-                assert.strictEqual(wasm.add(2, 3), 5);
-                assert.strictEqual(wasm.add3(2), 5);
-                assert.strictEqual(wasm.get2(true), 2);
-                assert.strictEqual(wasm.return_and_take_bool(true, false), false);
-            }
-        "#,
+                export function test() {
+                    assert.strictEqual(wasm.add(1, 2), 3);
+                    assert.strictEqual(wasm.add(2, 3), 5);
+                    assert.strictEqual(wasm.add3(2), 5);
+                    assert.strictEqual(wasm.get2(true), 2);
+                    assert.strictEqual(wasm.return_and_take_bool(true, false), false);
+                }
+            "#,
+        )
+        .test();
+}
+
+#[test]
+fn add_headless() {
+    project()
+        .headless(true)
+        .file(
+            "src/lib.rs",
+            r#"
+                #![feature(proc_macro, wasm_custom_section)]
+                extern crate wasm_bindgen;
+                use wasm_bindgen::prelude::*;
+
+                #[wasm_bindgen]
+                pub fn add(a: u32, b: u32) -> u32 {
+                    a + b
+                }
+            "#,
+        )
+        .file(
+            "test.js",
+            r#"
+                import * as assert from "assert";
+                import * as wasm from "./out";
+
+                export function test() {
+                    console.log("start `add_headless` test");
+                    assert.strictEqual(wasm.add(1, 2), 3);
+                    console.log("end `add_headless` test");
+               }
+            "#,
         )
         .test();
 }
@@ -65,34 +98,34 @@ fn string_arguments() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section)]
+                #![feature(proc_macro, wasm_custom_section)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen]
-            pub fn assert_foo_and_bar(a: &str, b: &str) {
-                assert_eq!(a, "foo2");
-                assert_eq!(b, "bar");
-            }
+                #[wasm_bindgen]
+                pub fn assert_foo_and_bar(a: &str, b: &str) {
+                    assert_eq!(a, "foo2");
+                    assert_eq!(b, "bar");
+                }
 
-            #[wasm_bindgen]
-            pub fn assert_foo(a: &str) {
-                assert_eq!(a, "foo");
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn assert_foo(a: &str) {
+                    assert_eq!(a, "foo");
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import * as wasm from "./out";
+                import * as wasm from "./out";
 
-            export function test() {
-                wasm.assert_foo("foo");
-                wasm.assert_foo_and_bar("foo2", "bar");
-            }
-        "#,
+                export function test() {
+                    wasm.assert_foo("foo");
+                    wasm.assert_foo_and_bar("foo2", "bar");
+                }
+            "#,
         )
         .test();
 }
@@ -103,36 +136,36 @@ fn return_a_string() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section)]
+                #![feature(proc_macro, wasm_custom_section)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen]
-            pub fn clone(a: &str) -> String {
-                a.to_string()
-            }
+                #[wasm_bindgen]
+                pub fn clone(a: &str) -> String {
+                    a.to_string()
+                }
 
-            #[wasm_bindgen]
-            pub fn concat(a: &str, b: &str, c: i8) -> String {
-                format!("{} {} {}", a, b, c)
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn concat(a: &str, b: &str, c: i8) -> String {
+                    format!("{} {} {}", a, b, c)
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import * as assert from "assert";
-            import * as wasm from "./out";
+                import * as assert from "assert";
+                import * as wasm from "./out";
 
-            export function test() {
-                assert.strictEqual(wasm.clone("foo"), "foo");
-                assert.strictEqual(wasm.clone("another"), "another");
-                assert.strictEqual(wasm.concat("a", "b", 3), "a b 3");
-                assert.strictEqual(wasm.concat("c", "d", -2), "c d -2");
-            }
-        "#,
+                export function test() {
+                    assert.strictEqual(wasm.clone("foo"), "foo");
+                    assert.strictEqual(wasm.clone("another"), "another");
+                    assert.strictEqual(wasm.concat("a", "b", 3), "a b 3");
+                    assert.strictEqual(wasm.concat("c", "d", -2), "c d -2");
+                }
+            "#,
         )
         .test();
 }
@@ -143,36 +176,30 @@ fn exceptions() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section)]
+                #![feature(proc_macro, wasm_custom_section)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen]
-            pub fn foo(_a: u32) {}
+                #[wasm_bindgen]
+                pub fn foo(_a: u32) {}
 
-            #[wasm_bindgen]
-            pub fn bar(_a: &str) {}
-        "#,
+                #[wasm_bindgen]
+                pub fn bar(_a: &str) {}
+            "#,
         )
         .file(
             "test.js",
             r#"
-            import * as assert from "assert";
-            import * as wasm from "./out";
+                import * as assert from "assert";
+                import * as wasm from "./out";
 
-            export function test() {
-                assert.throws(() => wasm.foo('a'), /expected a number argument/);
-                assert.throws(() => wasm.bar(3), /expected a string argument/);
-            }
-        "#,
-        )
-        .file(
-            "test.d.ts",
-            r#"
-            export function test(): void;
-        "#,
+                export function test() {
+                    assert.throws(() => wasm.foo('a'), /expected a number argument/);
+                    assert.throws(() => wasm.bar(3), /expected a string argument/);
+                }
+            "#,
         )
         .test();
 }
@@ -197,7 +224,7 @@ fn exceptions() {
 //                 }
 //             }
 //         "#)
-//         .file("test.ts", r#"
+//         .file("test.js", r#"
 //             import * as assert from "assert";
 //             import * as wasm from "./out";
 //
@@ -217,20 +244,20 @@ fn other_exports() {
         .file(
             "src/lib.rs",
             r#"
-            #[no_mangle]
-            pub extern fn foo(_a: u32) {
-            }
-        "#,
+                #[no_mangle]
+                pub extern fn foo(_a: u32) {
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import * as wasm from "./out_bg";
+                import * as wasm from "./out_bg";
 
-            export function test() {
-                wasm.foo(2);
-            }
-        "#,
+                export function test() {
+                    wasm.foo(2);
+                }
+            "#,
         )
         .test();
 }
@@ -242,49 +269,49 @@ fn no_std() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
-            #![no_std]
-            #![allow(dead_code)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![no_std]
+                #![allow(dead_code)]
 
-            extern crate wasm_bindgen;
-            extern crate std as _some_other_name;
+                extern crate wasm_bindgen;
+                extern crate std as _some_other_name;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen(module = "./foo")]
-            extern {
-                fn test(a: &str);
+                #[wasm_bindgen(module = "./foo")]
+                extern {
+                    fn test(a: &str);
 
-                type Js;
-                #[wasm_bindgen(constructor)]
-                fn new() -> Js;
-                #[wasm_bindgen(method)]
-                fn init(this: &Js);
-            }
+                    type Js;
+                    #[wasm_bindgen(constructor)]
+                    fn new() -> Js;
+                    #[wasm_bindgen(method)]
+                    fn init(this: &Js);
+                }
 
-            #[wasm_bindgen]
-            pub fn foo(_a: u32) {}
-        "#,
+                #[wasm_bindgen]
+                pub fn foo(_a: u32) {}
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import * as wasm from "./out_bg";
+                import * as wasm from "./out_bg";
 
-            export function test() {
-                // mostly just testing the project compiles here
-                wasm.foo(1);
-            }
-        "#,
+                export function test() {
+                    // mostly just testing the project compiles here
+                    wasm.foo(1);
+                }
+            "#,
         )
         .file(
             "foo.js",
             r#"
-            export class Js {
-                init() {
+                export class Js {
+                    init() {
+                    }
                 }
-            }
-        "#,
+            "#,
         )
         .test();
 }
@@ -295,49 +322,49 @@ fn no_std_class() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
-            #![no_std]
-            #![allow(dead_code)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![no_std]
+                #![allow(dead_code)]
 
-            extern crate wasm_bindgen;
-            extern crate std as _some_other_name;
+                extern crate wasm_bindgen;
+                extern crate std as _some_other_name;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen]
-            extern {
-                fn test(a: &str);
+                #[wasm_bindgen]
+                extern {
+                    fn test(a: &str);
 
-                type Js;
-                #[wasm_bindgen(constructor)]
-                fn new() -> Js;
-                #[wasm_bindgen(method, structural)]
-                fn init(this: &Js);
-            }
+                    type Js;
+                    #[wasm_bindgen(constructor)]
+                    fn new() -> Js;
+                    #[wasm_bindgen(method, structural)]
+                    fn init(this: &Js);
+                }
 
-            #[wasm_bindgen]
-            pub fn foo(_a: u32) {}
+                #[wasm_bindgen]
+                pub fn foo(_a: u32) {}
 
-            #[wasm_bindgen]
-            pub struct A {}
+                #[wasm_bindgen]
+                pub struct A {}
 
-            #[wasm_bindgen]
-            impl A {
-                pub fn foo(&self) {}
-                pub fn bar(&mut self) {}
-            }
-        "#,
+                #[wasm_bindgen]
+                impl A {
+                    pub fn foo(&self) {}
+                    pub fn bar(&mut self) {}
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import * as wasm from "./out_bg";
+                import * as wasm from "./out_bg";
 
-            export function test() {
-                // mostly just testing the project compiles here
-                wasm.foo(1);
-            }
-        "#,
+                export function test() {
+                    // mostly just testing the project compiles here
+                    wasm.foo(1);
+                }
+            "#,
         )
         .test();
 }
diff --git a/tests/all/slice.rs b/tests/all/slice.rs
index 200edac9..29b528b5 100644
--- a/tests/all/slice.rs
+++ b/tests/all/slice.rs
@@ -6,82 +6,82 @@ fn export() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section)]
+                #![feature(proc_macro, wasm_custom_section)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            macro_rules! doit {
-                ($($i:ident)*) => ($(
-                    #[wasm_bindgen]
-                    pub fn $i(a: &[$i]) -> Vec<$i> {
-                        assert_eq!(a.len(), 2);
-                        assert_eq!(a[0], 1 as $i);
-                        assert_eq!(a[1], 2 as $i);
-                        a.to_vec()
-                    }
-                )*)
-            }
+                macro_rules! doit {
+                    ($($i:ident)*) => ($(
+                        #[wasm_bindgen]
+                        pub fn $i(a: &[$i]) -> Vec<$i> {
+                            assert_eq!(a.len(), 2);
+                            assert_eq!(a[0], 1 as $i);
+                            assert_eq!(a[1], 2 as $i);
+                            a.to_vec()
+                        }
+                    )*)
+                }
 
 
-            doit! { i8 u8 i16 u16 i32 u32 f32 f64 }
-        "#,
+                doit! { i8 u8 i16 u16 i32 u32 f32 f64 }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import * as assert from "assert";
-            import * as wasm from "./out";
+                import * as assert from "assert";
+                import * as wasm from "./out";
 
-            function assert_arrays_equal(a: any, b: any) {
-                console.log(a, b);
-                assert.strictEqual(a.length, b.length);
-                assert.strictEqual(a.byteLength, b.byteLength);
-                for (let i = 0; i < a.length; i++) {
-                    assert.strictEqual(a[i], b[i]);
+                function assert_arrays_equal(a, b) {
+                    console.log(a, b);
+                    assert.strictEqual(a.length, b.length);
+                    assert.strictEqual(a.byteLength, b.byteLength);
+                    for (let i = 0; i < a.length; i++) {
+                        assert.strictEqual(a[i], b[i]);
+                    }
                 }
-            }
 
-            export function test() {
-                const i8 = new Int8Array(2);
-                i8[0] = 1;
-                i8[1] = 2;
-                assert_arrays_equal(wasm.i8(i8), i8);
-                const u8 = new Uint8Array(2);
-                u8[0] = 1;
-                u8[1] = 2;
-                assert_arrays_equal(wasm.u8(u8), u8);
+                export function test() {
+                    const i8 = new Int8Array(2);
+                    i8[0] = 1;
+                    i8[1] = 2;
+                    assert_arrays_equal(wasm.i8(i8), i8);
+                    const u8 = new Uint8Array(2);
+                    u8[0] = 1;
+                    u8[1] = 2;
+                    assert_arrays_equal(wasm.u8(u8), u8);
 
-                const i16 = new Int16Array(2);
-                i16[0] = 1;
-                i16[1] = 2;
-                assert_arrays_equal(wasm.i16(i16), i16);
-                const u16 = new Uint16Array(2);
-                u16[0] = 1;
-                u16[1] = 2;
-                assert_arrays_equal(wasm.u16(u16), u16);
+                    const i16 = new Int16Array(2);
+                    i16[0] = 1;
+                    i16[1] = 2;
+                    assert_arrays_equal(wasm.i16(i16), i16);
+                    const u16 = new Uint16Array(2);
+                    u16[0] = 1;
+                    u16[1] = 2;
+                    assert_arrays_equal(wasm.u16(u16), u16);
 
-                const i32 = new Int32Array(2);
-                i32[0] = 1;
-                i32[1] = 2;
-                wasm.i32(i32);
-                assert_arrays_equal(wasm.i32(i32), i32);
-                const u32 = new Uint32Array(2);
-                u32[0] = 1;
-                u32[1] = 2;
-                assert_arrays_equal(wasm.u32(u32), u32);
+                    const i32 = new Int32Array(2);
+                    i32[0] = 1;
+                    i32[1] = 2;
+                    wasm.i32(i32);
+                    assert_arrays_equal(wasm.i32(i32), i32);
+                    const u32 = new Uint32Array(2);
+                    u32[0] = 1;
+                    u32[1] = 2;
+                    assert_arrays_equal(wasm.u32(u32), u32);
 
-                const f32 = new Float32Array(2);
-                f32[0] = 1;
-                f32[1] = 2;
-                assert_arrays_equal(wasm.f32(f32), f32);
-                const f64 = new Float64Array(2);
-                f64[0] = 1;
-                f64[1] = 2;
-                assert_arrays_equal(wasm.f64(f64), f64);
-          }
-      "#,
+                    const f32 = new Float32Array(2);
+                    f32[0] = 1;
+                    f32[1] = 2;
+                    assert_arrays_equal(wasm.f32(f32), f32);
+                    const f64 = new Float64Array(2);
+                    f64[0] = 1;
+                    f64[1] = 2;
+                    assert_arrays_equal(wasm.f64(f64), f64);
+                }
+            "#,
         )
         .test();
 }
@@ -92,151 +92,151 @@ fn import() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            macro_rules! doit {
-                ($(($rust:ident, $js:ident, $i:ident))*) => ($(
-                    #[wasm_bindgen(module = "./test")]
-                    extern {
-                        fn $js(a: &[$i]) -> Vec<$i>;
-                    }
+                macro_rules! doit {
+                    ($(($rust:ident, $js:ident, $i:ident))*) => ($(
+                        #[wasm_bindgen(module = "./test")]
+                        extern {
+                            fn $js(a: &[$i]) -> Vec<$i>;
+                        }
 
-                    #[wasm_bindgen]
-                    pub fn $rust(a: &[$i]) -> Vec<$i> {
-                        assert_eq!(a.len(), 2);
-                        assert_eq!(a[0], 1 as $i);
-                        assert_eq!(a[1], 2 as $i);
-                        $js(a)
-                    }
-                )*)
-            }
+                        #[wasm_bindgen]
+                        pub fn $rust(a: &[$i]) -> Vec<$i> {
+                            assert_eq!(a.len(), 2);
+                            assert_eq!(a[0], 1 as $i);
+                            assert_eq!(a[1], 2 as $i);
+                            $js(a)
+                        }
+                    )*)
+                }
 
 
-            doit! {
-                (rust_i8, js_i8, i8)
-                (rust_u8, js_u8, u8)
-                (rust_i16, js_i16, i16)
-                (rust_u16, js_u16, u16)
-                (rust_i32, js_i32, i32)
-                (rust_u32, js_u32, u32)
-                (rust_f32, js_f32, f32)
-                (rust_f64, js_f64, f64)
-            }
-        "#,
+                doit! {
+                    (rust_i8, js_i8, i8)
+                    (rust_u8, js_u8, u8)
+                    (rust_i16, js_i16, i16)
+                    (rust_u16, js_u16, u16)
+                    (rust_i32, js_i32, i32)
+                    (rust_u32, js_u32, u32)
+                    (rust_f32, js_f32, f32)
+                    (rust_f64, js_f64, f64)
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import * as assert from "assert";
-            import * as wasm from "./out";
+                import * as assert from "assert";
+                import * as wasm from "./out";
 
-            export function js_i8(a: any): any {
-                assert.strictEqual(a.length, 2);
-                assert.strictEqual(a[0], 1);
-                assert.strictEqual(a[1], 2);
-                return a;
-            }
-
-            export function js_u8(a: any): any {
-                assert.strictEqual(a.length, 2);
-                assert.strictEqual(a[0], 1);
-                assert.strictEqual(a[1], 2);
-                return a;
-            }
-
-            export function js_i16(a: any): any {
-                assert.strictEqual(a.length, 2);
-                assert.strictEqual(a[0], 1);
-                assert.strictEqual(a[1], 2);
-                return a;
-            }
-
-            export function js_u16(a: any): any {
-                assert.strictEqual(a.length, 2);
-                assert.strictEqual(a[0], 1);
-                assert.strictEqual(a[1], 2);
-                return a;
-            }
-
-            export function js_i32(a: any): any {
-                assert.strictEqual(a.length, 2);
-                assert.strictEqual(a[0], 1);
-                assert.strictEqual(a[1], 2);
-                return a;
-            }
-
-            export function js_u32(a: any): any {
-                assert.strictEqual(a.length, 2);
-                assert.strictEqual(a[0], 1);
-                assert.strictEqual(a[1], 2);
-                return a;
-            }
-
-            export function js_f32(a: any): any {
-                assert.strictEqual(a.length, 2);
-                assert.strictEqual(a[0], 1);
-                assert.strictEqual(a[1], 2);
-                return a;
-            }
-
-            export function js_f64(a: any): any {
-                assert.strictEqual(a.length, 2);
-                assert.strictEqual(a[0], 1);
-                assert.strictEqual(a[1], 2);
-                return a;
-            }
-
-            function assert_arrays_equal(a: any, b: any) {
-                console.log(a, b);
-                assert.strictEqual(a.length, b.length);
-                assert.strictEqual(a.byteLength, b.byteLength);
-                for (let i = 0; i < a.length; i++) {
-                    assert.strictEqual(a[i], b[i]);
+                export function js_i8(a) {
+                    assert.strictEqual(a.length, 2);
+                    assert.strictEqual(a[0], 1);
+                    assert.strictEqual(a[1], 2);
+                    return a;
                 }
-            }
 
-            export function test() {
-                const i8 = new Int8Array(2);
-                i8[0] = 1;
-                i8[1] = 2;
-                assert_arrays_equal(wasm.rust_i8(i8), i8);
-                const u8 = new Uint8Array(2);
-                u8[0] = 1;
-                u8[1] = 2;
-                assert_arrays_equal(wasm.rust_u8(u8), u8);
+                export function js_u8(a) {
+                    assert.strictEqual(a.length, 2);
+                    assert.strictEqual(a[0], 1);
+                    assert.strictEqual(a[1], 2);
+                    return a;
+                }
 
-                const i16 = new Int16Array(2);
-                i16[0] = 1;
-                i16[1] = 2;
-                assert_arrays_equal(wasm.rust_i16(i16), i16);
-                const u16 = new Uint16Array(2);
-                u16[0] = 1;
-                u16[1] = 2;
-                assert_arrays_equal(wasm.rust_u16(u16), u16);
+                export function js_i16(a) {
+                    assert.strictEqual(a.length, 2);
+                    assert.strictEqual(a[0], 1);
+                    assert.strictEqual(a[1], 2);
+                    return a;
+                }
 
-                const i32 = new Int32Array(2);
-                i32[0] = 1;
-                i32[1] = 2;
-                assert_arrays_equal(wasm.rust_i32(i32), i32);
-                const u32 = new Uint32Array(2);
-                u32[0] = 1;
-                u32[1] = 2;
-                assert_arrays_equal(wasm.rust_u32(u32), u32);
+                export function js_u16(a) {
+                    assert.strictEqual(a.length, 2);
+                    assert.strictEqual(a[0], 1);
+                    assert.strictEqual(a[1], 2);
+                    return a;
+                }
 
-                const f32 = new Float32Array(2);
-                f32[0] = 1;
-                f32[1] = 2;
-                assert_arrays_equal(wasm.rust_f32(f32), f32);
-                const f64 = new Float64Array(2);
-                f64[0] = 1;
-                f64[1] = 2;
-                assert_arrays_equal(wasm.rust_f64(f64), f64);
-            }
-        "#,
+                export function js_i32(a) {
+                    assert.strictEqual(a.length, 2);
+                    assert.strictEqual(a[0], 1);
+                    assert.strictEqual(a[1], 2);
+                    return a;
+                }
+
+                export function js_u32(a) {
+                    assert.strictEqual(a.length, 2);
+                    assert.strictEqual(a[0], 1);
+                    assert.strictEqual(a[1], 2);
+                    return a;
+                }
+
+                export function js_f32(a) {
+                    assert.strictEqual(a.length, 2);
+                    assert.strictEqual(a[0], 1);
+                    assert.strictEqual(a[1], 2);
+                    return a;
+                }
+
+                export function js_f64(a) {
+                    assert.strictEqual(a.length, 2);
+                    assert.strictEqual(a[0], 1);
+                    assert.strictEqual(a[1], 2);
+                    return a;
+                }
+
+                function assert_arrays_equal(a, b) {
+                    console.log(a, b);
+                    assert.strictEqual(a.length, b.length);
+                    assert.strictEqual(a.byteLength, b.byteLength);
+                    for (let i = 0; i < a.length; i++) {
+                        assert.strictEqual(a[i], b[i]);
+                    }
+                }
+
+                export function test() {
+                    const i8 = new Int8Array(2);
+                    i8[0] = 1;
+                    i8[1] = 2;
+                    assert_arrays_equal(wasm.rust_i8(i8), i8);
+                    const u8 = new Uint8Array(2);
+                    u8[0] = 1;
+                    u8[1] = 2;
+                    assert_arrays_equal(wasm.rust_u8(u8), u8);
+
+                    const i16 = new Int16Array(2);
+                    i16[0] = 1;
+                    i16[1] = 2;
+                    assert_arrays_equal(wasm.rust_i16(i16), i16);
+                    const u16 = new Uint16Array(2);
+                    u16[0] = 1;
+                    u16[1] = 2;
+                    assert_arrays_equal(wasm.rust_u16(u16), u16);
+
+                    const i32 = new Int32Array(2);
+                    i32[0] = 1;
+                    i32[1] = 2;
+                    assert_arrays_equal(wasm.rust_i32(i32), i32);
+                    const u32 = new Uint32Array(2);
+                    u32[0] = 1;
+                    u32[1] = 2;
+                    assert_arrays_equal(wasm.rust_u32(u32), u32);
+
+                    const f32 = new Float32Array(2);
+                    f32[0] = 1;
+                    f32[1] = 2;
+                    assert_arrays_equal(wasm.rust_f32(f32), f32);
+                    const f64 = new Float64Array(2);
+                    f64[0] = 1;
+                    f64[1] = 2;
+                    assert_arrays_equal(wasm.rust_f64(f64), f64);
+                }
+            "#,
         )
         .test();
 }
@@ -247,52 +247,52 @@ fn pass_array_works() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            macro_rules! doit {
-                ($(($rust:ident, $i:ident))*) => ($(
-                    #[wasm_bindgen]
-                    pub fn $rust(a: &[$i]) {
-                        assert_eq!(a.len(), 2);
-                        assert_eq!(a[0], 1 as $i);
-                        assert_eq!(a[1], 2 as $i);
-                    }
-                )*)
-            }
+                macro_rules! doit {
+                    ($(($rust:ident, $i:ident))*) => ($(
+                        #[wasm_bindgen]
+                        pub fn $rust(a: &[$i]) {
+                            assert_eq!(a.len(), 2);
+                            assert_eq!(a[0], 1 as $i);
+                            assert_eq!(a[1], 2 as $i);
+                        }
+                    )*)
+                }
 
 
-            doit! {
-                (rust_i8, i8)
-                (rust_u8, u8)
-                (rust_i16, i16)
-                (rust_u16, u16)
-                (rust_i32, i32)
-                (rust_u32, u32)
-                (rust_f32, f32)
-                (rust_f64, f64)
-            }
-        "#,
+                doit! {
+                    (rust_i8, i8)
+                    (rust_u8, u8)
+                    (rust_i16, i16)
+                    (rust_u16, u16)
+                    (rust_i32, i32)
+                    (rust_u32, u32)
+                    (rust_f32, f32)
+                    (rust_f64, f64)
+                }
+            "#,
         )
         .file(
             "test.js",
             r#"
-            const wasm = require("./out");
+                import * as wasm from "./out";
 
-            module.exports.test = function() {
-                wasm.rust_i8([1, 2]);
-                wasm.rust_u8([1, 2]);
-                wasm.rust_i16([1, 2]);
-                wasm.rust_u16([1, 2]);
-                wasm.rust_i32([1, 2]);
-                wasm.rust_u32([1, 2]);
-                wasm.rust_f32([1, 2]);
-                wasm.rust_f64([1, 2]);
-            };
-        "#,
+                export function test() {
+                    wasm.rust_i8([1, 2]);
+                    wasm.rust_u8([1, 2]);
+                    wasm.rust_i16([1, 2]);
+                    wasm.rust_u16([1, 2]);
+                    wasm.rust_i32([1, 2]);
+                    wasm.rust_u32([1, 2]);
+                    wasm.rust_f32([1, 2]);
+                    wasm.rust_f64([1, 2]);
+                }
+            "#,
         )
         .test();
 }
@@ -303,80 +303,80 @@ fn import_mut() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            macro_rules! doit {
-                ($(($rust:ident, $js:ident, $i:ident))*) => (
-                    $(
-                        #[wasm_bindgen(module = "./test")]
-                        extern {
-                            fn $js(a: &mut [$i]);
+                macro_rules! doit {
+                    ($(($rust:ident, $js:ident, $i:ident))*) => (
+                        $(
+                            #[wasm_bindgen(module = "./test")]
+                            extern {
+                                fn $js(a: &mut [$i]);
+                            }
+
+                            fn $rust() {
+                                let mut buf = [
+                                    1 as $i,
+                                    2 as $i,
+                                    3 as $i,
+                                ];
+                                $js(&mut buf);
+                                assert_eq!(buf[0], 4 as $i);
+                                assert_eq!(buf[1], 5 as $i);
+                                assert_eq!(buf[2], 3 as $i);
+                            }
+                        )*
+
+                        #[wasm_bindgen]
+                        pub fn run() {
+                            $($rust();)*
                         }
-
-                        fn $rust() {
-                            let mut buf = [
-                                1 as $i,
-                                2 as $i,
-                                3 as $i,
-                            ];
-                            $js(&mut buf);
-                            assert_eq!(buf[0], 4 as $i);
-                            assert_eq!(buf[1], 5 as $i);
-                            assert_eq!(buf[2], 3 as $i);
-                        }
-                    )*
-
-                    #[wasm_bindgen]
-                    pub fn run() {
-                        $($rust();)*
-                    }
-                )
-            }
+                    )
+                }
 
 
-            doit! {
-                (rust_i8, js_i8, i8)
-                (rust_u8, js_u8, u8)
-                (rust_i16, js_i16, i16)
-                (rust_u16, js_u16, u16)
-                (rust_i32, js_i32, i32)
-                (rust_u32, js_u32, u32)
-                (rust_f32, js_f32, f32)
-                (rust_f64, js_f64, f64)
-            }
-        "#,
+                doit! {
+                    (rust_i8, js_i8, i8)
+                    (rust_u8, js_u8, u8)
+                    (rust_i16, js_i16, i16)
+                    (rust_u16, js_u16, u16)
+                    (rust_i32, js_i32, i32)
+                    (rust_u32, js_u32, u32)
+                    (rust_f32, js_f32, f32)
+                    (rust_f64, js_f64, f64)
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import * as assert from "assert";
-            import * as wasm from "./out";
+                import * as assert from "assert";
+                import * as wasm from "./out";
 
-            function foo(a: any) {
-                assert.strictEqual(a.length, 3);
-                assert.strictEqual(a[0], 1);
-                assert.strictEqual(a[1], 2);
-                a[0] = 4;
-                a[1] = 5;
-            }
+                function foo(a) {
+                    assert.strictEqual(a.length, 3);
+                    assert.strictEqual(a[0], 1);
+                    assert.strictEqual(a[1], 2);
+                    a[0] = 4;
+                    a[1] = 5;
+                }
 
-            export const js_i8 = foo;
-            export const js_u8 = foo;
-            export const js_i16 = foo;
-            export const js_u16 = foo;
-            export const js_i32 = foo;
-            export const js_u32 = foo;
-            export const js_f32 = foo;
-            export const js_f64 = foo;
+                export const js_i8 = foo;
+                export const js_u8 = foo;
+                export const js_i16 = foo;
+                export const js_u16 = foo;
+                export const js_i32 = foo;
+                export const js_u32 = foo;
+                export const js_f32 = foo;
+                export const js_f64 = foo;
 
-            export function test() {
-                wasm.run();
-            }
-        "#,
+                export function test() {
+                    wasm.run();
+                }
+            "#,
         )
         .test();
 }
@@ -387,61 +387,61 @@ fn export_mut() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section)]
+                #![feature(proc_macro, wasm_custom_section)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            macro_rules! doit {
-                ($($i:ident)*) => ($(
-                    #[wasm_bindgen]
-                    pub fn $i(a: &mut [$i])  {
-                        assert_eq!(a.len(), 3);
-                        assert_eq!(a[0], 1 as $i);
-                        assert_eq!(a[1], 2 as $i);
-                        assert_eq!(a[2], 3 as $i);
-                        a[0] = 4 as $i;
-                        a[1] = 5 as $i;
-                    }
-                )*)
-            }
+                macro_rules! doit {
+                    ($($i:ident)*) => ($(
+                        #[wasm_bindgen]
+                        pub fn $i(a: &mut [$i])  {
+                            assert_eq!(a.len(), 3);
+                            assert_eq!(a[0], 1 as $i);
+                            assert_eq!(a[1], 2 as $i);
+                            assert_eq!(a[2], 3 as $i);
+                            a[0] = 4 as $i;
+                            a[1] = 5 as $i;
+                        }
+                    )*)
+                }
 
 
-            doit! { i8 u8 i16 u16 i32 u32 f32 f64 }
-        "#,
+                doit! { i8 u8 i16 u16 i32 u32 f32 f64 }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import * as assert from "assert";
-            import * as wasm from "./out";
+                import * as assert from "assert";
+                import * as wasm from "./out";
 
-            function run(a: any, rust: any) {
-                assert.strictEqual(a.length, 3);
-                a[0] = 1;
-                a[1] = 2;
-                a[2] = 3;
-                console.log(a);
-                rust(a);
-                console.log(a);
-                assert.strictEqual(a.length, 3);
-                assert.strictEqual(a[0], 4);
-                assert.strictEqual(a[1], 5);
-                assert.strictEqual(a[2], 3);
-            }
+                function run(a, rust) {
+                    assert.strictEqual(a.length, 3);
+                    a[0] = 1;
+                    a[1] = 2;
+                    a[2] = 3;
+                    console.log(a);
+                    rust(a);
+                    console.log(a);
+                    assert.strictEqual(a.length, 3);
+                    assert.strictEqual(a[0], 4);
+                    assert.strictEqual(a[1], 5);
+                    assert.strictEqual(a[2], 3);
+                }
 
-            export function test() {
-                run(new Int8Array(3), wasm.i8);
-                run(new Uint8Array(3), wasm.u8);
-                run(new Int16Array(3), wasm.i16);
-                run(new Uint16Array(3), wasm.u16);
-                run(new Int32Array(3), wasm.i32);
-                run(new Uint32Array(3), wasm.u32);
-                run(new Float32Array(3), wasm.f32);
-                run(new Float64Array(3), wasm.f64);
-          }
-      "#,
+                export function test() {
+                    run(new Int8Array(3), wasm.i8);
+                    run(new Uint8Array(3), wasm.u8);
+                    run(new Int16Array(3), wasm.i16);
+                    run(new Uint16Array(3), wasm.u16);
+                    run(new Int32Array(3), wasm.i32);
+                    run(new Uint32Array(3), wasm.u32);
+                    run(new Float32Array(3), wasm.f32);
+                    run(new Float64Array(3), wasm.f64);
+                }
+            "#,
         )
         .test();
 }
@@ -452,75 +452,75 @@ fn return_vec_ok() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
-            extern crate wasm_bindgen;
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen]
-            pub fn broken_vec() -> Vec<u32> {
-                vec![1, 2, 3, 4, 5, 6, 7, 8, 9]
-            }
+                #[wasm_bindgen]
+                pub fn broken_vec() -> Vec<u32> {
+                    vec![1, 2, 3, 4, 5, 6, 7, 8, 9]
+                }
 
-            #[wasm_bindgen]
-            pub fn web_main() -> Application {
-                Application::new()
-            }
+                #[wasm_bindgen]
+                pub fn web_main() -> Application {
+                    Application::new()
+                }
 
-            #[wasm_bindgen]
-            pub struct Application {
-                thing: Vec<u32>,
-            }
+                #[wasm_bindgen]
+                pub struct Application {
+                    thing: Vec<u32>,
+                }
 
-            #[wasm_bindgen]
-            impl Application {
-                pub fn new() -> Application {
-                    let mut thing = vec![];
-                    thing.push(0);
-                    thing.push(0);
-                    thing.push(0);
-                    thing.push(0);
-                    thing.push(0);
+                #[wasm_bindgen]
+                impl Application {
+                    pub fn new() -> Application {
+                        let mut thing = vec![];
+                        thing.push(0);
+                        thing.push(0);
+                        thing.push(0);
+                        thing.push(0);
+                        thing.push(0);
 
-                    Application {
-                        thing: thing
+                        Application {
+                            thing: thing
+                        }
+                    }
+                    pub fn tick(&mut self) {
+                        self.thing = self.thing.clone();
                     }
                 }
-                pub fn tick(&mut self) {
-                    self.thing = self.thing.clone();
-                }
-            }
 
-            pub fn main() {
-            }
-        "#,
+                pub fn main() {
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import * as assert from "assert";
-            import * as wasm from "./out";
+                import * as assert from "assert";
+                import * as wasm from "./out";
 
 
-            export function test() {
-                let app = wasm.web_main();
+                export function test() {
+                    let app = wasm.web_main();
 
-                for (let i = 0; i < 10; i++) {
-                    app.tick();
-                    let bad = wasm.broken_vec();
-                    console.log("Received from rust:", i, bad);
-                    assert.strictEqual(bad[0], 1);
-                    assert.strictEqual(bad[1], 2);
-                    assert.strictEqual(bad[2], 3);
-                    assert.strictEqual(bad[3], 4);
-                    assert.strictEqual(bad[4], 5);
-                    assert.strictEqual(bad[5], 6);
-                    assert.strictEqual(bad[6], 7);
-                    assert.strictEqual(bad[7], 8);
-                    assert.strictEqual(bad[8], 9);
+                    for (let i = 0; i < 10; i++) {
+                        app.tick();
+                        let bad = wasm.broken_vec();
+                        console.log("Received from rust:", i, bad);
+                        assert.strictEqual(bad[0], 1);
+                        assert.strictEqual(bad[1], 2);
+                        assert.strictEqual(bad[2], 3);
+                        assert.strictEqual(bad[3], 4);
+                        assert.strictEqual(bad[4], 5);
+                        assert.strictEqual(bad[5], 6);
+                        assert.strictEqual(bad[6], 7);
+                        assert.strictEqual(bad[7], 8);
+                        assert.strictEqual(bad[8], 9);
+                    }
                 }
-            }
-      "#,
+            "#,
         )
         .test();
 }
diff --git a/tests/all/structural.rs b/tests/all/structural.rs
index 6d7ad574..3f07bc87 100644
--- a/tests/all/structural.rs
+++ b/tests/all/structural.rs
@@ -6,47 +6,47 @@ fn works() {
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
-            extern crate wasm_bindgen;
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            #[wasm_bindgen]
-            extern {
-                pub type Foo;
+                #[wasm_bindgen]
+                extern {
+                    pub type Foo;
 
-                #[wasm_bindgen(method, structural)]
-                fn bar(this: &Foo);
-                #[wasm_bindgen(method, getter, structural)]
-                fn baz(this: &Foo) -> u32;
-                #[wasm_bindgen(method, setter, structural)]
-                fn set_baz(this: &Foo, val: u32);
-            }
+                    #[wasm_bindgen(method, structural)]
+                    fn bar(this: &Foo);
+                    #[wasm_bindgen(method, getter, structural)]
+                    fn baz(this: &Foo) -> u32;
+                    #[wasm_bindgen(method, setter, structural)]
+                    fn set_baz(this: &Foo, val: u32);
+                }
 
-            #[wasm_bindgen]
-            pub fn run(a: &Foo) {
-                a.bar();
-                assert_eq!(a.baz(), 1);
-                a.set_baz(2);
-                assert_eq!(a.baz(), 2);
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn run(a: &Foo) {
+                    a.bar();
+                    assert_eq!(a.baz(), 1);
+                    a.set_baz(2);
+                    assert_eq!(a.baz(), 2);
+                }
+            "#,
         )
         .file(
-            "test.ts",
+            "test.js",
             r#"
-            import * as assert from "assert";
-            import { run } from "./out";
+                import * as assert from "assert";
+                import { run } from "./out";
 
-            export function test() {
-                let called = false;
-                run({
-                    bar() { called = true; },
-                    baz: 1,
-                });
-                assert.strictEqual(called, true);
-            }
-        "#,
+                export function test() {
+                    let called = false;
+                    run({
+                        bar() { called = true; },
+                        baz: 1,
+                    });
+                    assert.strictEqual(called, true);
+                }
+            "#,
         )
         .test();
 }
diff --git a/tests/all/typescript.rs b/tests/all/typescript.rs
new file mode 100644
index 00000000..a6d16b57
--- /dev/null
+++ b/tests/all/typescript.rs
@@ -0,0 +1,79 @@
+use super::project;
+
+#[test]
+fn works() {
+    project()
+        .webpack(true)
+        .file(
+            "src/lib.rs",
+            r#"
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+
+                extern crate wasm_bindgen;
+
+                use wasm_bindgen::prelude::*;
+
+                #[wasm_bindgen]
+                pub fn foo() {}
+
+                #[wasm_bindgen]
+                pub fn bar(a: &str, b: u32) -> String {
+                    format!("{} {}", a, b)
+                }
+
+                #[wasm_bindgen]
+                pub fn thunk(a: &JsValue) {
+                    drop(a);
+                }
+
+                #[wasm_bindgen]
+                pub struct A {
+                }
+
+                #[wasm_bindgen]
+                impl A {
+                    #[wasm_bindgen(constructor)]
+                    pub fn new() -> A {
+                        A {}
+                    }
+
+                    pub fn new2() -> A {
+                        A {}
+                    }
+
+                    pub fn foo(&self) {}
+
+                    pub fn bar(&self, _a: u32) {}
+
+                    pub fn baz(&self, _d: &A) {}
+                }
+            "#,
+        )
+        .file(
+            "test.ts",
+            r#"
+                import * as assert from 'assert';
+                import { foo, bar, A, thunk } from './out';
+                import { memory } from './out_bg';
+
+                export function test() {
+                    foo();
+                    assert.strictEqual(bar('a', 3), 'a 3');
+
+                    const x = new A();
+                    x.foo();
+                    x.free();
+
+                    const y = A.new2();
+                    y.foo();
+                    y.bar(2);
+                    y.baz(y);
+                    y.free();
+
+                    thunk(memory);
+                };
+            "#,
+        )
+        .test();
+}
+
diff --git a/tests/all/webidl/simple.rs b/tests/all/webidl/simple.rs
index 30aab25e..2fa500d2 100644
--- a/tests/all/webidl/simple.rs
+++ b/tests/all/webidl/simple.rs
@@ -6,55 +6,55 @@ fn method() {
         .file(
             "foo.webidl",
             r#"
-            [Constructor(double value)]
-            interface Foo {
-                [Pure]
-                boolean myCmp(Foo bar);
-            };
-        "#,
+                [Constructor(double value)]
+                interface Foo {
+                    [Pure]
+                    boolean myCmp(Foo bar);
+                };
+            "#,
         )
         .file(
-            "foo.ts",
+            "foo.js",
             r#"
-            export class Foo {
-                constructor(private value: number) {
-                    this.value = value;
+                export class Foo {
+                    constructor(value) {
+                        this.value = value;
+                    }
+                    myCmp(other) {
+                        return this.value === other.value;
+                    }
                 }
-                myCmp(other: Foo): boolean {
-                    return this.value === other.value;
-                }
-            }
             "#,
         )
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            pub mod foo;
+                pub mod foo;
 
-            use foo::Foo;
+                use foo::Foo;
 
-            #[wasm_bindgen]
-            pub fn test() {
-                let pi = Foo::new(3.14159);
-                let e = Foo::new(2.71828);
-                // TODO: figure out why the following doesn't fail
-                // assert!(!pi.my_cmp(Foo::new(3.14159)));
-                let tmp = pi.my_cmp(Foo::new(3.14159));
-                assert!(tmp);
-                let tmp =!pi.my_cmp(Foo::new(2.71828));
-                assert!(tmp);
-                let tmp = !e.my_cmp(Foo::new(3.14159));
-                assert!(tmp);
-                let tmp = e.my_cmp(Foo::new(2.71828));
-                assert!(tmp);
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn test() {
+                    let pi = Foo::new(3.14159);
+                    let e = Foo::new(2.71828);
+                    // TODO: figure out why the following doesn't fail
+                    // assert!(!pi.my_cmp(Foo::new(3.14159)));
+                    let tmp = pi.my_cmp(Foo::new(3.14159));
+                    assert!(tmp);
+                    let tmp =!pi.my_cmp(Foo::new(2.71828));
+                    assert!(tmp);
+                    let tmp = !e.my_cmp(Foo::new(3.14159));
+                    assert!(tmp);
+                    let tmp = e.my_cmp(Foo::new(2.71828));
+                    assert!(tmp);
+                }
+            "#,
         )
         .test();
 }
@@ -65,54 +65,54 @@ fn property() {
         .file(
             "foo.webidl",
             r#"
-            [Constructor(double value)]
-            interface Foo {
-                [Pure]
-                attribute double value;
-            };
-        "#,
+                [Constructor(double value)]
+                interface Foo {
+                    [Pure]
+                    attribute double value;
+                };
+            "#,
         )
         .file(
-            "foo.ts",
+            "foo.js",
             r#"
-            export class Foo {
-                constructor(private _value: number) {
-                    this._value = _value;
-                }
+                export class Foo {
+                    constructor(value) {
+                        this._value = value;
+                    }
 
-                get value(): number {
-                    return this._value;
-                }
+                    get value() {
+                        return this._value;
+                    }
 
-                set value(_value: number) {
-                    this._value = _value;
+                    set value(value) {
+                        this._value = value;
+                    }
                 }
-            }
             "#,
         )
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            pub mod foo;
+                pub mod foo;
 
-            use foo::Foo;
+                use foo::Foo;
 
-            #[wasm_bindgen]
-            pub fn test() {
-                let x = Foo::new(3.14159);
-                assert_eq!(x.value(), 3.14159);
-                assert_ne!(x.value(), 2.71828);
-                x.set_value(2.71828);
-                assert_ne!(x.value(), 3.14159);
-                assert_eq!(x.value(), 2.71828);
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn test() {
+                    let x = Foo::new(3.14159);
+                    assert_eq!(x.value(), 3.14159);
+                    assert_ne!(x.value(), 2.71828);
+                    x.set_value(2.71828);
+                    assert_ne!(x.value(), 3.14159);
+                    assert_eq!(x.value(), 2.71828);
+                }
+            "#,
         )
         .test();
 }
@@ -123,52 +123,55 @@ fn named_constructor() {
         .file(
             "foo.webidl",
             r#"
-            [NamedConstructor=Bar(double value)]
-            interface Foo {
-                [Pure]
-                readonly attribute double value;
-            };
-        "#,
+                [NamedConstructor=Bar(double value)]
+                interface Foo {
+                    [Pure]
+                    readonly attribute double value;
+                };
+            "#,
         )
         .file(
             // Not a perfect test, but it gets the job done.
-            "foo.ts",
+            "foo.js",
             r#"
-            export class Foo {
-                protected _value: number = 0;
-                get value(): number {
-                    return this._value;
-                }
-            }
+                export class Foo {
+                    constructor() {
+                        this._value = 0;
+                    }
 
-            export class Bar extends Foo {
-                constructor(_value: number) {
-                    super();
-                    this._value = _value;
+                    get value(){
+                        return this._value;
+                    }
+                }
+
+                export class Bar extends Foo {
+                    constructor(_value) {
+                        super();
+                        this._value = _value;
+                    }
                 }
-            }
             "#,
         )
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            pub mod foo;
+                pub mod foo;
 
-            use foo::Foo;
+                use foo::Foo;
 
-            #[wasm_bindgen]
-            pub fn test() {
-                let x = Foo::new(3.14159);
-                assert_eq!(x.value(), 3.14159);
-                assert_ne!(x.value(), 0.);
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn test() {
+                    let x = Foo::new(3.14159);
+                    assert_eq!(x.value(), 3.14159);
+                    assert_ne!(x.value(), 0.);
+                }
+            "#,
         )
         .test();
 }
@@ -179,46 +182,47 @@ fn static_method() {
         .file(
             "foo.webidl",
             r#"
-            interface Foo {
-                static double swap(double value);
-            };
-        "#,
+                interface Foo {
+                    static double swap(double value);
+                };
+            "#,
         )
         .file(
-            "foo.ts",
+            "foo.js",
             r#"
-            export class Foo {
-                private static value: number = 0;
-                static swap(value: number): number {
-                    const res = Foo.value;
-                    Foo.value = value;
-                    return res;
+                export class Foo {
+                    static swap(value) {
+                        const res = Foo.value;
+                        Foo.value = value;
+                        return res;
+                    }
                 }
-            }
+
+                Foo.value = 0;
             "#,
         )
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            pub mod foo;
+                pub mod foo;
 
-            use foo::Foo;
+                use foo::Foo;
 
-            #[wasm_bindgen]
-            pub fn test() {
-                assert_eq!(Foo::swap(3.14159), 0.);
-                assert_eq!(Foo::swap(2.71828), 3.14159);
-                assert_ne!(Foo::swap(2.71828), 3.14159);
-                assert_eq!(Foo::swap(3.14159), 2.71828);
-                assert_ne!(Foo::swap(3.14159), 2.71828);
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn test() {
+                    assert_eq!(Foo::swap(3.14159), 0.);
+                    assert_eq!(Foo::swap(2.71828), 3.14159);
+                    assert_ne!(Foo::swap(2.71828), 3.14159);
+                    assert_eq!(Foo::swap(3.14159), 2.71828);
+                    assert_ne!(Foo::swap(3.14159), 2.71828);
+                }
+            "#,
         )
         .test();
 }
@@ -229,51 +233,51 @@ fn static_property() {
         .file(
             "foo.webidl",
             r#"
-            interface Foo {
-                static attribute double value;
-            };
-        "#,
+                interface Foo {
+                    static attribute double value;
+                };
+            "#,
         )
         .file(
-            "foo.ts",
+            "foo.js",
             r#"
-            export class Foo {
-                private static _value: number = 0;
+                export class Foo {
+                    static get value(){
+                        return Foo._value;
+                    }
 
-                static get value(): number {
-                    return Foo._value;
+                    static set value(value) {
+                        Foo._value = value;
+                    }
                 }
 
-                static set value(_value: number) {
-                    Foo._value = _value;
-                }
-            }
+                Foo._value = 0;
             "#,
         )
         .file(
             "src/lib.rs",
             r#"
-            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
 
-            extern crate wasm_bindgen;
+                extern crate wasm_bindgen;
 
-            use wasm_bindgen::prelude::*;
+                use wasm_bindgen::prelude::*;
 
-            pub mod foo;
+                pub mod foo;
 
-            use foo::Foo;
+                use foo::Foo;
 
-            #[wasm_bindgen]
-            pub fn test() {
-                assert_eq!(Foo::value(), 0.);
-                Foo::set_value(3.14159);
-                assert_eq!(Foo::value(), 3.14159);
-                assert_ne!(Foo::value(), 2.71828);
-                Foo::set_value(2.71828);
-                assert_eq!(Foo::value(), 2.71828);
-                assert_ne!(Foo::value(), 3.14159);
-            }
-        "#,
+                #[wasm_bindgen]
+                pub fn test() {
+                    assert_eq!(Foo::value(), 0.);
+                    Foo::set_value(3.14159);
+                    assert_eq!(Foo::value(), 3.14159);
+                    assert_ne!(Foo::value(), 2.71828);
+                    Foo::set_value(2.71828);
+                    assert_eq!(Foo::value(), 2.71828);
+                    assert_ne!(Foo::value(), 3.14159);
+                }
+            "#,
         )
         .test();
 }