.

node_modules/stealthy-require/.npmignore

@@ -0,0 +1,13 @@
+/.idea/
+/coverage/
+/test/
+
+/.editorconfig
+/.eslintrc.json
+/.gitignore
+/.publishrc
+/.travis.yml
+/gulpfile.js
+
+.DS_Store
+npm-debug.log

node_modules/stealthy-require/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2017, Nicolai Kamenzky and contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

node_modules/stealthy-require/README.md

@@ -0,0 +1,192 @@
+# Stealthy-Require
+
+[![Build Status](https://img.shields.io/travis/analog-nico/stealthy-require/master.svg?style=flat-square)](https://travis-ci.org/analog-nico/stealthy-require)
+[![Coverage Status](https://img.shields.io/coveralls/analog-nico/stealthy-require.svg?style=flat-square)](https://coveralls.io/r/analog-nico/stealthy-require)
+[![Dependency Status](https://img.shields.io/david/analog-nico/stealthy-require.svg?style=flat-square)](https://david-dm.org/analog-nico/stealthy-require)
+
+This is probably the closest you can currently get to require something in node.js with completely bypassing the require cache.
+
+`stealthy-require` works like this:
+
+1. It clears the require cache.
+2. It calls a callback in which you require your module(s) without the cache kicking in.
+3. It clears the cache again and restores its old state.
+
+The restrictions are:
+
+- [Native modules cannot be required twice.](https://github.com/nodejs/node/issues/5016) Thus this module bypasses the require cache only for non-native (e.g. JS) modules.
+- The require cache is only bypassed for all operations that happen synchronously when a module is required. If a module lazy loads another module at a later time that require call will not bypass the cache anymore.
+
+This means you should have a close look at all internal require calls before you decide to use this library.
+
+## Installation
+
+[![NPM Stats](https://nodei.co/npm/stealthy-require.png?downloads=true)](https://npmjs.org/package/stealthy-require)
+
+This is a module for node.js and is installed via npm:
+
+``` bash
+npm install stealthy-require --save
+```
+
+## Usage
+
+Let's say you want to bypass the require cache for this require call:
+
+``` js
+var request = require('request');
+```
+
+With `stealthy-require` you can do that like this:
+
+``` js
+var stealthyRequire = require('stealthy-require');
+
+var requestFresh = stealthyRequire(require.cache, function () {
+    return require('request');
+});
+```
+
+The require cache is bypassed for the module you require (i.e. `request`) as well as all modules the module requires (i.e. `http` and many more).
+
+Sometimes the require cache shall not be bypassed for specific modules. E.g. `request` is required but `tough-cookie` – on which `request` depends on – shall be required using the regular cache. For that you can pass two extra arguments to `stealthyRequire(...)`:
+
+- A callback that requires the modules that shall be required without bypassing the cache
+- The `module` variable
+
+``` js
+var stealthyRequire = require('stealthy-require');
+
+var requestFresh = stealthyRequire(require.cache, function () {
+    return require('request');
+},
+function () {
+    require('tough-cookie'); // No return needed
+    // You can require multiple modules here
+}, module);
+```
+
+## Usage with Module Bundlers
+
+- [Webpack](https://webpack.github.io) works out-of-the-box like described in the [Usage section](#usage) above.
+- [Browserify](http://browserify.org) does not expose `require.cache`. However, as of `browserify@13.0.1` the cache is passed as the 6th argument to CommonJS modules. Thus you can pass this argument instead:
+
+``` js
+// Tweak for Browserify - using arguments[5] instead of require.cache
+var requestFresh = stealthyRequire(arguments[5], function () {
+    return require('request');
+});
+```
+
+## Preventing a Memory Leak When Repeatedly Requiring Fresh Module Instances in Node.js
+
+If you are using `stealthy-require` in node.js and repeatedly require fresh module instances the `module.children` array will hold all module instances which prevents unneeded instances to be garbage collected.
+
+Assume your code calls `doSomething()` repeatedly.
+
+``` js
+var stealthyRequire = require('stealthy-require');
+
+function doSomething() {
+
+    var freshInstance = stealthyRequire(require.cache, function () {
+        return require('some-module');
+    });
+    
+    return freshInstance.calc();
+
+}
+```
+
+After `doSomething()` returns `freshInstance` is not used anymore but won’t be garbage collected because `module.children` still holds a reference. The solution is to truncate `module.children` accordingly:
+
+``` js
+var stealthyRequire = require('stealthy-require');
+
+function doSomething() {
+
+    var initialChildren = module.children.slice(); // Creates a shallow copy of the array
+
+    var freshInstance = stealthyRequire(require.cache, function () {
+        return require('some-module');
+    });
+
+    module.children = initialChildren;
+
+    return freshInstance.calc();
+
+}
+```
+
+The `slice` operation removes all new `module.children` entries created during the `stealthyRequire(...)` call and thus `freshInstance` gets garbage collected after `doSomething()` returns.
+
+
+## Technical Walkthrough
+
+``` js
+// 1. Load stealthy-require
+var stealthyRequire = require('stealthy-require');
+// This does nothing but loading the code.
+// It has no side-effects like patching the module loader or anything.
+
+// Any regular require works as always.
+var request1 = require('request');
+
+// 2. Call stealthyRequire with passing the require cache and a callback.
+var requestFresh = stealthyRequire(require.cache, function () {
+
+    // 2a. Before this callback gets called the require cache is cleared.
+
+    // 2b. Any require taking place here takes place on a clean require cache.
+    // Since the require call is part of the user's code it also works with module bundlers.
+    return require('request');
+    // Anything returned here will be returned by stealthyRequire(...).
+
+    // 2c. After this callback gets called the require cache is
+    // - cleared again and
+    // - restored to its old state before step 2.
+
+});
+
+// Any regular require again works as always.
+// In this case require returns the cached request module instance.
+var request2 = require('request');
+
+// And voilà:
+request1 === request2 // -> true
+request1 === requestFresh // -> false
+```
+
+## Contributing
+
+To set up your development environment for `stealthy-require`:
+
+1. Clone this repo to your desktop,
+2. in the shell `cd` to the main folder,
+3. hit `npm install`,
+4. hit `npm install gulp -g` if you haven't installed gulp globally yet, and
+5. run `gulp dev`. (Or run `node ./node_modules/.bin/gulp dev` if you don't want to install gulp globally.)
+
+`gulp dev` watches all source files and if you save some changes it will lint the code and execute all tests. The test coverage report can be viewed from `./coverage/lcov-report/index.html`.
+
+If you want to debug a test you should use `gulp test-without-coverage` to run all tests without obscuring the code by the test coverage instrumentation.
+
+## Change History
+
+- v1.1.1 (2017-05-08)
+    - Fix that stops `undefined` entries from appearing in `require.cache` *(Thanks to @jasperjn from reporting this in [issue #4](https://github.com/analog-nico/stealthy-require/issues/4))*
+- v1.1.0 (2017-04-25)
+    - Added ability to disable bypassing the cache for certain modules *(Thanks to @novemberborn for suggesting this in [issue #3](https://github.com/analog-nico/stealthy-require/issues/3))*
+    - Added section in README about a [potential memory leak](#preventing-a-memory-leak-when-repeatedly-requiring-fresh-module-instances-in-nodejs) *(Thanks to @Flarna and @novemberborn for bringing that up in [issue #2](https://github.com/analog-nico/stealthy-require/issues/2))*
+    - Performance optimizations *(Thanks to @jcready for [pull request #1](https://github.com/analog-nico/stealthy-require/pull/1))*
+- v1.0.0 (2016-07-18)
+    - **Breaking Change:** API completely changed. Please read the [Usage section](#usage) again.
+    - Redesigned library to support module bundlers like [Webpack](https://webpack.github.io) and [Browserify](http://browserify.org)
+- v0.1.0 (2016-05-26)
+    - Initial version
+
+## License (ISC)
+
+In case you never heard about the [ISC license](http://en.wikipedia.org/wiki/ISC_license) it is functionally equivalent to the MIT license.
+
+See the [LICENSE file](LICENSE) for details.

node_modules/stealthy-require/lib/index.js

@@ -0,0 +1,81 @@
+'use strict';
+
+var isNative = /\.node$/;
+
+function forEach(obj, callback) {
+    for ( var key in obj ) {
+        if (!Object.prototype.hasOwnProperty.call(obj, key)) {
+            continue;
+        }
+        callback(key);
+    }
+}
+
+function assign(target, source) {
+    forEach(source, function (key) {
+        target[key] = source[key];
+    });
+    return target;
+}
+
+function clearCache(requireCache) {
+    forEach(requireCache, function (resolvedPath) {
+        if (!isNative.test(resolvedPath)) {
+            delete requireCache[resolvedPath];
+        }
+    });
+}
+
+module.exports = function (requireCache, callback, callbackForModulesToKeep, module) {
+
+    var originalCache = assign({}, requireCache);
+    clearCache(requireCache);
+
+    if (callbackForModulesToKeep) {
+
+        var originalModuleChildren = module.children ? module.children.slice() : false; // Creates a shallow copy of module.children
+
+        callbackForModulesToKeep();
+
+        // Lists the cache entries made by callbackForModulesToKeep()
+        var modulesToKeep = [];
+        forEach(requireCache, function (key) {
+            modulesToKeep.push(key);
+        });
+
+        // Discards the modules required in callbackForModulesToKeep()
+        clearCache(requireCache);
+
+        if (module.children) { // Only true for node.js
+            module.children = originalModuleChildren; // Removes last references to modules required in callbackForModulesToKeep() -> No memory leak
+        }
+
+        // Takes the cache entries of the original cache in case the modules where required before
+        for ( var i = 0; i < modulesToKeep.length; i+=1 ) {
+            if (originalCache[modulesToKeep[i]]) {
+                requireCache[modulesToKeep[i]] = originalCache[modulesToKeep[i]];
+            }
+        }
+
+    }
+
+    var freshModule = callback();
+
+    var stealthCache = callbackForModulesToKeep ? assign({}, requireCache) : false;
+
+    clearCache(requireCache);
+
+    if (callbackForModulesToKeep) {
+        // In case modules to keep were required inside the stealthy require for the first time, copy them to the restored cache
+        for ( var k = 0; k < modulesToKeep.length; k+=1 ) {
+            if (stealthCache[modulesToKeep[k]]) {
+                requireCache[modulesToKeep[k]] = stealthCache[modulesToKeep[k]];
+            }
+        }
+    }
+
+    assign(requireCache, originalCache);
+
+    return freshModule;
+
+};

node_modules/stealthy-require/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "stealthy-require",
+  "version": "1.1.1",
+  "description": "The closest you can get to require something with bypassing the require cache",
+  "keywords": [
+    "require",
+    "bypass",
+    "no",
+    "cache",
+    "fresh"
+  ],
+  "main": "./lib/index.js",
+  "scripts": {
+    "test": "./node_modules/.bin/gulp ci",
+    "test-publish": "./node_modules/.bin/gulp ci-no-cov",
+    "publish-please": "publish-please",
+    "prepublish": "publish-please guard"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/analog-nico/stealthy-require.git"
+  },
+  "author": "Nicolai Kamenzky (https://github.com/analog-nico)",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/analog-nico/stealthy-require/issues"
+  },
+  "homepage": "https://github.com/analog-nico/stealthy-require#readme",
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "bcrypt": "~1.0.2",
+    "browserify": "~14.3.0",
+    "chai": "~3.5.0",
+    "chalk": "~1.1.3",
+    "gulp": "~3.9.1",
+    "gulp-coveralls": "~0.1.4",
+    "gulp-eslint": "~2.1.0",
+    "gulp-istanbul": "~1.1.1",
+    "gulp-mocha": "~3.0.1",
+    "mkdirp": "~0.5.1",
+    "publish-please": "~2.3.1",
+    "rimraf": "~2.6.1",
+    "run-sequence": "~1.2.2",
+    "webpack": "~1.15.0"
+  }
+
+,"_resolved": "https://registry.npmjs.org/stealthy-require/-/stealthy-require-1.1.1.tgz"
+,"_integrity": "sha1-NbCYdbT/SfJqd35QmzCQoyJr8ks="
+,"_from": "stealthy-require@1.1.1"
+}