hero_web

node_modules/detective/.travis.yml

@@ -0,0 +1,17 @@
+language: node_js
+node_js:
+  - "11"
+  - "10"
+  - "9"
+  - "8"
+  - "6"
+  - "4"
+  - "iojs"
+  - "0.12"
+  - "0.10"
+  - "0.8"
+sudo: false
+before_install:
+  - 'nvm install-latest-npm'
+matrix:
+  fast_finish: true

node_modules/detective/CHANGELOG.md

@@ -0,0 +1,26 @@
+# detective Change Log
+All notable changes to this project will be documented in this file.
+This project adheres to [Semantic Versioning](http://semver.org/).
+
+## x.y.z - unreleased
+* update acorn-node to 1.8.2 (make use of acorn 7.x)
+
+## 5.2.1 - 2022-05-27
+* Update to "minimist": "^1.2.6" from "^1.1.1" to quiet down dependabot security theater.
+
+## 5.2.0 - 2019-01-28
+* Use acorn-node's option defaults, adds support for new ES features (https://github.com/browserify/detective/pull/81)
+
+## 5.1.0 - 2018-02-28
+* Use acorn-node parser, which matches latest Node syntax support (https://github.com/browserify/detective/pull/78)
+* Add basic cli: `detective index.js` outputs dependency names (https://github.com/browserify/detective/pull/51)
+
+## 5.0.2 - 2018-01-06
+* Extend support back to 0.8 until we can determine a LTS plan.
+
+## 5.0.1 - 2018-01-02
+* Add engines field set to `>=4.0.0`.
+
+## 5.0.0 - 2018-01-02
+* Fix: Don't crash on files with the spread operator (https://github.com/browserify/detective/pull/75)
+* Breaking: Drop support for node 0.12 (https://github.com/browserify/detective/pull/75)

node_modules/detective/LICENSE

@@ -0,0 +1,18 @@
+This software is released under the MIT license:
+
+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.

node_modules/detective/bench/detect.js

@@ -0,0 +1,7 @@
+var detective = require('../');
+var fs = require('fs');
+
+var src = fs.readFileSync(__dirname + '/src/jquery.js', 'utf8');
+var t0 = Date.now();
+var requires = detective(src);
+console.log(Date.now() - t0);

node_modules/detective/bench/esprima_v_acorn.txt

@@ -0,0 +1,18 @@
+esprima:
+
+  $ for i in {1..5}; do node detect.js; done
+  704
+  702
+  704
+  704
+  697
+
+acorn:
+
+  $ for i in {1..5}; do node detect.js; done
+  555
+  552
+  585
+  549
+  583
+

node_modules/detective/bin/detective.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+
+var detective = require('../');
+var argv = require('minimist')(process.argv.slice(2));
+var fs = require('fs');
+
+argv._.forEach(function(file) {
+    var src = fs.readFileSync(file, 'utf8');
+    var requires = detective(src, argv);
+    console.log(requires.join('\n'));
+});

node_modules/detective/example/strings.js

@@ -0,0 +1,6 @@
+var detective = require('../');
+var fs = require('fs');
+
+var src = fs.readFileSync(__dirname + '/strings_src.js');
+var requires = detective(src);
+console.dir(requires);

node_modules/detective/example/strings_src.js

@@ -0,0 +1,3 @@
+var a = require('a');
+var b = require('b');
+var c = require('c');

node_modules/detective/index.js

@@ -0,0 +1,80 @@
+var acorn = require('acorn-node');
+var walk = require('acorn-node/walk');
+var defined = require('defined');
+
+var requireRe = /\brequire\b/;
+
+function parse (src, opts) {
+    if (!opts) opts = {};
+    var acornOpts = {
+        ranges: defined(opts.ranges, opts.range),
+        locations: defined(opts.locations, opts.loc),
+        allowReserved: defined(opts.allowReserved, true),
+        allowImportExportEverywhere: defined(opts.allowImportExportEverywhere, false)
+    };
+
+    // Use acorn-node's defaults for the rest.
+    if (opts.ecmaVersion != null) acornOpts.ecmaVersion = opts.ecmaVersion;
+    if (opts.sourceType != null) acornOpts.sourceType = opts.sourceType;
+    if (opts.allowHashBang != null) acornOpts.allowHashBang = opts.allowHashBang;
+    if (opts.allowReturnOutsideFunction != null) acornOpts.allowReturnOutsideFunction = opts.allowReturnOutsideFunction;
+
+    return acorn.parse(src, acornOpts);
+}
+
+var exports = module.exports = function (src, opts) {
+    return exports.find(src, opts).strings;
+};
+
+exports.find = function (src, opts) {
+    if (!opts) opts = {};
+    
+    var word = opts.word === undefined ? 'require' : opts.word;
+    if (typeof src !== 'string') src = String(src);
+    
+    var isRequire = opts.isRequire || function (node) {
+        return node.callee.type === 'Identifier'
+            && node.callee.name === word
+        ;
+    };
+    
+    var modules = { strings : [], expressions : [] };
+    if (opts.nodes) modules.nodes = [];
+    
+    var wordRe = word === 'require' ? requireRe : RegExp('\\b' + word + '\\b');
+    if (!wordRe.test(src)) return modules;
+    
+    var ast = parse(src, opts.parse);
+    
+    function visit(node, st, c) {
+        var hasRequire = wordRe.test(src.slice(node.start, node.end));
+        if (!hasRequire) return;
+        walk.base[node.type](node, st, c);
+        if (node.type !== 'CallExpression') return;
+        if (isRequire(node)) {
+            if (node.arguments.length) {
+                var arg = node.arguments[0];
+                if (arg.type === 'Literal') {
+                    modules.strings.push(arg.value);
+                }
+                else if (arg.type === 'TemplateLiteral'
+                        && arg.quasis.length === 1
+                        && arg.expressions.length === 0) {
+
+                    modules.strings.push(arg.quasis[0].value.raw);
+                }
+                else {
+                    modules.expressions.push(src.slice(arg.start, arg.end));
+                }
+            }
+            if (opts.nodes) modules.nodes.push(node);
+        }
+    }
+    
+    walk.recursive(ast, null, {
+        Statement: visit,
+        Expression: visit
+    });
+    
+    return modules;
+};

node_modules/detective/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "detective",
+  "description": "find all require() calls by walking the AST",
+  "version": "5.2.1",
+  "author": {
+    "name": "James Halliday",
+    "email": "mail@substack.net",
+    "url": "http://substack.net"
+  },
+  "bin": "bin/detective.js",
+  "dependencies": {
+    "acorn-node": "^1.8.2",
+    "defined": "^1.0.0",
+    "minimist": "^1.2.6"
+  },
+  "devDependencies": {
+    "tap": "^10.7.3"
+  },
+  "engines": {
+    "node": ">=0.8.0"
+  },
+  "keywords": [
+    "analyze",
+    "ast",
+    "require",
+    "source"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/browserify/detective.git"
+  },
+  "scripts": {
+    "test": "tap test/*.js"
+  }
+}

node_modules/detective/readme.markdown

@@ -0,0 +1,81 @@
+# detective
+
+find all calls to `require()` by walking the AST
+
+[![build status](https://secure.travis-ci.org/browserify/detective.png)](http://travis-ci.org/browserify/detective)
+
+# example
+
+## strings
+
+strings_src.js:
+
+``` js
+var a = require('a');
+var b = require('b');
+var c = require('c');
+```
+
+strings.js:
+
+``` js
+var detective = require('detective');
+var fs = require('fs');
+
+var src = fs.readFileSync(__dirname + '/strings_src.js');
+var requires = detective(src);
+console.dir(requires);
+```
+
+output:
+
+```
+$ node examples/strings.js
+[ 'a', 'b', 'c' ]
+```
+
+# methods
+
+``` js
+var detective = require('detective');
+```
+
+## detective(src, opts)
+
+Give some source body `src`, return an array of all the `require()` calls with
+string arguments.
+
+The options parameter `opts` is passed along to `detective.find()`.
+
+## var found = detective.find(src, opts)
+
+Give some source body `src`, return `found` with:
+
+* `found.strings` - an array of each string found in a `require()`
+* `found.expressions` - an array of each stringified expression found in a
+`require()` call
+* `found.nodes` (when `opts.nodes === true`) - an array of AST nodes for each
+argument found in a `require()` call
+
+Optionally:
+
+* `opts.word` - specify a different function name instead of `"require"`
+* `opts.nodes` - when `true`, populate `found.nodes`
+* `opts.isRequire(node)` - a function returning whether an AST `CallExpression`
+node is a require call
+* `opts.parse` - supply options directly to
+[acorn](https://npmjs.org/package/acorn) with some support for esprima-style
+options `range` and `loc`
+* `opts.ecmaVersion` - default: 9
+
+# install
+
+With [npm](https://npmjs.org) do:
+
+```
+npm install detective
+```
+
+# license
+
+MIT

node_modules/detective/test/both.js

@@ -0,0 +1,26 @@
+var test = require('tap').test;
+var detective = require('../');
+var fs = require('fs');
+var src = fs.readFileSync(__dirname + '/files/both.js');
+
+test('both', function (t) {
+    var modules = detective.find(src);
+    t.deepEqual(modules.strings, [ 'a', 'b' ]);
+    t.deepEqual(modules.expressions, [ "'c' + x", "'d' + y" ]);
+    t.notOk(modules.nodes, 'has no nodes');
+    t.end();
+});
+
+test('both with nodes specified in opts', function (t) {
+    var modules = detective.find(src, { nodes: true });
+    t.deepEqual(modules.strings, [ 'a', 'b' ]);
+    t.deepEqual(modules.expressions, [ "'c' + x", "'d' + y" ]);
+    t.deepEqual(
+      modules.nodes.map(function (n) { 
+        var arg = n.arguments[0];
+        return arg.value || arg.left.value; 
+      }),
+      [ 'a', 'b', 'c', 'd' ],
+      'has a node for each require');
+    t.end();
+});

node_modules/detective/test/chained.js

@@ -0,0 +1,9 @@
+var test = require('tap').test;
+var detective = require('../');
+var fs = require('fs');
+var src = fs.readFileSync(__dirname + '/files/chained.js');
+
+test('chained', function (t) {
+    t.deepEqual(detective(src), [ 'c', 'b', 'a' ]);
+    t.end();
+});

node_modules/detective/test/complicated.js

@@ -0,0 +1,58 @@
+var test = require('tap').test;
+var detective = require('../');
+
+var sources = [
+    'require("a")',
+    "require('a')",
+    'require(`a`)',
+    ';require("a")',
+    ' require("a")',
+    'void require("a")',
+    '+require("a")',
+    '!require("a")',
+    '/*comments*/require("a")',
+    '(require("a"))',
+
+    'require/*comments*/("a")',
+    ';require/*comments*/("a")',
+    ' require/*comments*/("a")',
+    'void require/*comments*/("a")',
+    '+require/*comments*/("a")',
+    '!require/*comments*/("a")',
+    '/*comments*/require/*comments*/("a")',
+    '(require/*comments*/("a"))',
+
+    'require /*comments*/ ("a")',
+    ';require /*comments*/ ("a")',
+    ' require /*comments*/ ("a")',
+    'void require /*comments*/ ("a")',
+    '+require /*comments*/ ("a")',
+    '!require /*comments*/ ("a")',
+    ' /*comments*/ require /*comments*/ ("a")',
+    '(require /*comments*/ ("a"))',
+
+    'require /*comments*/ /*more comments*/ ("a")',
+    ';require /*comments*/ /*more comments*/ ("a")',
+    ' require /*comments*/ /*more comments*/ ("a")',
+    'void require /*comments*/ /*more comments*/ ("a")',
+    '+require /*comments*/ /*more comments*/ ("a")',
+    '!require /*comments*/ /*more comments*/ ("a")',
+    ' /*comments*/ /*more comments*/ require /*comments*/ /*more comments*/ ("a")',
+    '(require /*comments*/ /*more comments*/ ("a"))',
+
+    'require//comments\n("a")',
+    ';require//comments\n("a")',
+    ' require//comments\n("a")',
+    'void require//comments\n("a")',
+    '+require//comments\n("a")',
+    '!require//comments\n("a")',
+    '  require//comments\n("a")',
+    '(require//comments\n("a"))'
+];
+
+test('complicated', function (t) {
+    t.plan(sources.length);
+    sources.forEach(function(src) {
+        t.deepEqual(detective(src), [ 'a' ]);
+    });
+});

node_modules/detective/test/es2019.js

@@ -0,0 +1,15 @@
+var test = require('tap').test;
+var detective = require('../');
+var fs = require('fs');
+
+test('es2019 - for-await', function (t) {
+    var src = fs.readFileSync(__dirname + '/files/for-await.js');
+    t.doesNotThrow(detective.bind(detective, src), 'Files with `for await()` do not throw')
+    t.end();
+});
+
+test('es2019 - optional-catch', function (t) {
+    var src = fs.readFileSync(__dirname + '/files/optional-catch.js');
+    t.doesNotThrow(detective.bind(detective, src), 'Files with omitted catch binding do not throw')
+    t.end();
+});

node_modules/detective/test/es6-module.js

@@ -0,0 +1,9 @@
+var test = require('tap').test;
+var detective = require('../');
+var fs = require('fs');
+var src = fs.readFileSync(__dirname + '/files/es6-module.js');
+
+test('es6-module', function (t) {
+    t.plan(1);
+    t.deepEqual(detective(src, {parse: {sourceType: 'module'}}), [ 'a', 'b' ]);
+});

node_modules/detective/test/files/both.js

@@ -0,0 +1,4 @@
+require('a');
+require('b');
+require('c' + x);
+var moo = require('d' + y).moo;

node_modules/detective/test/files/chained.js

@@ -0,0 +1,5 @@
+
+
+require('c').hello().goodbye()
+require('b').hello()
+require('a')

node_modules/detective/test/files/es6-module.js

@@ -0,0 +1,5 @@
+var a = require('a');
+
+export default function () {
+    var b = require('b');
+}

node_modules/detective/test/files/for-await.js

@@ -0,0 +1,5 @@
+async function main () {
+    for await (const _ of (async function* () {})()) {
+        require(_)
+    }
+}

node_modules/detective/test/files/generators.js

@@ -0,0 +1,5 @@
+var a = require('a');
+
+function *gen() {
+  yield require('b');
+}

node_modules/detective/test/files/isrequire.js

@@ -0,0 +1,14 @@
+var a = require.async('a');
+var b = require.async('b');
+var c = require.async('c');
+var abc = a.b(c);
+
+var EventEmitter = require.async('events').EventEmitter;
+
+var x = require.async('doom')(5,6,7);
+x(8,9);
+c.load('notthis');
+var y = require.async('y') * 100;
+
+var EventEmitter2 = require.async('events2').EventEmitter();
+

node_modules/detective/test/files/nested.js

@@ -0,0 +1,22 @@
+
+if (true) {
+    (function () {
+        require('a');
+    })();
+}
+if (false) {
+    (function () {
+        var x = 10;
+        switch (x) {
+            case 1 : require('b'); break;
+            default : break;
+        }
+    })()
+}
+
+function qqq () {
+    require
+        (
+        "c"
+    );
+}

node_modules/detective/test/files/optional-catch.js

@@ -0,0 +1,4 @@
+try {
+    require;
+} catch {
+}

node_modules/detective/test/files/rest-spread.js

@@ -0,0 +1,9 @@
+var a = require('a');
+var b = require('b');
+var c = require('c');
+
+
+var obj = { foo: 'bar', bee: 'bop' }
+var spread = { ...obj }
+var { foo, ...rest } = obj
+

node_modules/detective/test/files/set-in-object-pattern.js

@@ -0,0 +1,10 @@
+var a = load('a');
+var b = load('b');
+var c = load('c');
+var abc = a.b(c);
+
+function load2({set = 'hello'}) {
+	return load('tt');
+}
+
+var loadUse = load2();

node_modules/detective/test/files/shebang.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+var a = require('a');
+var b = require('b');
+var c = require('c');

node_modules/detective/test/files/sparse-array.js

@@ -0,0 +1,3 @@
+var o = [,,,,]
+
+require('./foo')

node_modules/detective/test/files/strings.js

@@ -0,0 +1,13 @@
+var a = require('a');
+var b = require('b');
+var c = require('c');
+var abc = a.b(c);
+
+var EventEmitter = require('events').EventEmitter;
+
+var x = require('doom')(5,6,7);
+x(8,9);
+c.require('notthis');
+var y = require('y') * 100;
+
+var EventEmitter2 = require('events2').EventEmitter();

node_modules/detective/test/files/word.js

@@ -0,0 +1,13 @@
+var a = load('a');
+var b = load('b');
+var c = load('c');
+var abc = a.b(c);
+
+var EventEmitter = load('events').EventEmitter;
+
+var x = load('doom')(5,6,7);
+x(8,9);
+c.load('notthis');
+var y = load('y') * 100;
+
+var EventEmitter2 = load('events2').EventEmitter();

node_modules/detective/test/files/yield.js

@@ -0,0 +1,4 @@
+(function * () {
+    var a = require('a');
+    var b = yield require('c')(a);
+})();

node_modules/detective/test/generators.js

@@ -0,0 +1,9 @@
+var test = require('tap').test;
+var detective = require('../');
+var fs = require('fs');
+var src = fs.readFileSync(__dirname + '/files/generators.js');
+
+test('generators', function (t) {
+    t.plan(1);
+    t.deepEqual(detective(src), [ 'a', 'b' ]);
+});

node_modules/detective/test/isrequire.js

@@ -0,0 +1,20 @@
+var test = require('tap').test;
+var detective = require('../');
+var fs = require('fs');
+var src = fs.readFileSync(__dirname + '/files/isrequire.js');
+
+test('word', function (t) {
+    t.deepEqual(
+        detective(src, { isRequire: function(node) {
+          return (node.type === 'CallExpression' &&
+              node.callee.type === 'MemberExpression' &&
+              node.callee.object.type == 'Identifier' &&
+              node.callee.object.name == 'require' &&
+              node.callee.property.type == 'Identifier' &&
+              node.callee.property.name == 'async')
+        } }),
+        [ 'a', 'b', 'c', 'events', 'doom', 'y', 'events2' ]
+    );
+    t.end();
+});
+

node_modules/detective/test/nested.js

@@ -0,0 +1,9 @@
+var test = require('tap').test;
+var detective = require('../');
+var fs = require('fs');
+var src = fs.readFileSync(__dirname + '/files/nested.js');
+
+test('nested', function (t) {
+    t.deepEqual(detective(src), [ 'a', 'b', 'c' ]);
+    t.end();
+});

node_modules/detective/test/noargs.js

@@ -0,0 +1,26 @@
+var test = require('tap').test;
+var detective = require('../');
+var fs = require('fs');
+
+// in order to use detective to find any function
+// it needs to properly handle functions called without args
+var src = [ 'fn();', 'otherfn();', 'fn();' ].join('\n')
+
+test('noargs', function (t) {
+    t.plan(1);
+    t.deepEqual(detective(src, { word: 'fn' }).length, 0, 'finds no arg id');
+});
+
+test('find noargs with nodes', function (t) {
+    t.plan(4);
+    var modules = detective.find(src, { word: 'fn', nodes: true });
+    t.equal(modules.strings.length, 0, 'finds no arg id');
+    t.equal(modules.expressions.length, 0, 'finds no expressions');
+    t.equal(modules.nodes.length, 2, 'finds a node for each matching function call');
+    t.equal(
+      modules.nodes.filter(function (x) { 
+        return x.callee.name === 'fn' 
+      }).length, 2, 
+      'all matches are correct'
+    );
+});

node_modules/detective/test/parseopts.js

@@ -0,0 +1,62 @@
+var test = require('tap').test;
+var detective = require('../');
+var fs = require('fs');
+var src = fs.readFileSync(__dirname + '/files/both.js');
+
+test('nodes specified in opts and parseopts { range: true }', function (t) {
+    var modules = detective.find(src, { nodes: true, parse: { range: true } });
+    t.deepEqual(modules.strings, [ 'a', 'b' ]);
+    t.deepEqual(modules.expressions, [ "'c' + x", "'d' + y" ]);
+    t.deepEqual(
+      modules.nodes.map(function (n) { 
+        var arg = n.arguments[0];
+        return arg.value || arg.left.value; 
+      }),
+      [ 'a', 'b', 'c', 'd' ],
+      'has a node for each require');
+
+    var range = modules.nodes[0].range;
+    t.equal(range[0], 0, 'includes range start');
+    t.equal(range[1], 12, 'includes range end');
+    t.end();
+});
+
+test('nodes specified in opts and parseopts { range: false }', function (t) {
+    var modules = detective.find(src, { nodes: true, parse: { range: false } });
+    t.deepEqual(modules.strings, [ 'a', 'b' ]);
+    t.deepEqual(modules.expressions, [ "'c' + x", "'d' + y" ]);
+    t.deepEqual(
+      modules.nodes.map(function (n) { 
+        var arg = n.arguments[0];
+        return arg.value || arg.left.value; 
+      }),
+      [ 'a', 'b', 'c', 'd' ],
+      'has a node for each require');
+
+    t.notOk(modules.nodes[0].range, 'includes no ranges');
+    t.end();
+});
+
+test('nodes specified in opts and parseopts { range: true, loc: true }', function (t) {
+    var modules = detective.find(src, { nodes: true, parse: { range: true, loc: true } });
+    t.deepEqual(modules.strings, [ 'a', 'b' ]);
+    t.deepEqual(modules.expressions, [ "'c' + x", "'d' + y" ]);
+    t.deepEqual(
+      modules.nodes.map(function (n) { 
+        var arg = n.arguments[0];
+        return arg.value || arg.left.value; 
+      }),
+      [ 'a', 'b', 'c', 'd' ],
+      'has a node for each require');
+
+    var range = modules.nodes[0].range;
+    t.equal(range[0], 0, 'includes range start');
+    t.equal(range[1], 12, 'includes range end');
+
+    var loc = modules.nodes[0].loc;
+    t.equal(loc.start.line, 1, 'includes start line');
+    t.equal(loc.start.column, 0, 'includes start column');
+    t.equal(loc.end.line, 1, 'includes end line');
+    t.equal(loc.end.column, 12, 'includes end column');
+    t.end();
+});

node_modules/detective/test/rest-spread.js

@@ -0,0 +1,9 @@
+var test = require('tap').test;
+var detective = require('../');
+var fs = require('fs');
+var src = fs.readFileSync(__dirname + '/files/rest-spread.js');
+
+test('rest-spread', function (t) {
+    t.doesNotThrow(detective.bind(detective, src), 'Files with rest or spread do not throw')
+    t.end();
+});

node_modules/detective/test/return.js

@@ -0,0 +1,9 @@
+var test = require('tap').test;
+var detective = require('../');
+var fs = require('fs');
+var src = [ 'require("a")\nreturn' ];
+
+test('return', function (t) {
+    t.plan(1);
+    t.deepEqual(detective(src), [ 'a' ]);
+});

node_modules/detective/test/set-in-object-pattern.js

@@ -0,0 +1,12 @@
+var test = require('tap').test;
+var detective = require('../');
+var fs = require('fs');
+var src = fs.readFileSync(__dirname + '/files/set-in-object-pattern.js');
+
+test('set in object pattern', function (t) {
+    t.deepEqual(
+        detective(src, { word : 'load' }),
+        [ 'a', 'b', 'c', 'tt' ]
+    );
+    t.end();
+});

node_modules/detective/test/shebang.js

@@ -0,0 +1,9 @@
+var test = require('tap').test;
+var detective = require('../');
+var fs = require('fs');
+var src = fs.readFileSync(__dirname + '/files/shebang.js');
+
+test('shebang', function (t) {
+    t.plan(1);
+    t.deepEqual(detective(src), [ 'a', 'b', 'c' ]);
+});

node_modules/detective/test/sparse-array.js

@@ -0,0 +1,14 @@
+var test = require('tap').test;
+var detective = require('../');
+var fs = require('fs');
+var src = fs.readFileSync(__dirname + '/files/sparse-array.js');
+
+test('sparse-array', function (t) {
+    //just check that this does not crash.
+    t.doesNotThrow(function () {
+      detective(src)
+    })
+    t.end();
+});
+
+

node_modules/detective/test/strings.js

@@ -0,0 +1,9 @@
+var test = require('tap').test;
+var detective = require('../');
+var fs = require('fs');
+var src = fs.readFileSync(__dirname + '/files/strings.js');
+
+test('single', function (t) {
+    t.deepEqual(detective(src), [ 'a', 'b', 'c', 'events', 'doom', 'y', 'events2' ]);
+    t.end();
+});

node_modules/detective/test/word.js

@@ -0,0 +1,12 @@
+var test = require('tap').test;
+var detective = require('../');
+var fs = require('fs');
+var src = fs.readFileSync(__dirname + '/files/word.js');
+
+test('word', function (t) {
+    t.deepEqual(
+        detective(src, { word : 'load' }),
+        [ 'a', 'b', 'c', 'events', 'doom', 'y', 'events2' ]
+    );
+    t.end();
+});

node_modules/detective/test/yield.js

@@ -0,0 +1,9 @@
+var test = require('tap').test;
+var detective = require('../');
+var fs = require('fs');
+var src = fs.readFileSync(__dirname + '/files/yield.js');
+
+test('yield', function (t) {
+    t.plan(1);
+    t.deepEqual(detective(src), [ 'a', 'c' ]);
+});