Added some tests

2021-06-23 22:30:45 +02:00
parent 24f897e907
commit 3d3d7fae48
3796 changed files with 218744 additions and 3 deletions
--- a/tests/node_modules/tape-es/LICENSE
+++ b/tests/node_modules/tape-es/LICENSE
@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Evan Plaice <evanplaice@gmail.com>
+
+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.
--- a/tests/node_modules/tape-es/README.md
+++ b/tests/node_modules/tape-es/README.md
@@ -0,0 +1,105 @@
+<h1 align="center">Tape-ES</h1>
+
+A **[Tape.js][]** test runner and watcher for modern JavaScript. Works with both ES modules and CommonJS.
+
+<div align="center">
+  <a href="https://github.com/vanillaes/tape-es/releases"><img src="https://badgen.net/github/tag/vanillaes/tape-es" alt="GitHub Release"></a>
+  <a href="https://www.npmjs.com/package/tape-es"><img src="https://badgen.net/npm/v/tape-es" alt="NPM Release"></a>
+  <a href="https://github.com/vanillaes/tape-es/actions"><img src="https://github.com/vanillaes/tape-es/workflows/Latest/badge.svg" alt="Latest Status"></a>
+  <a href="https://github.com/vanillaes/tape-es/actions"><img src="https://github.com/vanillaes/tape-es/workflows/Release/badge.svg" alt="Release Status"></a>
+
+  <a href="https://discord.gg/aSWYgtybzV"><img alt="Discord" src="https://img.shields.io/discord/723296249121603604?color=%23738ADB"></a>
+</div>
+
+## Features
+
+- runs ES module tests
+- runs tests in parallel for speed
+- uses sensible defaults
+- works with `type: module` packages
+
+*Note: Since this is an ES package, it requires Node >= v14.x*
+
+## tape-es
+
+### Arguments
+
+`tape-es [pattern] -i [pattern] -r [path] -t [number]`
+
+- `[pattern]` - the file matcher pattern (default `**/*.spec.js`)
+- `-i` | `--ignore` - the ignore matcher pattern (default `**/node_modules/**`)
+- `-r` | `--root` - the root path to run the tests from (default `process.cwd()`)
+- `-t` | `--threads` - Number of threads to run concurrently (default `10`)
+
+### Basic Usage
+
+Use the defaults
+
+```sh
+tape-es
+```
+
+### Advanced Usage
+
+Specify custom parameters
+
+```sh
+tape-es "**/*.spec.js" -i "node_modules/**" -r ../absurdum/ -t 20
+```
+
+**Note: In Linux/OSX the matcher patterns must be delimited in quotes.**
+
+## tape-watch-es
+
+### Arguments
+
+`tape-es [pattern] -i [pattern] -r [path]`
+
+- `[pattern]` - the file matcher pattern (default `**/*.spec.js`)
+- `-i` | `--ignore` - the ignore matcher pattern (default `**/node_modules/**`)
+- `-r` | `--root` - the root path to run the tests from (default `process.cwd()`)
+
+### Basic Usage
+
+Use the defaults
+
+```sh
+tape-watch-es
+```
+
+### Advanced Usage
+
+Specify custom parameters
+
+```sh
+tape-es "**/*.spec.js" -i "node_modules/**" -r ../absurdum/
+```
+
+**Note: In Linux/OSX the matcher patterns must be delimited in quotes.**
+
+## Writing Tests
+
+Tests are identical to Tape.js, except `import` is used to load modules rather than require.
+
+```javascript
+import test from 'tape';
+import { arrays } from '../../index.js';
+
+test('arrays.chunk(array) - should return a chunk for each item in the array', t => {
+  // ...test code
+});
+```
+
+## Tap Reporters
+
+One of the greatest advantages to using Tape, is that it outputs results in the standard [TAP][] format. That means you can pipe the results into a wide array of TAP reporters.
+
+The parallel nature of this runner will break most reporters. As a General rule.
+
+1. if you want speed (ie CI/CD) don't use a reporter
+2. if you want speed and readability use [tap-spec][]
+3. if you want to use any reporter, run tests in parallel with `tape-es -t 1`
+
+[Tape.js]: https://github.com/substack/tape
+[TAP]: https://en.wikipedia.org/wiki/Test_Anything_Protocol
+[tap-spec]: https://github.com/scottcorgan/tap-spec
--- a/tests/node_modules/tape-es/bin/tape-es.js
+++ b/tests/node_modules/tape-es/bin/tape-es.js
@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import cli from 'commander'
+import { runAll } from '../src/runners.js'
+import { match, readPkg } from '../src/util/index.js'
+
+const DEFAULT_PATTERN = '**/*.spec.js'
+const DEFAULT_IGNORE = '**/node_modules/**'
+const DEFAULT_ROOT = process.cwd()
+const DEFAULT_THREADS = 10;
+
+(async () => {
+  const pkg = await readPkg()
+
+  cli.version(pkg.version)
+    .arguments('[pattern]')
+    .option('-i, --ignore [value]', 'Ignore files pattern')
+    .option('-r, --root [value]', 'The root path')
+    .option('-t, --threads [number]', 'Number of threads to run tests concurrently', parseInt)
+    .parse(process.argv)
+
+  const pattern = cli.args[0] ? cli.args[0] : DEFAULT_PATTERN
+  const ignore = cli.ignore ? cli.ignore : DEFAULT_IGNORE
+  const root = cli.root ? cli.root : DEFAULT_ROOT
+  const threads = cli.threads ? cli.threads : DEFAULT_THREADS
+
+  const tests = await match(pattern, ignore, root)
+  await runAll(tests, threads, root)
+})().catch(e => {
+  console.error(e)
+})
--- a/tests/node_modules/tape-es/bin/tape-watch-es.js
+++ b/tests/node_modules/tape-es/bin/tape-watch-es.js
@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import cli from 'commander'
+import chokidar from 'chokidar'
+import { run } from '../src/runners.js'
+import { readPkg } from '../src/util/index.js'
+
+const DEFAULT_PATTERN = '**/*.spec.js'
+const DEFAULT_IGNORE = '**/node_modules/**'
+const DEFAULT_ROOT = process.cwd();
+
+(async () => {
+  const pkg = await readPkg()
+
+  cli.version(pkg.version)
+    .arguments('[pattern]')
+    .option('-i, --ignore [value]', 'Ignore files pattern')
+    .option('-r, --root [value]', 'The root path')
+    .parse(process.argv)
+
+  const pattern = cli.pattern ? cli.pattern : DEFAULT_PATTERN
+  const ignore = cli.ignore ? cli.ignore : DEFAULT_IGNORE
+  const root = cli.root ? cli.root : DEFAULT_ROOT
+
+  const watcher = chokidar.watch(pattern, {
+    ignored: [ignore],
+    persistent: true,
+    ignoreInitial: true,
+    cwd: root
+  })
+  watcher.on('all', (event, path, stat) => run(path, root))
+})().catch(e => {
+  console.error(e)
+})
--- a/tests/node_modules/tape-es/node_modules/.bin/tape
+++ b/tests/node_modules/tape-es/node_modules/.bin/tape
@@ -0,0 +1 @@
+../tape/bin/tape
--- a/tests/node_modules/tape-es/node_modules/deep-equal/.eslintrc
+++ b/tests/node_modules/tape-es/node_modules/deep-equal/.eslintrc
@@ -0,0 +1,22 @@
+{
+  "root": true,
+  "extends": "@ljharb",
+  "rules": {
+    "complexity": 0,
+    "eqeqeq": 1,
+    "func-style": [2, "declaration"],
+    "indent": [2, 2],
+    "max-params": [2, 3],
+    "max-statements-per-line": [2, { "max": 2 }],
+    "strict": 1,
+  },
+  "overrides": [
+    {
+      "files": ["example/**", "test/**"],
+      "rules": {
+        "max-params": 0,
+        "no-console": 0,
+      },
+    },
+  ],
+}
--- a/tests/node_modules/tape-es/node_modules/deep-equal/.travis.yml
+++ b/tests/node_modules/tape-es/node_modules/deep-equal/.travis.yml
@@ -0,0 +1,12 @@
+version: ~> 1.0
+language: node_js
+os:
+ - linux
+import:
+ - ljharb/travis-ci:node/all.yml
+ - ljharb/travis-ci:node/pretest.yml
+ - ljharb/travis-ci:node/posttest.yml
+ - ljharb/travis-ci:node/coverage.yml
+matrix:
+  allow_failures:
+    - env: COVERAGE=true
--- a/tests/node_modules/tape-es/node_modules/deep-equal/CHANGELOG.md
+++ b/tests/node_modules/tape-es/node_modules/deep-equal/CHANGELOG.md
@@ -0,0 +1,120 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+Generated by [`auto-changelog`](https://github.com/CookPete/auto-changelog).
+
+## [v1.1.1](https://github.com/inspect-js/node-deep-equal/compare/v1.1.0...v1.1.1) - 2019-11-12
+
+### Commits
+
+- [Tests] use shared travis-ci configs [`678cb2a`](https://github.com/inspect-js/node-deep-equal/commit/678cb2a34ef920eab563af69bdf402b9273c3e2c)
+- [meta] add `auto-changelog` [`569bcce`](https://github.com/inspect-js/node-deep-equal/commit/569bcce030784f7506367055122c54c6cac00ebc)
+- [Dev Deps] update `eslint`, `@ljharb/eslint-config`; add `safe-publish-latest` [`9dedd40`](https://github.com/inspect-js/node-deep-equal/commit/9dedd409cb74c538153287db546a14f2fa583e6f)
+- [Tests] add `npx aud` in `posttest` [`0b76639`](https://github.com/inspect-js/node-deep-equal/commit/0b766394504f74d002ad85e7b8244ce89bb27130)
+- [meta] add `funding` field [`3e519e3`](https://github.com/inspect-js/node-deep-equal/commit/3e519e36998ea82120cfe9a509dc0090a87d7063)
+
+## [v1.1.0](https://github.com/inspect-js/node-deep-equal/compare/v1.0.1...v1.1.0) - 2019-08-28
+
+### Commits
+
+- [Tests] up to `node` `v12.7`, `v11.15`, `v10.16`, `v9.11`, `v8.16`, `v7.10`, `v6.17`, `4.9`; use `nvm install-latest-npm` [`ba11166`](https://github.com/inspect-js/node-deep-equal/commit/ba111664928f3a9279528dd05330b974950003b4)
+- [Tests] make a `tape` helper, to easily compare loose/strict, and (a,b)/(b,a) arg order [`0c25e94`](https://github.com/inspect-js/node-deep-equal/commit/0c25e9438b2d4a96e75c3c2e6fbb353ae450ed1f)
+- [Tests] add `npm run lint` [`8590816`](https://github.com/inspect-js/node-deep-equal/commit/8590816be6bc57a07fbc160985f5f04f11c7fa97)
+- test: Fails simple array tests on IE &lt; 9 #10 [`bc37498`](https://github.com/inspect-js/node-deep-equal/commit/bc374988ee763a881ef39d8f6949838ec4df4e64)
+- [Tests] clean up/flesh out test cases [`3fffed9`](https://github.com/inspect-js/node-deep-equal/commit/3fffed9a7e095bbf922561fa0b18681422861af8)
+- [Fix] (array,arguments) now behaves the same as (arguments,array) [`a9528ff`](https://github.com/inspect-js/node-deep-equal/commit/a9528ff71561c303e722eb5ae0a3b9b2ecae4a3b)
+- [Refactor] move Date and RegExp tests into `objEquiv` [`5b3bf31`](https://github.com/inspect-js/node-deep-equal/commit/5b3bf315b603f00bab49e78c05c075cdc0dfd506)
+- [Fix] properly compare RegExp objects [`b8c179c`](https://github.com/inspect-js/node-deep-equal/commit/b8c179c5aa91c8a2f71f053e2d9e2d477780250e)
+- [Refactor] Use `object-keys` and `is-arguments` instead of a homegrown shim. [`3b503fb`](https://github.com/inspect-js/node-deep-equal/commit/3b503fb262c431df72a6c91cbb384be557315645)
+- [Fix] use `object-is` to support `NaN` and `-0` properly [`28fde4a`](https://github.com/inspect-js/node-deep-equal/commit/28fde4a411073e3131d3637248f8c25aac9329f2)
+- [meta] fix license text so GitHub can detect it [`7000403`](https://github.com/inspect-js/node-deep-equal/commit/700040347119ce46b3e917e800d87628af1384f9)
+- [Tests] add array/object tests [`558eecf`](https://github.com/inspect-js/node-deep-equal/commit/558eecf9daa815468f0bc4c9799041507b7ffa15)
+- [Fix] ensure Buffer + non-Buffer comparison order does not matter [`de4e75c`](https://github.com/inspect-js/node-deep-equal/commit/de4e75ce7f0621cdc09ae8cbdc82de9e4c17578e)
+- [Refactor] `objEquiv`: bail early if typeofs are different [`410e2d6`](https://github.com/inspect-js/node-deep-equal/commit/410e2d63730763e7e92c9b45b916f97058ab31f7)
+- [Tests] add tests for `Object.create(null)` [`ed266e8`](https://github.com/inspect-js/node-deep-equal/commit/ed266e8571d1efdbb4ece0a01f849cbc57461076)
+- [Refactor] there is no need to do further compareation when two types are not equal [`6a5efc1`](https://github.com/inspect-js/node-deep-equal/commit/6a5efc130e96398de55cf517969746c52735f34b)
+- Only apps should have lockfiles [`f60442f`](https://github.com/inspect-js/node-deep-equal/commit/f60442fa6fd10004366d80481ada7df668bd6adb)
+- [Tests] clean up redundant test [`cbbef21`](https://github.com/inspect-js/node-deep-equal/commit/cbbef21045e3b2e1ee30f6d0a83381d489df296e)
+- [Fix] use `is-date-object` to properly detect cross-realm Dates [`0c5b21a`](https://github.com/inspect-js/node-deep-equal/commit/0c5b21ad245d1427caefe20b2bace752cbe5e493)
+- [meta] Add copyright statements [`56a7746`](https://github.com/inspect-js/node-deep-equal/commit/56a774674f55bb3e0627aaec4dda90e4a06df7d6)
+- [Dev Deps] update `tape` [`3e9c1b9`](https://github.com/inspect-js/node-deep-equal/commit/3e9c1b903703e32bbed45fddcae815eb25822fd4)
+
+## [v1.0.1](https://github.com/inspect-js/node-deep-equal/compare/v1.0.0...v1.0.1) - 2015-08-29
+
+### Fixed
+
+- Null should == undefined [`#23`](https://github.com/inspect-js/node-deep-equal/issues/23)
+
+### Commits
+
+- Update travis.yml to modern node [`5055802`](https://github.com/inspect-js/node-deep-equal/commit/5055802274a85a3e1493fa1b7378499554c6a4dc)
+
+## [v1.0.0](https://github.com/inspect-js/node-deep-equal/compare/v0.2.2...v1.0.0) - 2015-02-07
+
+## [v0.2.2](https://github.com/inspect-js/node-deep-equal/compare/v0.2.1...v0.2.2) - 2015-02-07
+
+### Commits
+
+- latest tape [`1d18617`](https://github.com/inspect-js/node-deep-equal/commit/1d18617608316a034c8ee6727838c9b82614f0f9)
+- add type check to support browsers [`3acb0d7`](https://github.com/inspect-js/node-deep-equal/commit/3acb0d7fb8915fb7f1ca97701b5761793738bad3)
+
+## [v0.2.1](https://github.com/inspect-js/node-deep-equal/compare/v0.2.0...v0.2.1) - 2014-01-29
+
+### Commits
+
+- license file [`b3431d4`](https://github.com/inspect-js/node-deep-equal/commit/b3431d48e0f7c406a08d0e077f2dd9580d4561ae)
+
+## [v0.2.0](https://github.com/inspect-js/node-deep-equal/compare/v0.1.2...v0.2.0) - 2014-01-29
+
+### Commits
+
+- buffer check without Buffer [`5271f39`](https://github.com/inspect-js/node-deep-equal/commit/5271f39f3ce61fecb71fa6ca28cb4a8a8b963bbd)
+- failing test for buffer comparison [`cc8990b`](https://github.com/inspect-js/node-deep-equal/commit/cc8990b9d84a2267d84253e21c9f7db238e961e9)
+
+## [v0.1.2](https://github.com/inspect-js/node-deep-equal/compare/v0.1.1...v0.1.2) - 2013-12-21
+
+### Commits
+
+- test the arguments shim and properly factor out the arguments handling [`cf88b9c`](https://github.com/inspect-js/node-deep-equal/commit/cf88b9c2e87d6050ba1a46a82be216d0244ee428)
+- more coverage for the keys shim [`7a41f0e`](https://github.com/inspect-js/node-deep-equal/commit/7a41f0ec813616b0e1272c2bf463028a84d51c99)
+- test coverage for the non-object case [`abd3358`](https://github.com/inspect-js/node-deep-equal/commit/abd33586af0006e8492bbcdb1eb27a306359b03c)
+- fix the argument comparisons to properly call equal() [`0114a10`](https://github.com/inspect-js/node-deep-equal/commit/0114a10398e386ab0e073966e8525cd2ce125de4)
+- more code coverage for date comparisons [`41ac40e`](https://github.com/inspect-js/node-deep-equal/commit/41ac40e844b10833a75a39ea92e73bcdb1ae3cd9)
+- use the latest version of tape [`f8341cb`](https://github.com/inspect-js/node-deep-equal/commit/f8341cbff475ee7ee1ec651662cb5bd621c75838)
+- use https: for the badges [`514b332`](https://github.com/inspect-js/node-deep-equal/commit/514b332e9c2390c89c5beac8cf866c2f9a4afa9e)
+- 100% coverage [`e55aac7`](https://github.com/inspect-js/node-deep-equal/commit/e55aac78a6e013d6f5a10febc7009476a8f10ca5)
+
+## [v0.1.1](https://github.com/inspect-js/node-deep-equal/compare/v0.1.0...v0.1.1) - 2013-12-20
+
+### Commits
+
+- Fixed arguments support for IE8- [`174d41a`](https://github.com/inspect-js/node-deep-equal/commit/174d41a5559820458648d237ebedfe78e44f7430)
+
+## [v0.1.0](https://github.com/inspect-js/node-deep-equal/compare/v0.0.0...v0.1.0) - 2013-10-14
+
+### Commits
+
+- upgrade the markdown [`30e1f8f`](https://github.com/inspect-js/node-deep-equal/commit/30e1f8fe5b1fb7d5d68b156bf69bb04a7bb807a3)
+- opts.strict instead of a boolean arg [`58cbdb2`](https://github.com/inspect-js/node-deep-equal/commit/58cbdb2a97e623a68310833218af5ada6c97c2ce)
+- using testling-ci [`064af17`](https://github.com/inspect-js/node-deep-equal/commit/064af170f895fc67ec4bbf654e7de27721cf40c0)
+- Add optional strict parameter [`f3413b1`](https://github.com/inspect-js/node-deep-equal/commit/f3413b1d95e261f735939fbcaee65e598fe92852)
+- strict equality test [`281189b`](https://github.com/inspect-js/node-deep-equal/commit/281189b6962c9c57105474d01a8127da3318f555)
+- document opts.strict [`69fae5a`](https://github.com/inspect-js/node-deep-equal/commit/69fae5ab4b9278e28d09864c62dcfe9b4f00c1d8)
+- using tape [`4384db8`](https://github.com/inspect-js/node-deep-equal/commit/4384db8a9cc7af1cf79e1976d1b36e66934b2b4c)
+- using travis [`e508692`](https://github.com/inspect-js/node-deep-equal/commit/e5086928e1edf120d227d5e7f5e6ac4d755248a1)
+- deepEquals comparing nulls seems to break in ie6-8 [`b2cfeb9`](https://github.com/inspect-js/node-deep-equal/commit/b2cfeb95da6982f8bc2e676231820a3a47385db3)
+- performance note in the readme [`da9bfc9`](https://github.com/inspect-js/node-deep-equal/commit/da9bfc9aadfb9045bbf8157e9403de7184b404fd)
+- more firefoxes [`3d60ec5`](https://github.com/inspect-js/node-deep-equal/commit/3d60ec58d6fe269c13c5be04b749f01972aa5b1c)
+
+## v0.0.0 - 2012-02-11
+
+### Commits
+
+- implementation with an example [`2dd56f9`](https://github.com/inspect-js/node-deep-equal/commit/2dd56f9e6d42e841c74289c2e2d489047d077622)
+- readme [`4a44f99`](https://github.com/inspect-js/node-deep-equal/commit/4a44f99bea3277e32d9842d9d49ac21f316ac74d)
+- and a test [`357ccd3`](https://github.com/inspect-js/node-deep-equal/commit/357ccd37d23ba7814c8fe284d36d6e86a39b7526)
+- actually just MIT [`3d348c8`](https://github.com/inspect-js/node-deep-equal/commit/3d348c88fc92ce1d69a3fedbb2aa8cb6ea1480f7)
--- a/tests/node_modules/tape-es/node_modules/deep-equal/LICENSE
+++ b/tests/node_modules/tape-es/node_modules/deep-equal/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2012, 2013, 2014 James Halliday <mail@substack.net>, 2009 Thomas Robinson <280north.com>
+
+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.
--- a/tests/node_modules/tape-es/node_modules/deep-equal/example/cmp.js
+++ b/tests/node_modules/tape-es/node_modules/deep-equal/example/cmp.js
@@ -0,0 +1,11 @@
+var equal = require('../');
+console.dir([
+  equal(
+    { a: [2, 3], b: [4] },
+    { a: [2, 3], b: [4] }
+  ),
+  equal(
+    { x: 5, y: [6] },
+    { x: 5, y: 6 }
+  )
+]);
--- a/tests/node_modules/tape-es/node_modules/deep-equal/index.js
+++ b/tests/node_modules/tape-es/node_modules/deep-equal/index.js
@@ -0,0 +1,112 @@
+var objectKeys = require('object-keys');
+var isArguments = require('is-arguments');
+var is = require('object-is');
+var isRegex = require('is-regex');
+var flags = require('regexp.prototype.flags');
+var isDate = require('is-date-object');
+
+var getTime = Date.prototype.getTime;
+
+function deepEqual(actual, expected, options) {
+  var opts = options || {};
+
+  // 7.1. All identical values are equivalent, as determined by ===.
+  if (opts.strict ? is(actual, expected) : actual === expected) {
+    return true;
+  }
+
+  // 7.3. Other pairs that do not both pass typeof value == 'object', equivalence is determined by ==.
+  if (!actual || !expected || (typeof actual !== 'object' && typeof expected !== 'object')) {
+    return opts.strict ? is(actual, expected) : actual == expected;
+  }
+
+  /*
+   * 7.4. For all other Object pairs, including Array objects, equivalence is
+   * determined by having the same number of owned properties (as verified
+   * with Object.prototype.hasOwnProperty.call), the same set of keys
+   * (although not necessarily the same order), equivalent values for every
+   * corresponding key, and an identical 'prototype' property. Note: this
+   * accounts for both named and indexed properties on Arrays.
+   */
+  // eslint-disable-next-line no-use-before-define
+  return objEquiv(actual, expected, opts);
+}
+
+function isUndefinedOrNull(value) {
+  return value === null || value === undefined;
+}
+
+function isBuffer(x) {
+  if (!x || typeof x !== 'object' || typeof x.length !== 'number') {
+    return false;
+  }
+  if (typeof x.copy !== 'function' || typeof x.slice !== 'function') {
+    return false;
+  }
+  if (x.length > 0 && typeof x[0] !== 'number') {
+    return false;
+  }
+  return true;
+}
+
+function objEquiv(a, b, opts) {
+  /* eslint max-statements: [2, 50] */
+  var i, key;
+  if (typeof a !== typeof b) { return false; }
+  if (isUndefinedOrNull(a) || isUndefinedOrNull(b)) { return false; }
+
+  // an identical 'prototype' property.
+  if (a.prototype !== b.prototype) { return false; }
+
+  if (isArguments(a) !== isArguments(b)) { return false; }
+
+  var aIsRegex = isRegex(a);
+  var bIsRegex = isRegex(b);
+  if (aIsRegex !== bIsRegex) { return false; }
+  if (aIsRegex || bIsRegex) {
+    return a.source === b.source && flags(a) === flags(b);
+  }
+
+  if (isDate(a) && isDate(b)) {
+    return getTime.call(a) === getTime.call(b);
+  }
+
+  var aIsBuffer = isBuffer(a);
+  var bIsBuffer = isBuffer(b);
+  if (aIsBuffer !== bIsBuffer) { return false; }
+  if (aIsBuffer || bIsBuffer) { // && would work too, because both are true or both false here
+    if (a.length !== b.length) { return false; }
+    for (i = 0; i < a.length; i++) {
+      if (a[i] !== b[i]) { return false; }
+    }
+    return true;
+  }
+
+  if (typeof a !== typeof b) { return false; }
+
+  try {
+    var ka = objectKeys(a);
+    var kb = objectKeys(b);
+  } catch (e) { // happens when one is a string literal and the other isn't
+    return false;
+  }
+  // having the same number of owned properties (keys incorporates hasOwnProperty)
+  if (ka.length !== kb.length) { return false; }
+
+  // the same set of keys (although not necessarily the same order),
+  ka.sort();
+  kb.sort();
+  // ~~~cheap key test
+  for (i = ka.length - 1; i >= 0; i--) {
+    if (ka[i] != kb[i]) { return false; }
+  }
+  // equivalent values for every corresponding key, and ~~~possibly expensive deep test
+  for (i = ka.length - 1; i >= 0; i--) {
+    key = ka[i];
+    if (!deepEqual(a[key], b[key], opts)) { return false; }
+  }
+
+  return true;
+}
+
+module.exports = deepEqual;
--- a/tests/node_modules/tape-es/node_modules/deep-equal/lib/is_arguments.js
+++ b/tests/node_modules/tape-es/node_modules/deep-equal/lib/is_arguments.js
@@ -0,0 +1 @@
+module.exports = require('is-arguments');
--- a/tests/node_modules/tape-es/node_modules/deep-equal/lib/keys.js
+++ b/tests/node_modules/tape-es/node_modules/deep-equal/lib/keys.js
@@ -0,0 +1 @@
+module.exports = require('object-keys');
--- a/tests/node_modules/tape-es/node_modules/deep-equal/package.json
+++ b/tests/node_modules/tape-es/node_modules/deep-equal/package.json
@@ -0,0 +1,116 @@
+{
+  "_from": "deep-equal@~1.1.1",
+  "_id": "deep-equal@1.1.1",
+  "_inBundle": false,
+  "_integrity": "sha512-yd9c5AdiqVcR+JjcwUQb9DkhJc8ngNr0MahEBGvDiJw8puWab2yZlh+nkasOnZP+EGTAP6rRp2JzJhJZzvNF8g==",
+  "_location": "/tape-es/deep-equal",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "deep-equal@~1.1.1",
+    "name": "deep-equal",
+    "escapedName": "deep-equal",
+    "rawSpec": "~1.1.1",
+    "saveSpec": null,
+    "fetchSpec": "~1.1.1"
+  },
+  "_requiredBy": [
+    "/tape-es/tape"
+  ],
+  "_resolved": "https://registry.npmjs.org/deep-equal/-/deep-equal-1.1.1.tgz",
+  "_shasum": "b5c98c942ceffaf7cb051e24e1434a25a2e6076a",
+  "_spec": "deep-equal@~1.1.1",
+  "_where": "/home/lilleman/go/src/gitlab.larvit.se/power-plan/auth/tests/node_modules/tape-es/node_modules/tape",
+  "author": {
+    "name": "James Halliday",
+    "email": "mail@substack.net",
+    "url": "http://substack.net"
+  },
+  "auto-changelog": {
+    "output": "CHANGELOG.md",
+    "template": "keepachangelog",
+    "unreleased": false,
+    "commitLimit": false,
+    "backfillLimit": false
+  },
+  "bugs": {
+    "url": "https://github.com/substack/node-deep-equal/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "is-arguments": "^1.0.4",
+    "is-date-object": "^1.0.1",
+    "is-regex": "^1.0.4",
+    "object-is": "^1.0.1",
+    "object-keys": "^1.1.1",
+    "regexp.prototype.flags": "^1.2.0"
+  },
+  "deprecated": false,
+  "description": "node's assert.deepEqual algorithm",
+  "devDependencies": {
+    "@ljharb/eslint-config": "^15.0.1",
+    "auto-changelog": "^1.16.2",
+    "eslint": "^6.6.0",
+    "safe-publish-latest": "^1.1.4",
+    "tape": "^4.11.0"
+  },
+  "directories": {
+    "lib": ".",
+    "example": "example",
+    "test": "test"
+  },
+  "funding": {
+    "url": "https://github.com/sponsors/ljharb"
+  },
+  "homepage": "https://github.com/substack/node-deep-equal#readme",
+  "keywords": [
+    "equality",
+    "equal",
+    "compare"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "name": "deep-equal",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/substack/node-deep-equal.git"
+  },
+  "scripts": {
+    "lint": "eslint .",
+    "posttest": "npx aud",
+    "postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\"",
+    "prepublish": "safe-publish-latest",
+    "pretest": "npm run lint",
+    "test": "npm run tests-only",
+    "tests-only": "tape test/*",
+    "version": "auto-changelog && git add CHANGELOG.md"
+  },
+  "testling": {
+    "files": "test/*.js",
+    "browsers": {
+      "ie": [
+        6,
+        7,
+        8,
+        9
+      ],
+      "ff": [
+        3.5,
+        10,
+        15
+      ],
+      "chrome": [
+        10,
+        22
+      ],
+      "safari": [
+        5.1
+      ],
+      "opera": [
+        12
+      ]
+    }
+  },
+  "version": "1.1.1"
+}
--- a/tests/node_modules/tape-es/node_modules/deep-equal/readme.markdown
+++ b/tests/node_modules/tape-es/node_modules/deep-equal/readme.markdown
@@ -0,0 +1,57 @@
+# deep-equal
+
+Node's `assert.deepEqual() algorithm` as a standalone module.
+
+This module is around [5 times faster](https://gist.github.com/2790507)
+than wrapping `assert.deepEqual()` in a `try/catch`.
+
+[![browser support](https://ci.testling.com/substack/node-deep-equal.png)](https://ci.testling.com/substack/node-deep-equal)
+
+[![build status](https://secure.travis-ci.org/substack/node-deep-equal.png)](https://travis-ci.org/substack/node-deep-equal)
+
+# example
+
+``` js
+var equal = require('deep-equal');
+console.dir([
+    equal(
+        { a : [ 2, 3 ], b : [ 4 ] },
+        { a : [ 2, 3 ], b : [ 4 ] }
+    ),
+    equal(
+        { x : 5, y : [6] },
+        { x : 5, y : 6 }
+    )
+]);
+```
+
+# methods
+
+``` js
+var deepEqual = require('deep-equal')
+```
+
+## deepEqual(a, b, opts)
+
+Compare objects `a` and `b`, returning whether they are equal according to a
+recursive equality algorithm.
+
+If `opts.strict` is `true`, use strict equality (`===`) to compare leaf nodes.
+The default is to use coercive equality (`==`) because that's how
+`assert.deepEqual()` works by default.
+
+# install
+
+With [npm](http://npmjs.org) do:
+
+```
+npm install deep-equal
+```
+
+# test
+
+With [npm](http://npmjs.org) do:
+
+```
+npm test
+```
--- a/tests/node_modules/tape-es/node_modules/deep-equal/test/_tape.js
+++ b/tests/node_modules/tape-es/node_modules/deep-equal/test/_tape.js
@@ -0,0 +1,21 @@
+var Test = require('tape/lib/test');
+var is = require('object-is');
+var equal = require('../');
+
+function equalReversed(t, a, b, isEqual, msg, isStrict, skipReversed) {
+  var actual = isStrict ? equal(a, b, { strict: true }) : equal(a, b);
+  var suffix = isEqual ? ' are equal' : ' are not equal';
+  t.equal(actual, !!isEqual, msg + suffix);
+  if (typeof skipReversed === 'boolean' ? !skipReversed : !is(a, b)) {
+    var actualReverse = isStrict ? equal(b, a, { strict: true }) : equal(b, a);
+    t.equal(actualReverse, !!isEqual, msg + suffix + ' (reversed)');
+  }
+}
+function deepEqualTest(t, a, b, msg, isEqual, isStrictEqual, skipReversed) {
+  equalReversed(t, a, b, isEqual, msg, false, skipReversed);
+  equalReversed(t, a, b, isStrictEqual, 'strict: ' + msg, true, skipReversed);
+}
+
+Test.prototype.deepEqualTest = function (a, b, message, isEqual, isStrictEqual, skipReversed) {
+  return deepEqualTest(this, a, b, message, !!isEqual, !!isStrictEqual, skipReversed);
+};
--- a/tests/node_modules/tape-es/node_modules/deep-equal/test/cmp.js
+++ b/tests/node_modules/tape-es/node_modules/deep-equal/test/cmp.js
@@ -0,0 +1,344 @@
+var test = require('tape');
+require('./_tape');
+
+var equal = require('../');
+
+test('equal', function (t) {
+  t.deepEqualTest(
+    { a: [2, 3], b: [4] },
+    { a: [2, 3], b: [4] },
+    'two equal objects',
+    true,
+    true,
+    false
+  );
+  t.end();
+});
+
+test('not equal', function (t) {
+  t.deepEqualTest(
+    { x: 5, y: [6] },
+    { x: 5, y: 6 },
+    'two inequal objects are',
+    false,
+    false
+  );
+  t.end();
+});
+
+test('nested nulls', function (t) {
+  t.deepEqualTest(
+    [null, null, null],
+    [null, null, null],
+    'same-length arrays of nulls',
+    true,
+    true,
+    true
+  );
+  t.end();
+});
+
+test('objects with strings vs numbers', function (t) {
+  t.deepEqualTest(
+    [{ a: 3 }, { b: 4 }],
+    [{ a: '3' }, { b: '4' }],
+    'objects with equivalent string/number values',
+    true,
+    false
+  );
+  t.end();
+});
+
+test('non-objects', function (t) {
+  t.deepEqualTest(3, 3, 'same numbers', true, true, true);
+  t.deepEqualTest('beep', 'beep', 'same strings', true, true, true);
+  t.deepEqualTest('3', 3, 'numeric string and number', true, false);
+  t.deepEqualTest('3', [3], 'numeric string and array containing number', false, false);
+  t.deepEqualTest(3, [3], 'number and array containing number', false, false);
+
+  t.end();
+});
+
+test('infinities', function (t) {
+  t.deepEqualTest(Infinity, Infinity, '∞ and ∞', true, true, true);
+  t.deepEqualTest(-Infinity, -Infinity, '-∞ and -∞', true, true, true);
+  t.deepEqualTest(Infinity, -Infinity, '∞ and -∞', false, false);
+
+  t.end();
+});
+
+test('arguments class', function (t) {
+  function getArgs() {
+    return arguments;
+  }
+  t.ok(
+    equal(getArgs(1, 2, 3), getArgs(1, 2, 3)),
+    'equivalent arguments objects are equal'
+  );
+
+  t.deepEqualTest(
+    getArgs(1, 2, 3),
+    [1, 2, 3],
+    'array and arguments with same contents',
+    false,
+    false
+  );
+
+  t.end();
+});
+
+test('dates', function (t) {
+  var d0 = new Date(1387585278000);
+  var d1 = new Date('Fri Dec 20 2013 16:21:18 GMT-0800 (PST)');
+  t.deepEqualTest(d0, d1, 'equivalent Dates', true, true);
+  t.end();
+});
+
+test('buffers', function (t) {
+  /* eslint no-buffer-constructor: 1, new-cap: 1 */
+  t.ok(equal(Buffer('xyz'), Buffer('xyz')), 'buffers with same contents are equal');
+  t.ok(equal(Buffer('xyz'), Buffer('xyz'), { strict: true }), 'strict: buffers with same contents are equal');
+
+  t.deepEqualTest(
+    Buffer('abc'),
+    Buffer('xyz'),
+    'buffers with different contents',
+    false,
+    false
+  );
+
+  t.deepEqualTest(
+    Buffer(''),
+    [],
+    'empty buffer and empty array',
+    false,
+    false
+  );
+
+  t.end();
+});
+
+test('booleans and arrays', function (t) {
+  t.deepEqualTest(
+    true,
+    [],
+    'true and an empty array',
+    false,
+    false
+  );
+  t.deepEqualTest(
+    false,
+    [],
+    'false and an empty array',
+    true,
+    false
+  );
+  t.end();
+});
+
+test('arrays initiated', function (t) {
+  var a0 = [
+      undefined,
+      null,
+      -1,
+      0,
+      1,
+      false,
+      true,
+      undefined,
+      '',
+      'abc',
+      null,
+      undefined
+    ],
+    a1 = [
+      undefined,
+      null,
+      -1,
+      0,
+      1,
+      false,
+      true,
+      undefined,
+      '',
+      'abc',
+      null,
+      undefined
+    ];
+
+  t.ok(equal(a0, a1));
+  t.end();
+});
+
+// eslint-disable-next-line max-statements
+test('arrays assigned', function (t) {
+  var a0 = [
+    undefined,
+    null,
+    -1,
+    0,
+    1,
+    false,
+    true,
+    undefined,
+    '',
+    'abc',
+    null,
+    undefined
+  ];
+  var a1 = [];
+
+  a1[0] = undefined;
+  a1[1] = null;
+  a1[2] = -1;
+  a1[3] = 0;
+  a1[4] = 1;
+  a1[5] = false;
+  a1[6] = true;
+  a1[7] = undefined;
+  a1[8] = '';
+  a1[9] = 'abc';
+  a1[10] = null;
+  a1[11] = undefined;
+  a1.length = 12;
+
+  t.deepEqualTest(a0, a1, 'a literal array and an assigned array', true, true);
+  t.end();
+});
+
+// eslint-disable-next-line max-statements
+test('arrays push', function (t) {
+  var a0 = [
+      undefined,
+      null,
+      -1,
+      0,
+      1,
+      false,
+      true,
+      undefined,
+      '',
+      'abc',
+      null,
+      undefined
+    ],
+    a1 = [];
+
+  a1.push(undefined);
+  a1.push(null);
+  a1.push(-1);
+  a1.push(0);
+  a1.push(1);
+  a1.push(false);
+  a1.push(true);
+  a1.push(undefined);
+  a1.push('');
+  a1.push('abc');
+  a1.push(null);
+  a1.push(undefined);
+  a1.length = 12;
+
+  t.deepEqualTest(a0, a1, 'a literal array and a pushed array', true, true);
+  t.end();
+});
+
+test('null == undefined', function (t) {
+  t.deepEqualTest(null, undefined, 'null and undefined', true, false);
+
+  t.end();
+});
+
+test('NaNs', function (t) {
+  t.notOk(equal(NaN, NaN), 'NaN is not NaN');
+  t.ok(equal(NaN, NaN, { strict: true }), 'strict: NaN is NaN');
+
+  t.notOk(equal({ a: NaN }, { a: NaN }), 'two equiv objects with a NaN value are not equiv');
+  t.ok(equal({ a: NaN }, { a: NaN }, { strict: true }), 'strict: two equiv objects with a NaN value are equiv');
+
+  t.notOk(equal(NaN, 1), 'NaN !== 1');
+  t.notOk(equal(NaN, 1, { strict: true }), 'strict: NaN !== 1');
+
+  t.end();
+});
+
+test('zeroes', function (t) {
+  t.deepEqualTest(0, -0, '0 and -0', true, false);
+
+  t.deepEqualTest({ a: 0 }, { a: -0 }, 'two objects with a same-keyed 0/-0 value', true, false);
+
+  t.end();
+});
+
+test('Object.create', { skip: !Object.create }, function (t) {
+  var a = { a: 'A' };
+  var b = Object.create(a);
+  b.b = 'B';
+  var c = Object.create(a);
+  c.b = 'C';
+
+  t.deepEqualTest(
+    b,
+    c,
+    'two objects with the same [[Prototype]] but a different own property',
+    false,
+    false
+  );
+
+  t.end();
+});
+
+test('Object.create(null)', { skip: !Object.create }, function (t) {
+  t.deepEqualTest(
+    Object.create(null),
+    Object.create(null),
+    'two empty null objects',
+    true,
+    true,
+    true
+  );
+
+  t.deepEqualTest(
+    Object.create(null, { a: { value: 'b' } }),
+    Object.create(null, { a: { value: 'b' } }),
+    'two null objects with the same property pair',
+    true,
+    true,
+    true
+  );
+
+  t.end();
+});
+
+test('regexes vs dates', function (t) {
+  var d = new Date(1387585278000);
+  var r = /abc/;
+
+  t.deepEqualTest(d, r, 'Date and RegExp', false, false);
+
+  t.end();
+});
+
+test('regexen', function (t) {
+  t.deepEqualTest(/abc/, /xyz/, 'two different regexes', false, false);
+  t.deepEqualTest(/abc/, /abc/, 'two abc regexes', true, true, false);
+  t.deepEqualTest(/xyz/, /xyz/, 'two xyz regexes', true, true, false);
+
+  t.end();
+});
+
+test('arrays and objects', function (t) {
+  t.deepEqualTest([], {}, 'empty array and empty object', true, true);
+  t.deepEqualTest([], { length: 0 }, 'empty array and empty arraylike object', false, false);
+  t.deepEqualTest([1], { 0: 1 }, 'array and similar object', true, true);
+
+  t.end();
+});
+
+test('functions', function (t) {
+  function f() {}
+
+  t.deepEqualTest(f, f, 'a function and itself', true, true, true);
+  t.deepEqualTest(function () {}, function () {}, 'two distinct functions', false, false, true);
+
+  t.end();
+});
--- a/tests/node_modules/tape-es/node_modules/is-regex/.eslintrc
+++ b/tests/node_modules/tape-es/node_modules/is-regex/.eslintrc
@@ -0,0 +1,9 @@
+{
+	"root": true,
+
+	"extends": "@ljharb",
+
+	"rules": {
+		"id-length": [1]
+	}
+}
--- a/tests/node_modules/tape-es/node_modules/is-regex/.github/workflows/rebase.yml
+++ b/tests/node_modules/tape-es/node_modules/is-regex/.github/workflows/rebase.yml
@@ -0,0 +1,15 @@
+name: Automatic Rebase
+
+on: [pull_request]
+
+jobs:
+  _:
+    name: "Automatic Rebase"
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v1
+    - uses: ljharb/rebase@master
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
--- a/tests/node_modules/tape-es/node_modules/is-regex/.travis.yml
+++ b/tests/node_modules/tape-es/node_modules/is-regex/.travis.yml
@@ -0,0 +1,12 @@
+version: ~> 1.0
+language: node_js
+os:
+ - linux
+import:
+ - ljharb/travis-ci:node/all.yml
+ - ljharb/travis-ci:node/pretest.yml
+ - ljharb/travis-ci:node/posttest.yml
+ - ljharb/travis-ci:node/coverage.yml
+matrix:
+  allow_failures:
+    - env: COVERAGE=true
--- a/tests/node_modules/tape-es/node_modules/is-regex/CHANGELOG.md
+++ b/tests/node_modules/tape-es/node_modules/is-regex/CHANGELOG.md
@@ -0,0 +1,148 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+Generated by [`auto-changelog`](https://github.com/CookPete/auto-changelog).
+
+## [v1.0.5](https://github.com/inspect-js/is-regex/compare/v1.0.4...v1.0.5) - 2019-12-15
+
+### Commits
+
+- [Tests] use shared travis-ci configs [`af728b2`](https://github.com/inspect-js/is-regex/commit/af728b21c5cc9e41234fb4015594bffdcfff597c)
+- [Tests] remove `jscs` [`1b8cfe8`](https://github.com/inspect-js/is-regex/commit/1b8cfe8cfb14820c196775f19d370276e4034791)
+- [meta] add `auto-changelog` [`c3131d8`](https://github.com/inspect-js/is-regex/commit/c3131d8ab5d06ea5fa05a4bb2ad28bbfb81668ad)
+- [Tests] up to `node` `v8.1`, `v7.10`, `v6.11`, `v4.8`; newer npm fails on older nodes [`660b658`](https://github.com/inspect-js/is-regex/commit/660b6585d1a9607dbdae879b70ce2f6a5684616c)
+- [Tests] up to `node` `v9.3`, `v8.9`, `v6.12`; use `nvm install-latest-npm`; pin included builds to LTS [`7c25218`](https://github.com/inspect-js/is-regex/commit/7c25218d540ab17c18e4ae333677c5725806a778)
+- [Tests] up to `node` `v12.10`, `v11.15`, `v10.16`, `v8.16`, `v6.17` [`fa95547`](https://github.com/inspect-js/is-regex/commit/fa955478950a5ba0a920010d5daaa29487500b30)
+- [meta] remove unused Makefile and associated utilities [`9fd2a29`](https://github.com/inspect-js/is-regex/commit/9fd2a29dc57ed125f3d61e94f6254a9dd8ee0044)
+- [Tests] up to `node` `v11.3`, `v10.14`, `v8.14`, `v6.15` [`7f2ac41`](https://github.com/inspect-js/is-regex/commit/7f2ac41ef5dc4d53bfe2fb1c24486c688a2537bd)
+- [Tests] up to `node` `v10.0`, `v9.11`, `v8.11`, `v6.14`, `v4.9` [`6fa2b0f`](https://github.com/inspect-js/is-regex/commit/6fa2b0fe171a5b02086a06679a92d989e83a8b8e)
+- [Dev Deps] update `eslint`, `@ljharb/eslint-config` [`697e1de`](https://github.com/inspect-js/is-regex/commit/697e1de1c9e69f08e591cc0040d81fdbbde6fe4e)
+- [actions] add automatic rebasing / merge commit blocking [`ad86dc9`](https://github.com/inspect-js/is-regex/commit/ad86dc97a52e4f66fbfb3b8c9c78da3963588b54)
+- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `jscs`, `nsp`, `replace`, `semver`, `tape` [`5c99c8e`](https://github.com/inspect-js/is-regex/commit/5c99c8e384d5ce2ef434be5853c301477cf35456)
+- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `replace`, `semver`, `tape` [`bb63686`](https://github.com/inspect-js/is-regex/commit/bb63686a9d0fc586d121549cf484da95edec3b0a)
+- [Dev Deps] update `eslint`, `@ljharb/eslint-config@`, `replace`, `semver`, `tape` [`ddf3670`](https://github.com/inspect-js/is-regex/commit/ddf36705e5f7bd29832721e4a23abf06195032c6)
+- [Dev Deps] update `tape`, `nsp`, `eslint`, `@ljharb/eslint-config` [`e7b5a62`](https://github.com/inspect-js/is-regex/commit/e7b5a626eef3b9648c7d52d4620ce2e2a98a9ab8)
+- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `covert`, `tape` [`c803db5`](https://github.com/inspect-js/is-regex/commit/c803db5cd94cf9e0a559617adbc1e4c9d22007ff)
+- [Tests] switch from `nsp` to `npm audit` [`b7239be`](https://github.com/inspect-js/is-regex/commit/b7239be9da263a0f7066f79d087eaf700a9613e9)
+- [Dev Deps] update `eslint`, `nsp`, `semver`, `tape` [`347ee6c`](https://github.com/inspect-js/is-regex/commit/347ee6c67ba0f56b03f21a5abe743658f6515963)
+- Only apps should have lockfiles. [`3866575`](https://github.com/inspect-js/is-regex/commit/38665755ecf028061f15816059e26023890a0dc7)
+- [Tests] use `npx aud` instead of `nsp` or `npm audit` with hoops [`d099a39`](https://github.com/inspect-js/is-regex/commit/d099a3943eb7e156a3e64fb8b74e11d7c83a4bec)
+- [meta] add `funding` field [`741aecd`](https://github.com/inspect-js/is-regex/commit/741aecd92cd49868b3606c8cc99ce299e5f3c7d5)
+- [Tests] use `eclint` instead of `editorconfig-tools` [`bc6aa75`](https://github.com/inspect-js/is-regex/commit/bc6aa7539e506788709b96f7bf3d7549850a81c3)
+- [Tests] on `node` `v10.1` [`262226f`](https://github.com/inspect-js/is-regex/commit/262226f08fa34dff9a8dffd16daabb3dc6e262eb)
+- [Dev Deps] update `eslint` [`31fd719`](https://github.com/inspect-js/is-regex/commit/31fd719dd59a6111ca710cdb0d19a8adadf9b8c6)
+- [Deps] update `has` [`e9e25a3`](https://github.com/inspect-js/is-regex/commit/e9e25a3de7e89faaa6aadf5010477074140e8218)
+- [Dev Deps] update `replace` [`aeeb968`](https://github.com/inspect-js/is-regex/commit/aeeb968bf5a4fc07f0fa6905f2c699fc563b6c32)
+- [Tests] set audit level [`2a6290e`](https://github.com/inspect-js/is-regex/commit/2a6290e78b58bf14b734d7998fe53b4a84db5e44)
+- [Tests] remove `nsp` [`fc74c2b`](https://github.com/inspect-js/is-regex/commit/fc74c2bb6970a7f3280abe6eff3b492d77d89c9f)
+
+## [v1.0.4](https://github.com/inspect-js/is-regex/compare/v1.0.3...v1.0.4) - 2017-02-18
+
+### Fixed
+
+- [Fix] ensure that `lastIndex` is not mutated [`#3`](https://github.com/inspect-js/is-regex/issues/3)
+
+### Commits
+
+- Update `eslint`, `tape`, `semver`; use my personal shared `eslint` config [`c4a41c3`](https://github.com/inspect-js/is-regex/commit/c4a41c3a8203a3919b01cd0d1b577daadf30a452)
+- [Tests] on all node minors; improve test matrix [`58d7508`](https://github.com/inspect-js/is-regex/commit/58d7508a36eb92bd76717486b9e78bde502ffe3e)
+- [Dev Deps] update `tape`, `jscs`, `nsp`, `eslint`, `@ljharb/eslint-config`, `semver` [`7290076`](https://github.com/inspect-js/is-regex/commit/729007606e9ed162953d1f5812c37eb06c554ec2)
+- Update `covert`, `jscs`, `eslint`, `semver` [`dabc729`](https://github.com/inspect-js/is-regex/commit/dabc729cfc4458264c6f7642004d41dd5c214bfd)
+- Update `eslint` [`a946b05`](https://github.com/inspect-js/is-regex/commit/a946b051159396b4311c564880f96e3d00e8b8e2)
+- Update `tape`, `jscs`, `eslint`, `@ljharb/eslint-config` [`1744dde`](https://github.com/inspect-js/is-regex/commit/1744dde77526841f216fa2c1c866c5a82b1638c0)
+- [Refactor] when try/catch is needed, bail early if the value lacks an own `lastIndex` data property. [`288ad93`](https://github.com/inspect-js/is-regex/commit/288ad93dbfed9f6828de20de67105ee6d6504425)
+- Update `editorconfig-tools`, `eslint`, `semver`, `replace` [`4d895c6`](https://github.com/inspect-js/is-regex/commit/4d895c68a0cdbb5803185928963c15147aad0404)
+- Update `eslint`, `tape`, `semver` [`f387f03`](https://github.com/inspect-js/is-regex/commit/f387f03b260b56372bfca301d4e79c4067633854)
+- All grade A-supported `node`/`iojs` versions now ship with an `npm` that understands `^`. [`55e480f`](https://github.com/inspect-js/is-regex/commit/55e480f407cafb6c21a6c32aef04ccaa3ba4216c)
+- [Dev Deps] update `jscs`, `nsp`, `eslint`, `@ljharb/eslint-config`, `semver` [`89d9528`](https://github.com/inspect-js/is-regex/commit/89d95285b364913ebcd8ac7e0872570fe009a5d3)
+- [Dev Deps] update `jscs` [`eb222a8`](https://github.com/inspect-js/is-regex/commit/eb222a8435e59909354f3700fd4880e4ce1cb13e)
+- [Tests] up to `io.js` `v3.3`, `node` `v4.1` [`c65429c`](https://github.com/inspect-js/is-regex/commit/c65429cea0366508c10ad2ab773af7b83a34fc81)
+- Update `nsp`, `eslint` [`c60fbd8`](https://github.com/inspect-js/is-regex/commit/c60fbd8680f7fb3508ec3c5be8ebb788672516c8)
+- Update `eslint`, `semver` [`6a62116`](https://github.com/inspect-js/is-regex/commit/6a621168c63616bf004ca8b1f885b4eb8a58a3e5)
+- [Tests] on `node` `v7.5`, `v4.7` [`e764651`](https://github.com/inspect-js/is-regex/commit/e764651336f5da5e239e9fe8869f3a3201c19d2b)
+- Test up to `io.js` `v2.1` [`3bf326a`](https://github.com/inspect-js/is-regex/commit/3bf326a9bcd530fd16c9fc806e249a68e25ab7e3)
+- Test on the latest `io.js` versions. [`693d047`](https://github.com/inspect-js/is-regex/commit/693d0477631c5d7671f6c99eca5594ffffa75771)
+- [Refactor] use an early return instead of a ternary. [`31eaca2`](https://github.com/inspect-js/is-regex/commit/31eaca28b7d0aaac0599fe7a569b93b842f8ab16)
+- Test on `io.js` `v2.2` [`c18c55a`](https://github.com/inspect-js/is-regex/commit/c18c55aee6358d70531f935e98851e42b698d93c)
+- Run `travis-ci` tests on `iojs` and `node` v0.12; speed up builds; allow 0.8 failures. [`a1c237d`](https://github.com/inspect-js/is-regex/commit/a1c237d35f880fe0bcbc9275254611a6a2300aaf)
+- [Dev Deps] update `eslint`, `@ljharb/eslint-config` [`aa3ea0f`](https://github.com/inspect-js/is-regex/commit/aa3ea0f148af31d75f7ef8a800412729d82def04)
+- [Dev Deps] update `eslint`, `@ljharb/eslint-config` [`d97831d`](https://github.com/inspect-js/is-regex/commit/d97831d0e2ccd3d00d1f7354b7f81e2575f90953)
+- [Dev Deps] Update `tape`, `eslint` [`95e6def`](https://github.com/inspect-js/is-regex/commit/95e6defe3178c45dc9df16e474e558979d5f5c05)
+- Update `eslint`, `nsp` [`3844c93`](https://github.com/inspect-js/is-regex/commit/3844c935cfe7c52fae0dc74d27e884c417cb4616)
+- Update `tape`, `jscs` [`0d6dac8`](https://github.com/inspect-js/is-regex/commit/0d6dac818ed251910171965932f021291919e770)
+- Fix tests for faked @@toStringTag [`2ebef9f`](https://github.com/inspect-js/is-regex/commit/2ebef9f0759843e9a063de7a512b46e3e7daea7e)
+- Test up to `io.js` `v3.0` [`ec1d2d4`](https://github.com/inspect-js/is-regex/commit/ec1d2d44481fa0fa11448527da8030c99fe47a12)
+- [Refactor] bail earlier when the value is falsy. [`a9e333e`](https://github.com/inspect-js/is-regex/commit/a9e333e2ac8912ca05b7e31d30e4eea683c0da4b)
+- [Dev Deps] update `tape` [`8cdcaae`](https://github.com/inspect-js/is-regex/commit/8cdcaae07be8c790cdb99849e6076ea7702a4c84)
+- Switch from vb.teelaun.ch to versionbadg.es for the npm version badge SVG. [`281c4ef`](https://github.com/inspect-js/is-regex/commit/281c4efeb71c86dd380e741bcaee3f7dbf956151)
+- Test on `io.js` `v2.4` [`4d54c68`](https://github.com/inspect-js/is-regex/commit/4d54c68a81b5332a3b76259d8aa8f514be5efd13)
+- Test on `io.js` `v2.3` [`23170f5`](https://github.com/inspect-js/is-regex/commit/23170f5cae632d0377de73bd2febc53db8aebbc9)
+- Test on `iojs-v1.6` [`4487ad0`](https://github.com/inspect-js/is-regex/commit/4487ad0194a5684223bfa2690da4e0a441f7132a)
+
+## [v1.0.3](https://github.com/inspect-js/is-regex/compare/v1.0.2...v1.0.3) - 2015-01-30
+
+### Commits
+
+- Update npm run scripts. [`dc528dd`](https://github.com/inspect-js/is-regex/commit/dc528dd25e775089bc0a3f5a8f7ae7ffc4cdf52a)
+- Add toStringTag tests. [`f48a83a`](https://github.com/inspect-js/is-regex/commit/f48a83a78720b78ab60ca586c16f6f3dbcfec825)
+- If @@toStringTag is not present, use the old-school Object#toString test. [`50b0ffd`](https://github.com/inspect-js/is-regex/commit/50b0ffd9c7fdbd54aee8cde1b07e680ae84f6a0d)
+
+## [v1.0.2](https://github.com/inspect-js/is-regex/compare/v1.0.1...v1.0.2) - 2015-01-29
+
+### Commits
+
+- `make release` [`a1de7ec`](https://github.com/inspect-js/is-regex/commit/a1de7eca4cecc8015fd27804669f8fc61bd16a68)
+- Improve optimization by separating the try/catch, and bailing out early when not typeof "object". [`5ab7632`](https://github.com/inspect-js/is-regex/commit/5ab76322a348487fa8b16761e83f6824c3c27d11)
+
+## [v1.0.1](https://github.com/inspect-js/is-regex/compare/v1.0.0...v1.0.1) - 2015-01-28
+
+### Commits
+
+- Using my standard jscs.json file [`1f1733a`](https://github.com/inspect-js/is-regex/commit/1f1733ac8433cdcceb25356f86b74136a4477cb9)
+- Adding `npm run lint` [`51ea70f`](https://github.com/inspect-js/is-regex/commit/51ea70fa7e461d022f611c195f343ea8d0333d71)
+- Use RegExp#exec to test if something is a regex, which works even with ES6 @@toStringTag. [`042c8c7`](https://github.com/inspect-js/is-regex/commit/042c8c734faade9015932b61f1e8ea4f3a93b1b3)
+- Adding license and downloads badges [`366d619`](https://github.com/inspect-js/is-regex/commit/366d61965d3a4119126e78e09b2166bbcddd0c5a)
+- Use SVG badges instead of PNG [`6a32e4f`](https://github.com/inspect-js/is-regex/commit/6a32e4fc87d7d3a3787b800dd033c9293aead6df)
+- Update `tape`, `jscs` [`f1b9462`](https://github.com/inspect-js/is-regex/commit/f1b9462f86d1b69de07176e7f277f668757ba964)
+- Update `jscs` [`1bff23f`](https://github.com/inspect-js/is-regex/commit/1bff23ff0fe88c8263e8bf04cf99e290af96d5b0)
+- Update `tape`, `jscs` [`c22ea2e`](https://github.com/inspect-js/is-regex/commit/c22ea2e7967f45618deed01ff5ea483f918be216)
+- Update `tape`, `jscs` [`b0479db`](https://github.com/inspect-js/is-regex/commit/b0479db99a1b1b872d1618fb0a71f0c74a78b29b)
+- Use consistent quotes [`1a6e347`](https://github.com/inspect-js/is-regex/commit/1a6e34730d9270f3f20519139faa4c4e6ec2e1f5)
+- Make travis builds faster. [`090a4ea`](https://github.com/inspect-js/is-regex/commit/090a4ea7c5fa709d108d596e3bc304e6ce973dec)
+- Update `tape` [`7d76129`](https://github.com/inspect-js/is-regex/commit/7d7612928bdd43230fbd835db71797249ca24f35)
+- Lock covert to v1.0.0. [`9a90b03`](https://github.com/inspect-js/is-regex/commit/9a90b03fb390e66f874223a34c58ba2bb109edd3)
+- Updating tape [`bfbc7f5`](https://github.com/inspect-js/is-regex/commit/bfbc7f593a007acd0411152bbb55f724dc4ca935)
+- Updating jscs [`13ad511`](https://github.com/inspect-js/is-regex/commit/13ad511d80cd67300c2c0c5387fc4b3b423e2768)
+- Updating jscs [`cda1945`](https://github.com/inspect-js/is-regex/commit/cda1945d603dfe99e24d5a909a931d366451bc4d)
+- Updating jscs [`de96c99`](https://github.com/inspect-js/is-regex/commit/de96c99d4bf5787df671de6df9138b6547a6545b)
+- Running linter as part of tests [`2cb6567`](https://github.com/inspect-js/is-regex/commit/2cb656733b1ed0af14ad11fb584006d22de0c69d)
+- Updating covert [`a56ae74`](https://github.com/inspect-js/is-regex/commit/a56ae74ec8d5f0473295a8b10519a18580f16624)
+- Updating tape [`ffe47f7`](https://github.com/inspect-js/is-regex/commit/ffe47f7fe9cf6d16896b4bdc286bd1d0805d5c49)
+
+## [v1.0.0](https://github.com/inspect-js/is-regex/compare/v0.0.0...v1.0.0) - 2014-05-19
+
+### Commits
+
+- Make sure old and unstable nodes don't break Travis [`05da747`](https://github.com/inspect-js/is-regex/commit/05da7478f960dc131ec3ad864e27e8c6b7d74a80)
+- toString is a reserved var name in old Opera [`885c48c`](https://github.com/inspect-js/is-regex/commit/885c48c120f921a55f1842b0607d3e7875379821)
+- Updating deps [`2ca0e79`](https://github.com/inspect-js/is-regex/commit/2ca0e79a2443ca34d85e8b2ea2e26f55855b74a7)
+- Updating tape. [`9678435`](https://github.com/inspect-js/is-regex/commit/96784355611deb0c23b9064be774216d76e3e457)
+- Updating covert [`c3bb898`](https://github.com/inspect-js/is-regex/commit/c3bb8985a422e3e0c81f9c43899b6c19a72c755f)
+- Updating tape [`7811708`](https://github.com/inspect-js/is-regex/commit/78117089688258b8f939b397b37897b5b3e30f74)
+- Testing on node 0.6 again [`dec36ae`](https://github.com/inspect-js/is-regex/commit/dec36ae58a39a3f80e832b702c3e19406363c160)
+- Run code coverage as part of tests [`e6f4ebe`](https://github.com/inspect-js/is-regex/commit/e6f4ebec26894543747603f2cb360e839f2ca290)
+
+## v0.0.0 - 2014-01-15
+
+### Commits
+
+- package.json [`aa60d43`](https://github.com/inspect-js/is-regex/commit/aa60d43d2c8adb9fdd47f5898e5e1e570bd238d8)
+- read me [`861e944`](https://github.com/inspect-js/is-regex/commit/861e944de88e84010eaa662ea9ea9f17c90cff8c)
+- Initial commit [`d0cdd71`](https://github.com/inspect-js/is-regex/commit/d0cdd71a637d8490b7ee3eaaf75c7e31d0f9242f)
+- Tests. [`b533f74`](https://github.com/inspect-js/is-regex/commit/b533f741a88dff002790fb7af054b2a74e72d4da)
+- Implementation. [`3c9a8c0`](https://github.com/inspect-js/is-regex/commit/3c9a8c06994003cdfffeb3620f251f4c4cae7755)
+- Travis CI [`742c440`](https://github.com/inspect-js/is-regex/commit/742c4407015f9108875fd108fde137f5245e9e7a)
--- a/tests/node_modules/tape-es/node_modules/is-regex/LICENSE
+++ b/tests/node_modules/tape-es/node_modules/is-regex/LICENSE
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Jordan Harband
+
+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.
--- a/tests/node_modules/tape-es/node_modules/is-regex/README.md
+++ b/tests/node_modules/tape-es/node_modules/is-regex/README.md
@@ -0,0 +1,54 @@
+#is-regex <sup>[![Version Badge][2]][1]</sup>
+
+[![Build Status][3]][4]
+[![dependency status][5]][6]
+[![dev dependency status][7]][8]
+[![License][license-image]][license-url]
+[![Downloads][downloads-image]][downloads-url]
+
+[![npm badge][11]][1]
+
+[![browser support][9]][10]
+
+Is this value a JS regex?
+This module works cross-realm/iframe, and despite ES6 @@toStringTag.
+
+## Example
+
+```js
+var isRegex = require('is-regex');
+var assert = require('assert');
+
+assert.notOk(isRegex(undefined));
+assert.notOk(isRegex(null));
+assert.notOk(isRegex(false));
+assert.notOk(isRegex(true));
+assert.notOk(isRegex(42));
+assert.notOk(isRegex('foo'));
+assert.notOk(isRegex(function () {}));
+assert.notOk(isRegex([]));
+assert.notOk(isRegex({}));
+
+assert.ok(isRegex(/a/g));
+assert.ok(isRegex(new RegExp('a', 'g')));
+```
+
+## Tests
+Simply clone the repo, `npm install`, and run `npm test`
+
+[1]: https://npmjs.org/package/is-regex
+[2]: http://versionbadg.es/ljharb/is-regex.svg
+[3]: https://travis-ci.org/ljharb/is-regex.svg
+[4]: https://travis-ci.org/ljharb/is-regex
+[5]: https://david-dm.org/ljharb/is-regex.svg
+[6]: https://david-dm.org/ljharb/is-regex
+[7]: https://david-dm.org/ljharb/is-regex/dev-status.svg
+[8]: https://david-dm.org/ljharb/is-regex#info=devDependencies
+[9]: https://ci.testling.com/ljharb/is-regex.png
+[10]: https://ci.testling.com/ljharb/is-regex
+[11]: https://nodei.co/npm/is-regex.png?downloads=true&stars=true
+[license-image]: http://img.shields.io/npm/l/is-regex.svg
+[license-url]: LICENSE
+[downloads-image]: http://img.shields.io/npm/dm/is-regex.svg
+[downloads-url]: http://npm-stat.com/charts.html?package=is-regex
+
--- a/tests/node_modules/tape-es/node_modules/is-regex/index.js
+++ b/tests/node_modules/tape-es/node_modules/is-regex/index.js
@@ -0,0 +1,39 @@
+'use strict';
+
+var has = require('has');
+var regexExec = RegExp.prototype.exec;
+var gOPD = Object.getOwnPropertyDescriptor;
+
+var tryRegexExecCall = function tryRegexExec(value) {
+	try {
+		var lastIndex = value.lastIndex;
+		value.lastIndex = 0; // eslint-disable-line no-param-reassign
+
+		regexExec.call(value);
+		return true;
+	} catch (e) {
+		return false;
+	} finally {
+		value.lastIndex = lastIndex; // eslint-disable-line no-param-reassign
+	}
+};
+var toStr = Object.prototype.toString;
+var regexClass = '[object RegExp]';
+var hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';
+
+module.exports = function isRegex(value) {
+	if (!value || typeof value !== 'object') {
+		return false;
+	}
+	if (!hasToStringTag) {
+		return toStr.call(value) === regexClass;
+	}
+
+	var descriptor = gOPD(value, 'lastIndex');
+	var hasLastIndexDataProperty = descriptor && has(descriptor, 'value');
+	if (!hasLastIndexDataProperty) {
+		return false;
+	}
+
+	return tryRegexExecCall(value);
+};
--- a/tests/node_modules/tape-es/node_modules/is-regex/package.json
+++ b/tests/node_modules/tape-es/node_modules/is-regex/package.json
@@ -0,0 +1,107 @@
+{
+  "_from": "is-regex@~1.0.5",
+  "_id": "is-regex@1.0.5",
+  "_inBundle": false,
+  "_integrity": "sha512-vlKW17SNq44owv5AQR3Cq0bQPEb8+kF3UKZ2fiZNOWtztYE5i0CzCZxFDwO58qAOWtxdBRVO/V5Qin1wjCqFYQ==",
+  "_location": "/tape-es/is-regex",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "is-regex@~1.0.5",
+    "name": "is-regex",
+    "escapedName": "is-regex",
+    "rawSpec": "~1.0.5",
+    "saveSpec": null,
+    "fetchSpec": "~1.0.5"
+  },
+  "_requiredBy": [
+    "/tape-es/deep-equal",
+    "/tape-es/tape"
+  ],
+  "_resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.0.5.tgz",
+  "_shasum": "39d589a358bf18967f726967120b8fc1aed74eae",
+  "_spec": "is-regex@~1.0.5",
+  "_where": "/home/lilleman/go/src/gitlab.larvit.se/power-plan/auth/tests/node_modules/tape-es/node_modules/tape",
+  "author": {
+    "name": "Jordan Harband",
+    "email": "ljharb@gmail.com"
+  },
+  "auto-changelog": {
+    "output": "CHANGELOG.md",
+    "template": "keepachangelog",
+    "unreleased": false,
+    "commitLimit": false,
+    "backfillLimit": false
+  },
+  "bugs": {
+    "url": "https://github.com/ljharb/is-regex/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "has": "^1.0.3"
+  },
+  "deprecated": false,
+  "description": "Is this value a JS regex? Works cross-realm/iframe, and despite ES6 @@toStringTag",
+  "devDependencies": {
+    "@ljharb/eslint-config": "^15.0.2",
+    "auto-changelog": "^1.16.2",
+    "covert": "^1.1.1",
+    "eclint": "^2.8.1",
+    "eslint": "^6.7.2",
+    "tape": "^4.11.0"
+  },
+  "engines": {
+    "node": ">= 0.4"
+  },
+  "funding": {
+    "url": "https://github.com/sponsors/ljharb"
+  },
+  "homepage": "https://github.com/ljharb/is-regex",
+  "keywords": [
+    "regex",
+    "regexp",
+    "is",
+    "regular expression",
+    "regular",
+    "expression"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "name": "is-regex",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/ljharb/is-regex.git"
+  },
+  "scripts": {
+    "coverage": "covert test/index.js",
+    "eccheck": "eclint check *.js **/*.js > /dev/null",
+    "lint": "eslint .",
+    "posttest": "npx aud",
+    "postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\"",
+    "pretest": "npm run lint",
+    "test": "npm run tests-only",
+    "tests-only": "node --harmony --es-staging test",
+    "version": "auto-changelog && git add CHANGELOG.md"
+  },
+  "testling": {
+    "files": "test.js",
+    "browsers": [
+      "iexplore/6.0..latest",
+      "firefox/3.0..6.0",
+      "firefox/15.0..latest",
+      "firefox/nightly",
+      "chrome/4.0..10.0",
+      "chrome/20.0..latest",
+      "chrome/canary",
+      "opera/10.0..12.0",
+      "opera/15.0..latest",
+      "opera/next",
+      "safari/4.0..latest",
+      "ipad/6.0..latest",
+      "iphone/6.0..latest",
+      "android-browser/4.2"
+    ]
+  },
+  "version": "1.0.5"
+}
--- a/tests/node_modules/tape-es/node_modules/is-regex/test/index.js
+++ b/tests/node_modules/tape-es/node_modules/is-regex/test/index.js
@@ -0,0 +1,58 @@
+'use strict';
+
+var test = require('tape');
+var isRegex = require('..');
+var hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';
+
+test('not regexes', function (t) {
+	t.notOk(isRegex(), 'undefined is not regex');
+	t.notOk(isRegex(null), 'null is not regex');
+	t.notOk(isRegex(false), 'false is not regex');
+	t.notOk(isRegex(true), 'true is not regex');
+	t.notOk(isRegex(42), 'number is not regex');
+	t.notOk(isRegex('foo'), 'string is not regex');
+	t.notOk(isRegex([]), 'array is not regex');
+	t.notOk(isRegex({}), 'object is not regex');
+	t.notOk(isRegex(function () {}), 'function is not regex');
+	t.end();
+});
+
+test('@@toStringTag', { skip: !hasToStringTag }, function (t) {
+	var regex = /a/g;
+	var fakeRegex = {
+		toString: function () { return String(regex); },
+		valueOf: function () { return regex; }
+	};
+	fakeRegex[Symbol.toStringTag] = 'RegExp';
+	t.notOk(isRegex(fakeRegex), 'fake RegExp with @@toStringTag "RegExp" is not regex');
+	t.end();
+});
+
+test('regexes', function (t) {
+	t.ok(isRegex(/a/g), 'regex literal is regex');
+	t.ok(isRegex(new RegExp('a', 'g')), 'regex object is regex');
+	t.end();
+});
+
+test('does not mutate regexes', function (t) {
+	t.test('lastIndex is a marker object', function (st) {
+		var regex = /a/;
+		var marker = {};
+		regex.lastIndex = marker;
+		st.equal(regex.lastIndex, marker, 'lastIndex is the marker object');
+		st.ok(isRegex(regex), 'is regex');
+		st.equal(regex.lastIndex, marker, 'lastIndex is the marker object after isRegex');
+		st.end();
+	});
+
+	t.test('lastIndex is nonzero', function (st) {
+		var regex = /a/;
+		regex.lastIndex = 3;
+		st.equal(regex.lastIndex, 3, 'lastIndex is 3');
+		st.ok(isRegex(regex), 'is regex');
+		st.equal(regex.lastIndex, 3, 'lastIndex is 3 after isRegex');
+		st.end();
+	});
+
+	t.end();
+});
--- a/tests/node_modules/tape-es/node_modules/object-inspect/.eslintignore
+++ b/tests/node_modules/tape-es/node_modules/object-inspect/.eslintignore
@@ -0,0 +1 @@
+coverage/
--- a/tests/node_modules/tape-es/node_modules/object-inspect/.eslintrc
+++ b/tests/node_modules/tape-es/node_modules/object-inspect/.eslintrc
@@ -0,0 +1,61 @@
+{
+    "root": true,
+    "extends": "@ljharb",
+    "rules": {
+		"complexity": 0,
+		"func-style": [2, 'declaration'],
+        "indent": [2, 4],
+        "max-lines-per-function": [2, 130],
+        "max-params": [2, 4],
+		"max-statements": [2, 90],
+        "max-statements-per-line": [2, { "max": 2 }],
+        "no-magic-numbers": 0,
+		"no-param-reassign": 1,
+        "strict": 0, // TODO
+    },
+    "globals": {
+        "BigInt": false,
+        "WeakSet": false,
+        "WeakMap": false,
+    },
+    "overrides": [
+        {
+            "files": ["test/**", "test-*", "example/**"],
+            "rules": {
+              "array-bracket-newline": 0,
+              "max-params": 0,
+              "max-statements": 0,
+              "max-statements-per-line": 0,
+              "object-curly-newline": 0,
+              "sort-keys": 0,
+            },
+        },
+        {
+            "files": ["example/**"],
+            "rules": {
+                "no-console": 0,
+            },
+        },
+        {
+            "files": ["test/browser/**"],
+            "env": {
+                "browser": true,
+            },
+        },
+        {
+            "files": ["test/bigint*"],
+            "rules": {
+                "new-cap": [2, { "capIsNewExceptions": ["BigInt"] }],
+            },
+        },
+        {
+            "files": "index.js",
+            "globals": {
+                "HTMLElement": false,
+            },
+            "rules": {
+                "no-use-before-define": 1,
+            },
+        },
+    ],
+}
--- a/tests/node_modules/tape-es/node_modules/object-inspect/.nycrc
+++ b/tests/node_modules/tape-es/node_modules/object-inspect/.nycrc
@@ -0,0 +1,17 @@
+{
+  "all": true,
+  "check-coverage": true,
+  "instrumentation": false,
+  "sourceMap": false,
+  "reporter": ["html", "text-summary"],
+  "lines": 93,
+  "statements": 93,
+  "functions": 96,
+  "branches": 89,
+  "exclude": [
+    "coverage",
+    "example",
+    "test",
+    "test-core-js.js"
+  ]
+}
--- a/tests/node_modules/tape-es/node_modules/object-inspect/.travis.yml
+++ b/tests/node_modules/tape-es/node_modules/object-inspect/.travis.yml
@@ -0,0 +1,9 @@
+version: ~> 1.0
+language: node_js
+os:
+ - linux
+import:
+  - ljharb/travis-ci:node/all.yml
+  - ljharb/travis-ci:node/pretest.yml
+  - ljharb/travis-ci:node/posttest.yml
+  - ljharb/travis-ci:node/coverage.yml
--- a/tests/node_modules/tape-es/node_modules/object-inspect/LICENSE
+++ b/tests/node_modules/tape-es/node_modules/object-inspect/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2013 James Halliday
+
+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.
--- a/tests/node_modules/tape-es/node_modules/object-inspect/example/all.js
+++ b/tests/node_modules/tape-es/node_modules/object-inspect/example/all.js
@@ -0,0 +1,23 @@
+'use strict';
+
+var inspect = require('../');
+var Buffer = require('safer-buffer').Buffer;
+
+var holes = ['a', 'b'];
+holes[4] = 'e';
+holes[6] = 'g';
+
+var obj = {
+    a: 1,
+    b: [3, 4, undefined, null],
+    c: undefined,
+    d: null,
+    e: {
+        regex: /^x/i,
+        buf: Buffer.from('abc'),
+        holes: holes
+    },
+    now: new Date()
+};
+obj.self = obj;
+console.log(inspect(obj));
--- a/tests/node_modules/tape-es/node_modules/object-inspect/example/circular.js
+++ b/tests/node_modules/tape-es/node_modules/object-inspect/example/circular.js
@@ -0,0 +1,6 @@
+'use strict';
+
+var inspect = require('../');
+var obj = { a: 1, b: [3, 4] };
+obj.c = obj;
+console.log(inspect(obj));
--- a/tests/node_modules/tape-es/node_modules/object-inspect/example/fn.js
+++ b/tests/node_modules/tape-es/node_modules/object-inspect/example/fn.js
@@ -0,0 +1,5 @@
+'use strict';
+
+var inspect = require('../');
+var obj = [1, 2, function f(n) { return n + 5; }, 4];
+console.log(inspect(obj));
--- a/tests/node_modules/tape-es/node_modules/object-inspect/example/inspect.js
+++ b/tests/node_modules/tape-es/node_modules/object-inspect/example/inspect.js
@@ -0,0 +1,10 @@
+'use strict';
+
+/* eslint-env browser */
+var inspect = require('../');
+
+var d = document.createElement('div');
+d.setAttribute('id', 'beep');
+d.innerHTML = '<b>wooo</b><i>iiiii</i>';
+
+console.log(inspect([d, { a: 3, b: 4, c: [5, 6, [7, [8, [9]]]] }]));
--- a/tests/node_modules/tape-es/node_modules/object-inspect/index.js
+++ b/tests/node_modules/tape-es/node_modules/object-inspect/index.js
@@ -0,0 +1,307 @@
+var hasMap = typeof Map === 'function' && Map.prototype;
+var mapSizeDescriptor = Object.getOwnPropertyDescriptor && hasMap ? Object.getOwnPropertyDescriptor(Map.prototype, 'size') : null;
+var mapSize = hasMap && mapSizeDescriptor && typeof mapSizeDescriptor.get === 'function' ? mapSizeDescriptor.get : null;
+var mapForEach = hasMap && Map.prototype.forEach;
+var hasSet = typeof Set === 'function' && Set.prototype;
+var setSizeDescriptor = Object.getOwnPropertyDescriptor && hasSet ? Object.getOwnPropertyDescriptor(Set.prototype, 'size') : null;
+var setSize = hasSet && setSizeDescriptor && typeof setSizeDescriptor.get === 'function' ? setSizeDescriptor.get : null;
+var setForEach = hasSet && Set.prototype.forEach;
+var hasWeakMap = typeof WeakMap === 'function' && WeakMap.prototype;
+var weakMapHas = hasWeakMap ? WeakMap.prototype.has : null;
+var hasWeakSet = typeof WeakSet === 'function' && WeakSet.prototype;
+var weakSetHas = hasWeakSet ? WeakSet.prototype.has : null;
+var booleanValueOf = Boolean.prototype.valueOf;
+var objectToString = Object.prototype.toString;
+var match = String.prototype.match;
+var bigIntValueOf = typeof BigInt === 'function' ? BigInt.prototype.valueOf : null;
+
+var inspectCustom = require('./util.inspect').custom;
+var inspectSymbol = inspectCustom && isSymbol(inspectCustom) ? inspectCustom : null;
+
+module.exports = function inspect_(obj, options, depth, seen) {
+    var opts = options || {};
+
+    if (has(opts, 'quoteStyle') && (opts.quoteStyle !== 'single' && opts.quoteStyle !== 'double')) {
+        throw new TypeError('option "quoteStyle" must be "single" or "double"');
+    }
+
+    if (typeof obj === 'undefined') {
+        return 'undefined';
+    }
+    if (obj === null) {
+        return 'null';
+    }
+    if (typeof obj === 'boolean') {
+        return obj ? 'true' : 'false';
+    }
+
+    if (typeof obj === 'string') {
+        return inspectString(obj, opts);
+    }
+    if (typeof obj === 'number') {
+        if (obj === 0) {
+            return Infinity / obj > 0 ? '0' : '-0';
+        }
+        return String(obj);
+    }
+    if (typeof obj === 'bigint') { // eslint-disable-line valid-typeof
+        return String(obj) + 'n';
+    }
+
+    var maxDepth = typeof opts.depth === 'undefined' ? 5 : opts.depth;
+    if (typeof depth === 'undefined') { depth = 0; }
+    if (depth >= maxDepth && maxDepth > 0 && typeof obj === 'object') {
+        return '[Object]';
+    }
+
+    if (typeof seen === 'undefined') {
+        seen = [];
+    } else if (indexOf(seen, obj) >= 0) {
+        return '[Circular]';
+    }
+
+    function inspect(value, from) {
+        if (from) {
+            seen = seen.slice();
+            seen.push(from);
+        }
+        return inspect_(value, opts, depth + 1, seen);
+    }
+
+    if (typeof obj === 'function') {
+        var name = nameOf(obj);
+        return '[Function' + (name ? ': ' + name : '') + ']';
+    }
+    if (isSymbol(obj)) {
+        var symString = Symbol.prototype.toString.call(obj);
+        return typeof obj === 'object' ? markBoxed(symString) : symString;
+    }
+    if (isElement(obj)) {
+        var s = '<' + String(obj.nodeName).toLowerCase();
+        var attrs = obj.attributes || [];
+        for (var i = 0; i < attrs.length; i++) {
+            s += ' ' + attrs[i].name + '=' + wrapQuotes(quote(attrs[i].value), 'double', opts);
+        }
+        s += '>';
+        if (obj.childNodes && obj.childNodes.length) { s += '...'; }
+        s += '</' + String(obj.nodeName).toLowerCase() + '>';
+        return s;
+    }
+    if (isArray(obj)) {
+        if (obj.length === 0) { return '[]'; }
+        return '[ ' + arrObjKeys(obj, inspect).join(', ') + ' ]';
+    }
+    if (isError(obj)) {
+        var parts = arrObjKeys(obj, inspect);
+        if (parts.length === 0) { return '[' + String(obj) + ']'; }
+        return '{ [' + String(obj) + '] ' + parts.join(', ') + ' }';
+    }
+    if (typeof obj === 'object') {
+        if (inspectSymbol && typeof obj[inspectSymbol] === 'function') {
+            return obj[inspectSymbol]();
+        } else if (typeof obj.inspect === 'function') {
+            return obj.inspect();
+        }
+    }
+    if (isMap(obj)) {
+        var mapParts = [];
+        mapForEach.call(obj, function (value, key) {
+            mapParts.push(inspect(key, obj) + ' => ' + inspect(value, obj));
+        });
+        return collectionOf('Map', mapSize.call(obj), mapParts);
+    }
+    if (isSet(obj)) {
+        var setParts = [];
+        setForEach.call(obj, function (value) {
+            setParts.push(inspect(value, obj));
+        });
+        return collectionOf('Set', setSize.call(obj), setParts);
+    }
+    if (isWeakMap(obj)) {
+        return weakCollectionOf('WeakMap');
+    }
+    if (isWeakSet(obj)) {
+        return weakCollectionOf('WeakSet');
+    }
+    if (isNumber(obj)) {
+        return markBoxed(inspect(Number(obj)));
+    }
+    if (isBigInt(obj)) {
+        return markBoxed(inspect(bigIntValueOf.call(obj)));
+    }
+    if (isBoolean(obj)) {
+        return markBoxed(booleanValueOf.call(obj));
+    }
+    if (isString(obj)) {
+        return markBoxed(inspect(String(obj)));
+    }
+    if (!isDate(obj) && !isRegExp(obj)) {
+        var xs = arrObjKeys(obj, inspect);
+        if (xs.length === 0) { return '{}'; }
+        return '{ ' + xs.join(', ') + ' }';
+    }
+    return String(obj);
+};
+
+function wrapQuotes(s, defaultStyle, opts) {
+    var quoteChar = (opts.quoteStyle || defaultStyle) === 'double' ? '"' : "'";
+    return quoteChar + s + quoteChar;
+}
+
+function quote(s) {
+    return String(s).replace(/"/g, '&quot;');
+}
+
+function isArray(obj) { return toStr(obj) === '[object Array]'; }
+function isDate(obj) { return toStr(obj) === '[object Date]'; }
+function isRegExp(obj) { return toStr(obj) === '[object RegExp]'; }
+function isError(obj) { return toStr(obj) === '[object Error]'; }
+function isSymbol(obj) { return toStr(obj) === '[object Symbol]'; }
+function isString(obj) { return toStr(obj) === '[object String]'; }
+function isNumber(obj) { return toStr(obj) === '[object Number]'; }
+function isBigInt(obj) { return toStr(obj) === '[object BigInt]'; }
+function isBoolean(obj) { return toStr(obj) === '[object Boolean]'; }
+
+var hasOwn = Object.prototype.hasOwnProperty || function (key) { return key in this; };
+function has(obj, key) {
+    return hasOwn.call(obj, key);
+}
+
+function toStr(obj) {
+    return objectToString.call(obj);
+}
+
+function nameOf(f) {
+    if (f.name) { return f.name; }
+    var m = match.call(f, /^function\s*([\w$]+)/);
+    if (m) { return m[1]; }
+    return null;
+}
+
+function indexOf(xs, x) {
+    if (xs.indexOf) { return xs.indexOf(x); }
+    for (var i = 0, l = xs.length; i < l; i++) {
+        if (xs[i] === x) { return i; }
+    }
+    return -1;
+}
+
+function isMap(x) {
+    if (!mapSize || !x || typeof x !== 'object') {
+        return false;
+    }
+    try {
+        mapSize.call(x);
+        try {
+            setSize.call(x);
+        } catch (s) {
+            return true;
+        }
+        return x instanceof Map; // core-js workaround, pre-v2.5.0
+    } catch (e) {}
+    return false;
+}
+
+function isWeakMap(x) {
+    if (!weakMapHas || !x || typeof x !== 'object') {
+        return false;
+    }
+    try {
+        weakMapHas.call(x, weakMapHas);
+        try {
+            weakSetHas.call(x, weakSetHas);
+        } catch (s) {
+            return true;
+        }
+        return x instanceof WeakMap; // core-js workaround, pre-v2.5.0
+    } catch (e) {}
+    return false;
+}
+
+function isSet(x) {
+    if (!setSize || !x || typeof x !== 'object') {
+        return false;
+    }
+    try {
+        setSize.call(x);
+        try {
+            mapSize.call(x);
+        } catch (m) {
+            return true;
+        }
+        return x instanceof Set; // core-js workaround, pre-v2.5.0
+    } catch (e) {}
+    return false;
+}
+
+function isWeakSet(x) {
+    if (!weakSetHas || !x || typeof x !== 'object') {
+        return false;
+    }
+    try {
+        weakSetHas.call(x, weakSetHas);
+        try {
+            weakMapHas.call(x, weakMapHas);
+        } catch (s) {
+            return true;
+        }
+        return x instanceof WeakSet; // core-js workaround, pre-v2.5.0
+    } catch (e) {}
+    return false;
+}
+
+function isElement(x) {
+    if (!x || typeof x !== 'object') { return false; }
+    if (typeof HTMLElement !== 'undefined' && x instanceof HTMLElement) {
+        return true;
+    }
+    return typeof x.nodeName === 'string' && typeof x.getAttribute === 'function';
+}
+
+function inspectString(str, opts) {
+    // eslint-disable-next-line no-control-regex
+    var s = str.replace(/(['\\])/g, '\\$1').replace(/[\x00-\x1f]/g, lowbyte);
+    return wrapQuotes(s, 'single', opts);
+}
+
+function lowbyte(c) {
+    var n = c.charCodeAt(0);
+    var x = {
+        8: 'b', 9: 't', 10: 'n', 12: 'f', 13: 'r'
+    }[n];
+    if (x) { return '\\' + x; }
+    return '\\x' + (n < 0x10 ? '0' : '') + n.toString(16);
+}
+
+function markBoxed(str) {
+    return 'Object(' + str + ')';
+}
+
+function weakCollectionOf(type) {
+    return type + ' { ? }';
+}
+
+function collectionOf(type, size, entries) {
+    return type + ' (' + size + ') {' + entries.join(', ') + '}';
+}
+
+function arrObjKeys(obj, inspect) {
+    var isArr = isArray(obj);
+    var xs = [];
+    if (isArr) {
+        xs.length = obj.length;
+        for (var i = 0; i < obj.length; i++) {
+            xs[i] = has(obj, i) ? inspect(obj[i], obj) : '';
+        }
+    }
+    for (var key in obj) { // eslint-disable-line no-restricted-syntax
+        if (!has(obj, key)) { continue; } // eslint-disable-line no-restricted-syntax, no-continue
+        if (isArr && String(Number(key)) === key && key < obj.length) { continue; } // eslint-disable-line no-restricted-syntax, no-continue
+        if ((/[^\w$]/).test(key)) {
+            xs.push(inspect(key, obj) + ': ' + inspect(obj[key], obj));
+        } else {
+            xs.push(key + ': ' + inspect(obj[key], obj));
+        }
+    }
+    return xs;
+}
--- a/tests/node_modules/tape-es/node_modules/object-inspect/package.json
+++ b/tests/node_modules/tape-es/node_modules/object-inspect/package.json
@@ -0,0 +1,96 @@
+{
+  "_from": "object-inspect@~1.7.0",
+  "_id": "object-inspect@1.7.0",
+  "_inBundle": false,
+  "_integrity": "sha512-a7pEHdh1xKIAgTySUGgLMx/xwDZskN1Ud6egYYN3EdRW4ZMPNEDUTF+hwy2LUC+Bl+SyLXANnwz/jyh/qutKUw==",
+  "_location": "/tape-es/object-inspect",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "object-inspect@~1.7.0",
+    "name": "object-inspect",
+    "escapedName": "object-inspect",
+    "rawSpec": "~1.7.0",
+    "saveSpec": null,
+    "fetchSpec": "~1.7.0"
+  },
+  "_requiredBy": [
+    "/tape-es/tape"
+  ],
+  "_resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.7.0.tgz",
+  "_shasum": "f4f6bd181ad77f006b5ece60bd0b6f398ff74a67",
+  "_spec": "object-inspect@~1.7.0",
+  "_where": "/home/lilleman/go/src/gitlab.larvit.se/power-plan/auth/tests/node_modules/tape-es/node_modules/tape",
+  "author": {
+    "name": "James Halliday",
+    "email": "mail@substack.net",
+    "url": "http://substack.net"
+  },
+  "browser": {
+    "./util.inspect.js": false
+  },
+  "bugs": {
+    "url": "https://github.com/substack/object-inspect/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "string representations of objects in node and the browser",
+  "devDependencies": {
+    "@ljharb/eslint-config": "^15.0.1",
+    "core-js": "^2.6.10",
+    "eslint": "^6.6.0",
+    "nyc": "^10.3.2",
+    "tape": "^4.11.0"
+  },
+  "funding": {
+    "url": "https://github.com/sponsors/ljharb"
+  },
+  "greenkeeper": {
+    "ignore": [
+      "nyc",
+      "core-js"
+    ]
+  },
+  "homepage": "https://github.com/substack/object-inspect",
+  "keywords": [
+    "inspect",
+    "util.inspect",
+    "object",
+    "stringify",
+    "pretty"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "name": "object-inspect",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/substack/object-inspect.git"
+  },
+  "scripts": {
+    "coverage": "nyc npm run tests-only",
+    "lint": "eslint .",
+    "posttest": "npx aud --production",
+    "pretest": "npm run lint",
+    "pretests-only": "node test-core-js",
+    "test": "npm run tests-only",
+    "tests-only": "tape test/*.js"
+  },
+  "testling": {
+    "files": [
+      "test/*.js",
+      "test/browser/*.js"
+    ],
+    "browsers": [
+      "ie/6..latest",
+      "chrome/latest",
+      "firefox/latest",
+      "safari/latest",
+      "opera/latest",
+      "iphone/latest",
+      "ipad/latest",
+      "android/latest"
+    ]
+  },
+  "version": "1.7.0"
+}
--- a/tests/node_modules/tape-es/node_modules/object-inspect/readme.markdown
+++ b/tests/node_modules/tape-es/node_modules/object-inspect/readme.markdown
@@ -0,0 +1,61 @@
+# object-inspect
+
+string representations of objects in node and the browser
+
+[![testling badge](https://ci.testling.com/substack/object-inspect.png)](https://ci.testling.com/substack/object-inspect)
+
+[![build status](https://secure.travis-ci.org/substack/object-inspect.png)](http://travis-ci.org/substack/object-inspect)
+
+# example
+
+## circular
+
+``` js
+var inspect = require('object-inspect');
+var obj = { a: 1, b: [3,4] };
+obj.c = obj;
+console.log(inspect(obj));
+```
+
+## dom element
+
+``` js
+var inspect = require('object-inspect');
+
+var d = document.createElement('div');
+d.setAttribute('id', 'beep');
+d.innerHTML = '<b>wooo</b><i>iiiii</i>';
+
+console.log(inspect([ d, { a: 3, b : 4, c: [5,6,[7,[8,[9]]]] } ]));
+```
+
+output:
+
+```
+[ <div id="beep">...</div>, { a: 3, b: 4, c: [ 5, 6, [ 7, [ 8, [ ... ] ] ] ] } ]
+```
+
+# methods
+
+``` js
+var inspect = require('object-inspect')
+```
+
+## var s = inspect(obj, opts={})
+
+Return a string `s` with the string representation of `obj` up to a depth of `opts.depth`.
+
+Additional options:
+  - `quoteStyle`: must be "single" or "double", if present
+
+# install
+
+With [npm](https://npmjs.org) do:
+
+```
+npm install object-inspect
+```
+
+# license
+
+MIT
--- a/tests/node_modules/tape-es/node_modules/object-inspect/test-core-js.js
+++ b/tests/node_modules/tape-es/node_modules/object-inspect/test-core-js.js
@@ -0,0 +1,16 @@
+'use strict';
+
+require('core-js');
+
+var inspect = require('./');
+var test = require('tape');
+
+test('Maps', function (t) {
+    t.equal(inspect(new Map([[1, 2]])), 'Map (1) {1 => 2}');
+    t.end();
+});
+
+test('Sets', function (t) {
+    t.equal(inspect(new Set([[1, 2]])), 'Set (1) {[ 1, 2 ]}');
+    t.end();
+});
--- a/tests/node_modules/tape-es/node_modules/object-inspect/test/bigint.js
+++ b/tests/node_modules/tape-es/node_modules/object-inspect/test/bigint.js
@@ -0,0 +1,31 @@
+var inspect = require('../');
+var test = require('tape');
+
+test('bigint', { skip: typeof BigInt === 'undefined' }, function (t) {
+    t.test('primitives', function (st) {
+        st.plan(3);
+
+        st.equal(inspect(BigInt(-256)), '-256n');
+        st.equal(inspect(BigInt(0)), '0n');
+        st.equal(inspect(BigInt(256)), '256n');
+    });
+
+    t.test('objects', function (st) {
+        st.plan(3);
+
+        st.equal(inspect(Object(BigInt(-256))), 'Object(-256n)');
+        st.equal(inspect(Object(BigInt(0))), 'Object(0n)');
+        st.equal(inspect(Object(BigInt(256))), 'Object(256n)');
+    });
+
+    t.test('syntactic primitives', function (st) {
+        st.plan(3);
+
+        /* eslint-disable no-new-func */
+        st.equal(inspect(Function('return -256n')()), '-256n');
+        st.equal(inspect(Function('return 0n')()), '0n');
+        st.equal(inspect(Function('return 256n')()), '256n');
+    });
+
+    t.end();
+});
--- a/tests/node_modules/tape-es/node_modules/object-inspect/test/browser/dom.js
+++ b/tests/node_modules/tape-es/node_modules/object-inspect/test/browser/dom.js
@@ -0,0 +1,15 @@
+var inspect = require('../../');
+var test = require('tape');
+
+test('dom element', function (t) {
+    t.plan(1);
+
+    var d = document.createElement('div');
+    d.setAttribute('id', 'beep');
+    d.innerHTML = '<b>wooo</b><i>iiiii</i>';
+
+    t.equal(
+        inspect([d, { a: 3, b: 4, c: [5, 6, [7, [8, [9]]]] }]),
+        '[ <div id="beep">...</div>, { a: 3, b: 4, c: [ 5, 6, [ 7, [ 8, [Object] ] ] ] } ]'
+    );
+});
--- a/tests/node_modules/tape-es/node_modules/object-inspect/test/circular.js
+++ b/tests/node_modules/tape-es/node_modules/object-inspect/test/circular.js
@@ -0,0 +1,9 @@
+var inspect = require('../');
+var test = require('tape');
+
+test('circular', function (t) {
+    t.plan(1);
+    var obj = { a: 1, b: [3, 4] };
+    obj.c = obj;
+    t.equal(inspect(obj), '{ a: 1, b: [ 3, 4 ], c: [Circular] }');
+});
--- a/tests/node_modules/tape-es/node_modules/object-inspect/test/deep.js
+++ b/tests/node_modules/tape-es/node_modules/object-inspect/test/deep.js
@@ -0,0 +1,9 @@
+var inspect = require('../');
+var test = require('tape');
+
+test('deep', function (t) {
+    t.plan(2);
+    var obj = [[[[[[500]]]]]];
+    t.equal(inspect(obj), '[ [ [ [ [ [Object] ] ] ] ] ]');
+    t.equal(inspect(obj, { depth: 2 }), '[ [ [Object] ] ]');
+});
--- a/tests/node_modules/tape-es/node_modules/object-inspect/test/element.js
+++ b/tests/node_modules/tape-es/node_modules/object-inspect/test/element.js
@@ -0,0 +1,53 @@
+var inspect = require('../');
+var test = require('tape');
+
+test('element', function (t) {
+    t.plan(3);
+    var elem = {
+        nodeName: 'div',
+        attributes: [{ name: 'class', value: 'row' }],
+        getAttribute: function (key) { return key; },
+        childNodes: []
+    };
+    var obj = [1, elem, 3];
+    t.deepEqual(inspect(obj), '[ 1, <div class="row"></div>, 3 ]');
+    t.deepEqual(inspect(obj, { quoteStyle: 'single' }), "[ 1, <div class='row'></div>, 3 ]");
+    t.deepEqual(inspect(obj, { quoteStyle: 'double' }), '[ 1, <div class="row"></div>, 3 ]');
+});
+
+test('element no attr', function (t) {
+    t.plan(1);
+    var elem = {
+        nodeName: 'div',
+        getAttribute: function (key) { return key; },
+        childNodes: []
+    };
+    var obj = [1, elem, 3];
+    t.deepEqual(inspect(obj), '[ 1, <div></div>, 3 ]');
+});
+
+test('element with contents', function (t) {
+    t.plan(1);
+    var elem = {
+        nodeName: 'div',
+        getAttribute: function (key) { return key; },
+        childNodes: [{ nodeName: 'b' }]
+    };
+    var obj = [1, elem, 3];
+    t.deepEqual(inspect(obj), '[ 1, <div>...</div>, 3 ]');
+});
+
+test('element instance', function (t) {
+    t.plan(1);
+    var h = global.HTMLElement;
+    global.HTMLElement = function (name, attr) {
+        this.nodeName = name;
+        this.attributes = attr;
+    };
+    global.HTMLElement.prototype.getAttribute = function () {};
+
+    var elem = new global.HTMLElement('div', []);
+    var obj = [1, elem, 3];
+    t.deepEqual(inspect(obj), '[ 1, <div></div>, 3 ]');
+    global.HTMLElement = h;
+});
--- a/tests/node_modules/tape-es/node_modules/object-inspect/test/err.js
+++ b/tests/node_modules/tape-es/node_modules/object-inspect/test/err.js
@@ -0,0 +1,31 @@
+var inspect = require('../');
+var test = require('tape');
+
+test('type error', function (t) {
+    t.plan(1);
+    var aerr = new TypeError();
+    aerr.foo = 555;
+    aerr.bar = [1, 2, 3];
+
+    var berr = new TypeError('tuv');
+    berr.baz = 555;
+
+    var cerr = new SyntaxError();
+    cerr.message = 'whoa';
+    cerr['a-b'] = 5;
+
+    var obj = [
+        new TypeError(),
+        new TypeError('xxx'),
+        aerr,
+        berr,
+        cerr
+    ];
+    t.equal(inspect(obj), '[ ' + [
+        '[TypeError]',
+        '[TypeError: xxx]',
+        '{ [TypeError] foo: 555, bar: [ 1, 2, 3 ] }',
+        '{ [TypeError: tuv] baz: 555 }',
+        '{ [SyntaxError: whoa] message: \'whoa\', \'a-b\': 5 }'
+    ].join(', ') + ' ]');
+});
--- a/tests/node_modules/tape-es/node_modules/object-inspect/test/fn.js
+++ b/tests/node_modules/tape-es/node_modules/object-inspect/test/fn.js
@@ -0,0 +1,28 @@
+var inspect = require('../');
+var test = require('tape');
+
+test('function', function (t) {
+    t.plan(1);
+    var obj = [1, 2, function f(n) { return n; }, 4];
+    t.equal(inspect(obj), '[ 1, 2, [Function: f], 4 ]');
+});
+
+test('function name', function (t) {
+    t.plan(1);
+    var f = (function () {
+        return function () {};
+    }());
+    f.toString = function () { return 'function xxx () {}'; };
+    var obj = [1, 2, f, 4];
+    t.equal(inspect(obj), '[ 1, 2, [Function: xxx], 4 ]');
+});
+
+test('anon function', function (t) {
+    var f = (function () {
+        return function () {};
+    }());
+    var obj = [1, 2, f, 4];
+    t.equal(inspect(obj), '[ 1, 2, [Function], 4 ]');
+
+    t.end();
+});
--- a/tests/node_modules/tape-es/node_modules/object-inspect/test/has.js
+++ b/tests/node_modules/tape-es/node_modules/object-inspect/test/has.js
@@ -0,0 +1,34 @@
+var inspect = require('../');
+var test = require('tape');
+
+function withoutProperty(object, property, fn) {
+    var original;
+    if (Object.getOwnPropertyDescriptor) {
+        original = Object.getOwnPropertyDescriptor(object, property);
+    } else {
+        original = object[property];
+    }
+    delete object[property];
+    try {
+        fn();
+    } finally {
+        if (Object.getOwnPropertyDescriptor) {
+            Object.defineProperty(object, property, original);
+        } else {
+            object[property] = original;
+        }
+    }
+}
+
+test('when Object#hasOwnProperty is deleted', function (t) {
+    t.plan(1);
+    var arr = [1, , 3]; // eslint-disable-line no-sparse-arrays
+
+    // eslint-disable-next-line no-extend-native
+    Array.prototype[1] = 2; // this is needed to account for "in" vs "hasOwnProperty"
+
+    withoutProperty(Object.prototype, 'hasOwnProperty', function () {
+        t.equal(inspect(arr), '[ 1, , 3 ]');
+    });
+    delete Array.prototype[1];
+});
--- a/tests/node_modules/tape-es/node_modules/object-inspect/test/holes.js
+++ b/tests/node_modules/tape-es/node_modules/object-inspect/test/holes.js
@@ -0,0 +1,15 @@
+var test = require('tape');
+var inspect = require('../');
+
+var xs = ['a', 'b'];
+xs[5] = 'f';
+xs[7] = 'j';
+xs[8] = 'k';
+
+test('holes', function (t) {
+    t.plan(1);
+    t.equal(
+        inspect(xs),
+        "[ 'a', 'b', , , , 'f', , 'j', 'k' ]"
+    );
+});
--- a/tests/node_modules/tape-es/node_modules/object-inspect/test/inspect.js
+++ b/tests/node_modules/tape-es/node_modules/object-inspect/test/inspect.js
@@ -0,0 +1,20 @@
+var test = require('tape');
+var hasSymbols = require('has-symbols')();
+var utilInspect = require('../util.inspect');
+
+var inspect = require('..');
+
+test('inspect', function (t) {
+    t.plan(1);
+    var obj = [{ inspect: function () { return '!XYZ¡'; } }, []];
+    t.equal(inspect(obj), '[ !XYZ¡, [] ]');
+});
+
+test('inspect custom symbol', { skip: !hasSymbols || !utilInspect }, function (t) {
+    t.plan(1);
+
+    var obj = { inspect: function () { return 'string'; } };
+    obj[utilInspect.custom] = function () { return 'symbol'; };
+
+    t.equal(inspect([obj, []]), '[ ' + (utilInspect.custom ? 'symbol' : 'string') + ', [] ]');
+});
--- a/tests/node_modules/tape-es/node_modules/object-inspect/test/lowbyte.js
+++ b/tests/node_modules/tape-es/node_modules/object-inspect/test/lowbyte.js
@@ -0,0 +1,12 @@
+var test = require('tape');
+var inspect = require('../');
+
+var obj = { x: 'a\r\nb', y: '\x05! \x1f \x12' };
+
+test('interpolate low bytes', function (t) {
+    t.plan(1);
+    t.equal(
+        inspect(obj),
+        "{ x: 'a\\r\\nb', y: '\\x05! \\x1f \\x12' }"
+    );
+});
--- a/tests/node_modules/tape-es/node_modules/object-inspect/test/number.js
+++ b/tests/node_modules/tape-es/node_modules/object-inspect/test/number.js
@@ -0,0 +1,12 @@
+var inspect = require('../');
+var test = require('tape');
+
+test('negative zero', function (t) {
+    t.equal(inspect(0), '0', 'inspect(0) === "0"');
+    t.equal(inspect(Object(0)), 'Object(0)', 'inspect(Object(0)) === "Object(0)"');
+
+    t.equal(inspect(-0), '-0', 'inspect(-0) === "-0"');
+    t.equal(inspect(Object(-0)), 'Object(-0)', 'inspect(Object(-0)) === "Object(-0)"');
+
+    t.end();
+});
--- a/tests/node_modules/tape-es/node_modules/object-inspect/test/quoteStyle.js
+++ b/tests/node_modules/tape-es/node_modules/object-inspect/test/quoteStyle.js
@@ -0,0 +1,17 @@
+'use strict';
+
+var inspect = require('../');
+var test = require('tape');
+
+test('quoteStyle option', function (t) {
+    t['throws'](function () { inspect(null, { quoteStyle: false }); }, 'false is not a valid value');
+    t['throws'](function () { inspect(null, { quoteStyle: true }); }, 'true is not a valid value');
+    t['throws'](function () { inspect(null, { quoteStyle: '' }); }, '"" is not a valid value');
+    t['throws'](function () { inspect(null, { quoteStyle: {} }); }, '{} is not a valid value');
+    t['throws'](function () { inspect(null, { quoteStyle: [] }); }, '[] is not a valid value');
+    t['throws'](function () { inspect(null, { quoteStyle: 42 }); }, '42 is not a valid value');
+    t['throws'](function () { inspect(null, { quoteStyle: NaN }); }, 'NaN is not a valid value');
+    t['throws'](function () { inspect(null, { quoteStyle: function () {} }); }, 'a function is not a valid value');
+
+    t.end();
+});
--- a/tests/node_modules/tape-es/node_modules/object-inspect/test/undef.js
+++ b/tests/node_modules/tape-es/node_modules/object-inspect/test/undef.js
@@ -0,0 +1,12 @@
+var test = require('tape');
+var inspect = require('../');
+
+var obj = { a: 1, b: [3, 4, undefined, null], c: undefined, d: null };
+
+test('undef and null', function (t) {
+    t.plan(1);
+    t.equal(
+        inspect(obj),
+        '{ a: 1, b: [ 3, 4, undefined, null ], c: undefined, d: null }'
+    );
+});
--- a/tests/node_modules/tape-es/node_modules/object-inspect/test/values.js
+++ b/tests/node_modules/tape-es/node_modules/object-inspect/test/values.js
@@ -0,0 +1,156 @@
+var inspect = require('../');
+var test = require('tape');
+
+test('values', function (t) {
+    t.plan(1);
+    var obj = [{}, [], { 'a-b': 5 }];
+    t.equal(inspect(obj), '[ {}, [], { \'a-b\': 5 } ]');
+});
+
+test('arrays with properties', function (t) {
+    t.plan(1);
+    var arr = [3];
+    arr.foo = 'bar';
+    var obj = [1, 2, arr];
+    obj.baz = 'quux';
+    obj.index = -1;
+    t.equal(inspect(obj), '[ 1, 2, [ 3, foo: \'bar\' ], baz: \'quux\', index: -1 ]');
+});
+
+test('has', function (t) {
+    t.plan(1);
+    var has = Object.prototype.hasOwnProperty;
+    delete Object.prototype.hasOwnProperty;
+    t.equal(inspect({ a: 1, b: 2 }), '{ a: 1, b: 2 }');
+    Object.prototype.hasOwnProperty = has; // eslint-disable-line no-extend-native
+});
+
+test('indexOf seen', function (t) {
+    t.plan(1);
+    var xs = [1, 2, 3, {}];
+    xs.push(xs);
+
+    var seen = [];
+    seen.indexOf = undefined;
+
+    t.equal(
+        inspect(xs, {}, 0, seen),
+        '[ 1, 2, 3, {}, [Circular] ]'
+    );
+});
+
+test('seen seen', function (t) {
+    t.plan(1);
+    var xs = [1, 2, 3];
+
+    var seen = [xs];
+    seen.indexOf = undefined;
+
+    t.equal(
+        inspect(xs, {}, 0, seen),
+        '[Circular]'
+    );
+});
+
+test('seen seen seen', function (t) {
+    t.plan(1);
+    var xs = [1, 2, 3];
+
+    var seen = [5, xs];
+    seen.indexOf = undefined;
+
+    t.equal(
+        inspect(xs, {}, 0, seen),
+        '[Circular]'
+    );
+});
+
+test('symbols', { skip: typeof Symbol !== 'function' }, function (t) {
+    var sym = Symbol('foo');
+    t.equal(inspect(sym), 'Symbol(foo)', 'Symbol("foo") should be "Symbol(foo)"');
+    t.equal(inspect(Object(sym)), 'Object(Symbol(foo))', 'Object(Symbol("foo")) should be "Object(Symbol(foo))"');
+    t.end();
+});
+
+test('Map', { skip: typeof Map !== 'function' }, function (t) {
+    var map = new Map();
+    map.set({ a: 1 }, ['b']);
+    map.set(3, NaN);
+    var expectedString = 'Map (2) {' + inspect({ a: 1 }) + ' => ' + inspect(['b']) + ', 3 => NaN}';
+    t.equal(inspect(map), expectedString, 'new Map([[{ a: 1 }, ["b"]], [3, NaN]]) should show size and contents');
+    t.equal(inspect(new Map()), 'Map (0) {}', 'empty Map should show as empty');
+
+    var nestedMap = new Map();
+    nestedMap.set(nestedMap, map);
+    t.equal(inspect(nestedMap), 'Map (1) {[Circular] => ' + expectedString + '}', 'Map containing a Map should work');
+
+    t.end();
+});
+
+test('WeakMap', { skip: typeof WeakMap !== 'function' }, function (t) {
+    var map = new WeakMap();
+    map.set({ a: 1 }, ['b']);
+    var expectedString = 'WeakMap { ? }';
+    t.equal(inspect(map), expectedString, 'new WeakMap([[{ a: 1 }, ["b"]]]) should not show size or contents');
+    t.equal(inspect(new WeakMap()), 'WeakMap { ? }', 'empty WeakMap should not show as empty');
+
+    t.end();
+});
+
+test('Set', { skip: typeof Set !== 'function' }, function (t) {
+    var set = new Set();
+    set.add({ a: 1 });
+    set.add(['b']);
+    var expectedString = 'Set (2) {' + inspect({ a: 1 }) + ', ' + inspect(['b']) + '}';
+    t.equal(inspect(set), expectedString, 'new Set([{ a: 1 }, ["b"]]) should show size and contents');
+    t.equal(inspect(new Set()), 'Set (0) {}', 'empty Set should show as empty');
+
+    var nestedSet = new Set();
+    nestedSet.add(set);
+    nestedSet.add(nestedSet);
+    t.equal(inspect(nestedSet), 'Set (2) {' + expectedString + ', [Circular]}', 'Set containing a Set should work');
+
+    t.end();
+});
+
+test('WeakSet', { skip: typeof WeakSet !== 'function' }, function (t) {
+    var map = new WeakSet();
+    map.add({ a: 1 });
+    var expectedString = 'WeakSet { ? }';
+    t.equal(inspect(map), expectedString, 'new WeakSet([{ a: 1 }]) should not show size or contents');
+    t.equal(inspect(new WeakSet()), 'WeakSet { ? }', 'empty WeakSet should not show as empty');
+
+    t.end();
+});
+
+test('Strings', function (t) {
+    var str = 'abc';
+
+    t.equal(inspect(str), "'" + str + "'", 'primitive string shows as such');
+    t.equal(inspect(str, { quoteStyle: 'single' }), "'" + str + "'", 'primitive string shows as such, single quoted');
+    t.equal(inspect(str, { quoteStyle: 'double' }), '"' + str + '"', 'primitive string shows as such, double quoted');
+    t.equal(inspect(Object(str)), 'Object(' + inspect(str) + ')', 'String object shows as such');
+    t.equal(inspect(Object(str), { quoteStyle: 'single' }), 'Object(' + inspect(str, { quoteStyle: 'single' }) + ')', 'String object shows as such, single quoted');
+    t.equal(inspect(Object(str), { quoteStyle: 'double' }), 'Object(' + inspect(str, { quoteStyle: 'double' }) + ')', 'String object shows as such, double quoted');
+
+    t.end();
+});
+
+test('Numbers', function (t) {
+    var num = 42;
+
+    t.equal(inspect(num), String(num), 'primitive number shows as such');
+    t.equal(inspect(Object(num)), 'Object(' + inspect(num) + ')', 'Number object shows as such');
+
+    t.end();
+});
+
+test('Booleans', function (t) {
+    t.equal(inspect(true), String(true), 'primitive true shows as such');
+    t.equal(inspect(Object(true)), 'Object(' + inspect(true) + ')', 'Boolean object true shows as such');
+
+    t.equal(inspect(false), String(false), 'primitive false shows as such');
+    t.equal(inspect(Object(false)), 'Object(' + inspect(false) + ')', 'Boolean false object shows as such');
+
+    t.end();
+});
--- a/tests/node_modules/tape-es/node_modules/object-inspect/util.inspect.js
+++ b/tests/node_modules/tape-es/node_modules/object-inspect/util.inspect.js
@@ -0,0 +1 @@
+module.exports = require('util').inspect;
--- a/tests/node_modules/tape-es/node_modules/resolve/.editorconfig
+++ b/tests/node_modules/tape-es/node_modules/resolve/.editorconfig
@@ -0,0 +1,20 @@
+root = true
+
+[*]
+indent_style = tab
+indent_size = 4
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+max_line_length = 150
+
+[CHANGELOG.md]
+indent_style = space
+indent_size = 2
+
+[*.json]
+max_line_length = off
+
+[Makefile]
+max_line_length = off
--- a/tests/node_modules/tape-es/node_modules/resolve/.eslintignore
+++ b/tests/node_modules/tape-es/node_modules/resolve/.eslintignore
@@ -0,0 +1 @@
+node_modules
--- a/tests/node_modules/tape-es/node_modules/resolve/.eslintrc
+++ b/tests/node_modules/tape-es/node_modules/resolve/.eslintrc
@@ -0,0 +1,39 @@
+{
+    "extends": "@ljharb",
+    "root": true,
+    "rules": {
+        "array-bracket-newline": 0,
+        "array-element-newline": 0,
+        "indent": [2, 4],
+        "strict": 0,
+        "complexity": 0,
+        "consistent-return": 0,
+        "curly": 0,
+        "dot-notation": [2, { "allowKeywords": true }],
+        "func-name-matching": 0,
+        "func-style": 0,
+        "global-require": 0,
+        "id-length": [2, { "min": 1, "max": 30 }],
+        "max-lines-per-function": 0,
+        "max-nested-callbacks": 0,
+        "max-params": 0,
+        "max-statements-per-line": [2, { "max": 2 }],
+        "max-statements": 0,
+        "no-magic-numbers": 0,
+        "no-console": 0,
+        "no-shadow": 0,
+        "no-unused-vars": [2, { "vars": "all", "args": "none" }],
+        "no-use-before-define": 0,
+        "object-curly-newline": 0,
+        "operator-linebreak": [2, "before"],
+        "sort-keys": 0,
+    },
+    "overrides": [
+        {
+            "files": "test/resolver/nested_symlinks/mylib/*.js",
+            "rules": {
+                "no-throw-literal": 0,
+            },
+        },
+    ],
+}
--- a/tests/node_modules/tape-es/node_modules/resolve/.travis.yml
+++ b/tests/node_modules/tape-es/node_modules/resolve/.travis.yml
@@ -0,0 +1,8 @@
+version: ~> 1.0
+language: node_js
+os:
+ - linux
+import:
+ - ljharb/travis-ci:node/all.yml
+ - ljharb/travis-ci:node/pretest.yml
+ - ljharb/travis-ci:node/posttest.yml
--- a/tests/node_modules/tape-es/node_modules/resolve/LICENSE
+++ b/tests/node_modules/tape-es/node_modules/resolve/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2012 James Halliday
+
+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.
--- a/tests/node_modules/tape-es/node_modules/resolve/appveyor.yml
+++ b/tests/node_modules/tape-es/node_modules/resolve/appveyor.yml
@@ -0,0 +1,54 @@
+version: 1.0.{build}
+skip_branch_with_pr: true
+build: off
+
+environment:
+  matrix:
+    - nodejs_version: "12"
+    - nodejs_version: "11"
+    - nodejs_version: "10"
+    - nodejs_version: "9"
+    - nodejs_version: "8"
+    - nodejs_version: "7"
+    - nodejs_version: "6"
+    - nodejs_version: "5"
+    - nodejs_version: "4"
+    - nodejs_version: "3"
+    - nodejs_version: "2"
+    - nodejs_version: "1"
+    - nodejs_version: "0.12"
+    - nodejs_version: "0.10"
+    - nodejs_version: "0.8"
+    - nodejs_version: "0.6"
+matrix:
+  # fast_finish: true
+  allow_failures:
+    - nodejs_version: "5" # due to windows npm bug, registry-side
+    - nodejs_version: "0.8"
+    - nodejs_version: "0.6"
+
+platform:
+  - x86
+  - x64
+
+# Install scripts. (runs after repo cloning)
+install:
+ # Fix symlinks in working copy (see https://github.com/appveyor/ci/issues/650#issuecomment-186592582) / https://github.com/charleskorn/batect/commit/d08986802ec43086902958c4ee7e57ff3e71dbef
+ - git config core.symlinks true
+ - git reset --hard
+ # Get the latest stable version of Node.js or io.js
+ - ps: Install-Product node $env:nodejs_version $env:platform
+ - IF %nodejs_version% EQU 0.6 npm config set strict-ssl false && npm -g install npm@1.3
+ - IF %nodejs_version% EQU 0.8 npm config set strict-ssl false && npm -g install npm@1.4.28 && npm install -g npm@4.5
+ - set PATH=%APPDATA%\npm;%PATH%
+ #- IF %nodejs_version% NEQ 0.6 AND %nodejs_version% NEQ 0.8 npm -g install npm
+ # install modules
+ - npm install
+
+# Post-install test scripts.
+test_script:
+ # Output useful info for debugging.
+ - node --version
+ - npm --version
+ # run tests
+ - npm run tests-only
--- a/tests/node_modules/tape-es/node_modules/resolve/example/async.js
+++ b/tests/node_modules/tape-es/node_modules/resolve/example/async.js
@@ -0,0 +1,5 @@
+var resolve = require('../');
+resolve('tap', { basedir: __dirname }, function (err, res) {
+    if (err) console.error(err);
+    else console.log(res);
+});
--- a/tests/node_modules/tape-es/node_modules/resolve/example/sync.js
+++ b/tests/node_modules/tape-es/node_modules/resolve/example/sync.js
@@ -0,0 +1,3 @@
+var resolve = require('../');
+var res = resolve.sync('tap', { basedir: __dirname });
+console.log(res);
--- a/tests/node_modules/tape-es/node_modules/resolve/index.js
+++ b/tests/node_modules/tape-es/node_modules/resolve/index.js
@@ -0,0 +1,6 @@
+var async = require('./lib/async');
+async.core = require('./lib/core');
+async.isCore = require('./lib/is-core');
+async.sync = require('./lib/sync');
+
+module.exports = async;
--- a/tests/node_modules/tape-es/node_modules/resolve/lib/async.js
+++ b/tests/node_modules/tape-es/node_modules/resolve/lib/async.js
@@ -0,0 +1,298 @@
+var fs = require('fs');
+var path = require('path');
+var caller = require('./caller.js');
+var nodeModulesPaths = require('./node-modules-paths.js');
+var normalizeOptions = require('./normalize-options.js');
+var isCore = require('./is-core');
+
+var realpathFS = fs.realpath && typeof fs.realpath.native === 'function' ? fs.realpath.native : fs.realpath;
+
+var defaultIsFile = function isFile(file, cb) {
+    fs.stat(file, function (err, stat) {
+        if (!err) {
+            return cb(null, stat.isFile() || stat.isFIFO());
+        }
+        if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return cb(null, false);
+        return cb(err);
+    });
+};
+
+var defaultIsDir = function isDirectory(dir, cb) {
+    fs.stat(dir, function (err, stat) {
+        if (!err) {
+            return cb(null, stat.isDirectory());
+        }
+        if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return cb(null, false);
+        return cb(err);
+    });
+};
+
+var defaultRealpath = function realpath(x, cb) {
+    realpathFS(x, function (realpathErr, realPath) {
+        if (realpathErr && realpathErr.code !== 'ENOENT') cb(realpathErr);
+        else cb(null, realpathErr ? x : realPath);
+    });
+};
+
+var maybeRealpath = function maybeRealpath(realpath, x, opts, cb) {
+    if (opts && opts.preserveSymlinks === false) {
+        realpath(x, cb);
+    } else {
+        cb(null, x);
+    }
+};
+
+var getPackageCandidates = function getPackageCandidates(x, start, opts) {
+    var dirs = nodeModulesPaths(start, opts, x);
+    for (var i = 0; i < dirs.length; i++) {
+        dirs[i] = path.join(dirs[i], x);
+    }
+    return dirs;
+};
+
+module.exports = function resolve(x, options, callback) {
+    var cb = callback;
+    var opts = options;
+    if (typeof options === 'function') {
+        cb = opts;
+        opts = {};
+    }
+    if (typeof x !== 'string') {
+        var err = new TypeError('Path must be a string.');
+        return process.nextTick(function () {
+            cb(err);
+        });
+    }
+
+    opts = normalizeOptions(x, opts);
+
+    var isFile = opts.isFile || defaultIsFile;
+    var isDirectory = opts.isDirectory || defaultIsDir;
+    var readFile = opts.readFile || fs.readFile;
+    var realpath = opts.realpath || defaultRealpath;
+    var packageIterator = opts.packageIterator;
+
+    var extensions = opts.extensions || ['.js'];
+    var basedir = opts.basedir || path.dirname(caller());
+    var parent = opts.filename || basedir;
+
+    opts.paths = opts.paths || [];
+
+    // ensure that `basedir` is an absolute path at this point, resolving against the process' current working directory
+    var absoluteStart = path.resolve(basedir);
+
+    maybeRealpath(
+        realpath,
+        absoluteStart,
+        opts,
+        function (err, realStart) {
+            if (err) cb(err);
+            else init(realStart);
+        }
+    );
+
+    var res;
+    function init(basedir) {
+        if ((/^(?:\.\.?(?:\/|$)|\/|([A-Za-z]:)?[/\\])/).test(x)) {
+            res = path.resolve(basedir, x);
+            if (x === '.' || x === '..' || x.slice(-1) === '/') res += '/';
+            if ((/\/$/).test(x) && res === basedir) {
+                loadAsDirectory(res, opts.package, onfile);
+            } else loadAsFile(res, opts.package, onfile);
+        } else if (isCore(x)) {
+            return cb(null, x);
+        } else loadNodeModules(x, basedir, function (err, n, pkg) {
+            if (err) cb(err);
+            else if (n) {
+                return maybeRealpath(realpath, n, opts, function (err, realN) {
+                    if (err) {
+                        cb(err);
+                    } else {
+                        cb(null, realN, pkg);
+                    }
+                });
+            } else {
+                var moduleError = new Error("Cannot find module '" + x + "' from '" + parent + "'");
+                moduleError.code = 'MODULE_NOT_FOUND';
+                cb(moduleError);
+            }
+        });
+    }
+
+    function onfile(err, m, pkg) {
+        if (err) cb(err);
+        else if (m) cb(null, m, pkg);
+        else loadAsDirectory(res, function (err, d, pkg) {
+            if (err) cb(err);
+            else if (d) {
+                maybeRealpath(realpath, d, opts, function (err, realD) {
+                    if (err) {
+                        cb(err);
+                    } else {
+                        cb(null, realD, pkg);
+                    }
+                });
+            } else {
+                var moduleError = new Error("Cannot find module '" + x + "' from '" + parent + "'");
+                moduleError.code = 'MODULE_NOT_FOUND';
+                cb(moduleError);
+            }
+        });
+    }
+
+    function loadAsFile(x, thePackage, callback) {
+        var loadAsFilePackage = thePackage;
+        var cb = callback;
+        if (typeof loadAsFilePackage === 'function') {
+            cb = loadAsFilePackage;
+            loadAsFilePackage = undefined;
+        }
+
+        var exts = [''].concat(extensions);
+        load(exts, x, loadAsFilePackage);
+
+        function load(exts, x, loadPackage) {
+            if (exts.length === 0) return cb(null, undefined, loadPackage);
+            var file = x + exts[0];
+
+            var pkg = loadPackage;
+            if (pkg) onpkg(null, pkg);
+            else loadpkg(path.dirname(file), onpkg);
+
+            function onpkg(err, pkg_, dir) {
+                pkg = pkg_;
+                if (err) return cb(err);
+                if (dir && pkg && opts.pathFilter) {
+                    var rfile = path.relative(dir, file);
+                    var rel = rfile.slice(0, rfile.length - exts[0].length);
+                    var r = opts.pathFilter(pkg, x, rel);
+                    if (r) return load(
+                        [''].concat(extensions.slice()),
+                        path.resolve(dir, r),
+                        pkg
+                    );
+                }
+                isFile(file, onex);
+            }
+            function onex(err, ex) {
+                if (err) return cb(err);
+                if (ex) return cb(null, file, pkg);
+                load(exts.slice(1), x, pkg);
+            }
+        }
+    }
+
+    function loadpkg(dir, cb) {
+        if (dir === '' || dir === '/') return cb(null);
+        if (process.platform === 'win32' && (/^\w:[/\\]*$/).test(dir)) {
+            return cb(null);
+        }
+        if ((/[/\\]node_modules[/\\]*$/).test(dir)) return cb(null);
+
+        maybeRealpath(realpath, dir, opts, function (unwrapErr, pkgdir) {
+            if (unwrapErr) return loadpkg(path.dirname(dir), cb);
+            var pkgfile = path.join(pkgdir, 'package.json');
+            isFile(pkgfile, function (err, ex) {
+                // on err, ex is false
+                if (!ex) return loadpkg(path.dirname(dir), cb);
+
+                readFile(pkgfile, function (err, body) {
+                    if (err) cb(err);
+                    try { var pkg = JSON.parse(body); } catch (jsonErr) {}
+
+                    if (pkg && opts.packageFilter) {
+                        pkg = opts.packageFilter(pkg, pkgfile);
+                    }
+                    cb(null, pkg, dir);
+                });
+            });
+        });
+    }
+
+    function loadAsDirectory(x, loadAsDirectoryPackage, callback) {
+        var cb = callback;
+        var fpkg = loadAsDirectoryPackage;
+        if (typeof fpkg === 'function') {
+            cb = fpkg;
+            fpkg = opts.package;
+        }
+
+        maybeRealpath(realpath, x, opts, function (unwrapErr, pkgdir) {
+            if (unwrapErr) return cb(unwrapErr);
+            var pkgfile = path.join(pkgdir, 'package.json');
+            isFile(pkgfile, function (err, ex) {
+                if (err) return cb(err);
+                if (!ex) return loadAsFile(path.join(x, 'index'), fpkg, cb);
+
+                readFile(pkgfile, function (err, body) {
+                    if (err) return cb(err);
+                    try {
+                        var pkg = JSON.parse(body);
+                    } catch (jsonErr) {}
+
+                    if (pkg && opts.packageFilter) {
+                        pkg = opts.packageFilter(pkg, pkgfile);
+                    }
+
+                    if (pkg && pkg.main) {
+                        if (typeof pkg.main !== 'string') {
+                            var mainError = new TypeError('package “' + pkg.name + '” `main` must be a string');
+                            mainError.code = 'INVALID_PACKAGE_MAIN';
+                            return cb(mainError);
+                        }
+                        if (pkg.main === '.' || pkg.main === './') {
+                            pkg.main = 'index';
+                        }
+                        loadAsFile(path.resolve(x, pkg.main), pkg, function (err, m, pkg) {
+                            if (err) return cb(err);
+                            if (m) return cb(null, m, pkg);
+                            if (!pkg) return loadAsFile(path.join(x, 'index'), pkg, cb);
+
+                            var dir = path.resolve(x, pkg.main);
+                            loadAsDirectory(dir, pkg, function (err, n, pkg) {
+                                if (err) return cb(err);
+                                if (n) return cb(null, n, pkg);
+                                loadAsFile(path.join(x, 'index'), pkg, cb);
+                            });
+                        });
+                        return;
+                    }
+
+                    loadAsFile(path.join(x, '/index'), pkg, cb);
+                });
+            });
+        });
+    }
+
+    function processDirs(cb, dirs) {
+        if (dirs.length === 0) return cb(null, undefined);
+        var dir = dirs[0];
+
+        isDirectory(path.dirname(dir), isdir);
+
+        function isdir(err, isdir) {
+            if (err) return cb(err);
+            if (!isdir) return processDirs(cb, dirs.slice(1));
+            loadAsFile(dir, opts.package, onfile);
+        }
+
+        function onfile(err, m, pkg) {
+            if (err) return cb(err);
+            if (m) return cb(null, m, pkg);
+            loadAsDirectory(dir, opts.package, ondir);
+        }
+
+        function ondir(err, n, pkg) {
+            if (err) return cb(err);
+            if (n) return cb(null, n, pkg);
+            processDirs(cb, dirs.slice(1));
+        }
+    }
+    function loadNodeModules(x, start, cb) {
+        var thunk = function () { return getPackageCandidates(x, start, opts); };
+        processDirs(
+            cb,
+            packageIterator ? packageIterator(x, start, thunk, opts) : thunk()
+        );
+    }
+};
--- a/tests/node_modules/tape-es/node_modules/resolve/lib/caller.js
+++ b/tests/node_modules/tape-es/node_modules/resolve/lib/caller.js
@@ -0,0 +1,8 @@
+module.exports = function () {
+    // see https://code.google.com/p/v8/wiki/JavaScriptStackTraceApi
+    var origPrepareStackTrace = Error.prepareStackTrace;
+    Error.prepareStackTrace = function (_, stack) { return stack; };
+    var stack = (new Error()).stack;
+    Error.prepareStackTrace = origPrepareStackTrace;
+    return stack[2].getFileName();
+};
--- a/tests/node_modules/tape-es/node_modules/resolve/lib/core.js
+++ b/tests/node_modules/tape-es/node_modules/resolve/lib/core.js
@@ -0,0 +1,53 @@
+var current = (process.versions && process.versions.node && process.versions.node.split('.')) || [];
+
+function specifierIncluded(specifier) {
+    var parts = specifier.split(' ');
+    var op = parts.length > 1 ? parts[0] : '=';
+    var versionParts = (parts.length > 1 ? parts[1] : parts[0]).split('.');
+
+    for (var i = 0; i < 3; ++i) {
+        var cur = Number(current[i] || 0);
+        var ver = Number(versionParts[i] || 0);
+        if (cur === ver) {
+            continue; // eslint-disable-line no-restricted-syntax, no-continue
+        }
+        if (op === '<') {
+            return cur < ver;
+        } else if (op === '>=') {
+            return cur >= ver;
+        } else {
+            return false;
+        }
+    }
+    return op === '>=';
+}
+
+function matchesRange(range) {
+    var specifiers = range.split(/ ?&& ?/);
+    if (specifiers.length === 0) { return false; }
+    for (var i = 0; i < specifiers.length; ++i) {
+        if (!specifierIncluded(specifiers[i])) { return false; }
+    }
+    return true;
+}
+
+function versionIncluded(specifierValue) {
+    if (typeof specifierValue === 'boolean') { return specifierValue; }
+    if (specifierValue && typeof specifierValue === 'object') {
+        for (var i = 0; i < specifierValue.length; ++i) {
+            if (matchesRange(specifierValue[i])) { return true; }
+        }
+        return false;
+    }
+    return matchesRange(specifierValue);
+}
+
+var data = require('./core.json');
+
+var core = {};
+for (var mod in data) { // eslint-disable-line no-restricted-syntax
+    if (Object.prototype.hasOwnProperty.call(data, mod)) {
+        core[mod] = versionIncluded(data[mod]);
+    }
+}
+module.exports = core;
--- a/tests/node_modules/tape-es/node_modules/resolve/lib/core.json
+++ b/tests/node_modules/tape-es/node_modules/resolve/lib/core.json
@@ -0,0 +1,75 @@
+{
+    "assert": true,
+    "async_hooks": ">= 8",
+    "buffer_ieee754": "< 0.9.7",
+    "buffer": true,
+    "child_process": true,
+    "cluster": true,
+    "console": true,
+    "constants": true,
+    "crypto": true,
+    "_debug_agent": ">= 1 && < 8",
+    "_debugger": "< 8",
+    "dgram": true,
+    "dns": true,
+    "domain": true,
+    "events": true,
+    "freelist": "< 6",
+    "fs": true,
+    "fs/promises": [">= 10 && < 10.1", ">= 14"],
+    "_http_agent": ">= 0.11.1",
+    "_http_client": ">= 0.11.1",
+    "_http_common": ">= 0.11.1",
+    "_http_incoming": ">= 0.11.1",
+    "_http_outgoing": ">= 0.11.1",
+    "_http_server": ">= 0.11.1",
+    "http": true,
+    "http2": ">= 8.8",
+    "https": true,
+    "inspector": ">= 8.0.0",
+    "_linklist": "< 8",
+    "module": true,
+    "net": true,
+    "node-inspect/lib/_inspect": ">= 7.6.0 && < 12",
+    "node-inspect/lib/internal/inspect_client": ">= 7.6.0 && < 12",
+    "node-inspect/lib/internal/inspect_repl": ">= 7.6.0 && < 12",
+    "os": true,
+    "path": true,
+    "perf_hooks": ">= 8.5",
+    "process": ">= 1",
+    "punycode": true,
+    "querystring": true,
+    "readline": true,
+    "repl": true,
+    "smalloc": ">= 0.11.5 && < 3",
+    "_stream_duplex": ">= 0.9.4",
+    "_stream_transform": ">= 0.9.4",
+    "_stream_wrap": ">= 1.4.1",
+    "_stream_passthrough": ">= 0.9.4",
+    "_stream_readable": ">= 0.9.4",
+    "_stream_writable": ">= 0.9.4",
+    "stream": true,
+    "string_decoder": true,
+    "sys": true,
+    "timers": true,
+    "_tls_common": ">= 0.11.13",
+    "_tls_legacy": ">= 0.11.3 && < 10",
+    "_tls_wrap": ">= 0.11.3",
+    "tls": true,
+    "trace_events": ">= 10",
+    "tty": true,
+    "url": true,
+    "util": true,
+    "v8/tools/arguments": ">= 10 && < 12",
+    "v8/tools/codemap": [">= 4.4.0 && < 5", ">= 5.2.0 && < 12"],
+    "v8/tools/consarray": [">= 4.4.0 && < 5", ">= 5.2.0 && < 12"],
+    "v8/tools/csvparser": [">= 4.4.0 && < 5", ">= 5.2.0 && < 12"],
+    "v8/tools/logreader": [">= 4.4.0 && < 5", ">= 5.2.0 && < 12"],
+    "v8/tools/profile_view": [">= 4.4.0 && < 5", ">= 5.2.0 && < 12"],
+    "v8/tools/splaytree": [">= 4.4.0 && < 5", ">= 5.2.0 && < 12"],
+    "v8": ">= 1",
+    "vm": true,
+    "wasi": ">= 13.4 && < 13.5",
+    "worker_threads": ">= 11.7",
+    "zlib": true
+}
--- a/tests/node_modules/tape-es/node_modules/resolve/lib/is-core.js
+++ b/tests/node_modules/tape-es/node_modules/resolve/lib/is-core.js
@@ -0,0 +1,5 @@
+var core = require('./core');
+
+module.exports = function isCore(x) {
+    return Object.prototype.hasOwnProperty.call(core, x);
+};
--- a/tests/node_modules/tape-es/node_modules/resolve/lib/node-modules-paths.js
+++ b/tests/node_modules/tape-es/node_modules/resolve/lib/node-modules-paths.js
@@ -0,0 +1,42 @@
+var path = require('path');
+var parse = path.parse || require('path-parse');
+
+var getNodeModulesDirs = function getNodeModulesDirs(absoluteStart, modules) {
+    var prefix = '/';
+    if ((/^([A-Za-z]:)/).test(absoluteStart)) {
+        prefix = '';
+    } else if ((/^\\\\/).test(absoluteStart)) {
+        prefix = '\\\\';
+    }
+
+    var paths = [absoluteStart];
+    var parsed = parse(absoluteStart);
+    while (parsed.dir !== paths[paths.length - 1]) {
+        paths.push(parsed.dir);
+        parsed = parse(parsed.dir);
+    }
+
+    return paths.reduce(function (dirs, aPath) {
+        return dirs.concat(modules.map(function (moduleDir) {
+            return path.resolve(prefix, aPath, moduleDir);
+        }));
+    }, []);
+};
+
+module.exports = function nodeModulesPaths(start, opts, request) {
+    var modules = opts && opts.moduleDirectory
+        ? [].concat(opts.moduleDirectory)
+        : ['node_modules'];
+
+    if (opts && typeof opts.paths === 'function') {
+        return opts.paths(
+            request,
+            start,
+            function () { return getNodeModulesDirs(start, modules); },
+            opts
+        );
+    }
+
+    var dirs = getNodeModulesDirs(start, modules);
+    return opts && opts.paths ? dirs.concat(opts.paths) : dirs;
+};
--- a/tests/node_modules/tape-es/node_modules/resolve/lib/normalize-options.js
+++ b/tests/node_modules/tape-es/node_modules/resolve/lib/normalize-options.js
@@ -0,0 +1,10 @@
+module.exports = function (x, opts) {
+    /**
+     * This file is purposefully a passthrough. It's expected that third-party
+     * environments will override it at runtime in order to inject special logic
+     * into `resolve` (by manipulating the options). One such example is the PnP
+     * code path in Yarn.
+     */
+
+    return opts || {};
+};
--- a/tests/node_modules/tape-es/node_modules/resolve/lib/sync.js
+++ b/tests/node_modules/tape-es/node_modules/resolve/lib/sync.js
@@ -0,0 +1,191 @@
+var isCore = require('./is-core');
+var fs = require('fs');
+var path = require('path');
+var caller = require('./caller.js');
+var nodeModulesPaths = require('./node-modules-paths.js');
+var normalizeOptions = require('./normalize-options.js');
+
+var realpathFS = fs.realpathSync && typeof fs.realpathSync.native === 'function' ? fs.realpathSync.native : fs.realpathSync;
+
+var defaultIsFile = function isFile(file) {
+    try {
+        var stat = fs.statSync(file);
+    } catch (e) {
+        if (e && (e.code === 'ENOENT' || e.code === 'ENOTDIR')) return false;
+        throw e;
+    }
+    return stat.isFile() || stat.isFIFO();
+};
+
+var defaultIsDir = function isDirectory(dir) {
+    try {
+        var stat = fs.statSync(dir);
+    } catch (e) {
+        if (e && (e.code === 'ENOENT' || e.code === 'ENOTDIR')) return false;
+        throw e;
+    }
+    return stat.isDirectory();
+};
+
+var defaultRealpathSync = function realpathSync(x) {
+    try {
+        return realpathFS(x);
+    } catch (realpathErr) {
+        if (realpathErr.code !== 'ENOENT') {
+            throw realpathErr;
+        }
+    }
+    return x;
+};
+
+var maybeRealpathSync = function maybeRealpathSync(realpathSync, x, opts) {
+    if (opts && opts.preserveSymlinks === false) {
+        return realpathSync(x);
+    }
+    return x;
+};
+
+var getPackageCandidates = function getPackageCandidates(x, start, opts) {
+    var dirs = nodeModulesPaths(start, opts, x);
+    for (var i = 0; i < dirs.length; i++) {
+        dirs[i] = path.join(dirs[i], x);
+    }
+    return dirs;
+};
+
+module.exports = function resolveSync(x, options) {
+    if (typeof x !== 'string') {
+        throw new TypeError('Path must be a string.');
+    }
+    var opts = normalizeOptions(x, options);
+
+    var isFile = opts.isFile || defaultIsFile;
+    var readFileSync = opts.readFileSync || fs.readFileSync;
+    var isDirectory = opts.isDirectory || defaultIsDir;
+    var realpathSync = opts.realpathSync || defaultRealpathSync;
+    var packageIterator = opts.packageIterator;
+
+    var extensions = opts.extensions || ['.js'];
+    var basedir = opts.basedir || path.dirname(caller());
+    var parent = opts.filename || basedir;
+
+    opts.paths = opts.paths || [];
+
+    // ensure that `basedir` is an absolute path at this point, resolving against the process' current working directory
+    var absoluteStart = maybeRealpathSync(realpathSync, path.resolve(basedir), opts);
+
+    if ((/^(?:\.\.?(?:\/|$)|\/|([A-Za-z]:)?[/\\])/).test(x)) {
+        var res = path.resolve(absoluteStart, x);
+        if (x === '.' || x === '..' || x.slice(-1) === '/') res += '/';
+        var m = loadAsFileSync(res) || loadAsDirectorySync(res);
+        if (m) return maybeRealpathSync(realpathSync, m, opts);
+    } else if (isCore(x)) {
+        return x;
+    } else {
+        var n = loadNodeModulesSync(x, absoluteStart);
+        if (n) return maybeRealpathSync(realpathSync, n, opts);
+    }
+
+    var err = new Error("Cannot find module '" + x + "' from '" + parent + "'");
+    err.code = 'MODULE_NOT_FOUND';
+    throw err;
+
+    function loadAsFileSync(x) {
+        var pkg = loadpkg(path.dirname(x));
+
+        if (pkg && pkg.dir && pkg.pkg && opts.pathFilter) {
+            var rfile = path.relative(pkg.dir, x);
+            var r = opts.pathFilter(pkg.pkg, x, rfile);
+            if (r) {
+                x = path.resolve(pkg.dir, r); // eslint-disable-line no-param-reassign
+            }
+        }
+
+        if (isFile(x)) {
+            return x;
+        }
+
+        for (var i = 0; i < extensions.length; i++) {
+            var file = x + extensions[i];
+            if (isFile(file)) {
+                return file;
+            }
+        }
+    }
+
+    function loadpkg(dir) {
+        if (dir === '' || dir === '/') return;
+        if (process.platform === 'win32' && (/^\w:[/\\]*$/).test(dir)) {
+            return;
+        }
+        if ((/[/\\]node_modules[/\\]*$/).test(dir)) return;
+
+        var pkgfile = path.join(maybeRealpathSync(realpathSync, dir, opts), 'package.json');
+
+        if (!isFile(pkgfile)) {
+            return loadpkg(path.dirname(dir));
+        }
+
+        var body = readFileSync(pkgfile);
+
+        try {
+            var pkg = JSON.parse(body);
+        } catch (jsonErr) {}
+
+        if (pkg && opts.packageFilter) {
+            // v2 will pass pkgfile
+            pkg = opts.packageFilter(pkg, /*pkgfile,*/ dir); // eslint-disable-line spaced-comment
+        }
+
+        return { pkg: pkg, dir: dir };
+    }
+
+    function loadAsDirectorySync(x) {
+        var pkgfile = path.join(maybeRealpathSync(realpathSync, x, opts), '/package.json');
+        if (isFile(pkgfile)) {
+            try {
+                var body = readFileSync(pkgfile, 'UTF8');
+                var pkg = JSON.parse(body);
+            } catch (e) {}
+
+            if (pkg && opts.packageFilter) {
+                // v2 will pass pkgfile
+                pkg = opts.packageFilter(pkg, /*pkgfile,*/ x); // eslint-disable-line spaced-comment
+            }
+
+            if (pkg && pkg.main) {
+                if (typeof pkg.main !== 'string') {
+                    var mainError = new TypeError('package “' + pkg.name + '” `main` must be a string');
+                    mainError.code = 'INVALID_PACKAGE_MAIN';
+                    throw mainError;
+                }
+                if (pkg.main === '.' || pkg.main === './') {
+                    pkg.main = 'index';
+                }
+                try {
+                    var m = loadAsFileSync(path.resolve(x, pkg.main));
+                    if (m) return m;
+                    var n = loadAsDirectorySync(path.resolve(x, pkg.main));
+                    if (n) return n;
+                } catch (e) {}
+            }
+        }
+
+        return loadAsFileSync(path.join(x, '/index'));
+    }
+
+    function loadNodeModulesSync(x, start) {
+        var thunk = function () { return getPackageCandidates(x, start, opts); };
+        var dirs = packageIterator ? packageIterator(x, start, thunk, opts) : thunk();
+
+        for (var i = 0; i < dirs.length; i++) {
+            var dir = dirs[i];
+            if (isDirectory(path.dirname(dir))) {
+                var m = loadAsFileSync(dir);
+                if (m) return m;
+                var n = loadAsDirectorySync(dir);
+                if (n) return n;
+            }
+        }
+    }
+};
--- a/tests/node_modules/tape-es/node_modules/resolve/package.json
+++ b/tests/node_modules/tape-es/node_modules/resolve/package.json
@@ -0,0 +1,76 @@
+{
+  "_from": "resolve@~1.17.0",
+  "_id": "resolve@1.17.0",
+  "_inBundle": false,
+  "_integrity": "sha512-ic+7JYiV8Vi2yzQGFWOkiZD5Z9z7O2Zhm9XMaTxdJExKasieFCr+yXZ/WmXsckHiKl12ar0y6XiXDx3m4RHn1w==",
+  "_location": "/tape-es/resolve",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "resolve@~1.17.0",
+    "name": "resolve",
+    "escapedName": "resolve",
+    "rawSpec": "~1.17.0",
+    "saveSpec": null,
+    "fetchSpec": "~1.17.0"
+  },
+  "_requiredBy": [
+    "/tape-es/tape"
+  ],
+  "_resolved": "https://registry.npmjs.org/resolve/-/resolve-1.17.0.tgz",
+  "_shasum": "b25941b54968231cc2d1bb76a79cb7f2c0bf8444",
+  "_spec": "resolve@~1.17.0",
+  "_where": "/home/lilleman/go/src/gitlab.larvit.se/power-plan/auth/tests/node_modules/tape-es/node_modules/tape",
+  "author": {
+    "name": "James Halliday",
+    "email": "mail@substack.net",
+    "url": "http://substack.net"
+  },
+  "bugs": {
+    "url": "https://github.com/browserify/resolve/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "path-parse": "^1.0.6"
+  },
+  "deprecated": false,
+  "description": "resolve like require.resolve() on behalf of files asynchronously and synchronously",
+  "devDependencies": {
+    "@ljharb/eslint-config": "^16.0.0",
+    "array.prototype.map": "^1.0.2",
+    "eslint": "^6.8.0",
+    "object-keys": "^1.1.1",
+    "safe-publish-latest": "^1.1.4",
+    "tap": "0.4.13",
+    "tape": "^5.0.0-next.5"
+  },
+  "funding": {
+    "url": "https://github.com/sponsors/ljharb"
+  },
+  "homepage": "https://github.com/browserify/resolve#readme",
+  "keywords": [
+    "resolve",
+    "require",
+    "node",
+    "module"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "name": "resolve",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/browserify/resolve.git"
+  },
+  "scripts": {
+    "lint": "eslint .",
+    "posttest": "npm run test:multirepo",
+    "prepublish": "safe-publish-latest",
+    "pretest": "npm run lint",
+    "pretests-only": "cd ./test/resolver/nested_symlinks && node mylib/sync && node mylib/async",
+    "test": "npm run --silent tests-only",
+    "test:multirepo": "cd ./test/resolver/multirepo && npm install && npm test",
+    "tests-only": "tape test/*.js"
+  },
+  "version": "1.17.0"
+}
--- a/tests/node_modules/tape-es/node_modules/resolve/readme.markdown
+++ b/tests/node_modules/tape-es/node_modules/resolve/readme.markdown
@@ -0,0 +1,242 @@
+# resolve
+
+implements the [node `require.resolve()`
+algorithm](https://nodejs.org/api/modules.html#modules_all_together)
+such that you can `require.resolve()` on behalf of a file asynchronously and
+synchronously
+
+[![build status](https://secure.travis-ci.org/browserify/resolve.png)](http://travis-ci.org/browserify/resolve)
+
+# example
+
+asynchronously resolve:
+
+```js
+var resolve = require('resolve');
+resolve('tap', { basedir: __dirname }, function (err, res) {
+    if (err) console.error(err);
+    else console.log(res);
+});
+```
+
+```
+$ node example/async.js
+/home/substack/projects/node-resolve/node_modules/tap/lib/main.js
+```
+
+synchronously resolve:
+
+```js
+var resolve = require('resolve');
+var res = resolve.sync('tap', { basedir: __dirname });
+console.log(res);
+```
+
+```
+$ node example/sync.js
+/home/substack/projects/node-resolve/node_modules/tap/lib/main.js
+```
+
+# methods
+
+```js
+var resolve = require('resolve');
+```
+
+## resolve(id, opts={}, cb)
+
+Asynchronously resolve the module path string `id` into `cb(err, res [, pkg])`, where `pkg` (if defined) is the data from `package.json`.
+
+options are:
+
+* opts.basedir - directory to begin resolving from
+
+* opts.package - `package.json` data applicable to the module being loaded
+
+* opts.extensions - array of file extensions to search in order
+
+* opts.readFile - how to read files asynchronously
+
+* opts.isFile - function to asynchronously test whether a file exists
+
+* opts.isDirectory - function to asynchronously test whether a directory exists
+
+* opts.realpath - function to asynchronously resolve a potential symlink to its real path
+
+* `opts.packageFilter(pkg, pkgfile, dir)` - transform the parsed package.json contents before looking at the "main" field
+  * pkg - package data
+  * pkgfile - path to package.json
+  * dir - directory for package.json
+
+* `opts.pathFilter(pkg, path, relativePath)` - transform a path within a package
+  * pkg - package data
+  * path - the path being resolved
+  * relativePath - the path relative from the package.json location
+  * returns - a relative path that will be joined from the package.json location
+
+* opts.paths - require.paths array to use if nothing is found on the normal `node_modules` recursive walk (probably don't use this)
+
+  For advanced users, `paths` can also be a `opts.paths(request, start, opts)` function
+    * request - the import specifier being resolved
+    * start - lookup path
+    * getNodeModulesDirs - a thunk (no-argument function) that returns the paths using standard `node_modules` resolution
+    * opts - the resolution options
+
+* `opts.packageIterator(request, start, opts)` - return the list of candidate paths where the packages sources may be found (probably don't use this)
+    * request - the import specifier being resolved
+    * start - lookup path
+    * getPackageCandidates - a thunk (no-argument function) that returns the paths using standard `node_modules` resolution
+    * opts - the resolution options
+
+* opts.moduleDirectory - directory (or directories) in which to recursively look for modules. default: `"node_modules"`
+
+* opts.preserveSymlinks - if true, doesn't resolve `basedir` to real path before resolving.
+This is the way Node resolves dependencies when executed with the [--preserve-symlinks](https://nodejs.org/api/all.html#cli_preserve_symlinks) flag.
+**Note:** this property is currently `true` by default but it will be changed to
+`false` in the next major version because *Node's resolution algorithm does not preserve symlinks by default*.
+
+default `opts` values:
+
+```js
+{
+    paths: [],
+    basedir: __dirname,
+    extensions: ['.js'],
+    readFile: fs.readFile,
+    isFile: function isFile(file, cb) {
+        fs.stat(file, function (err, stat) {
+            if (!err) {
+                return cb(null, stat.isFile() || stat.isFIFO());
+            }
+            if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return cb(null, false);
+            return cb(err);
+        });
+    },
+    isDirectory: function isDirectory(dir, cb) {
+        fs.stat(dir, function (err, stat) {
+            if (!err) {
+                return cb(null, stat.isDirectory());
+            }
+            if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return cb(null, false);
+            return cb(err);
+        });
+    },
+    realpath: function realpath(file, cb) {
+       var realpath = typeof fs.realpath.native === 'function' ? fs.realpath.native : fs.realpath;
+       realpath(file, function (realPathErr, realPath) {
+           if (realPathErr && realPathErr.code !== 'ENOENT') cb(realPathErr);
+           else cb(null, realPathErr ? file : realPath);
+       });
+   },
+    moduleDirectory: 'node_modules',
+    preserveSymlinks: true
+}
+```
+
+## resolve.sync(id, opts)
+
+Synchronously resolve the module path string `id`, returning the result and
+throwing an error when `id` can't be resolved.
+
+options are:
+
+* opts.basedir - directory to begin resolving from
+
+* opts.extensions - array of file extensions to search in order
+
+* opts.readFile - how to read files synchronously
+
+* opts.isFile - function to synchronously test whether a file exists
+
+* opts.isDirectory - function to synchronously test whether a directory exists
+
+* opts.realpathSync - function to synchronously resolve a potential symlink to its real path
+
+* `opts.packageFilter(pkg, dir)` - transform the parsed package.json contents before looking at the "main" field
+  * pkg - package data
+  * dir - directory for package.json (Note: the second argument will change to "pkgfile" in v2)
+
+* `opts.pathFilter(pkg, path, relativePath)` - transform a path within a package
+  * pkg - package data
+  * path - the path being resolved
+  * relativePath - the path relative from the package.json location
+  * returns - a relative path that will be joined from the package.json location
+
+* opts.paths - require.paths array to use if nothing is found on the normal `node_modules` recursive walk (probably don't use this)
+
+  For advanced users, `paths` can also be a `opts.paths(request, start, opts)` function
+    * request - the import specifier being resolved
+    * start - lookup path
+    * getNodeModulesDirs - a thunk (no-argument function) that returns the paths using standard `node_modules` resolution
+    * opts - the resolution options
+
+* `opts.packageIterator(request, start, opts)` - return the list of candidate paths where the packages sources may be found (probably don't use this)
+    * request - the import specifier being resolved
+    * start - lookup path
+    * getPackageCandidates - a thunk (no-argument function) that returns the paths using standard `node_modules` resolution
+    * opts - the resolution options
+
+* opts.moduleDirectory - directory (or directories) in which to recursively look for modules. default: `"node_modules"`
+
+* opts.preserveSymlinks - if true, doesn't resolve `basedir` to real path before resolving.
+This is the way Node resolves dependencies when executed with the [--preserve-symlinks](https://nodejs.org/api/all.html#cli_preserve_symlinks) flag.
+**Note:** this property is currently `true` by default but it will be changed to
+`false` in the next major version because *Node's resolution algorithm does not preserve symlinks by default*.
+
+default `opts` values:
+
+```js
+{
+    paths: [],
+    basedir: __dirname,
+    extensions: ['.js'],
+    readFileSync: fs.readFileSync,
+    isFile: function isFile(file) {
+        try {
+            var stat = fs.statSync(file);
+        } catch (e) {
+            if (e && (e.code === 'ENOENT' || e.code === 'ENOTDIR')) return false;
+            throw e;
+        }
+        return stat.isFile() || stat.isFIFO();
+    },
+    isDirectory: function isDirectory(dir) {
+        try {
+            var stat = fs.statSync(dir);
+        } catch (e) {
+            if (e && (e.code === 'ENOENT' || e.code === 'ENOTDIR')) return false;
+            throw e;
+        }
+        return stat.isDirectory();
+    },
+    realpathSync: function realpathSync(file) {
+        try {
+            var realpath = typeof fs.realpathSync.native === 'function' ? fs.realpathSync.native : fs.realpathSync;
+            return realpath(file);
+        } catch (realPathErr) {
+            if (realPathErr.code !== 'ENOENT') {
+                throw realPathErr;
+            }
+        }
+        return file;
+    },
+    moduleDirectory: 'node_modules',
+    preserveSymlinks: true
+}
+```
+
+## resolve.isCore(pkg)
+
+Return whether a package is in core.
+
+# install
+
+With [npm](https://npmjs.org) do:
+
+```sh
+npm install resolve
+```
+
+# license
+
+MIT
--- a/tests/node_modules/tape-es/node_modules/resolve/test/.eslintrc
+++ b/tests/node_modules/tape-es/node_modules/resolve/test/.eslintrc
@@ -0,0 +1,5 @@
+{
+    "rules": {
+        "max-lines": 0
+    }
+}
--- a/tests/node_modules/tape-es/node_modules/resolve/test/core.js
+++ b/tests/node_modules/tape-es/node_modules/resolve/test/core.js
@@ -0,0 +1,85 @@
+var test = require('tape');
+var keys = require('object-keys');
+var resolve = require('../');
+
+test('core modules', function (t) {
+    t.test('isCore()', function (st) {
+        st.ok(resolve.isCore('fs'));
+        st.ok(resolve.isCore('net'));
+        st.ok(resolve.isCore('http'));
+
+        st.ok(!resolve.isCore('seq'));
+        st.ok(!resolve.isCore('../'));
+
+        st.ok(!resolve.isCore('toString'));
+
+        st.end();
+    });
+
+    t.test('core list', function (st) {
+        var cores = keys(resolve.core);
+        st.plan(cores.length);
+
+        for (var i = 0; i < cores.length; ++i) {
+            var mod = cores[i];
+            if (resolve.core[mod]) {
+                st.doesNotThrow(
+                    function () { require(mod); }, // eslint-disable-line no-loop-func
+                    mod + ' supported; requiring does not throw'
+                );
+            } else {
+                st.throws(
+                    function () { require(mod); }, // eslint-disable-line no-loop-func
+                    mod + ' not supported; requiring throws'
+                );
+            }
+        }
+
+        st.end();
+    });
+
+    t.test('core via repl module', { skip: !resolve.core.repl }, function (st) {
+        var libs = require('repl')._builtinLibs; // eslint-disable-line no-underscore-dangle
+        if (!libs) {
+            st.skip('module.builtinModules does not exist');
+            return st.end();
+        }
+        for (var i = 0; i < libs.length; ++i) {
+            var mod = libs[i];
+            st.ok(resolve.core[mod], mod + ' is a core module');
+            st.doesNotThrow(
+                function () { require(mod); }, // eslint-disable-line no-loop-func
+                'requiring ' + mod + ' does not throw'
+            );
+        }
+        st.end();
+    });
+
+    t.test('core via builtinModules list', { skip: !resolve.core.module }, function (st) {
+        var libs = require('module').builtinModules;
+        if (!libs) {
+            st.skip('module.builtinModules does not exist');
+            return st.end();
+        }
+        var blacklist = [
+            '_debug_agent',
+            'v8/tools/tickprocessor-driver',
+            'v8/tools/SourceMap',
+            'v8/tools/tickprocessor',
+            'v8/tools/profile'
+        ];
+        for (var i = 0; i < libs.length; ++i) {
+            var mod = libs[i];
+            if (blacklist.indexOf(mod) === -1) {
+                st.ok(resolve.core[mod], mod + ' is a core module');
+                st.doesNotThrow(
+                    function () { require(mod); }, // eslint-disable-line no-loop-func
+                    'requiring ' + mod + ' does not throw'
+                );
+            }
+        }
+        st.end();
+    });
+
+    t.end();
+});
--- a/tests/node_modules/tape-es/node_modules/resolve/test/dotdot.js
+++ b/tests/node_modules/tape-es/node_modules/resolve/test/dotdot.js
@@ -0,0 +1,29 @@
+var path = require('path');
+var test = require('tape');
+var resolve = require('../');
+
+test('dotdot', function (t) {
+    t.plan(4);
+    var dir = path.join(__dirname, '/dotdot/abc');
+
+    resolve('..', { basedir: dir }, function (err, res, pkg) {
+        t.ifError(err);
+        t.equal(res, path.join(__dirname, 'dotdot/index.js'));
+    });
+
+    resolve('.', { basedir: dir }, function (err, res, pkg) {
+        t.ifError(err);
+        t.equal(res, path.join(dir, 'index.js'));
+    });
+});
+
+test('dotdot sync', function (t) {
+    t.plan(2);
+    var dir = path.join(__dirname, '/dotdot/abc');
+
+    var a = resolve.sync('..', { basedir: dir });
+    t.equal(a, path.join(__dirname, 'dotdot/index.js'));
+
+    var b = resolve.sync('.', { basedir: dir });
+    t.equal(b, path.join(dir, 'index.js'));
+});
--- a/tests/node_modules/tape-es/node_modules/resolve/test/dotdot/abc/index.js
+++ b/tests/node_modules/tape-es/node_modules/resolve/test/dotdot/abc/index.js
@@ -0,0 +1,2 @@
+var x = require('..');
+console.log(x);
--- a/tests/node_modules/tape-es/node_modules/resolve/test/dotdot/index.js
+++ b/tests/node_modules/tape-es/node_modules/resolve/test/dotdot/index.js
@@ -0,0 +1 @@
+module.exports = 'whatever';
--- a/tests/node_modules/tape-es/node_modules/resolve/test/faulty_basedir.js
+++ b/tests/node_modules/tape-es/node_modules/resolve/test/faulty_basedir.js
@@ -0,0 +1,29 @@
+var test = require('tape');
+var path = require('path');
+var resolve = require('../');
+
+test('faulty basedir must produce error in windows', { skip: process.platform !== 'win32' }, function (t) {
+    t.plan(1);
+
+    var resolverDir = 'C:\\a\\b\\c\\d';
+
+    resolve('tape/lib/test.js', { basedir: resolverDir }, function (err, res, pkg) {
+        t.equal(!!err, true);
+    });
+});
+
+test('non-existent basedir should not throw when preserveSymlinks is false', function (t) {
+    t.plan(2);
+
+    var opts = {
+        basedir: path.join(path.sep, 'unreal', 'path', 'that', 'does', 'not', 'exist'),
+        preserveSymlinks: false
+    };
+
+    var module = './dotdot/abc';
+
+    resolve(module, opts, function (err, res) {
+        t.equal(err.code, 'MODULE_NOT_FOUND');
+        t.equal(res, undefined);
+    });
+});
--- a/tests/node_modules/tape-es/node_modules/resolve/test/filter.js
+++ b/tests/node_modules/tape-es/node_modules/resolve/test/filter.js
@@ -0,0 +1,34 @@
+var path = require('path');
+var test = require('tape');
+var resolve = require('../');
+
+test('filter', function (t) {
+    t.plan(4);
+    var dir = path.join(__dirname, 'resolver');
+    var packageFilterArgs;
+    resolve('./baz', {
+        basedir: dir,
+        packageFilter: function (pkg, pkgfile) {
+            pkg.main = 'doom'; // eslint-disable-line no-param-reassign
+            packageFilterArgs = [pkg, pkgfile];
+            return pkg;
+        }
+    }, function (err, res, pkg) {
+        if (err) t.fail(err);
+
+        t.equal(res, path.join(dir, 'baz/doom.js'), 'changing the package "main" works');
+
+        var packageData = packageFilterArgs[0];
+        t.equal(pkg, packageData, 'first packageFilter argument is "pkg"');
+        t.equal(packageData.main, 'doom', 'package "main" was altered');
+
+        var packageFile = packageFilterArgs[1];
+        t.equal(
+            packageFile,
+            path.join(dir, 'baz/package.json'),
+            'second packageFilter argument is "pkgfile"'
+        );
+
+        t.end();
+    });
+});
--- a/tests/node_modules/tape-es/node_modules/resolve/test/filter_sync.js
+++ b/tests/node_modules/tape-es/node_modules/resolve/test/filter_sync.js
@@ -0,0 +1,33 @@
+var path = require('path');
+var test = require('tape');
+var resolve = require('../');
+
+test('filter', function (t) {
+    var dir = path.join(__dirname, 'resolver');
+    var packageFilterArgs;
+    var res = resolve.sync('./baz', {
+        basedir: dir,
+        // NOTE: in v2.x, this will be `pkg, pkgfile, dir`, but must remain "broken" here in v1.x for compatibility
+        packageFilter: function (pkg, /*pkgfile,*/ dir) { // eslint-disable-line spaced-comment
+            pkg.main = 'doom'; // eslint-disable-line no-param-reassign
+            packageFilterArgs = 'is 1.x' ? [pkg, dir] : [pkg, pkgfile, dir]; // eslint-disable-line no-constant-condition, no-undef
+            return pkg;
+        }
+    });
+
+    t.equal(res, path.join(dir, 'baz/doom.js'), 'changing the package "main" works');
+
+    var packageData = packageFilterArgs[0];
+    t.equal(packageData.main, 'doom', 'package "main" was altered');
+
+    if (!'is 1.x') { // eslint-disable-line no-constant-condition
+        var packageFile = packageFilterArgs[1];
+        t.equal(packageFile, path.join(dir, 'baz', 'package.json'), 'package.json path is correct');
+    }
+
+    var packageDir = packageFilterArgs['is 1.x' ? 1 : 2]; // eslint-disable-line no-constant-condition
+    // eslint-disable-next-line no-constant-condition
+    t.equal(packageDir, path.join(dir, 'baz'), ('is 1.x' ? 'second' : 'third') + ' packageFilter argument is "dir"');
+
+    t.end();
+});
--- a/tests/node_modules/tape-es/node_modules/resolve/test/mock.js
+++ b/tests/node_modules/tape-es/node_modules/resolve/test/mock.js
@@ -0,0 +1,239 @@
+var path = require('path');
+var test = require('tape');
+var resolve = require('../');
+
+test('mock', function (t) {
+    t.plan(8);
+
+    var files = {};
+    files[path.resolve('/foo/bar/baz.js')] = 'beep';
+
+    var dirs = {};
+    dirs[path.resolve('/foo/bar')] = true;
+
+    function opts(basedir) {
+        return {
+            basedir: path.resolve(basedir),
+            isFile: function (file, cb) {
+                cb(null, Object.prototype.hasOwnProperty.call(files, path.resolve(file)));
+            },
+            isDirectory: function (dir, cb) {
+                cb(null, !!dirs[path.resolve(dir)]);
+            },
+            readFile: function (file, cb) {
+                cb(null, files[path.resolve(file)]);
+            },
+            realpath: function (file, cb) {
+                cb(null, file);
+            }
+        };
+    }
+
+    resolve('./baz', opts('/foo/bar'), function (err, res, pkg) {
+        if (err) return t.fail(err);
+        t.equal(res, path.resolve('/foo/bar/baz.js'));
+        t.equal(pkg, undefined);
+    });
+
+    resolve('./baz.js', opts('/foo/bar'), function (err, res, pkg) {
+        if (err) return t.fail(err);
+        t.equal(res, path.resolve('/foo/bar/baz.js'));
+        t.equal(pkg, undefined);
+    });
+
+    resolve('baz', opts('/foo/bar'), function (err, res) {
+        t.equal(err.message, "Cannot find module 'baz' from '" + path.resolve('/foo/bar') + "'");
+        t.equal(err.code, 'MODULE_NOT_FOUND');
+    });
+
+    resolve('../baz', opts('/foo/bar'), function (err, res) {
+        t.equal(err.message, "Cannot find module '../baz' from '" + path.resolve('/foo/bar') + "'");
+        t.equal(err.code, 'MODULE_NOT_FOUND');
+    });
+});
+
+test('mock from package', function (t) {
+    t.plan(8);
+
+    var files = {};
+    files[path.resolve('/foo/bar/baz.js')] = 'beep';
+
+    var dirs = {};
+    dirs[path.resolve('/foo/bar')] = true;
+
+    function opts(basedir) {
+        return {
+            basedir: path.resolve(basedir),
+            isFile: function (file, cb) {
+                cb(null, Object.prototype.hasOwnProperty.call(files, file));
+            },
+            isDirectory: function (dir, cb) {
+                cb(null, !!dirs[path.resolve(dir)]);
+            },
+            'package': { main: 'bar' },
+            readFile: function (file, cb) {
+                cb(null, files[file]);
+            },
+            realpath: function (file, cb) {
+                cb(null, file);
+            }
+        };
+    }
+
+    resolve('./baz', opts('/foo/bar'), function (err, res, pkg) {
+        if (err) return t.fail(err);
+        t.equal(res, path.resolve('/foo/bar/baz.js'));
+        t.equal(pkg && pkg.main, 'bar');
+    });
+
+    resolve('./baz.js', opts('/foo/bar'), function (err, res, pkg) {
+        if (err) return t.fail(err);
+        t.equal(res, path.resolve('/foo/bar/baz.js'));
+        t.equal(pkg && pkg.main, 'bar');
+    });
+
+    resolve('baz', opts('/foo/bar'), function (err, res) {
+        t.equal(err.message, "Cannot find module 'baz' from '" + path.resolve('/foo/bar') + "'");
+        t.equal(err.code, 'MODULE_NOT_FOUND');
+    });
+
+    resolve('../baz', opts('/foo/bar'), function (err, res) {
+        t.equal(err.message, "Cannot find module '../baz' from '" + path.resolve('/foo/bar') + "'");
+        t.equal(err.code, 'MODULE_NOT_FOUND');
+    });
+});
+
+test('mock package', function (t) {
+    t.plan(2);
+
+    var files = {};
+    files[path.resolve('/foo/node_modules/bar/baz.js')] = 'beep';
+    files[path.resolve('/foo/node_modules/bar/package.json')] = JSON.stringify({
+        main: './baz.js'
+    });
+
+    var dirs = {};
+    dirs[path.resolve('/foo')] = true;
+    dirs[path.resolve('/foo/node_modules')] = true;
+
+    function opts(basedir) {
+        return {
+            basedir: path.resolve(basedir),
+            isFile: function (file, cb) {
+                cb(null, Object.prototype.hasOwnProperty.call(files, path.resolve(file)));
+            },
+            isDirectory: function (dir, cb) {
+                cb(null, !!dirs[path.resolve(dir)]);
+            },
+            readFile: function (file, cb) {
+                cb(null, files[path.resolve(file)]);
+            },
+            realpath: function (file, cb) {
+                cb(null, file);
+            }
+        };
+    }
+
+    resolve('bar', opts('/foo'), function (err, res, pkg) {
+        if (err) return t.fail(err);
+        t.equal(res, path.resolve('/foo/node_modules/bar/baz.js'));
+        t.equal(pkg && pkg.main, './baz.js');
+    });
+});
+
+test('mock package from package', function (t) {
+    t.plan(2);
+
+    var files = {};
+    files[path.resolve('/foo/node_modules/bar/baz.js')] = 'beep';
+    files[path.resolve('/foo/node_modules/bar/package.json')] = JSON.stringify({
+        main: './baz.js'
+    });
+
+    var dirs = {};
+    dirs[path.resolve('/foo')] = true;
+    dirs[path.resolve('/foo/node_modules')] = true;
+
+    function opts(basedir) {
+        return {
+            basedir: path.resolve(basedir),
+            isFile: function (file, cb) {
+                cb(null, Object.prototype.hasOwnProperty.call(files, path.resolve(file)));
+            },
+            isDirectory: function (dir, cb) {
+                cb(null, !!dirs[path.resolve(dir)]);
+            },
+            'package': { main: 'bar' },
+            readFile: function (file, cb) {
+                cb(null, files[path.resolve(file)]);
+            },
+            realpath: function (file, cb) {
+                cb(null, file);
+            }
+        };
+    }
+
+    resolve('bar', opts('/foo'), function (err, res, pkg) {
+        if (err) return t.fail(err);
+        t.equal(res, path.resolve('/foo/node_modules/bar/baz.js'));
+        t.equal(pkg && pkg.main, './baz.js');
+    });
+});
+
+test('symlinked', function (t) {
+    t.plan(4);
+
+    var files = {};
+    files[path.resolve('/foo/bar/baz.js')] = 'beep';
+    files[path.resolve('/foo/bar/symlinked/baz.js')] = 'beep';
+
+    var dirs = {};
+    dirs[path.resolve('/foo/bar')] = true;
+    dirs[path.resolve('/foo/bar/symlinked')] = true;
+
+    function opts(basedir) {
+        return {
+            preserveSymlinks: false,
+            basedir: path.resolve(basedir),
+            isFile: function (file, cb) {
+                cb(null, Object.prototype.hasOwnProperty.call(files, path.resolve(file)));
+            },
+            isDirectory: function (dir, cb) {
+                cb(null, !!dirs[path.resolve(dir)]);
+            },
+            readFile: function (file, cb) {
+                cb(null, files[path.resolve(file)]);
+            },
+            realpath: function (file, cb) {
+                var resolved = path.resolve(file);
+
+                if (resolved.indexOf('symlinked') >= 0) {
+                    cb(null, resolved);
+                    return;
+                }
+
+                var ext = path.extname(resolved);
+
+                if (ext) {
+                    var dir = path.dirname(resolved);
+                    var base = path.basename(resolved);
+                    cb(null, path.join(dir, 'symlinked', base));
+                } else {
+                    cb(null, path.join(resolved, 'symlinked'));
+                }
+            }
+        };
+    }
+
+    resolve('./baz', opts('/foo/bar'), function (err, res, pkg) {
+        if (err) return t.fail(err);
+        t.equal(res, path.resolve('/foo/bar/symlinked/baz.js'));
+        t.equal(pkg, undefined);
+    });
+
+    resolve('./baz.js', opts('/foo/bar'), function (err, res, pkg) {
+        if (err) return t.fail(err);
+        t.equal(res, path.resolve('/foo/bar/symlinked/baz.js'));
+        t.equal(pkg, undefined);
+    });
+});
--- a/tests/node_modules/tape-es/node_modules/resolve/test/mock_sync.js
+++ b/tests/node_modules/tape-es/node_modules/resolve/test/mock_sync.js
@@ -0,0 +1,141 @@
+var path = require('path');
+var test = require('tape');
+var resolve = require('../');
+
+test('mock', function (t) {
+    t.plan(4);
+
+    var files = {};
+    files[path.resolve('/foo/bar/baz.js')] = 'beep';
+
+    var dirs = {};
+    dirs[path.resolve('/foo/bar')] = true;
+
+    function opts(basedir) {
+        return {
+            basedir: path.resolve(basedir),
+            isFile: function (file) {
+                return Object.prototype.hasOwnProperty.call(files, path.resolve(file));
+            },
+            isDirectory: function (dir) {
+                return !!dirs[path.resolve(dir)];
+            },
+            readFileSync: function (file) {
+                return files[path.resolve(file)];
+            },
+            realpathSync: function (file) {
+                return file;
+            }
+        };
+    }
+
+    t.equal(
+        resolve.sync('./baz', opts('/foo/bar')),
+        path.resolve('/foo/bar/baz.js')
+    );
+
+    t.equal(
+        resolve.sync('./baz.js', opts('/foo/bar')),
+        path.resolve('/foo/bar/baz.js')
+    );
+
+    t.throws(function () {
+        resolve.sync('baz', opts('/foo/bar'));
+    });
+
+    t.throws(function () {
+        resolve.sync('../baz', opts('/foo/bar'));
+    });
+});
+
+test('mock package', function (t) {
+    t.plan(1);
+
+    var files = {};
+    files[path.resolve('/foo/node_modules/bar/baz.js')] = 'beep';
+    files[path.resolve('/foo/node_modules/bar/package.json')] = JSON.stringify({
+        main: './baz.js'
+    });
+
+    var dirs = {};
+    dirs[path.resolve('/foo')] = true;
+    dirs[path.resolve('/foo/node_modules')] = true;
+
+    function opts(basedir) {
+        return {
+            basedir: path.resolve(basedir),
+            isFile: function (file) {
+                return Object.prototype.hasOwnProperty.call(files, path.resolve(file));
+            },
+            isDirectory: function (dir) {
+                return !!dirs[path.resolve(dir)];
+            },
+            readFileSync: function (file) {
+                return files[path.resolve(file)];
+            },
+            realpathSync: function (file) {
+                return file;
+            }
+        };
+    }
+
+    t.equal(
+        resolve.sync('bar', opts('/foo')),
+        path.resolve('/foo/node_modules/bar/baz.js')
+    );
+});
+
+test('symlinked', function (t) {
+    t.plan(2);
+
+    var files = {};
+    files[path.resolve('/foo/bar/baz.js')] = 'beep';
+    files[path.resolve('/foo/bar/symlinked/baz.js')] = 'beep';
+
+    var dirs = {};
+    dirs[path.resolve('/foo/bar')] = true;
+    dirs[path.resolve('/foo/bar/symlinked')] = true;
+
+    function opts(basedir) {
+        return {
+            preserveSymlinks: false,
+            basedir: path.resolve(basedir),
+            isFile: function (file) {
+                return Object.prototype.hasOwnProperty.call(files, path.resolve(file));
+            },
+            isDirectory: function (dir) {
+                return !!dirs[path.resolve(dir)];
+            },
+            readFileSync: function (file) {
+                return files[path.resolve(file)];
+            },
+            realpathSync: function (file) {
+                var resolved = path.resolve(file);
+
+                if (resolved.indexOf('symlinked') >= 0) {
+                    return resolved;
+                }
+
+                var ext = path.extname(resolved);
+
+                if (ext) {
+                    var dir = path.dirname(resolved);
+                    var base = path.basename(resolved);
+                    return path.join(dir, 'symlinked', base);
+                } else {
+                    return path.join(resolved, 'symlinked');
+                }
+            }
+        };
+    }
+
+    t.equal(
+        resolve.sync('./baz', opts('/foo/bar')),
+        path.resolve('/foo/bar/symlinked/baz.js')
+    );
+
+    t.equal(
+        resolve.sync('./baz.js', opts('/foo/bar')),
+        path.resolve('/foo/bar/symlinked/baz.js')
+    );
+});
--- a/tests/node_modules/tape-es/node_modules/resolve/test/module_dir.js
+++ b/tests/node_modules/tape-es/node_modules/resolve/test/module_dir.js
@@ -0,0 +1,56 @@
+var path = require('path');
+var test = require('tape');
+var resolve = require('../');
+
+test('moduleDirectory strings', function (t) {
+    t.plan(4);
+    var dir = path.join(__dirname, 'module_dir');
+    var xopts = {
+        basedir: dir,
+        moduleDirectory: 'xmodules'
+    };
+    resolve('aaa', xopts, function (err, res, pkg) {
+        t.ifError(err);
+        t.equal(res, path.join(dir, '/xmodules/aaa/index.js'));
+    });
+
+    var yopts = {
+        basedir: dir,
+        moduleDirectory: 'ymodules'
+    };
+    resolve('aaa', yopts, function (err, res, pkg) {
+        t.ifError(err);
+        t.equal(res, path.join(dir, '/ymodules/aaa/index.js'));
+    });
+});
+
+test('moduleDirectory array', function (t) {
+    t.plan(6);
+    var dir = path.join(__dirname, 'module_dir');
+    var aopts = {
+        basedir: dir,
+        moduleDirectory: ['xmodules', 'ymodules', 'zmodules']
+    };
+    resolve('aaa', aopts, function (err, res, pkg) {
+        t.ifError(err);
+        t.equal(res, path.join(dir, '/xmodules/aaa/index.js'));
+    });
+
+    var bopts = {
+        basedir: dir,
+        moduleDirectory: ['zmodules', 'ymodules', 'xmodules']
+    };
+    resolve('aaa', bopts, function (err, res, pkg) {
+        t.ifError(err);
+        t.equal(res, path.join(dir, '/ymodules/aaa/index.js'));
+    });
+
+    var copts = {
+        basedir: dir,
+        moduleDirectory: ['xmodules', 'ymodules', 'zmodules']
+    };
+    resolve('bbb', copts, function (err, res, pkg) {
+        t.ifError(err);
+        t.equal(res, path.join(dir, '/zmodules/bbb/main.js'));
+    });
+});
--- a/tests/node_modules/tape-es/node_modules/resolve/test/module_dir/xmodules/aaa/index.js
+++ b/tests/node_modules/tape-es/node_modules/resolve/test/module_dir/xmodules/aaa/index.js
@@ -0,0 +1 @@
+module.exports = function (x) { return x * 100; };
--- a/tests/node_modules/tape-es/node_modules/resolve/test/module_dir/ymodules/aaa/index.js
+++ b/tests/node_modules/tape-es/node_modules/resolve/test/module_dir/ymodules/aaa/index.js
@@ -0,0 +1 @@
+module.exports = function (x) { return x + 100; };
--- a/tests/node_modules/tape-es/node_modules/resolve/test/module_dir/zmodules/bbb/main.js
+++ b/tests/node_modules/tape-es/node_modules/resolve/test/module_dir/zmodules/bbb/main.js
@@ -0,0 +1 @@
+module.exports = function (n) { return n * 111; };
--- a/tests/node_modules/tape-es/node_modules/resolve/test/module_dir/zmodules/bbb/package.json
+++ b/tests/node_modules/tape-es/node_modules/resolve/test/module_dir/zmodules/bbb/package.json
@@ -0,0 +1,3 @@
+{
+  "main": "main.js"
+}
--- a/tests/node_modules/tape-es/node_modules/resolve/test/node-modules-paths.js
+++ b/tests/node_modules/tape-es/node_modules/resolve/test/node-modules-paths.js
@@ -0,0 +1,143 @@
+var test = require('tape');
+var path = require('path');
+var parse = path.parse || require('path-parse');
+var keys = require('object-keys');
+
+var nodeModulesPaths = require('../lib/node-modules-paths');
+
+var verifyDirs = function verifyDirs(t, start, dirs, moduleDirectories, paths) {
+    var moduleDirs = [].concat(moduleDirectories || 'node_modules');
+    if (paths) {
+        for (var k = 0; k < paths.length; ++k) {
+            moduleDirs.push(path.basename(paths[k]));
+        }
+    }
+
+    var foundModuleDirs = {};
+    var uniqueDirs = {};
+    var parsedDirs = {};
+    for (var i = 0; i < dirs.length; ++i) {
+        var parsed = parse(dirs[i]);
+        if (!foundModuleDirs[parsed.base]) { foundModuleDirs[parsed.base] = 0; }
+        foundModuleDirs[parsed.base] += 1;
+        parsedDirs[parsed.dir] = true;
+        uniqueDirs[dirs[i]] = true;
+    }
+    t.equal(keys(parsedDirs).length >= start.split(path.sep).length, true, 'there are >= dirs than "start" has');
+    var foundModuleDirNames = keys(foundModuleDirs);
+    t.deepEqual(foundModuleDirNames, moduleDirs, 'all desired module dirs were found');
+    t.equal(keys(uniqueDirs).length, dirs.length, 'all dirs provided were unique');
+
+    var counts = {};
+    for (var j = 0; j < foundModuleDirNames.length; ++j) {
+        counts[foundModuleDirs[j]] = true;
+    }
+    t.equal(keys(counts).length, 1, 'all found module directories had the same count');
+};
+
+test('node-modules-paths', function (t) {
+    t.test('no options', function (t) {
+        var start = path.join(__dirname, 'resolver');
+        var dirs = nodeModulesPaths(start);
+
+        verifyDirs(t, start, dirs);
+
+        t.end();
+    });
+
+    t.test('empty options', function (t) {
+        var start = path.join(__dirname, 'resolver');
+        var dirs = nodeModulesPaths(start, {});
+
+        verifyDirs(t, start, dirs);
+
+        t.end();
+    });
+
+    t.test('with paths=array option', function (t) {
+        var start = path.join(__dirname, 'resolver');
+        var paths = ['a', 'b'];
+        var dirs = nodeModulesPaths(start, { paths: paths });
+
+        verifyDirs(t, start, dirs, null, paths);
+
+        t.end();
+    });
+
+    t.test('with paths=function option', function (t) {
+        var paths = function paths(request, absoluteStart, getNodeModulesDirs, opts) {
+            return getNodeModulesDirs().concat(path.join(absoluteStart, 'not node modules', request));
+        };
+
+        var start = path.join(__dirname, 'resolver');
+        var dirs = nodeModulesPaths(start, { paths: paths }, 'pkg');
+
+        verifyDirs(t, start, dirs, null, [path.join(start, 'not node modules', 'pkg')]);
+
+        t.end();
+    });
+
+    t.test('with paths=function skipping node modules resolution', function (t) {
+        var paths = function paths(request, absoluteStart, getNodeModulesDirs, opts) {
+            return [];
+        };
+        var start = path.join(__dirname, 'resolver');
+        var dirs = nodeModulesPaths(start, { paths: paths });
+        t.deepEqual(dirs, [], 'no node_modules was computed');
+        t.end();
+    });
+
+    t.test('with moduleDirectory option', function (t) {
+        var start = path.join(__dirname, 'resolver');
+        var moduleDirectory = 'not node modules';
+        var dirs = nodeModulesPaths(start, { moduleDirectory: moduleDirectory });
+
+        verifyDirs(t, start, dirs, moduleDirectory);
+
+        t.end();
+    });
+
+    t.test('with 1 moduleDirectory and paths options', function (t) {
+        var start = path.join(__dirname, 'resolver');
+        var paths = ['a', 'b'];
+        var moduleDirectory = 'not node modules';
+        var dirs = nodeModulesPaths(start, { paths: paths, moduleDirectory: moduleDirectory });
+
+        verifyDirs(t, start, dirs, moduleDirectory, paths);
+
+        t.end();
+    });
+
+    t.test('with 1+ moduleDirectory and paths options', function (t) {
+        var start = path.join(__dirname, 'resolver');
+        var paths = ['a', 'b'];
+        var moduleDirectories = ['not node modules', 'other modules'];
+        var dirs = nodeModulesPaths(start, { paths: paths, moduleDirectory: moduleDirectories });
+
+        verifyDirs(t, start, dirs, moduleDirectories, paths);
+
+        t.end();
+    });
+
+    t.test('combine paths correctly on Windows', function (t) {
+        var start = 'C:\\Users\\username\\myProject\\src';
+        var paths = [];
+        var moduleDirectories = ['node_modules', start];
+        var dirs = nodeModulesPaths(start, { paths: paths, moduleDirectory: moduleDirectories });
+
+        t.equal(dirs.indexOf(path.resolve(start)) > -1, true, 'should contain start dir');
+
+        t.end();
+    });
+
+    t.test('combine paths correctly on non-Windows', { skip: process.platform === 'win32' }, function (t) {
+        var start = '/Users/username/git/myProject/src';
+        var paths = [];
+        var moduleDirectories = ['node_modules', '/Users/username/git/myProject/src'];
+        var dirs = nodeModulesPaths(start, { paths: paths, moduleDirectory: moduleDirectories });
+
+        t.equal(dirs.indexOf(path.resolve(start)) > -1, true, 'should contain start dir');
+
+        t.end();
+    });
+});
--- a/tests/node_modules/tape-es/node_modules/resolve/test/node_path.js
+++ b/tests/node_modules/tape-es/node_modules/resolve/test/node_path.js
@@ -0,0 +1,70 @@
+var fs = require('fs');
+var path = require('path');
+var test = require('tape');
+var resolve = require('../');
+
+test('$NODE_PATH', function (t) {
+    t.plan(8);
+
+    var isDir = function (dir, cb) {
+        if (dir === '/node_path' || dir === 'node_path/x') {
+            return cb(null, true);
+        }
+        fs.stat(dir, function (err, stat) {
+            if (!err) {
+                return cb(null, stat.isDirectory());
+            }
+            if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return cb(null, false);
+            return cb(err);
+        });
+    };
+
+    resolve('aaa', {
+        paths: [
+            path.join(__dirname, '/node_path/x'),
+            path.join(__dirname, '/node_path/y')
+        ],
+        basedir: __dirname,
+        isDirectory: isDir
+    }, function (err, res) {
+        t.error(err);
+        t.equal(res, path.join(__dirname, '/node_path/x/aaa/index.js'), 'aaa resolves');
+    });
+
+    resolve('bbb', {
+        paths: [
+            path.join(__dirname, '/node_path/x'),
+            path.join(__dirname, '/node_path/y')
+        ],
+        basedir: __dirname,
+        isDirectory: isDir
+    }, function (err, res) {
+        t.error(err);
+        t.equal(res, path.join(__dirname, '/node_path/y/bbb/index.js'), 'bbb resolves');
+    });
+
+    resolve('ccc', {
+        paths: [
+            path.join(__dirname, '/node_path/x'),
+            path.join(__dirname, '/node_path/y')
+        ],
+        basedir: __dirname,
+        isDirectory: isDir
+    }, function (err, res) {
+        t.error(err);
+        t.equal(res, path.join(__dirname, '/node_path/x/ccc/index.js'), 'ccc resolves');
+    });
+
+    // ensure that relative paths still resolve against the regular `node_modules` correctly
+    resolve('tap', {
+        paths: [
+            'node_path'
+        ],
+        basedir: path.join(__dirname, 'node_path/x'),
+        isDirectory: isDir
+    }, function (err, res) {
+        var root = require('tap/package.json').main;
+        t.error(err);
+        t.equal(res, path.resolve(__dirname, '..', 'node_modules/tap', root), 'tap resolves');
+    });
+});
--- a/tests/node_modules/tape-es/node_modules/resolve/test/node_path/x/aaa/index.js
+++ b/tests/node_modules/tape-es/node_modules/resolve/test/node_path/x/aaa/index.js
@@ -0,0 +1 @@
+module.exports = 'A';
--- a/tests/node_modules/tape-es/node_modules/resolve/test/node_path/x/ccc/index.js
+++ b/tests/node_modules/tape-es/node_modules/resolve/test/node_path/x/ccc/index.js
@@ -0,0 +1 @@
+module.exports = 'C';
--- a/tests/node_modules/tape-es/node_modules/resolve/test/node_path/y/bbb/index.js
+++ b/tests/node_modules/tape-es/node_modules/resolve/test/node_path/y/bbb/index.js
@@ -0,0 +1 @@
+module.exports = 'B';
--- a/tests/node_modules/tape-es/node_modules/resolve/test/node_path/y/ccc/index.js
+++ b/tests/node_modules/tape-es/node_modules/resolve/test/node_path/y/ccc/index.js
@@ -0,0 +1 @@
+module.exports = 'CY';
--- a/tests/node_modules/tape-es/node_modules/resolve/test/nonstring.js
+++ b/tests/node_modules/tape-es/node_modules/resolve/test/nonstring.js
@@ -0,0 +1,9 @@
+var test = require('tape');
+var resolve = require('../');
+
+test('nonstring', function (t) {
+    t.plan(1);
+    resolve(555, function (err, res, pkg) {
+        t.ok(err);
+    });
+});
--- a/tests/node_modules/tape-es/node_modules/resolve/test/pathfilter.js
+++ b/tests/node_modules/tape-es/node_modules/resolve/test/pathfilter.js
@@ -0,0 +1,75 @@
+var path = require('path');
+var test = require('tape');
+var resolve = require('../');
+
+var resolverDir = path.join(__dirname, '/pathfilter/deep_ref');
+
+var pathFilterFactory = function (t) {
+    return function (pkg, x, remainder) {
+        t.equal(pkg.version, '1.2.3');
+        t.equal(x, path.join(resolverDir, 'node_modules/deep/ref'));
+        t.equal(remainder, 'ref');
+        return 'alt';
+    };
+};
+
+test('#62: deep module references and the pathFilter', function (t) {
+    t.test('deep/ref.js', function (st) {
+        st.plan(3);
+
+        resolve('deep/ref', { basedir: resolverDir }, function (err, res, pkg) {
+            if (err) st.fail(err);
+
+            st.equal(pkg.version, '1.2.3');
+            st.equal(res, path.join(resolverDir, 'node_modules/deep/ref.js'));
+        });
+
+        var res = resolve.sync('deep/ref', { basedir: resolverDir });
+        st.equal(res, path.join(resolverDir, 'node_modules/deep/ref.js'));
+    });
+
+    t.test('deep/deeper/ref', function (st) {
+        st.plan(4);
+
+        resolve(
+            'deep/deeper/ref',
+            { basedir: resolverDir },
+            function (err, res, pkg) {
+                if (err) t.fail(err);
+                st.notEqual(pkg, undefined);
+                st.equal(pkg.version, '1.2.3');
+                st.equal(res, path.join(resolverDir, 'node_modules/deep/deeper/ref.js'));
+            }
+        );
+
+        var res = resolve.sync(
+            'deep/deeper/ref',
+            { basedir: resolverDir }
+        );
+        st.equal(res, path.join(resolverDir, 'node_modules/deep/deeper/ref.js'));
+    });
+
+    t.test('deep/ref alt', function (st) {
+        st.plan(8);
+
+        var pathFilter = pathFilterFactory(st);
+
+        var res = resolve.sync(
+            'deep/ref',
+            { basedir: resolverDir, pathFilter: pathFilter }
+        );
+        st.equal(res, path.join(resolverDir, 'node_modules/deep/alt.js'));
+
+        resolve(
+            'deep/ref',
+            { basedir: resolverDir, pathFilter: pathFilter },
+            function (err, res, pkg) {
+                if (err) st.fail(err);
+                st.equal(res, path.join(resolverDir, 'node_modules/deep/alt.js'));
+                st.end();
+            }
+        );
+    });
+
+    t.end();
+});
--- a/tests/node_modules/tape-es/node_modules/resolve/test/pathfilter/deep_ref/main.js
+++ b/tests/node_modules/tape-es/node_modules/resolve/test/pathfilter/deep_ref/main.js
--- a/tests/node_modules/tape-es/node_modules/resolve/test/precedence.js
+++ b/tests/node_modules/tape-es/node_modules/resolve/test/precedence.js
@@ -0,0 +1,23 @@
+var path = require('path');
+var test = require('tape');
+var resolve = require('../');
+
+test('precedence', function (t) {
+    t.plan(3);
+    var dir = path.join(__dirname, 'precedence/aaa');
+
+    resolve('./', { basedir: dir }, function (err, res, pkg) {
+        t.ifError(err);
+        t.equal(res, path.join(dir, 'index.js'));
+        t.equal(pkg.name, 'resolve');
+    });
+});
+
+test('./ should not load ${dir}.js', function (t) { // eslint-disable-line no-template-curly-in-string
+    t.plan(1);
+    var dir = path.join(__dirname, 'precedence/bbb');
+
+    resolve('./', { basedir: dir }, function (err, res, pkg) {
+        t.ok(err);
+    });
+});
--- a/tests/node_modules/tape-es/node_modules/resolve/test/precedence/aaa.js
+++ b/tests/node_modules/tape-es/node_modules/resolve/test/precedence/aaa.js
@@ -0,0 +1 @@
+module.exports = 'wtf';
--- a/Show More
+++ b/Show More
				`@@ -0,0 +1 @@`
				`module.exports = function (x) { return x * 100; };`
				`@@ -0,0 +1 @@`
				`module.exports = function (n) { return n * 111; };`