add linting (and some initial fixes)

15 files changed, 1453 insertions, 0 deletions

diff --git a/node_modules/babel-plugin-espower/CHANGELOG.md b/node_modules/babel-plugin-espower/CHANGELOG.md
new file mode 100644
index 000000000..b0891892b
--- /dev/null
+++ b/node_modules/babel-plugin-espower/CHANGELOG.md
@@ -0,0 +1,212 @@
+### [2.3.2](https://github.com/power-assert-js/babel-plugin-espower/releases/tag/v2.3.2) (2017-01-13)
+
+
+#### Bug Fixes
+
+* [Value recorder should clean up captured values at the end of assertion expression](https://github.com/power-assert-js/babel-plugin-espower/pull/19)
+
+
+### [2.3.1](https://github.com/power-assert-js/babel-plugin-espower/releases/tag/v2.3.1) (2016-06-21)
+
+
+#### Bug Fixes
+
+* stop capturing SequenceExpression itself since SequenceExpressions are not enclosed in parentheses in some cases ([bf64b96a](https://github.com/power-assert-js/babel-plugin-espower/commit/bf64b96a139e0872590d39f2e5f4df02a2472eb3))
+
+
+## [2.3.0](https://github.com/power-assert-js/babel-plugin-espower/releases/tag/v2.3.0) (2016-06-21)
+
+
+#### Features
+
+* [Support SequenceExpression (i.e., comma operator)](https://github.com/power-assert-js/babel-plugin-espower/pull/17)
+
+
+## [2.2.0](https://github.com/power-assert-js/babel-plugin-espower/releases/tag/v2.2.0) (2016-05-31)
+
+
+#### Features
+
+* [`embedAst` option to embed assertion's AST and tokens to make runtime side parser unnecessary](https://github.com/power-assert-js/babel-plugin-espower/pull/13)
+* [Make babel-plugin-espower customizable via plugin options](https://github.com/power-assert-js/babel-plugin-espower/pull/16)
+
+
+### [2.1.2](https://github.com/power-assert-js/babel-plugin-espower/releases/tag/v2.1.2) (2016-02-14)
+
+
+#### Bug Fixes
+
+* do not include comments in one-line format assertion ([c5af6c55](https://github.com/power-assert-js/babel-plugin-espower/commit/c5af6c558f2caad8e30c1494c218d7ad3203eb16))
+
+
+### [2.1.1](https://github.com/power-assert-js/babel-plugin-espower/releases/tag/v2.1.1) (2016-01-26)
+
+
+### Performance Improvements
+
+* [Use prototype based Recorder for performance boost](https://github.com/power-assert-js/babel-plugin-espower/pull/12) (by [@jamestalmage](https://github.com/jamestalmage))
+
+
+## [2.1.0](https://github.com/power-assert-js/babel-plugin-espower/releases/tag/v2.1.0) (2016-01-10)
+
+
+#### Features
+
+* [Embed value capturing helper into transpiled code](https://github.com/power-assert-js/babel-plugin-espower/pull/11)
+
+
+## [2.0.0](https://github.com/power-assert-js/babel-plugin-espower/releases/tag/v2.0.0) (2015-11-13)
+
+
+#### Features
+
+* [Babel 6.x support](https://github.com/power-assert-js/babel-plugin-espower/pull/5)
+
+
+#### Breaking Changes
+
+Babel6 is incompatible with Babel5. For Babel 5 or lower, you need to use the 1.x release of babel-plugin-espower.
+
+```
+$ npm install --save-dev babel-plugin-espower@1.1.0
+```
+
+
+### [1.1.1](https://github.com/power-assert-js/babel-plugin-espower/releases/tag/v1.1.1) (2016-06-22)
+
+
+#### Bug Fixes
+
+* pin espower dependency to >=1.0.0 <1.3.0 since there was a little breaking change ([f9a7d781](https://github.com/power-assert-js/babel-plugin-espower/commit/f9a7d78167d92ca7f86c0923478f1a7ab6e71f5d))
+
+
+## [1.1.0](https://github.com/power-assert-js/babel-plugin-espower/releases/tag/v1.1.0) (2015-11-06)
+
+
+#### Features
+
+* [async/await support](https://github.com/power-assert-js/babel-plugin-espower/pull/7) (by [@jamestalmage](https://github.com/jamestalmage))
+
+
+### [1.0.1](https://github.com/power-assert-js/babel-plugin-espower/releases/tag/v1.0.1) (2015-11-07)
+
+
+#### Bug Fixes
+
+* pin espower dependency to >=1.0.0 <=1.2.0 since there was a little breaking change ([6420b3dc](https://github.com/power-assert-js/babel-plugin-espower/commit/6420b3dc49a00f731eebbee695c90be8f13d5e73), closes [#8](https://github.com/power-assert-js/babel-plugin-espower/issues/8))
+
+
+## [1.0.0](https://github.com/power-assert-js/babel-plugin-espower/releases/tag/v1.0.0) (2015-05-25)
+
+
+#### Features
+
+* use `process.cwd()` for `sourceRoot` option value ([71016432](https://github.com/power-assert-js/babel-plugin-espower/commit/71016432565568e2b7325b11cf07ae90d029c45b))
+* update espower to 1.0.0 ([337cdfd2](https://github.com/power-assert-js/babel-plugin-espower/commit/337cdfd26a2868addd1aabdd7787733a79eab11a))
+
+
+### [0.4.1](https://github.com/power-assert-js/babel-plugin-espower/releases/tag/v0.4.1) (2015-05-21)
+
+
+#### Bug Fixes
+
+* eliminate remaining babel-core dependencies ([7735ed5f](https://github.com/power-assert-js/babel-plugin-espower/commit/7735ed5f8e6c38660c0328404057c6497370ebd7))
+
+
+## [0.4.0](https://github.com/power-assert-js/babel-plugin-espower/releases/tag/v0.4.0) (2015-05-21)
+
+
+#### Bug Fixes
+
+* avoid visiting replacement node ([c4da8f8f](https://github.com/power-assert-js/babel-plugin-espower/commit/c4da8f8f8d3a56ccfe64812ef4f2c839ebec892c))
+
+
+#### Features
+
+* use new 5.2.0+ API with shared babel-core. No more peerDependencies. ([39eb684b](https://github.com/power-assert-js/babel-plugin-espower/commit/39eb684b733729a0b0d6752bd52a008c5b08159b))
+
+
+#### Breaking Changes
+
+* function returned by `babel-plugin-espower/create` takes babel instance as a first argument.
+
+If you are customizing babel-plugin-espower using `babel-plugin-espower/create`, you may have to migrate.
+
+To migrate, change your code from the following:
+
+```
+var babel = require('babel-core');
+var createEspowerPlugin = require('babel-plugin-espower/create');
+var transformed = babel.transform(jsCode, {
+    plugins: [
+        createEspowerPlugin({
+            patterns: [
+                'assert.isNull(object, [message])',
+                'assert.same(actual, expected, [message])',
+                'assert.near(actual, expected, delta, [message])'
+            ]
+        })
+    ]
+});
+```
+
+To:
+
+```
+var babel = require('babel-core');
+var createEspowerPlugin = require('babel-plugin-espower/create');
+var transformed = babel.transform(jsCode, {
+    plugins: [
+        createEspowerPlugin(babel, {
+            patterns: [
+                'assert.isNull(object, [message])',
+                'assert.same(actual, expected, [message])',
+                'assert.near(actual, expected, delta, [message])'
+            ]
+        })
+    ]
+});
+```
+
+([39eb684b](https://github.com/power-assert-js/babel-plugin-espower/commit/39eb684b733729a0b0d6752bd52a008c5b08159b))
+
+
+### [0.3.1](https://github.com/power-assert-js/babel-plugin-espower/releases/tag/v0.3.1) (2015-05-18)
+
+
+#### Bug Fixes
+
+* use version range since babel-core 5.4.3 does not work. ([3b586fa9](https://github.com/power-assert-js/babel-plugin-espower/commit/3b586fa9c20650871f7420c70d6e9c189be7412c)
+
+
+## [0.3.0](https://github.com/power-assert-js/babel-plugin-espower/releases/tag/v0.3.0) (2015-05-01)
+
+
+#### Bug Fixes
+
+* deal with babel 5.2.x internal changes. ([17698583](https://github.com/power-assert-js/babel-plugin-espower/commit/17698583a871e59c0af660cd888c2e98f85aea38), closes [#3](https://github.com/power-assert-js/babel-plugin-espower/issues/3))
+
+
+### [0.2.2](https://github.com/power-assert-js/babel-plugin-espower/releases/tag/v0.2.2) (2015-04-24)
+
+
+* update escallmatch to 1.3.2 ([941c75c2](https://github.com/power-assert-js/babel-plugin-espower/commit/941c75c29504284fee7fa916752e4096fd65011f))
+
+
+### [0.2.1](https://github.com/power-assert-js/babel-plugin-espower/releases/tag/v0.2.1) (2015-04-21)
+
+
+* down peerDependencies to minimum version to make dedupe friendly ([093ce106](https://github.com/power-assert-js/babel-plugin-espower/commit/093ce1068a11ac1550830c5e541f93a3271623af))
+
+
+## [0.2.0](https://github.com/power-assert-js/babel-plugin-espower/releases/tag/v0.2.0) (2015-04-19)
+
+
+* export create.js to customize assertion patterns ([092c3464](https://github.com/power-assert-js/babel-plugin-espower/commit/092c3464ae37ab27a91cd01e3dd8fa2062a08dfe))
+* docs about customizing assertion patterns via Babel API ([f72a9b1](https://github.com/power-assert-js/babel-plugin-espower/commit/f72a9b19b68d3d12287ba8b33878c7ff63049175))
+
+
+## [0.1.0](https://github.com/power-assert-js/babel-plugin-espower/releases/tag/v0.1.0) (2015-04-18)
+
+
+The first release.
diff --git a/node_modules/babel-plugin-espower/LICENSE b/node_modules/babel-plugin-espower/LICENSE
new file mode 100644
index 000000000..4606ba496
--- /dev/null
+++ b/node_modules/babel-plugin-espower/LICENSE
@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2017 Takuto Wada, https://github.com/power-assert-js/babel-plugin-espower
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/babel-plugin-espower/README.md b/node_modules/babel-plugin-espower/README.md
new file mode 100644
index 000000000..df61bda66
--- /dev/null
+++ b/node_modules/babel-plugin-espower/README.md
@@ -0,0 +1,449 @@
+babel-plugin-espower
+================================
+
+Babel plugin for power-assert.
+
+[![Build Status][travis-image]][travis-url]
+[![NPM version][npm-image]][npm-url]
+[![Dependency Status][depstat-image]][depstat-url]
+[![License][license-image]][license-url]
+
+
+DESCRIPTION
+---------------------------------------
+
+`babel-plugin-espower` is a [Babel](https://babeljs.io/) plugin for [power-assert](https://github.com/power-assert-js/power-assert).
+
+`power-assert` provides descriptive assertion messages for your tests, like this.
+
+```
+  1) ES6 demo Destructuring and TemplateLiteral:
+
+      AssertionError:   # test/demo_test.js:7
+
+  assert(`${ alice.name } and ${ bob.name }` === `bob and alice`)
+         |   |     |             |   |       |   |
+         |   |     |             |   |       |   "bob and alice"
+         |   |     |             |   "bob"   false
+         |   |     "alice"       Object{name:"bob"}
+         |   Object{name:"alice"}
+         "alice and bob"
+
+  --- [string] `bob and alice`
+  +++ [string] `${ alice.name } and ${ bob.name }`
+  @@ -1,13 +1,13 @@
+  -bob and alice
+  +alice and bob
+```
+
+Pull-requests, issue reports and patches are always welcomed. See [power-assert](https://github.com/power-assert-js/power-assert) project for more documentation.
+
+
+FYI: There's a [babel preset for all power-assert plugins](https://github.com/power-assert-js/babel-preset-power-assert)
+
+
+INSTALL
+---------------------------------------
+
+```
+$ npm install --save-dev babel-plugin-espower
+```
+
+
+CAUTION
+---------------------------------------
+
+Babel6 is incompatible with Babel5. For Babel 5 or lower, you need to use the 1.x release of babel-plugin-espower.
+
+```
+$ npm install --save-dev babel-plugin-espower@1.1.1
+```
+
+
+HOW TO USE
+---------------------------------------
+
+
+### via [.babelrc](https://babeljs.io/docs/usage/babelrc/)
+
+```javascript
+{
+  "presets": [
+    ...
+  ],
+  "plugins": [
+    "babel-plugin-espower"
+  ]
+}
+```
+
+```
+$ babel /path/to/test/some_test.js > /path/to/build/some_test.js
+```
+
+For example, with `babel-register` module and `.babelrc` above, you can run mocha without code generation steps.
+
+```
+$ $(npm bin)/mocha --require babel-register test/some_test.js
+```
+
+
+### via [Babel API](https://babeljs.io/docs/usage/api/)
+
+```javascript
+var babel = require('babel-core');
+var jsCode = fs.readFileSync('/path/to/test/some_test.js');
+var transformed = babel.transform(jsCode, {
+    presets: [...],
+    plugins: ['babel-plugin-espower']
+});
+console.log(transformed.code);
+```
+
+
+### via [Babel Require Hook](https://babeljs.io/docs/usage/require/)
+
+```javascript
+require('babel-register')({
+    presets: [...],
+    plugins: ['babel-plugin-espower']
+});
+```
+
+For example, with `babel_hook.js` above, you can run mocha without code generation steps.
+
+```
+$ $(npm bin)/mocha --require ./babel_hook /path/to/test/demo_test.js
+```
+
+
+### with [babelify](https://github.com/babel/babelify)
+
+```javascript
+var fs = require('fs');
+var browserify = require('browserify');
+var babelify = require('babelify');
+var glob = require('glob'),
+browserify({ entries: glob.sync('./test/*_test.js'), debug: true })
+  .transform(babelify.configure({
+      presets: [...],
+      plugins: ['babel-plugin-espower']
+  }))
+  .bundle()
+  .on('error', function (err) { console.log('Error : ' + err.message); })
+  .pipe(fs.createWriteStream('all_test.js'));
+```
+
+```
+$ $(npm bin)/browserify -d -e ./test/*_test.js -t [ babelify --presets ... --plugins babel-plugin-espower ]
+```
+
+
+### with [babelify](https://github.com/babel/babelify) and [gulp](http://gulpjs.com/)
+
+```javascript
+var source = require('vinyl-source-stream');
+var browserify = require('browserify');
+var glob = require('glob'),
+gulp.task('build_test', function() {
+    var files = glob.sync('./test/*_test.js');
+    var b = browserify({entries: files, debug: true});
+    b.transform(babelify.configure({
+        presets: [...],
+        plugins: ['babel-plugin-espower']
+    }));
+    return b.bundle()
+        .pipe(source('all_test.js'))
+        .pipe(gulp.dest('./build'));
+});
+```
+
+
+### with [babelify](https://github.com/babel/babelify) and [Karma](https://karma-runner.github.io)
+
+```javascript
+module.exports = function(config) {
+  config.set({
+    frameworks: ['mocha', 'browserify'],
+    files: [
+      "test/**/*.js"
+    ],
+    preprocessors: {
+      "test/**/*.js": "browserify"
+    },
+    browserify: {
+      debug: true,
+      transform: [
+        [
+          'babelify', {
+            presets: [...],
+            plugins: ['babel-plugin-espower']
+          }
+        ]
+      ]
+    },
+    // ...
+```
+
+
+EXAMPLE
+---------------------------------------
+
+
+For given test file `test/demo_test.js` below,
+
+```javascript
+import assert from 'power-assert';
+
+describe('ES6 demo', () => {
+
+    it('Destructuring and TemplateLiteral', () => {
+        let [alice, bob] = [ { name: 'alice' }, { name: 'bob' } ];
+        assert(`${alice.name} and ${bob.name}` === `bob and alice`);
+    });
+
+    it('ArrowFunctionExpression and SpreadElement', () => {
+        let seven = 7, ary = [4, 5];
+        assert(seven === ((v, i) => v + i)(...[...ary]));
+    });
+
+    it('Enhanced Object Literals', () => {
+        let name = 'bobby';
+        assert.deepEqual({
+            name,
+            [ `${name}'s greet` ]: `Hello, I'm ${name}`
+        }, null);
+    });
+
+});
+```
+
+prepare `babel_hook.js` to transform tests.
+
+```javascript
+{
+  "presets": [
+    ...
+  ],
+  "plugins": [
+    "babel-plugin-espower"
+  ]
+}
+```
+
+Run `mocha` with `--require babel-register` option. You will see the power-assert output appears.
+
+```
+$ $(npm bin)/mocha --require babel-register test/demo_test.js
+
+  ES6 demo
+    1) Destructuring and TemplateLiteral
+    2) ArrowFunctionExpression and SpreadElement
+    3) Enhanced Object Literals
+
+
+  0 passing
+  3 failing
+
+  1) ES6 demo Destructuring and TemplateLiteral:
+
+      AssertionError:   # test/demo_test.js:7
+
+  assert(`${ alice.name } and ${ bob.name }` === `bob and alice`)
+         |   |     |             |   |       |   |
+         |   |     |             |   |       |   "bob and alice"
+         |   |     |             |   "bob"   false
+         |   |     "alice"       Object{name:"bob"}
+         |   Object{name:"alice"}
+         "alice and bob"
+
+  --- [string] `bob and alice`
+  +++ [string] `${ alice.name } and ${ bob.name }`
+  @@ -1,13 +1,13 @@
+  -bob and alice
+  +alice and bob
+
+      at Context.<anonymous> (test/demo_test.js:19:28)
+
+  2) ES6 demo ArrowFunctionExpression and SpreadElement:
+
+      AssertionError:   # test/demo_test.js:12
+
+  assert(seven === ((v, i) => v + i)(...[...ary]))
+         |     |   |                    |   |
+         |     |   |                    |   [4,5]
+         |     |   9                    [4,5]
+         7     false
+
+  [number] ((v, i) => v + i)(...[...ary])
+  => 9
+  [number] seven
+  => 7
+
+      at Context.<anonymous> (test/demo_test.js:29:28)
+
+  3) ES6 demo Enhanced Object Literals:
+     AssertionError:   # test/demo_test.js:17
+
+  assert.deepEqual({name,[`${ name }'s greet`]: `Hello, I'm ${ name }`}, null)
+                   |      |   |                 |              |
+                   |      |   |                 |              "bobby"
+                   |      |   "bobby"           "Hello, I'm bobby"
+                   |      "bobby's greet"
+                   Object{name:"bobby","bobby's greet":"Hello, I'm bobby"}
+
+      at Context.<anonymous> (test/demo_test.js:40:29)
+```
+
+
+CUSTOMIZE
+---------------------------------------
+
+### by plugin options
+
+You can customize configs such as assertion patterns via [.babelrc](https://babeljs.io/docs/usage/babelrc/)
+
+```javascript
+{
+  "presets": [
+    ...
+  ],
+  "plugins": [
+    ["babel-plugin-espower", {
+      "embedAst": true,
+      "patterns": [
+        "assert.isNull(object, [message])",
+        "assert.same(actual, expected, [message])",
+        "assert.near(actual, expected, delta, [message])"
+      ]
+    }]
+  ]
+}
+```
+
+### by API
+
+#### var plugin = createEspowerPlugin(babel, [options])
+
+You can customize configs such as assertion patterns via [Babel API](https://babeljs.io/docs/usage/api/),
+
+```javascript
+var babel = require('babel-core');
+var createEspowerPlugin = require('babel-plugin-espower/create');
+var jsCode = fs.readFileSync('/path/to/test/some_test.js');
+var transformed = babel.transform(jsCode, {
+    presets: [...],
+    plugins: [
+        createEspowerPlugin(babel, {
+            embedAst: true,
+            patterns: [
+                'assert.isNull(object, [message])',
+                'assert.same(actual, expected, [message])',
+                'assert.near(actual, expected, delta, [message])'
+            ]
+        })
+    ]
+});
+console.log(transformed.code);
+```
+
+or via [Require Hook](https://babeljs.io/docs/usage/require/).
+
+```javascript
+var createEspowerPlugin = require('babel-plugin-espower/create');
+require('babel-register')({
+    presets: [...],
+    plugins: [
+        createEspowerPlugin(babel, {
+            embedAst: true,
+            patterns: [
+                'assert.isNull(object, [message])',
+                'assert.same(actual, expected, [message])',
+                'assert.near(actual, expected, delta, [message])'
+            ]
+        })
+    ]
+});
+```
+
+#### options
+
+| type     | default value       |
+|:---------|:--------------------|
+| `object` | objects shown below |
+
+Configuration options for `babel-plugin-espower`. If not passed, default options will be used (return value of `defaultOptions()` with default `embedAst`, `visitorKeys`, `astWhiteList`, `path`, `sourceRoot` and `sourceMap`. `visitorKeys` is value of `babel.types.VISITOR_KEYS`. `astWhiteList` is value of `babel.types.BUILDER_KEYS`. `path` is filename passed to babel. `sourceRoot` is be return value of `process.cwd()`, `sourceMap` is babel's internal SourceMap object).
+
+```javascript
+{
+    patterns: [
+        'assert(value, [message])',
+        'assert.ok(value, [message])',
+        'assert.equal(actual, expected, [message])',
+        'assert.notEqual(actual, expected, [message])',
+        'assert.strictEqual(actual, expected, [message])',
+        'assert.notStrictEqual(actual, expected, [message])',
+        'assert.deepEqual(actual, expected, [message])',
+        'assert.notDeepEqual(actual, expected, [message])',
+        'assert.deepStrictEqual(actual, expected, [message])',
+        'assert.notDeepStrictEqual(actual, expected, [message])'
+    ],
+    embedAst: false,
+    visitorKeys: babel.types.VISITOR_KEYS,
+    astWhiteList: babel.types.BUILDER_KEYS,
+    sourceRoot: process.cwd(),
+    path: file.opts.filename,
+    sourceMap: file.opts.inputSourceMap
+}
+```
+
+#### options.embedAst
+
+If you want to use non-ECMASCript-standard features such as JSX tags in your `assert()`, you should set `embedAst` option to `true`.
+
+```js
+assert(shallow(<Foo />).is('.foo'));
+```
+
+
+CHANGELOG
+---------------------------------------
+See [CHANGELOG](https://github.com/power-assert-js/babel-plugin-espower/blob/master/CHANGELOG.md)
+
+
+AUTHOR
+---------------------------------------
+* [Takuto Wada](https://github.com/twada)
+
+
+CONTRIBUTORS
+---------------------------------------
+* [James Talmage (jamestalmage)](https://github.com/jamestalmage)
+
+
+OUR SUPPORT POLICY
+---------------------------------------
+
+We support Node under maintenance. In other words, we stop supporting old Node version when [their maintenance ends](https://github.com/nodejs/LTS).
+
+This means that any other environment is not supported.
+
+NOTE: If babel-plugin-espower works in any of the unsupported environments, it is purely coincidental and has no bearing on future compatibility. Use at your own risk.
+
+
+LICENSE
+---------------------------------------
+Licensed under the [MIT](https://github.com/power-assert-js/babel-plugin-espower/blob/master/LICENSE) license.
+
+
+[npm-url]: https://npmjs.org/package/babel-plugin-espower
+[npm-image]: https://badge.fury.io/js/babel-plugin-espower.svg
+
+[travis-url]: https://travis-ci.org/power-assert-js/babel-plugin-espower
+[travis-image]: https://secure.travis-ci.org/power-assert-js/babel-plugin-espower.svg?branch=master
+
+[depstat-url]: https://gemnasium.com/power-assert-js/babel-plugin-espower
+[depstat-image]: https://gemnasium.com/power-assert-js/babel-plugin-espower.svg
+
+[license-url]: https://github.com/power-assert-js/babel-plugin-espower/blob/master/LICENSE
+[license-image]: https://img.shields.io/badge/license-MIT-brightgreen.svg
diff --git a/node_modules/babel-plugin-espower/create.js b/node_modules/babel-plugin-espower/create.js
new file mode 100644
index 000000000..eaa16851a
--- /dev/null
+++ b/node_modules/babel-plugin-espower/create.js
@@ -0,0 +1,7 @@
+'use strict';
+
+var createEspowerVisitor = require('./lib/create-espower-visitor');
+
+module.exports = function createEspowerPlugin (babel, options) {
+    return createEspowerVisitor(babel, options);
+};
diff --git a/node_modules/babel-plugin-espower/index.js b/node_modules/babel-plugin-espower/index.js
new file mode 100644
index 000000000..72e659daf
--- /dev/null
+++ b/node_modules/babel-plugin-espower/index.js
@@ -0,0 +1,17 @@
+/**
+ * babel-plugin-espower:
+ *   Babel plugin for power-assert
+ * 
+ * https://github.com/power-assert-js/babel-plugin-espower
+ *
+ * Copyright (c) 2015-2017 Takuto Wada
+ * Licensed under the MIT license.
+ *   https://github.com/power-assert-js/babel-plugin-espower/blob/master/LICENSE
+ */
+'use strict';
+
+var createEspowerPlugin = require('./create');
+
+module.exports = function (babel) {
+    return createEspowerPlugin(babel);
+};
diff --git a/node_modules/babel-plugin-espower/lib/babel-assertion-visitor.js b/node_modules/babel-plugin-espower/lib/babel-assertion-visitor.js
new file mode 100644
index 000000000..6135f5766
--- /dev/null
+++ b/node_modules/babel-plugin-espower/lib/babel-assertion-visitor.js
@@ -0,0 +1,341 @@
+'use strict';
+
+var EspowerLocationDetector = require('espower-location-detector');
+var estraverse = require('estraverse');
+var cloneWithWhitelist = require('espurify').cloneWithWhitelist;
+var babelgen = require('babel-generator');
+var define = require('./define-properties');
+var toBeCaptured = require('./to-be-captured');
+var toBeSkipped = require('./to-be-skipped');
+var fs = require('fs');
+var helperCode = '(' +
+  fs.readFileSync(require.resolve('./power-assert-recorder.js'), 'utf8')
+    .split('\n')
+    .slice(2)
+    .join('\n')
+  + ')()';
+
+function BabelAssertionVisitor (babel, matcher, options) {
+    this.babel = babel;
+    this.matcher = matcher;
+    this.options = options;
+    this.currentArgumentNodePath = null;
+    this.argumentModified = false;
+    this.valueRecorder = null;
+    this.locationDetector = new EspowerLocationDetector(this.options);
+    var babelTemplate = babel.template;
+    this.helperTemplate = babelTemplate(helperCode);
+    var whiteListWithRange = Object.keys(options.astWhiteList).reduce(function (acc, key) {
+        acc[key] = options.astWhiteList[key].concat(['range']);
+        return acc;
+    }, {});
+    this.purifyAst = cloneWithWhitelist(whiteListWithRange);
+}
+
+BabelAssertionVisitor.prototype.enter = function (nodePath) {
+    this.assertionNodePath = nodePath;
+    var currentNode = nodePath.node;
+    this.location = this.locationDetector.locationFor(currentNode);
+    var enclosingFunc = this.findEnclosingFunction(nodePath);
+    this.withinGenerator = enclosingFunc && enclosingFunc.generator;
+    this.withinAsync = enclosingFunc && enclosingFunc.async;
+    this.generateCanonicalCode(nodePath, currentNode); // should be next to enclosingFunc detection
+    // store original espath for each node
+    var visitorKeys = this.options.visitorKeys;
+    estraverse.traverse(currentNode, {
+        keys: visitorKeys,
+        enter: function (node) {
+            if (this.path()) {
+                var espath = this.path().join('/');
+                define(node, { _espowerEspath: espath });
+            }
+        }
+    });
+};
+
+BabelAssertionVisitor.prototype.enterArgument = function (nodePath) {
+    var currentNode = nodePath.node;
+    var parentNode = nodePath.parent;
+    var argMatchResult = this.matcher.matchArgument(currentNode, parentNode);
+    if (!argMatchResult) {
+        return;
+    }
+    if (argMatchResult.name === 'message' && argMatchResult.kind === 'optional') {
+        // skip optional message argument
+        return;
+    }
+    this.verifyNotInstrumented(currentNode);
+    // create recorder per argument
+    this.valueRecorder = this.createNewRecorder(nodePath);
+    // entering target argument
+    this.currentArgumentNodePath = nodePath;
+};
+
+BabelAssertionVisitor.prototype.leave = function (nodePath) {
+    var currentNode = nodePath.node;
+    var visitorKeys = this.options.visitorKeys;
+    estraverse.traverse(currentNode, {
+        keys: visitorKeys,
+        enter: function (node) {
+            delete node._espowerEspath;
+        }
+    });
+};
+
+BabelAssertionVisitor.prototype.leaveArgument = function (resultTree) {
+    try {
+        return this.argumentModified ? this.captureArgument(resultTree) : resultTree;
+    } finally {
+        this.currentArgumentNodePath = null;
+        this.argumentModified = false;
+        this.valueRecorder = null;
+    }
+};
+
+BabelAssertionVisitor.prototype.captureNode = function (nodePath) {
+    var currentNode = nodePath.node;
+    var t = this.babel.types;
+    this.argumentModified = true;
+    var relativeEsPath = currentNode._espowerEspath;
+    var newNode = t.callExpression(
+        t.memberExpression(this.valueRecorder, t.identifier('_capt')),
+        [
+            currentNode,
+            t.valueToNode(relativeEsPath)
+        ]);
+    define(newNode, { _generatedByEspower: true });
+    return newNode;
+};
+
+BabelAssertionVisitor.prototype.toBeSkipped = function (nodePath) {
+    return toBeSkipped(this.babel.types, nodePath);
+};
+
+BabelAssertionVisitor.prototype.toBeCaptured = function (nodePath) {
+    return toBeCaptured(this.babel.types, nodePath);
+};
+
+BabelAssertionVisitor.prototype.isArgumentModified = function () {
+    return !!this.argumentModified;
+};
+
+BabelAssertionVisitor.prototype.isCapturingArgument = function () {
+    return !!this.currentArgumentNodePath;
+};
+
+BabelAssertionVisitor.prototype.isLeavingAssertion = function (nodePath) {
+    return this.assertionNodePath === nodePath;
+};
+
+BabelAssertionVisitor.prototype.isLeavingArgument = function (nodePath) {
+    return this.currentArgumentNodePath === nodePath;
+};
+
+BabelAssertionVisitor.prototype.isGeneratedNode = function (nodePath) {
+    var currentNode = nodePath.node;
+    return !!currentNode._generatedByEspower;
+};
+
+// internal
+
+BabelAssertionVisitor.prototype.generateCanonicalCode = function (nodePath, node) {
+    var file = nodePath.hub.file;
+    var gen = new babelgen.CodeGenerator(node, { concise: true, comments: false });
+    var output = gen.generate();
+    this.canonicalCode = output.code;
+    if (!this.options.embedAst) {
+        return;
+    }
+    var astAndTokens = this.parseCanonicalCode(file, this.canonicalCode);
+    this.ast = JSON.stringify(this.purifyAst(astAndTokens.expression));
+    this.tokens = JSON.stringify(astAndTokens.tokens);
+    var _this = this;
+    var types = this.babel.types;
+    this.visitorKeys = this.getOrCreateNode(nodePath, 'powerAssertVisitorKeys', function () {
+        return types.stringLiteral(JSON.stringify(_this.options.visitorKeys));
+    });
+};
+
+BabelAssertionVisitor.prototype.parseCanonicalCode = function (file, code) {
+    var ast, tokens;
+
+    function doParse(wrapper) {
+        var content = wrapper ? wrapper(code) : code;
+        var output = file.parse(content);
+        if (wrapper) {
+            ast = output.program.body[0].body;
+            tokens = output.tokens.slice(6, -2);
+        } else {
+            ast = output.program;
+            tokens = output.tokens.slice(0, -1);
+        }
+    }
+
+    if (this.withinAsync) {
+        doParse(wrappedInAsync);
+    } else if (this.withinGenerator) {
+        doParse(wrappedInGenerator);
+    } else {
+        doParse();
+    }
+
+    var exp = ast.body[0].expression;
+    var columnOffset = exp.loc.start.column;
+    var offsetTree = estraverse.replace(exp, {
+        keys: this.options.visitorKeys,
+        enter: function (eachNode) {
+            eachNode.range = [
+                eachNode.loc.start.column - columnOffset,
+                eachNode.loc.end.column - columnOffset
+            ];
+            delete eachNode.loc;
+            return eachNode;
+        }
+    });
+
+    return {
+        tokens: offsetAndSlimDownTokens(tokens),
+        expression: offsetTree
+    };
+};
+
+function wrappedInGenerator (jsCode) {
+    return 'function *wrapper() { ' + jsCode + ' }';
+}
+
+function wrappedInAsync (jsCode) {
+    return 'async function wrapper() { ' + jsCode + ' }';
+}
+
+function offsetAndSlimDownTokens (tokens) {
+    var i, token, newToken, result = [];
+    var columnOffset;
+    for(i = 0; i < tokens.length; i += 1) {
+        token = tokens[i];
+        if (i === 0) {
+            columnOffset = token.loc.start.column;
+        }
+        newToken = {
+            type: {
+                label: token.type.label
+            }
+        };
+        if (typeof token.value !== 'undefined') {
+            newToken.value = token.value;
+        }
+        newToken.range = [
+            token.loc.start.column - columnOffset,
+            token.loc.end.column - columnOffset
+        ];
+        result.push(newToken);
+    }
+    return result;
+}
+
+BabelAssertionVisitor.prototype.captureArgument = function (node) {
+    var t = this.babel.types;
+    var props = {
+        content: this.canonicalCode,
+        filepath: this.location.source,
+        line: this.location.line
+    };
+    if (this.withinAsync) {
+        props.async = true;
+    }
+    if (this.withinGenerator) {
+        props.generator = true;
+    }
+    if (this.ast) {
+        props.ast = this.ast;
+    }
+    if (this.tokens) {
+        props.tokens = this.tokens;
+    }
+    var propsNode = t.valueToNode(props);
+    if (this.visitorKeys) {
+        var visitorKeysNode = t.objectProperty(t.identifier('visitorKeys'), this.visitorKeys);
+        propsNode.properties.push(visitorKeysNode);
+    }
+    var newNode = t.callExpression(
+        t.memberExpression(this.valueRecorder, t.identifier('_expr')),
+        [
+            node,
+            propsNode
+        ]
+    );
+    define(newNode, { _generatedByEspower: true });
+    return newNode;
+};
+
+BabelAssertionVisitor.prototype.verifyNotInstrumented = function (currentNode) {
+    var types = this.babel.types;
+    if (!types.isCallExpression(currentNode)) {
+        return;
+    }
+    if (!types.isMemberExpression(currentNode.callee)) {
+        return;
+    }
+    var prop = currentNode.callee.property;
+    if (types.isIdentifier(prop) && prop.name === '_expr') {
+        var errorMessage = '[espower] Attempted to transform AST twice.';
+        if (this.options.path) {
+            errorMessage += ' path: ' + this.options.path;
+        }
+        throw new Error(errorMessage);
+    }
+};
+
+BabelAssertionVisitor.prototype.createNewRecorder = function (nodePath) {
+    var _this = this;
+    var types = this.babel.types;
+    var helperNameNode = this.getOrCreateNode(nodePath, 'powerAssertRecorder', function () {
+        return types.toExpression(_this.helperTemplate());
+    });
+    var recorderIdent = nodePath.scope.generateUidIdentifier('rec');
+    define(recorderIdent, { _generatedByEspower: true });
+    var init = types.newExpression(helperNameNode, []);
+    define(init, { _generatedByEspower: true });
+    nodePath.scope.push({ id: recorderIdent, init: init });
+    return recorderIdent;
+};
+
+BabelAssertionVisitor.prototype.getOrCreateNode = function (nodePath, keyName, generateNode) {
+    var file = nodePath.hub.file;
+    var ident = file.get(keyName);
+    if (!ident) {
+        ident = this.createNode(nodePath, keyName, generateNode);
+        // helperNameNode = file.addImport('power-assert-runtime/recorder', 'default', 'recorder');
+    }
+    return ident;
+};
+
+BabelAssertionVisitor.prototype.createNode = function (nodePath, keyName, generateNode) {
+    var file = nodePath.hub.file;
+    var programScope = nodePath.scope.getProgramParent();
+    var ident = programScope.generateUidIdentifier(keyName);
+    define(ident, { _generatedByEspower: true });
+    file.set(keyName, ident);
+    var generatedNode = generateNode();
+    var visitorKeys = this.options.visitorKeys;
+    estraverse.traverse(generatedNode, {
+        keys: visitorKeys,
+        enter: function (node) {
+            define(node, { _generatedByEspower: true });
+        }
+    });
+    generatedNode._compact = true;
+    programScope.push({ id: ident, init: generatedNode });
+    return ident;
+};
+
+BabelAssertionVisitor.prototype.findEnclosingFunction = function (nodePath) {
+    if (!nodePath) {
+        return null;
+    }
+    if (this.babel.types.isFunction(nodePath.node)) {
+        return nodePath.node;
+    }
+    return this.findEnclosingFunction(nodePath.parentPath);
+};
+
+module.exports = BabelAssertionVisitor;
diff --git a/node_modules/babel-plugin-espower/lib/babel-espower-visitor.js b/node_modules/babel-plugin-espower/lib/babel-espower-visitor.js
new file mode 100644
index 000000000..61a7e37be
--- /dev/null
+++ b/node_modules/babel-plugin-espower/lib/babel-espower-visitor.js
@@ -0,0 +1,86 @@
+'use strict';
+
+var CallMatcher = require('call-matcher');
+var babylon = require('babylon');
+var assign = require('core-js/library/fn/object/assign');
+var find = require('core-js/library/fn/array/find');
+var BabelAssertionVisitor = require('./babel-assertion-visitor');
+
+function BabelEspowerVisitor (babel, opts) {
+    this.babel = babel;
+    this.matchers = opts.patterns.map(function (pattern) {
+        var signatureAst = babylon.parse(pattern);
+        var expression = signatureAst.program.body[0].expression;
+        return new CallMatcher(expression, opts);
+    });
+    this.options = opts;
+}
+
+BabelEspowerVisitor.prototype.enter = function (nodePath) {
+    var currentNode = nodePath.node;
+    var file = nodePath.hub.file;
+    var assertionVisitor = file.get('espowerAssertionVisitor');
+    if (assertionVisitor) {
+        if (assertionVisitor.isGeneratedNode(nodePath) || assertionVisitor.toBeSkipped(nodePath)) {
+            // skipping this Node
+            // MEMO: exit() will not be called when skip() is called
+            nodePath.skip();
+            return;
+        }
+        if (!assertionVisitor.isCapturingArgument() && !this.isCalleeOfParentCallExpression(nodePath)) {
+            // entering argument
+            assertionVisitor.enterArgument(nodePath);
+        }
+    } else if (nodePath.isCallExpression()) {
+        var matcher = find(this.matchers, function (m) { return m.test(currentNode); });
+        if (matcher) {
+            // entering assertion
+            var espowerOptions = assign({
+                path: file.opts.filename, // or opts.sourceFileName?
+                sourceMap: file.opts.inputSourceMap
+            }, this.options);
+            assertionVisitor = new BabelAssertionVisitor(this.babel, matcher, espowerOptions);
+            assertionVisitor.enter(nodePath);
+            file.set('espowerAssertionVisitor', assertionVisitor);
+        }
+    }
+};
+
+BabelEspowerVisitor.prototype.exit = function (nodePath) {
+    var currentNode = nodePath.node;
+    var resultTree = currentNode;
+    var file = nodePath.hub.file;
+    var assertionVisitor = file.get('espowerAssertionVisitor');
+    if (!assertionVisitor) {
+        return;
+    }
+    if (assertionVisitor.isLeavingAssertion(nodePath)) {
+        // leaving assertion
+        assertionVisitor.leave(nodePath);
+        file.delete('espowerAssertionVisitor');
+        return;
+    }
+    if (!assertionVisitor.isCapturingArgument()) {
+        return;
+    }
+    if (assertionVisitor.toBeCaptured(nodePath)) {
+        // capturing Node
+        resultTree = assertionVisitor.captureNode(nodePath);
+    }
+    if (assertionVisitor.isLeavingArgument(nodePath)) {
+        // capturing whole argument on leaving argument
+        resultTree = assertionVisitor.leaveArgument(resultTree);
+    }
+    if (resultTree !== currentNode) {
+        nodePath.replaceWith(resultTree);
+    }
+};
+
+BabelEspowerVisitor.prototype.isCalleeOfParentCallExpression = function (nodePath) {
+    var currentKey = nodePath.key;
+    var parentNode = nodePath.parent;
+    var types = this.babel.types;
+    return types.isCallExpression(parentNode) && currentKey === 'callee';
+};
+
+module.exports = BabelEspowerVisitor;
diff --git a/node_modules/babel-plugin-espower/lib/create-espower-visitor.js b/node_modules/babel-plugin-espower/lib/create-espower-visitor.js
new file mode 100644
index 000000000..eab911ab8
--- /dev/null
+++ b/node_modules/babel-plugin-espower/lib/create-espower-visitor.js
@@ -0,0 +1,32 @@
+'use strict';
+
+var defaultOptions = require('./default-options');
+var assign = require('core-js/library/fn/object/assign');
+var BabelEspowerVisitor = require('./babel-espower-visitor');
+
+module.exports = function createEspowerVisitor (babel, options) {
+    return {
+        visitor: {
+            Program: function (path, state) {
+                var opts = assign(defaultOptions(), {
+                    astWhiteList: babel.types.BUILDER_KEYS,
+                    visitorKeys: babel.types.VISITOR_KEYS,
+                    sourceRoot: process.cwd()
+                }, options, state.opts);
+                var espowerVisitor = new BabelEspowerVisitor(babel, opts);
+                var innerVisitor = Object.keys(opts.visitorKeys).reduce(function (handlers, nodeType) {
+                    handlers[nodeType] = {
+                        enter: function (nodePath, pluginPass) {
+                            espowerVisitor.enter(nodePath);
+                        },
+                        exit: function (nodePath, pluginPass) {
+                            espowerVisitor.exit(nodePath);
+                        }
+                    };
+                    return handlers;
+                }, {});
+                path.traverse(innerVisitor, state);
+            }
+        }
+    };
+};
diff --git a/node_modules/babel-plugin-espower/lib/default-options.js b/node_modules/babel-plugin-espower/lib/default-options.js
new file mode 100644
index 000000000..d9d6cc1c6
--- /dev/null
+++ b/node_modules/babel-plugin-espower/lib/default-options.js
@@ -0,0 +1,19 @@
+'use strict';
+
+module.exports = function defaultOptions () {
+    return {
+        embedAst: false,
+        patterns: [
+            'assert(value, [message])',
+            'assert.ok(value, [message])',
+            'assert.equal(actual, expected, [message])',
+            'assert.notEqual(actual, expected, [message])',
+            'assert.strictEqual(actual, expected, [message])',
+            'assert.notStrictEqual(actual, expected, [message])',
+            'assert.deepEqual(actual, expected, [message])',
+            'assert.notDeepEqual(actual, expected, [message])',
+            'assert.deepStrictEqual(actual, expected, [message])',
+            'assert.notDeepStrictEqual(actual, expected, [message])'
+        ]
+    };
+};
diff --git a/node_modules/babel-plugin-espower/lib/define-properties.js b/node_modules/babel-plugin-espower/lib/define-properties.js
new file mode 100644
index 000000000..9f86150fb
--- /dev/null
+++ b/node_modules/babel-plugin-espower/lib/define-properties.js
@@ -0,0 +1,12 @@
+'use strict';
+
+module.exports = function defineProperties (obj, map) {
+    Object.keys(map).forEach(function (name) {
+        Object.defineProperty(obj, name, {
+            configurable: true,
+            enumerable: false,
+            value: map[name],
+            writable: true
+        });
+    });
+};
diff --git a/node_modules/babel-plugin-espower/lib/power-assert-recorder.js b/node_modules/babel-plugin-espower/lib/power-assert-recorder.js
new file mode 100644
index 000000000..0e59999f5
--- /dev/null
+++ b/node_modules/babel-plugin-espower/lib/power-assert-recorder.js
@@ -0,0 +1,26 @@
+'use strict';
+module.exports = /* intentional newline */
+  function () {
+  function PowerAssertRecorder() {
+    this.captured = [];
+  }
+
+  PowerAssertRecorder.prototype._capt = function _capt (value, espath) {
+    this.captured.push({value: value, espath: espath});
+    return value;
+  };
+
+  PowerAssertRecorder.prototype._expr = function _expr (value, source) {
+    var capturedValues = this.captured;
+    this.captured = [];
+    return {
+      powerAssertContext: {
+        value: value,
+        events: capturedValues
+      },
+      source: source
+    };
+  };
+
+  return PowerAssertRecorder;
+}
diff --git a/node_modules/babel-plugin-espower/lib/to-be-captured.js b/node_modules/babel-plugin-espower/lib/to-be-captured.js
new file mode 100644
index 000000000..248fe5366
--- /dev/null
+++ b/node_modules/babel-plugin-espower/lib/to-be-captured.js
@@ -0,0 +1,56 @@
+'use strict';
+
+var typesToBeCaptured = [
+    'Identifier',
+    'BinaryExpression',
+    'MemberExpression',
+    'CallExpression',
+    'UnaryExpression',
+    'LogicalExpression',
+    'ArrayExpression',
+    'ObjectExpression',
+    'TemplateLiteral',
+    'YieldExpression',
+    'AwaitExpression',
+    'NewExpression',
+    'AssignmentExpression',
+    'UpdateExpression',
+    'TaggedTemplateExpression'
+];
+
+function isCaputuringTargetType (types, nodePath) {
+    var currentNode = nodePath.node;
+    return typesToBeCaptured.some(function (nodeType) {
+        return types['is' + nodeType](currentNode);
+    });
+}
+
+function isCalleeOfParent(types, nodePath) {
+    var currentKey = nodePath.key;
+    var parentNode = nodePath.parent;
+    return (types.isCallExpression(parentNode) || types.isNewExpression(parentNode)) && currentKey === 'callee';
+}
+
+function isChildOfTaggedTemplateExpression(types, nodePath) {
+    var parentNode = nodePath.parent;
+    return types.isTaggedTemplateExpression(parentNode);
+}
+
+function isYieldOrAwaitArgument(types, nodePath) {
+    var currentKey = nodePath.key;
+    var parentNode = nodePath.parent;
+    // capture the yielded/await result, not the promise
+    return (types.isYieldExpression(parentNode) || types.isAwaitExpression(parentNode)) && currentKey === 'argument';
+}
+
+var blacklist = [
+    isYieldOrAwaitArgument,
+    isCalleeOfParent,
+    isChildOfTaggedTemplateExpression
+];
+
+module.exports = function toBeCaptured (types, nodePath) {
+    return isCaputuringTargetType(types, nodePath) && !blacklist.some(function (predicate) {
+        return predicate(types, nodePath);
+    });
+};
diff --git a/node_modules/babel-plugin-espower/lib/to-be-skipped.js b/node_modules/babel-plugin-espower/lib/to-be-skipped.js
new file mode 100644
index 000000000..92b2528c8
--- /dev/null
+++ b/node_modules/babel-plugin-espower/lib/to-be-skipped.js
@@ -0,0 +1,107 @@
+'use strict';
+
+var typesNotToBeSkippedDuringCapturing = [
+    'Identifier',
+    'BinaryExpression',
+    'MemberExpression',
+    'CallExpression',
+    'UnaryExpression',
+    'LogicalExpression',
+    'ArrayExpression',
+    'ObjectExpression',
+    'SequenceExpression',
+    'TemplateLiteral',
+    'YieldExpression',
+    'AwaitExpression',
+    'NewExpression',
+    'AssignmentExpression',
+    'UpdateExpression',
+    'TaggedTemplateExpression',
+    'ConditionalExpression',
+    'SpreadElement',
+    'Property'
+];
+
+function isTypeNotToBeSkippedDuringCapturing (types, nodePath) {
+    var currentNode = nodePath.node;
+    return typesNotToBeSkippedDuringCapturing.some(function (nodeType) {
+        return types['is' + nodeType](currentNode);
+    });
+}
+
+function isTypeToBeSkippedDuringCapturing (types, nodePath) {
+    return !isTypeNotToBeSkippedDuringCapturing(types, nodePath);
+}
+
+function isLeftHandSideOfAssignment(types, nodePath) {
+    var currentKey = nodePath.key;
+    var parentNode = nodePath.parent;
+    // Do not instrument left due to 'Invalid left-hand side in assignment'
+    return types.isAssignmentExpression(parentNode) && currentKey === 'left';
+}
+
+function isChildOfObjectLiteral (types, parentNode) {
+    return types.isObjectProperty(parentNode) ||
+        types.isObjectMethod(parentNode) ||
+        types.isSpreadProperty(parentNode);
+}
+
+function isObjectLiteralKey (types, parentNode, currentKey) {
+    return isChildOfObjectLiteral(types, parentNode) && currentKey === 'key';
+}
+
+function isObjectLiteralValue (types, parentNode, currentKey) {
+    return isChildOfObjectLiteral(types, parentNode) && currentKey === 'value';
+}
+
+function isNonComputedObjectLiteralKey(types, nodePath) {
+    var currentKey = nodePath.key;
+    var parentNode = nodePath.parent;
+    // Do not instrument non-computed Object literal key
+    return isObjectLiteralKey(types, parentNode, currentKey) && !parentNode.computed;
+}
+
+function isShorthandedValueOfObjectLiteral(types, nodePath) {
+    var currentKey = nodePath.key;
+    var parentNode = nodePath.parent;
+    // Do not instrument shorthanded Object literal value
+    return isObjectLiteralValue(types, parentNode, currentKey) && parentNode.shorthand;
+}
+
+function isUpdateExpression(types, nodePath) {
+    var parentNode = nodePath.parent;
+    // Just wrap UpdateExpression, not digging in.
+    return types.isUpdateExpression(parentNode);
+}
+
+function isCallExpressionWithNonComputedMemberExpression(types, nodePath) {
+    var currentKey = nodePath.key;
+    var currentNode = nodePath.node;
+    var parentNode = nodePath.parent;
+    // Do not instrument non-computed property of MemberExpression within CallExpression.
+    return types.isIdentifier(currentNode) && types.isMemberExpression(parentNode) && !parentNode.computed && currentKey === 'property';
+}
+
+function isTypeOfOrDeleteUnaryExpression(types, nodePath) {
+    var currentKey = nodePath.key;
+    var currentNode = nodePath.node;
+    var parentNode = nodePath.parent;
+    // 'typeof Identifier' or 'delete Identifier' is not instrumented
+    return types.isIdentifier(currentNode) && types.isUnaryExpression(parentNode) && (parentNode.operator === 'typeof' || parentNode.operator === 'delete') && currentKey === 'argument';
+}
+
+var criteriaForSkipping = [
+    isTypeToBeSkippedDuringCapturing,
+    isLeftHandSideOfAssignment,
+    isNonComputedObjectLiteralKey,
+    isShorthandedValueOfObjectLiteral,
+    isUpdateExpression,
+    isCallExpressionWithNonComputedMemberExpression,
+    isTypeOfOrDeleteUnaryExpression,
+];
+
+module.exports = function toBeSkipped (types, nodePath) {
+    return criteriaForSkipping.some(function (predicate) {
+        return predicate(types, nodePath);
+    });
+};
diff --git a/node_modules/babel-plugin-espower/node_modules/.bin/babylon b/node_modules/babel-plugin-espower/node_modules/.bin/babylon
new file mode 120000
index 000000000..7ceac0182
--- /dev/null
+++ b/node_modules/babel-plugin-espower/node_modules/.bin/babylon
@@ -0,0 +1 @@
+../../../babylon/bin/babylon.js
\ No newline at end of file
diff --git a/node_modules/babel-plugin-espower/package.json b/node_modules/babel-plugin-espower/package.json
new file mode 100644
index 000000000..e264321b8
--- /dev/null
+++ b/node_modules/babel-plugin-espower/package.json
@@ -0,0 +1,66 @@
+{
+  "name": "babel-plugin-espower",
+  "description": "Babel plugin for power-assert",
+  "version": "2.3.2",
+  "author": {
+    "name": "Takuto Wada",
+    "email": "takuto.wada@gmail.com",
+    "url": "https://github.com/twada"
+  },
+  "bugs": "https://github.com/power-assert-js/babel-plugin-espower/issues",
+  "contributors": [
+    {
+      "name": "James Talmage",
+      "url": "https://github.com/jamestalmage"
+    }
+  ],
+  "dependencies": {
+    "babel-generator": "^6.1.0",
+    "babylon": "^6.1.0",
+    "call-matcher": "^1.0.0",
+    "core-js": "^2.0.0",
+    "espower-location-detector": "^1.0.0",
+    "espurify": "^1.6.0",
+    "estraverse": "^4.1.1"
+  },
+  "devDependencies": {
+    "babel-core": "^6.1.0",
+    "babel-preset-es2015": "^6.1.2",
+    "babel-preset-react": "^6.1.2",
+    "babel-preset-stage-2": "^6.1.2",
+    "mocha": "^3.0.0"
+  },
+  "directories": {
+    "lib": "./lib",
+    "test": "./test"
+  },
+  "files": [
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "index.js",
+    "create.js",
+    "lib",
+    "package.json"
+  ],
+  "homepage": "https://github.com/power-assert-js/babel-plugin-espower",
+  "keywords": [
+    "assert",
+    "assertion",
+    "babel",
+    "babel-plugin",
+    "power-assert",
+    "test",
+    "testing",
+    "transform"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/power-assert-js/babel-plugin-espower.git"
+  },
+  "scripts": {
+    "test": "mocha --timeout 0"
+  }
+}