init

node_modules/resolve/test/core.js

@@ -0,0 +1,88 @@
+var test = require('tape');
+var keys = require('object-keys');
+var semver = require('semver');
+
+var resolve = require('../');
+
+var brokenNode = semver.satisfies(process.version, '11.11 - 11.13');
+
+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];
+            // note: this must be require, not require.resolve, due to https://github.com/nodejs/node/issues/43274
+            var requireFunc = function () { require(mod); }; // eslint-disable-line no-loop-func
+            t.comment(mod + ': ' + resolve.core[mod]);
+            if (resolve.core[mod]) {
+                st.doesNotThrow(requireFunc, mod + ' supported; requiring does not throw');
+            } else if (brokenNode) {
+                st.ok(true, 'this version of node is broken: attempting to require things that fail to resolve breaks "home_paths" tests');
+            } else {
+                st.throws(requireFunc, 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();
+});

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'));
+});

node_modules/resolve/test/dotdot/abc/index.js

@@ -0,0 +1,2 @@
+var x = require('..');
+console.log(x);

node_modules/resolve/test/dotdot/index.js

@@ -0,0 +1 @@
+module.exports = 'whatever';

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);
+    });
+});

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();
+    });
+});

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();
+});

node_modules/resolve/test/home_paths.js

@@ -0,0 +1,127 @@
+'use strict';
+
+var fs = require('fs');
+var homedir = require('../lib/homedir');
+var path = require('path');
+
+var test = require('tape');
+var mkdirp = require('mkdirp');
+var rimraf = require('rimraf');
+var mv = require('mv');
+var copyDir = require('copy-dir');
+var tmp = require('tmp');
+
+var HOME = homedir();
+
+var hnm = path.join(HOME, '.node_modules');
+var hnl = path.join(HOME, '.node_libraries');
+
+var resolve = require('../async');
+
+function makeDir(t, dir, cb) {
+    mkdirp(dir, function (err) {
+        if (err) {
+            cb(err);
+        } else {
+            t.teardown(function cleanup() {
+                rimraf.sync(dir);
+            });
+            cb();
+        }
+    });
+}
+
+function makeTempDir(t, dir, cb) {
+    if (fs.existsSync(dir)) {
+        var tmpResult = tmp.dirSync();
+        t.teardown(tmpResult.removeCallback);
+        var backup = path.join(tmpResult.name, path.basename(dir));
+        mv(dir, backup, function (err) {
+            if (err) {
+                cb(err);
+            } else {
+                t.teardown(function () {
+                    mv(backup, dir, cb);
+                });
+                makeDir(t, dir, cb);
+            }
+        });
+    } else {
+        makeDir(t, dir, cb);
+    }
+}
+
+test('homedir module paths', function (t) {
+    t.plan(7);
+
+    makeTempDir(t, hnm, function (err) {
+        t.error(err, 'no error with HNM temp dir');
+        if (err) {
+            return t.end();
+        }
+
+        var bazHNMDir = path.join(hnm, 'baz');
+        var dotMainDir = path.join(hnm, 'dot_main');
+        copyDir.sync(path.join(__dirname, 'resolver/baz'), bazHNMDir);
+        copyDir.sync(path.join(__dirname, 'resolver/dot_main'), dotMainDir);
+
+        var bazPkg = { name: 'baz', main: 'quux.js' };
+        var dotMainPkg = { main: 'index' };
+
+        var bazHNMmain = path.join(bazHNMDir, 'quux.js');
+        t.equal(require.resolve('baz'), bazHNMmain, 'sanity check: require.resolve finds HNM `baz`');
+        var dotMainMain = path.join(dotMainDir, 'index.js');
+        t.equal(require.resolve('dot_main'), dotMainMain, 'sanity check: require.resolve finds `dot_main`');
+
+        makeTempDir(t, hnl, function (err) {
+            t.error(err, 'no error with HNL temp dir');
+            if (err) {
+                return t.end();
+            }
+            var bazHNLDir = path.join(hnl, 'baz');
+            copyDir.sync(path.join(__dirname, 'resolver/baz'), bazHNLDir);
+
+            var dotSlashMainDir = path.join(hnl, 'dot_slash_main');
+            var dotSlashMainMain = path.join(dotSlashMainDir, 'index.js');
+            var dotSlashMainPkg = { main: 'index' };
+            copyDir.sync(path.join(__dirname, 'resolver/dot_slash_main'), dotSlashMainDir);
+
+            t.equal(require.resolve('baz'), bazHNMmain, 'sanity check: require.resolve finds HNM `baz`');
+            t.equal(require.resolve('dot_slash_main'), dotSlashMainMain, 'sanity check: require.resolve finds HNL `dot_slash_main`');
+
+            t.test('with temp dirs', function (st) {
+                st.plan(3);
+
+                st.test('just in `$HOME/.node_modules`', function (s2t) {
+                    s2t.plan(3);
+
+                    resolve('dot_main', function (err, res, pkg) {
+                        s2t.error(err, 'no error resolving `dot_main`');
+                        s2t.equal(res, dotMainMain, '`dot_main` resolves in `$HOME/.node_modules`');
+                        s2t.deepEqual(pkg, dotMainPkg);
+                    });
+                });
+
+                st.test('just in `$HOME/.node_libraries`', function (s2t) {
+                    s2t.plan(3);
+
+                    resolve('dot_slash_main', function (err, res, pkg) {
+                        s2t.error(err, 'no error resolving `dot_slash_main`');
+                        s2t.equal(res, dotSlashMainMain, '`dot_slash_main` resolves in `$HOME/.node_libraries`');
+                        s2t.deepEqual(pkg, dotSlashMainPkg);
+                    });
+                });
+
+                st.test('in `$HOME/.node_libraries` and `$HOME/.node_modules`', function (s2t) {
+                    s2t.plan(3);
+
+                    resolve('baz', function (err, res, pkg) {
+                        s2t.error(err, 'no error resolving `baz`');
+                        s2t.equal(res, bazHNMmain, '`baz` resolves in `$HOME/.node_modules` when in both');
+                        s2t.deepEqual(pkg, bazPkg);
+                    });
+                });
+            });
+        });
+    });
+});

node_modules/resolve/test/home_paths_sync.js

@@ -0,0 +1,114 @@
+'use strict';
+
+var fs = require('fs');
+var homedir = require('../lib/homedir');
+var path = require('path');
+
+var test = require('tape');
+var mkdirp = require('mkdirp');
+var rimraf = require('rimraf');
+var mv = require('mv');
+var copyDir = require('copy-dir');
+var tmp = require('tmp');
+
+var HOME = homedir();
+
+var hnm = path.join(HOME, '.node_modules');
+var hnl = path.join(HOME, '.node_libraries');
+
+var resolve = require('../sync');
+
+function makeDir(t, dir, cb) {
+    mkdirp(dir, function (err) {
+        if (err) {
+            cb(err);
+        } else {
+            t.teardown(function cleanup() {
+                rimraf.sync(dir);
+            });
+            cb();
+        }
+    });
+}
+
+function makeTempDir(t, dir, cb) {
+    if (fs.existsSync(dir)) {
+        var tmpResult = tmp.dirSync();
+        t.teardown(tmpResult.removeCallback);
+        var backup = path.join(tmpResult.name, path.basename(dir));
+        mv(dir, backup, function (err) {
+            if (err) {
+                cb(err);
+            } else {
+                t.teardown(function () {
+                    mv(backup, dir, cb);
+                });
+                makeDir(t, dir, cb);
+            }
+        });
+    } else {
+        makeDir(t, dir, cb);
+    }
+}
+
+test('homedir module paths', function (t) {
+    t.plan(7);
+
+    makeTempDir(t, hnm, function (err) {
+        t.error(err, 'no error with HNM temp dir');
+        if (err) {
+            return t.end();
+        }
+
+        var bazHNMDir = path.join(hnm, 'baz');
+        var dotMainDir = path.join(hnm, 'dot_main');
+        copyDir.sync(path.join(__dirname, 'resolver/baz'), bazHNMDir);
+        copyDir.sync(path.join(__dirname, 'resolver/dot_main'), dotMainDir);
+
+        var bazHNMmain = path.join(bazHNMDir, 'quux.js');
+        t.equal(require.resolve('baz'), bazHNMmain, 'sanity check: require.resolve finds HNM `baz`');
+        var dotMainMain = path.join(dotMainDir, 'index.js');
+        t.equal(require.resolve('dot_main'), dotMainMain, 'sanity check: require.resolve finds `dot_main`');
+
+        makeTempDir(t, hnl, function (err) {
+            t.error(err, 'no error with HNL temp dir');
+            if (err) {
+                return t.end();
+            }
+            var bazHNLDir = path.join(hnl, 'baz');
+            copyDir.sync(path.join(__dirname, 'resolver/baz'), bazHNLDir);
+
+            var dotSlashMainDir = path.join(hnl, 'dot_slash_main');
+            var dotSlashMainMain = path.join(dotSlashMainDir, 'index.js');
+            copyDir.sync(path.join(__dirname, 'resolver/dot_slash_main'), dotSlashMainDir);
+
+            t.equal(require.resolve('baz'), bazHNMmain, 'sanity check: require.resolve finds HNM `baz`');
+            t.equal(require.resolve('dot_slash_main'), dotSlashMainMain, 'sanity check: require.resolve finds HNL `dot_slash_main`');
+
+            t.test('with temp dirs', function (st) {
+                st.plan(3);
+
+                st.test('just in `$HOME/.node_modules`', function (s2t) {
+                    s2t.plan(1);
+
+                    var res = resolve('dot_main');
+                    s2t.equal(res, dotMainMain, '`dot_main` resolves in `$HOME/.node_modules`');
+                });
+
+                st.test('just in `$HOME/.node_libraries`', function (s2t) {
+                    s2t.plan(1);
+
+                    var res = resolve('dot_slash_main');
+                    s2t.equal(res, dotSlashMainMain, '`dot_slash_main` resolves in `$HOME/.node_libraries`');
+                });
+
+                st.test('in `$HOME/.node_libraries` and `$HOME/.node_modules`', function (s2t) {
+                    s2t.plan(1);
+
+                    var res = resolve('baz');
+                    s2t.equal(res, bazHNMmain, '`baz` resolves in `$HOME/.node_modules` when in both');
+                });
+            });
+        });
+    });
+});

node_modules/resolve/test/mock.js

@@ -0,0 +1,315 @@
+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);
+    });
+});
+
+test('readPackage', function (t) {
+    t.plan(3);
+
+    var files = {};
+    files[path.resolve('/foo/node_modules/bar/something-else.js')] = 'beep';
+    files[path.resolve('/foo/node_modules/bar/package.json')] = JSON.stringify({
+        main: './baz.js'
+    });
+    files[path.resolve('/foo/node_modules/bar/baz.js')] = 'boop';
+
+    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);
+            }
+        };
+    }
+
+    t.test('with readFile', function (st) {
+        st.plan(3);
+
+        resolve('bar', opts('/foo'), function (err, res, pkg) {
+            st.error(err);
+            st.equal(res, path.resolve('/foo/node_modules/bar/baz.js'));
+            st.equal(pkg && pkg.main, './baz.js');
+        });
+    });
+
+    var readPackage = function (readFile, file, cb) {
+        var barPackage = path.join('bar', 'package.json');
+        if (file.slice(-barPackage.length) === barPackage) {
+            cb(null, { main: './something-else.js' });
+        } else {
+            cb(null, JSON.parse(files[path.resolve(file)]));
+        }
+    };
+
+    t.test('with readPackage', function (st) {
+        st.plan(3);
+
+        var options = opts('/foo');
+        delete options.readFile;
+        options.readPackage = readPackage;
+        resolve('bar', options, function (err, res, pkg) {
+            st.error(err);
+            st.equal(res, path.resolve('/foo/node_modules/bar/something-else.js'));
+            st.equal(pkg && pkg.main, './something-else.js');
+        });
+    });
+
+    t.test('with readFile and readPackage', function (st) {
+        st.plan(1);
+
+        var options = opts('/foo');
+        options.readPackage = readPackage;
+        resolve('bar', options, function (err) {
+            st.throws(function () { throw err; }, TypeError, 'errors when both readFile and readPackage are provided');
+        });
+    });
+});

node_modules/resolve/test/mock_sync.js

@@ -0,0 +1,214 @@
+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);
+                }
+                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')
+    );
+});
+
+test('readPackageSync', function (t) {
+    t.plan(3);
+
+    var files = {};
+    files[path.resolve('/foo/node_modules/bar/something-else.js')] = 'beep';
+    files[path.resolve('/foo/node_modules/bar/package.json')] = JSON.stringify({
+        main: './baz.js'
+    });
+    files[path.resolve('/foo/node_modules/bar/baz.js')] = 'boop';
+
+    var dirs = {};
+    dirs[path.resolve('/foo')] = true;
+    dirs[path.resolve('/foo/node_modules')] = true;
+
+    function opts(basedir, useReadPackage) {
+        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: useReadPackage ? null : function (file) {
+                return files[path.resolve(file)];
+            },
+            realpathSync: function (file) {
+                return file;
+            }
+        };
+    }
+    t.test('with readFile', function (st) {
+        st.plan(1);
+
+        st.equal(
+            resolve.sync('bar', opts('/foo')),
+            path.resolve('/foo/node_modules/bar/baz.js')
+        );
+    });
+
+    var readPackageSync = function (readFileSync, file) {
+        if (file.indexOf(path.join('bar', 'package.json')) >= 0) {
+            return { main: './something-else.js' };
+        }
+        return JSON.parse(files[path.resolve(file)]);
+    };
+
+    t.test('with readPackage', function (st) {
+        st.plan(1);
+
+        var options = opts('/foo');
+        delete options.readFileSync;
+        options.readPackageSync = readPackageSync;
+
+        st.equal(
+            resolve.sync('bar', options),
+            path.resolve('/foo/node_modules/bar/something-else.js')
+        );
+    });
+
+    t.test('with readFile and readPackage', function (st) {
+        st.plan(1);
+
+        var options = opts('/foo');
+        options.readPackageSync = readPackageSync;
+        st.throws(
+            function () { resolve.sync('bar', options); },
+            TypeError,
+            'errors when both readFile and readPackage are provided'
+        );
+    });
+});
+

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'));
+    });
+});

node_modules/resolve/test/module_dir/xmodules/aaa/index.js

@@ -0,0 +1 @@
+module.exports = function (x) { return x * 100; };

node_modules/resolve/test/module_dir/ymodules/aaa/index.js

@@ -0,0 +1 @@
+module.exports = function (x) { return x + 100; };

node_modules/resolve/test/module_dir/zmodules/bbb/main.js

@@ -0,0 +1 @@
+module.exports = function (n) { return n * 111; };

node_modules/resolve/test/module_dir/zmodules/bbb/package.json

@@ -0,0 +1,3 @@
+{
+  "main": "main.js"
+}

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();
+    });
+});

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; // eslint-disable-line global-require
+        t.error(err);
+        t.equal(res, path.resolve(__dirname, '..', 'node_modules/tap', root), 'tap resolves');
+    });
+});

node_modules/resolve/test/node_path/x/aaa/index.js

@@ -0,0 +1 @@
+module.exports = 'A';

node_modules/resolve/test/node_path/x/ccc/index.js

@@ -0,0 +1 @@
+module.exports = 'C';

node_modules/resolve/test/node_path/y/bbb/index.js

@@ -0,0 +1 @@
+module.exports = 'B';

node_modules/resolve/test/node_path/y/ccc/index.js

@@ -0,0 +1 @@
+module.exports = 'CY';

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);
+    });
+});

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();
+});

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);
+    });
+});

node_modules/resolve/test/precedence/aaa.js

@@ -0,0 +1 @@
+module.exports = 'wtf';

node_modules/resolve/test/precedence/aaa/index.js

@@ -0,0 +1 @@
+module.exports = 'okok';

node_modules/resolve/test/precedence/aaa/main.js

@@ -0,0 +1 @@
+console.log(require('./'));

node_modules/resolve/test/precedence/bbb.js

@@ -0,0 +1 @@
+module.exports = '>_<';

node_modules/resolve/test/precedence/bbb/main.js

@@ -0,0 +1 @@
+console.log(require('./')); // should throw

node_modules/resolve/test/resolver.js

@@ -0,0 +1,597 @@
+var path = require('path');
+var fs = require('fs');
+var test = require('tape');
+var resolve = require('../');
+var async = require('../async');
+
+test('`./async` entry point', function (t) {
+    t.equal(resolve, async, '`./async` entry point is the same as `main`');
+    t.end();
+});
+
+test('async foo', function (t) {
+    t.plan(12);
+    var dir = path.join(__dirname, 'resolver');
+
+    resolve('./foo', { basedir: dir }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'foo.js'));
+        t.equal(pkg && pkg.name, 'resolve');
+    });
+
+    resolve('./foo.js', { basedir: dir }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'foo.js'));
+        t.equal(pkg && pkg.name, 'resolve');
+    });
+
+    resolve('./foo', { basedir: dir, 'package': { main: 'resolver' } }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'foo.js'));
+        t.equal(pkg && pkg.main, 'resolver');
+    });
+
+    resolve('./foo.js', { basedir: dir, 'package': { main: 'resolver' } }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'foo.js'));
+        t.equal(pkg.main, 'resolver');
+    });
+
+    resolve('./foo', { basedir: dir, filename: path.join(dir, 'baz.js') }, function (err, res) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'foo.js'));
+    });
+
+    resolve('foo', { basedir: dir }, function (err) {
+        t.equal(err.message, "Cannot find module 'foo' from '" + path.resolve(dir) + "'");
+        t.equal(err.code, 'MODULE_NOT_FOUND');
+    });
+
+    // Test that filename is reported as the "from" value when passed.
+    resolve('foo', { basedir: dir, filename: path.join(dir, 'baz.js') }, function (err) {
+        t.equal(err.message, "Cannot find module 'foo' from '" + path.join(dir, 'baz.js') + "'");
+    });
+});
+
+test('bar', function (t) {
+    t.plan(6);
+    var dir = path.join(__dirname, 'resolver');
+
+    resolve('foo', { basedir: dir + '/bar' }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'bar/node_modules/foo/index.js'));
+        t.equal(pkg, undefined);
+    });
+
+    resolve('foo', { basedir: dir + '/bar' }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'bar/node_modules/foo/index.js'));
+        t.equal(pkg, undefined);
+    });
+
+    resolve('foo', { basedir: dir + '/bar', 'package': { main: 'bar' } }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'bar/node_modules/foo/index.js'));
+        t.equal(pkg.main, 'bar');
+    });
+});
+
+test('baz', function (t) {
+    t.plan(4);
+    var dir = path.join(__dirname, 'resolver');
+
+    resolve('./baz', { basedir: dir }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'baz/quux.js'));
+        t.equal(pkg.main, 'quux.js');
+    });
+
+    resolve('./baz', { basedir: dir, 'package': { main: 'resolver' } }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'baz/quux.js'));
+        t.equal(pkg.main, 'quux.js');
+    });
+});
+
+test('biz', function (t) {
+    t.plan(24);
+    var dir = path.join(__dirname, 'resolver/biz/node_modules');
+
+    resolve('./grux', { basedir: dir }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'grux/index.js'));
+        t.equal(pkg, undefined);
+    });
+
+    resolve('./grux', { basedir: dir, 'package': { main: 'biz' } }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'grux/index.js'));
+        t.equal(pkg.main, 'biz');
+    });
+
+    resolve('./garply', { basedir: dir }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'garply/lib/index.js'));
+        t.equal(pkg.main, './lib');
+    });
+
+    resolve('./garply', { basedir: dir, 'package': { main: 'biz' } }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'garply/lib/index.js'));
+        t.equal(pkg.main, './lib');
+    });
+
+    resolve('tiv', { basedir: dir + '/grux' }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'tiv/index.js'));
+        t.equal(pkg, undefined);
+    });
+
+    resolve('tiv', { basedir: dir + '/grux', 'package': { main: 'grux' } }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'tiv/index.js'));
+        t.equal(pkg.main, 'grux');
+    });
+
+    resolve('tiv', { basedir: dir + '/garply' }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'tiv/index.js'));
+        t.equal(pkg, undefined);
+    });
+
+    resolve('tiv', { basedir: dir + '/garply', 'package': { main: './lib' } }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'tiv/index.js'));
+        t.equal(pkg.main, './lib');
+    });
+
+    resolve('grux', { basedir: dir + '/tiv' }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'grux/index.js'));
+        t.equal(pkg, undefined);
+    });
+
+    resolve('grux', { basedir: dir + '/tiv', 'package': { main: 'tiv' } }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'grux/index.js'));
+        t.equal(pkg.main, 'tiv');
+    });
+
+    resolve('garply', { basedir: dir + '/tiv' }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'garply/lib/index.js'));
+        t.equal(pkg.main, './lib');
+    });
+
+    resolve('garply', { basedir: dir + '/tiv', 'package': { main: 'tiv' } }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'garply/lib/index.js'));
+        t.equal(pkg.main, './lib');
+    });
+});
+
+test('quux', function (t) {
+    t.plan(2);
+    var dir = path.join(__dirname, 'resolver/quux');
+
+    resolve('./foo', { basedir: dir, 'package': { main: 'quux' } }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'foo/index.js'));
+        t.equal(pkg.main, 'quux');
+    });
+});
+
+test('normalize', function (t) {
+    t.plan(2);
+    var dir = path.join(__dirname, 'resolver/biz/node_modules/grux');
+
+    resolve('../grux', { basedir: dir }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'index.js'));
+        t.equal(pkg, undefined);
+    });
+});
+
+test('cup', function (t) {
+    t.plan(5);
+    var dir = path.join(__dirname, 'resolver');
+
+    resolve('./cup', { basedir: dir, extensions: ['.js', '.coffee'] }, function (err, res) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'cup.coffee'));
+    });
+
+    resolve('./cup.coffee', { basedir: dir }, function (err, res) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'cup.coffee'));
+    });
+
+    resolve('./cup', { basedir: dir, extensions: ['.js'] }, function (err, res) {
+        t.equal(err.message, "Cannot find module './cup' from '" + path.resolve(dir) + "'");
+        t.equal(err.code, 'MODULE_NOT_FOUND');
+    });
+
+    // Test that filename is reported as the "from" value when passed.
+    resolve('./cup', { basedir: dir, extensions: ['.js'], filename: path.join(dir, 'cupboard.js') }, function (err, res) {
+        t.equal(err.message, "Cannot find module './cup' from '" + path.join(dir, 'cupboard.js') + "'");
+    });
+});
+
+test('mug', function (t) {
+    t.plan(3);
+    var dir = path.join(__dirname, 'resolver');
+
+    resolve('./mug', { basedir: dir }, function (err, res) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'mug.js'));
+    });
+
+    resolve('./mug', { basedir: dir, extensions: ['.coffee', '.js'] }, function (err, res) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, '/mug.coffee'));
+    });
+
+    resolve('./mug', { basedir: dir, extensions: ['.js', '.coffee'] }, function (err, res) {
+        t.equal(res, path.join(dir, '/mug.js'));
+    });
+});
+
+test('other path', function (t) {
+    t.plan(6);
+    var resolverDir = path.join(__dirname, 'resolver');
+    var dir = path.join(resolverDir, 'bar');
+    var otherDir = path.join(resolverDir, 'other_path');
+
+    resolve('root', { basedir: dir, paths: [otherDir] }, function (err, res) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(resolverDir, 'other_path/root.js'));
+    });
+
+    resolve('lib/other-lib', { basedir: dir, paths: [otherDir] }, function (err, res) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(resolverDir, 'other_path/lib/other-lib.js'));
+    });
+
+    resolve('root', { basedir: dir }, function (err, res) {
+        t.equal(err.message, "Cannot find module 'root' from '" + path.resolve(dir) + "'");
+        t.equal(err.code, 'MODULE_NOT_FOUND');
+    });
+
+    resolve('zzz', { basedir: dir, paths: [otherDir] }, function (err, res) {
+        t.equal(err.message, "Cannot find module 'zzz' from '" + path.resolve(dir) + "'");
+        t.equal(err.code, 'MODULE_NOT_FOUND');
+    });
+});
+
+test('path iterator', function (t) {
+    t.plan(2);
+
+    var resolverDir = path.join(__dirname, 'resolver');
+
+    var exactIterator = function (x, start, getPackageCandidates, opts) {
+        return [path.join(resolverDir, x)];
+    };
+
+    resolve('baz', { packageIterator: exactIterator }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(resolverDir, 'baz/quux.js'));
+        t.equal(pkg && pkg.name, 'baz');
+    });
+});
+
+test('incorrect main', function (t) {
+    t.plan(1);
+
+    var resolverDir = path.join(__dirname, 'resolver');
+    var dir = path.join(resolverDir, 'incorrect_main');
+
+    resolve('./incorrect_main', { basedir: resolverDir }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'index.js'));
+    });
+});
+
+test('missing index', function (t) {
+    t.plan(2);
+
+    var resolverDir = path.join(__dirname, 'resolver');
+    resolve('./missing_index', { basedir: resolverDir }, function (err, res, pkg) {
+        t.ok(err instanceof Error);
+        t.equal(err && err.code, 'MODULE_NOT_FOUND', 'error has correct error code');
+    });
+});
+
+test('missing main', function (t) {
+    t.plan(1);
+
+    var resolverDir = path.join(__dirname, 'resolver');
+
+    resolve('./missing_main', { basedir: resolverDir }, function (err, res, pkg) {
+        t.equal(err && err.code, 'MODULE_NOT_FOUND', 'error has correct error code');
+    });
+});
+
+test('null main', function (t) {
+    t.plan(1);
+
+    var resolverDir = path.join(__dirname, 'resolver');
+
+    resolve('./null_main', { basedir: resolverDir }, function (err, res, pkg) {
+        t.equal(err && err.code, 'MODULE_NOT_FOUND', 'error has correct error code');
+    });
+});
+
+test('main: false', function (t) {
+    t.plan(2);
+
+    var basedir = path.join(__dirname, 'resolver');
+    var dir = path.join(basedir, 'false_main');
+    resolve('./false_main', { basedir: basedir }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(
+            res,
+            path.join(dir, 'index.js'),
+            '`"main": false`: resolves to `index.js`'
+        );
+        t.deepEqual(pkg, {
+            name: 'false_main',
+            main: false
+        });
+    });
+});
+
+test('without basedir', function (t) {
+    t.plan(1);
+
+    var dir = path.join(__dirname, 'resolver/without_basedir');
+    var tester = require(path.join(dir, 'main.js')); // eslint-disable-line global-require
+
+    tester(t, function (err, res, pkg) {
+        if (err) {
+            t.fail(err);
+        } else {
+            t.equal(res, path.join(dir, 'node_modules/mymodule.js'));
+        }
+    });
+});
+
+test('#52 - incorrectly resolves module-paths like "./someFolder/" when there is a file of the same name', function (t) {
+    t.plan(2);
+
+    var dir = path.join(__dirname, 'resolver');
+
+    resolve('./foo', { basedir: path.join(dir, 'same_names') }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'same_names/foo.js'));
+    });
+
+    resolve('./foo/', { basedir: path.join(dir, 'same_names') }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'same_names/foo/index.js'));
+    });
+});
+
+test('#211 - incorrectly resolves module-paths like "." when from inside a folder with a sibling file of the same name', function (t) {
+    t.plan(2);
+
+    var dir = path.join(__dirname, 'resolver');
+
+    resolve('./', { basedir: path.join(dir, 'same_names/foo') }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'same_names/foo/index.js'));
+    });
+
+    resolve('.', { basedir: path.join(dir, 'same_names/foo') }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'same_names/foo/index.js'));
+    });
+});
+
+test('async: #121 - treating an existing file as a dir when no basedir', function (t) {
+    var testFile = path.basename(__filename);
+
+    t.test('sanity check', function (st) {
+        st.plan(1);
+        resolve('./' + testFile, function (err, res, pkg) {
+            if (err) t.fail(err);
+            st.equal(res, __filename, 'sanity check');
+        });
+    });
+
+    t.test('with a fake directory', function (st) {
+        st.plan(4);
+
+        resolve('./' + testFile + '/blah', function (err, res, pkg) {
+            st.ok(err, 'there is an error');
+            st.notOk(res, 'no result');
+
+            st.equal(err && err.code, 'MODULE_NOT_FOUND', 'error code matches require.resolve');
+            st.equal(
+                err && err.message,
+                'Cannot find module \'./' + testFile + '/blah\' from \'' + __dirname + '\'',
+                'can not find nonexistent module'
+            );
+            st.end();
+        });
+    });
+
+    t.end();
+});
+
+test('async dot main', function (t) {
+    var start = new Date();
+    t.plan(3);
+    resolve('./resolver/dot_main', function (err, ret) {
+        t.notOk(err);
+        t.equal(ret, path.join(__dirname, 'resolver/dot_main/index.js'));
+        t.ok(new Date() - start < 50, 'resolve.sync timedout');
+        t.end();
+    });
+});
+
+test('async dot slash main', function (t) {
+    var start = new Date();
+    t.plan(3);
+    resolve('./resolver/dot_slash_main', function (err, ret) {
+        t.notOk(err);
+        t.equal(ret, path.join(__dirname, 'resolver/dot_slash_main/index.js'));
+        t.ok(new Date() - start < 50, 'resolve.sync timedout');
+        t.end();
+    });
+});
+
+test('not a directory', function (t) {
+    t.plan(6);
+    var path = './foo';
+    resolve(path, { basedir: __filename }, function (err, res, pkg) {
+        t.ok(err, 'a non-directory errors');
+        t.equal(arguments.length, 1);
+        t.equal(res, undefined);
+        t.equal(pkg, undefined);
+
+        t.equal(err && err.message, 'Cannot find module \'' + path + '\' from \'' + __filename + '\'');
+        t.equal(err && err.code, 'MODULE_NOT_FOUND');
+    });
+});
+
+test('non-string "main" field in package.json', function (t) {
+    t.plan(5);
+
+    var dir = path.join(__dirname, 'resolver');
+    resolve('./invalid_main', { basedir: dir }, function (err, res, pkg) {
+        t.ok(err, 'errors on non-string main');
+        t.equal(err.message, 'package “invalid_main” `main` must be a string');
+        t.equal(err.code, 'INVALID_PACKAGE_MAIN');
+        t.equal(res, undefined, 'res is undefined');
+        t.equal(pkg, undefined, 'pkg is undefined');
+    });
+});
+
+test('non-string "main" field in package.json', function (t) {
+    t.plan(5);
+
+    var dir = path.join(__dirname, 'resolver');
+    resolve('./invalid_main', { basedir: dir }, function (err, res, pkg) {
+        t.ok(err, 'errors on non-string main');
+        t.equal(err.message, 'package “invalid_main” `main` must be a string');
+        t.equal(err.code, 'INVALID_PACKAGE_MAIN');
+        t.equal(res, undefined, 'res is undefined');
+        t.equal(pkg, undefined, 'pkg is undefined');
+    });
+});
+
+test('browser field in package.json', function (t) {
+    t.plan(3);
+
+    var dir = path.join(__dirname, 'resolver');
+    resolve(
+        './browser_field',
+        {
+            basedir: dir,
+            packageFilter: function packageFilter(pkg) {
+                if (pkg.browser) {
+                    pkg.main = pkg.browser; // eslint-disable-line no-param-reassign
+                    delete pkg.browser; // eslint-disable-line no-param-reassign
+                }
+                return pkg;
+            }
+        },
+        function (err, res, pkg) {
+            if (err) t.fail(err);
+            t.equal(res, path.join(dir, 'browser_field', 'b.js'));
+            t.equal(pkg && pkg.main, 'b');
+            t.equal(pkg && pkg.browser, undefined);
+        }
+    );
+});
+
+test('absolute paths', function (t) {
+    t.plan(4);
+
+    var extensionless = __filename.slice(0, -path.extname(__filename).length);
+
+    resolve(__filename, function (err, res) {
+        t.equal(
+            res,
+            __filename,
+            'absolute path to this file resolves'
+        );
+    });
+    resolve(extensionless, function (err, res) {
+        t.equal(
+            res,
+            __filename,
+            'extensionless absolute path to this file resolves'
+        );
+    });
+    resolve(__filename, { basedir: process.cwd() }, function (err, res) {
+        t.equal(
+            res,
+            __filename,
+            'absolute path to this file with a basedir resolves'
+        );
+    });
+    resolve(extensionless, { basedir: process.cwd() }, function (err, res) {
+        t.equal(
+            res,
+            __filename,
+            'extensionless absolute path to this file with a basedir resolves'
+        );
+    });
+});
+
+var malformedDir = path.join(__dirname, 'resolver/malformed_package_json');
+test('malformed package.json', { skip: !fs.existsSync(malformedDir) }, function (t) {
+    /* eslint operator-linebreak: ["error", "before"], function-paren-newline: "off" */
+    t.plan(
+        (3 * 3) // 3 sets of 3 assertions in the final callback
+        + 2 // 1 readPackage call with malformed package.json
+    );
+
+    var basedir = malformedDir;
+    var expected = path.join(basedir, 'index.js');
+
+    resolve('./index.js', { basedir: basedir }, function (err, res, pkg) {
+        t.error(err, 'no error');
+        t.equal(res, expected, 'malformed package.json is silently ignored');
+        t.equal(pkg, undefined, 'malformed package.json gives an undefined `pkg` argument');
+    });
+
+    resolve(
+        './index.js',
+        {
+            basedir: basedir,
+            packageFilter: function (pkg, pkgfile, dir) {
+                t.fail('should not reach here');
+            }
+        },
+        function (err, res, pkg) {
+            t.error(err, 'with packageFilter: no error');
+            t.equal(res, expected, 'with packageFilter: malformed package.json is silently ignored');
+            t.equal(pkg, undefined, 'with packageFilter: malformed package.json gives an undefined `pkg` argument');
+        }
+    );
+
+    resolve(
+        './index.js',
+        {
+            basedir: basedir,
+            readPackage: function (readFile, pkgfile, cb) {
+                t.equal(pkgfile, path.join(basedir, 'package.json'), 'readPackageSync: `pkgfile` is package.json path');
+                readFile(pkgfile, function (err, result) {
+                    try {
+                        cb(null, JSON.parse(result));
+                    } catch (e) {
+                        t.ok(e instanceof SyntaxError, 'readPackage: malformed package.json parses as a syntax error');
+                        cb(null);
+                    }
+                });
+            }
+        },
+        function (err, res, pkg) {
+            t.error(err, 'with readPackage: no error');
+            t.equal(res, expected, 'with readPackage: malformed package.json is silently ignored');
+            t.equal(pkg, undefined, 'with readPackage: malformed package.json gives an undefined `pkg` argument');
+        }
+    );
+});

node_modules/resolve/test/resolver/baz/package.json

@@ -0,0 +1,4 @@
+{
+    "name": "baz",
+    "main": "quux.js"
+}

node_modules/resolve/test/resolver/baz/quux.js

@@ -0,0 +1 @@
+module.exports = 1;

node_modules/resolve/test/resolver/browser_field/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "browser_field",
+  "main": "a",
+  "browser": "b"
+}

node_modules/resolve/test/resolver/cup.coffee

@@ -0,0 +1 @@
+

node_modules/resolve/test/resolver/dot_main/index.js

@@ -0,0 +1 @@
+module.exports = 1;

node_modules/resolve/test/resolver/dot_main/package.json

@@ -0,0 +1,3 @@
+{
+    "main": "."
+}

node_modules/resolve/test/resolver/dot_slash_main/index.js

@@ -0,0 +1 @@
+module.exports = 1;

node_modules/resolve/test/resolver/dot_slash_main/package.json

@@ -0,0 +1,3 @@
+{
+    "main": "./"
+}

node_modules/resolve/test/resolver/false_main/package.json

@@ -0,0 +1,4 @@
+{
+	"name": "false_main",
+	"main": false
+}

node_modules/resolve/test/resolver/foo.js

@@ -0,0 +1 @@
+module.exports = 1;

node_modules/resolve/test/resolver/incorrect_main/index.js

@@ -0,0 +1,2 @@
+// this is the actual main file 'index.js', not 'wrong.js' like the package.json would indicate
+module.exports = 1;

node_modules/resolve/test/resolver/incorrect_main/package.json

@@ -0,0 +1,3 @@
+{
+    "main": "wrong.js"
+}

node_modules/resolve/test/resolver/invalid_main/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "invalid_main",
+  "main": [
+    "why is this a thing",
+    "srsly omg wtf"
+  ]
+}

node_modules/resolve/test/resolver/multirepo/lerna.json

@@ -0,0 +1,6 @@
+{
+  "packages": [
+    "packages/*"
+  ],
+  "version": "0.0.0"
+}

node_modules/resolve/test/resolver/multirepo/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "ljharb-monorepo-symlink-test",
+  "private": true,
+  "version": "0.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "postinstall": "lerna bootstrap",
+    "test": "node packages/package-a"
+  },
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "jquery": "^3.3.1",
+    "resolve": "../../../"
+  },
+  "devDependencies": {
+    "lerna": "^3.4.3"
+  }
+}

node_modules/resolve/test/resolver/multirepo/packages/package-a/index.js

@@ -0,0 +1,35 @@
+'use strict';
+
+var assert = require('assert');
+var path = require('path');
+var resolve = require('resolve');
+
+var basedir = __dirname + '/node_modules/@my-scope/package-b';
+
+var expected = path.join(__dirname, '../../node_modules/jquery/dist/jquery.js');
+
+/*
+ * preserveSymlinks === false
+ * will search NPM package from
+ * - packages/package-b/node_modules
+ * - packages/node_modules
+ * - node_modules
+ */
+assert.equal(resolve.sync('jquery', { basedir: basedir, preserveSymlinks: false }), expected);
+assert.equal(resolve.sync('../../node_modules/jquery', { basedir: basedir, preserveSymlinks: false }), expected);
+
+/*
+ * preserveSymlinks === true
+ * will search NPM package from
+ * - packages/package-a/node_modules/@my-scope/packages/package-b/node_modules
+ * - packages/package-a/node_modules/@my-scope/packages/node_modules
+ * - packages/package-a/node_modules/@my-scope/node_modules
+ * - packages/package-a/node_modules/node_modules
+ * - packages/package-a/node_modules
+ * - packages/node_modules
+ * - node_modules
+ */
+assert.equal(resolve.sync('jquery', { basedir: basedir, preserveSymlinks: true }), expected);
+assert.equal(resolve.sync('../../../../../node_modules/jquery', { basedir: basedir, preserveSymlinks: true }), expected);
+
+console.log(' * all monorepo paths successfully resolved through symlinks');

node_modules/resolve/test/resolver/multirepo/packages/package-a/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@my-scope/package-a",
+  "version": "0.0.0",
+  "private": true,
+  "description": "",
+  "license": "MIT",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: run tests from root\" && exit 1"
+  },
+  "dependencies": {
+    "@my-scope/package-b": "^0.0.0"
+  }
+}

node_modules/resolve/test/resolver/multirepo/packages/package-b/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@my-scope/package-b",
+  "private": true,
+  "version": "0.0.0",
+  "description": "",
+  "license": "MIT",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: run tests from root\" && exit 1"
+  },
+  "dependencies": {
+    "@my-scope/package-a": "^0.0.0"
+  }
+}

node_modules/resolve/test/resolver/nested_symlinks/mylib/async.js

@@ -0,0 +1,26 @@
+var a = require.resolve('buffer/').replace(process.cwd(), '$CWD');
+var b;
+var c;
+
+var test = function test() {
+    console.log(a, ': require.resolve, preserveSymlinks ' + (process.execArgv.indexOf('preserve-symlinks') > -1 ? 'true' : 'false'));
+    console.log(b, ': preserveSymlinks true');
+    console.log(c, ': preserveSymlinks false');
+
+    if (a !== b && a !== c) {
+        throw 'async: no match';
+    }
+    console.log('async: success! a matched either b or c\n');
+};
+
+require('resolve')('buffer/', { preserveSymlinks: true }, function (err, result) {
+    if (err) { throw err; }
+    b = result.replace(process.cwd(), '$CWD');
+    if (b && c) { test(); }
+});
+require('resolve')('buffer/', { preserveSymlinks: false }, function (err, result) {
+    if (err) { throw err; }
+    c = result.replace(process.cwd(), '$CWD');
+    if (b && c) { test(); }
+});
+

node_modules/resolve/test/resolver/nested_symlinks/mylib/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "mylib",
+  "version": "0.0.0",
+  "description": "",
+  "private": true,
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "buffer": "*"
+  }
+}

node_modules/resolve/test/resolver/nested_symlinks/mylib/sync.js

@@ -0,0 +1,12 @@
+var a = require.resolve('buffer/').replace(process.cwd(), '$CWD');
+var b = require('resolve').sync('buffer/', { preserveSymlinks: true }).replace(process.cwd(), '$CWD');
+var c = require('resolve').sync('buffer/', { preserveSymlinks: false }).replace(process.cwd(), '$CWD');
+
+console.log(a, ': require.resolve, preserveSymlinks ' + (process.execArgv.indexOf('preserve-symlinks') > -1 ? 'true' : 'false'));
+console.log(b, ': preserveSymlinks true');
+console.log(c, ': preserveSymlinks false');
+
+if (a !== b && a !== c) {
+    throw 'sync: no match';
+}
+console.log('sync: success! a matched either b or c\n');

node_modules/resolve/test/resolver/quux/foo/index.js

@@ -0,0 +1 @@
+module.exports = 1;

node_modules/resolve/test/resolver/same_names/foo.js

@@ -0,0 +1 @@
+module.exports = 42;

node_modules/resolve/test/resolver/same_names/foo/index.js

@@ -0,0 +1 @@
+module.exports = 1;

node_modules/resolve/test/resolver/symlinked/package/bar.js

@@ -0,0 +1 @@
+module.exports = 'bar';

node_modules/resolve/test/resolver/symlinked/package/package.json

@@ -0,0 +1,3 @@
+{
+    "main": "bar.js"
+}

node_modules/resolve/test/resolver/without_basedir/main.js

@@ -0,0 +1,5 @@
+var resolve = require('../../../');
+
+module.exports = function (t, cb) {
+    resolve('mymodule', null, cb);
+};

node_modules/resolve/test/resolver_sync.js

@@ -0,0 +1,730 @@
+var path = require('path');
+var fs = require('fs');
+var test = require('tape');
+
+var resolve = require('../');
+var sync = require('../sync');
+
+var requireResolveSupportsPaths = require.resolve.length > 1
+    && !(/^v12\.[012]\./).test(process.version); // broken in v12.0-12.2, see https://github.com/nodejs/node/issues/27794
+
+var requireResolveDefaultPathsBroken = (/^v8\.9\.|^v9\.[01]\.0|^v9\.2\./).test(process.version);
+// broken in node v8.9.x, v9.0, v9.1, v9.2.x. see https://github.com/nodejs/node/pull/17113
+
+test('`./sync` entry point', function (t) {
+    t.equal(resolve.sync, sync, '`./sync` entry point is the same as `.sync` on `main`');
+    t.end();
+});
+
+test('foo', function (t) {
+    var dir = path.join(__dirname, 'resolver');
+
+    t.equal(
+        resolve.sync('./foo', { basedir: dir }),
+        path.join(dir, 'foo.js'),
+        './foo'
+    );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./foo', { basedir: dir }),
+            require.resolve('./foo', { paths: [dir] }),
+            './foo: resolve.sync === require.resolve'
+        );
+    }
+
+    t.equal(
+        resolve.sync('./foo.js', { basedir: dir }),
+        path.join(dir, 'foo.js'),
+        './foo.js'
+    );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./foo.js', { basedir: dir }),
+            require.resolve('./foo.js', { paths: [dir] }),
+            './foo.js: resolve.sync === require.resolve'
+        );
+    }
+
+    t.equal(
+        resolve.sync('./foo.js', { basedir: dir, filename: path.join(dir, 'bar.js') }),
+        path.join(dir, 'foo.js')
+    );
+
+    t.throws(function () {
+        resolve.sync('foo', { basedir: dir });
+    });
+
+    // Test that filename is reported as the "from" value when passed.
+    t.throws(
+        function () {
+            resolve.sync('foo', { basedir: dir, filename: path.join(dir, 'bar.js') });
+        },
+        {
+            name: 'Error',
+            message: "Cannot find module 'foo' from '" + path.join(dir, 'bar.js') + "'"
+        }
+    );
+
+    t.end();
+});
+
+test('bar', function (t) {
+    var dir = path.join(__dirname, 'resolver');
+
+    var basedir = path.join(dir, 'bar');
+
+    t.equal(
+        resolve.sync('foo', { basedir: basedir }),
+        path.join(dir, 'bar/node_modules/foo/index.js'),
+        'foo in bar'
+    );
+    if (!requireResolveDefaultPathsBroken && requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('foo', { basedir: basedir }),
+            require.resolve('foo', { paths: [basedir] }),
+            'foo in bar: resolve.sync === require.resolve'
+        );
+    }
+
+    t.end();
+});
+
+test('baz', function (t) {
+    var dir = path.join(__dirname, 'resolver');
+
+    t.equal(
+        resolve.sync('./baz', { basedir: dir }),
+        path.join(dir, 'baz/quux.js'),
+        './baz'
+    );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./baz', { basedir: dir }),
+            require.resolve('./baz', { paths: [dir] }),
+            './baz: resolve.sync === require.resolve'
+        );
+    }
+
+    t.end();
+});
+
+test('biz', function (t) {
+    var dir = path.join(__dirname, 'resolver/biz/node_modules');
+
+    t.equal(
+        resolve.sync('./grux', { basedir: dir }),
+        path.join(dir, 'grux/index.js')
+    );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./grux', { basedir: dir }),
+            require.resolve('./grux', { paths: [dir] }),
+            './grux: resolve.sync === require.resolve'
+        );
+    }
+
+    var tivDir = path.join(dir, 'grux');
+    t.equal(
+        resolve.sync('tiv', { basedir: tivDir }),
+        path.join(dir, 'tiv/index.js')
+    );
+    if (!requireResolveDefaultPathsBroken && requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('tiv', { basedir: tivDir }),
+            require.resolve('tiv', { paths: [tivDir] }),
+            'tiv: resolve.sync === require.resolve'
+        );
+    }
+
+    var gruxDir = path.join(dir, 'tiv');
+    t.equal(
+        resolve.sync('grux', { basedir: gruxDir }),
+        path.join(dir, 'grux/index.js')
+    );
+    if (!requireResolveDefaultPathsBroken && requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('grux', { basedir: gruxDir }),
+            require.resolve('grux', { paths: [gruxDir] }),
+            'grux: resolve.sync === require.resolve'
+        );
+    }
+
+    t.end();
+});
+
+test('normalize', function (t) {
+    var dir = path.join(__dirname, 'resolver/biz/node_modules/grux');
+
+    t.equal(
+        resolve.sync('../grux', { basedir: dir }),
+        path.join(dir, 'index.js')
+    );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('../grux', { basedir: dir }),
+            require.resolve('../grux', { paths: [dir] }),
+            '../grux: resolve.sync === require.resolve'
+        );
+    }
+
+    t.end();
+});
+
+test('cup', function (t) {
+    var dir = path.join(__dirname, 'resolver');
+
+    t.equal(
+        resolve.sync('./cup', {
+            basedir: dir,
+            extensions: ['.js', '.coffee']
+        }),
+        path.join(dir, 'cup.coffee'),
+        './cup -> ./cup.coffee'
+    );
+
+    t.equal(
+        resolve.sync('./cup.coffee', { basedir: dir }),
+        path.join(dir, 'cup.coffee'),
+        './cup.coffee'
+    );
+
+    t.throws(function () {
+        resolve.sync('./cup', {
+            basedir: dir,
+            extensions: ['.js']
+        });
+    });
+
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./cup.coffee', { basedir: dir, extensions: ['.js', '.coffee'] }),
+            require.resolve('./cup.coffee', { paths: [dir] }),
+            './cup.coffee: resolve.sync === require.resolve'
+        );
+    }
+
+    t.end();
+});
+
+test('mug', function (t) {
+    var dir = path.join(__dirname, 'resolver');
+
+    t.equal(
+        resolve.sync('./mug', { basedir: dir }),
+        path.join(dir, 'mug.js'),
+        './mug -> ./mug.js'
+    );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./mug', { basedir: dir }),
+            require.resolve('./mug', { paths: [dir] }),
+            './mug: resolve.sync === require.resolve'
+        );
+    }
+
+    t.equal(
+        resolve.sync('./mug', {
+            basedir: dir,
+            extensions: ['.coffee', '.js']
+        }),
+        path.join(dir, 'mug.coffee'),
+        './mug -> ./mug.coffee'
+    );
+
+    t.equal(
+        resolve.sync('./mug', {
+            basedir: dir,
+            extensions: ['.js', '.coffee']
+        }),
+        path.join(dir, 'mug.js'),
+        './mug -> ./mug.js'
+    );
+
+    t.end();
+});
+
+test('other path', function (t) {
+    var resolverDir = path.join(__dirname, 'resolver');
+    var dir = path.join(resolverDir, 'bar');
+    var otherDir = path.join(resolverDir, 'other_path');
+
+    t.equal(
+        resolve.sync('root', {
+            basedir: dir,
+            paths: [otherDir]
+        }),
+        path.join(resolverDir, 'other_path/root.js')
+    );
+
+    t.equal(
+        resolve.sync('lib/other-lib', {
+            basedir: dir,
+            paths: [otherDir]
+        }),
+        path.join(resolverDir, 'other_path/lib/other-lib.js')
+    );
+
+    t.throws(function () {
+        resolve.sync('root', { basedir: dir });
+    });
+
+    t.throws(function () {
+        resolve.sync('zzz', {
+            basedir: dir,
+            paths: [otherDir]
+        });
+    });
+
+    t.end();
+});
+
+test('path iterator', function (t) {
+    var resolverDir = path.join(__dirname, 'resolver');
+
+    var exactIterator = function (x, start, getPackageCandidates, opts) {
+        return [path.join(resolverDir, x)];
+    };
+
+    t.equal(
+        resolve.sync('baz', { packageIterator: exactIterator }),
+        path.join(resolverDir, 'baz/quux.js')
+    );
+
+    t.end();
+});
+
+test('incorrect main', function (t) {
+    var resolverDir = path.join(__dirname, 'resolver');
+    var dir = path.join(resolverDir, 'incorrect_main');
+
+    t.equal(
+        resolve.sync('./incorrect_main', { basedir: resolverDir }),
+        path.join(dir, 'index.js')
+    );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./incorrect_main', { basedir: resolverDir }),
+            require.resolve('./incorrect_main', { paths: [resolverDir] }),
+            './incorrect_main: resolve.sync === require.resolve'
+        );
+    }
+
+    t.end();
+});
+
+test('missing index', function (t) {
+    t.plan(requireResolveSupportsPaths ? 2 : 1);
+
+    var resolverDir = path.join(__dirname, 'resolver');
+    try {
+        resolve.sync('./missing_index', { basedir: resolverDir });
+        t.fail('did not fail');
+    } catch (err) {
+        t.equal(err && err.code, 'MODULE_NOT_FOUND', 'error has correct error code');
+    }
+    if (requireResolveSupportsPaths) {
+        try {
+            require.resolve('./missing_index', { basedir: resolverDir });
+            t.fail('require.resolve did not fail');
+        } catch (err) {
+            t.equal(err && err.code, 'MODULE_NOT_FOUND', 'error has correct error code');
+        }
+    }
+});
+
+test('missing main', function (t) {
+    var resolverDir = path.join(__dirname, 'resolver');
+
+    try {
+        resolve.sync('./missing_main', { basedir: resolverDir });
+        t.fail('require.resolve did not fail');
+    } catch (err) {
+        t.equal(err && err.code, 'MODULE_NOT_FOUND', 'error has correct error code');
+    }
+    if (requireResolveSupportsPaths) {
+        try {
+            resolve.sync('./missing_main', { basedir: resolverDir });
+            t.fail('require.resolve did not fail');
+        } catch (err) {
+            t.equal(err && err.code, 'MODULE_NOT_FOUND', 'error has correct error code');
+        }
+    }
+
+    t.end();
+});
+
+test('null main', function (t) {
+    var resolverDir = path.join(__dirname, 'resolver');
+
+    try {
+        resolve.sync('./null_main', { basedir: resolverDir });
+        t.fail('require.resolve did not fail');
+    } catch (err) {
+        t.equal(err && err.code, 'MODULE_NOT_FOUND', 'error has correct error code');
+    }
+    if (requireResolveSupportsPaths) {
+        try {
+            resolve.sync('./null_main', { basedir: resolverDir });
+            t.fail('require.resolve did not fail');
+        } catch (err) {
+            t.equal(err && err.code, 'MODULE_NOT_FOUND', 'error has correct error code');
+        }
+    }
+
+    t.end();
+});
+
+test('main: false', function (t) {
+    var basedir = path.join(__dirname, 'resolver');
+    var dir = path.join(basedir, 'false_main');
+    t.equal(
+        resolve.sync('./false_main', { basedir: basedir }),
+        path.join(dir, 'index.js'),
+        '`"main": false`: resolves to `index.js`'
+    );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./false_main', { basedir: basedir }),
+            require.resolve('./false_main', { paths: [basedir] }),
+            '`"main": false`: resolve.sync === require.resolve'
+        );
+    }
+
+    t.end();
+});
+
+var stubStatSync = function stubStatSync(fn) {
+    var statSync = fs.statSync;
+    try {
+        fs.statSync = function () {
+            throw new EvalError('Unknown Error');
+        };
+        return fn();
+    } finally {
+        fs.statSync = statSync;
+    }
+};
+
+test('#79 - re-throw non ENOENT errors from stat', function (t) {
+    var dir = path.join(__dirname, 'resolver');
+
+    stubStatSync(function () {
+        t.throws(function () {
+            resolve.sync('foo', { basedir: dir });
+        }, /Unknown Error/);
+    });
+
+    t.end();
+});
+
+test('#52 - incorrectly resolves module-paths like "./someFolder/" when there is a file of the same name', function (t) {
+    var dir = path.join(__dirname, 'resolver');
+    var basedir = path.join(dir, 'same_names');
+
+    t.equal(
+        resolve.sync('./foo', { basedir: basedir }),
+        path.join(dir, 'same_names/foo.js')
+    );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./foo', { basedir: basedir }),
+            require.resolve('./foo', { paths: [basedir] }),
+            './foo: resolve.sync === require.resolve'
+        );
+    }
+
+    t.equal(
+        resolve.sync('./foo/', { basedir: basedir }),
+        path.join(dir, 'same_names/foo/index.js')
+    );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./foo/', { basedir: basedir }),
+            require.resolve('./foo/', { paths: [basedir] }),
+            './foo/: resolve.sync === require.resolve'
+        );
+    }
+
+    t.end();
+});
+
+test('#211 - incorrectly resolves module-paths like "." when from inside a folder with a sibling file of the same name', function (t) {
+    var dir = path.join(__dirname, 'resolver');
+    var basedir = path.join(dir, 'same_names/foo');
+
+    t.equal(
+        resolve.sync('./', { basedir: basedir }),
+        path.join(dir, 'same_names/foo/index.js'),
+        './'
+    );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./', { basedir: basedir }),
+            require.resolve('./', { paths: [basedir] }),
+            './: resolve.sync === require.resolve'
+        );
+    }
+
+    t.equal(
+        resolve.sync('.', { basedir: basedir }),
+        path.join(dir, 'same_names/foo/index.js'),
+        '.'
+    );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('.', { basedir: basedir }),
+            require.resolve('.', { paths: [basedir] }),
+            '.: resolve.sync === require.resolve',
+            { todo: true }
+        );
+    }
+
+    t.end();
+});
+
+test('sync: #121 - treating an existing file as a dir when no basedir', function (t) {
+    var testFile = path.basename(__filename);
+
+    t.test('sanity check', function (st) {
+        st.equal(
+            resolve.sync('./' + testFile),
+            __filename,
+            'sanity check'
+        );
+        st.equal(
+            resolve.sync('./' + testFile),
+            require.resolve('./' + testFile),
+            'sanity check: resolve.sync === require.resolve'
+        );
+
+        st.end();
+    });
+
+    t.test('with a fake directory', function (st) {
+        function run() { return resolve.sync('./' + testFile + '/blah'); }
+
+        st.throws(run, 'throws an error');
+
+        try {
+            run();
+        } catch (e) {
+            st.equal(e.code, 'MODULE_NOT_FOUND', 'error code matches require.resolve');
+            st.equal(
+                e.message,
+                'Cannot find module \'./' + testFile + '/blah\' from \'' + __dirname + '\'',
+                'can not find nonexistent module'
+            );
+        }
+
+        st.end();
+    });
+
+    t.end();
+});
+
+test('sync dot main', function (t) {
+    var start = new Date();
+
+    t.equal(
+        resolve.sync('./resolver/dot_main'),
+        path.join(__dirname, 'resolver/dot_main/index.js'),
+        './resolver/dot_main'
+    );
+    t.equal(
+        resolve.sync('./resolver/dot_main'),
+        require.resolve('./resolver/dot_main'),
+        './resolver/dot_main: resolve.sync === require.resolve'
+    );
+
+    t.ok(new Date() - start < 50, 'resolve.sync timedout');
+
+    t.end();
+});
+
+test('sync dot slash main', function (t) {
+    var start = new Date();
+
+    t.equal(
+        resolve.sync('./resolver/dot_slash_main'),
+        path.join(__dirname, 'resolver/dot_slash_main/index.js')
+    );
+    t.equal(
+        resolve.sync('./resolver/dot_slash_main'),
+        require.resolve('./resolver/dot_slash_main'),
+        './resolver/dot_slash_main: resolve.sync === require.resolve'
+    );
+
+    t.ok(new Date() - start < 50, 'resolve.sync timedout');
+
+    t.end();
+});
+
+test('not a directory', function (t) {
+    var path = './foo';
+    try {
+        resolve.sync(path, { basedir: __filename });
+        t.fail();
+    } catch (err) {
+        t.ok(err, 'a non-directory errors');
+        t.equal(err && err.message, 'Cannot find module \'' + path + "' from '" + __filename + "'");
+        t.equal(err && err.code, 'MODULE_NOT_FOUND');
+    }
+    t.end();
+});
+
+test('non-string "main" field in package.json', function (t) {
+    var dir = path.join(__dirname, 'resolver');
+    try {
+        var result = resolve.sync('./invalid_main', { basedir: dir });
+        t.equal(result, undefined, 'result should not exist');
+        t.fail('should not get here');
+    } catch (err) {
+        t.ok(err, 'errors on non-string main');
+        t.equal(err.message, 'package “invalid_main” `main` must be a string');
+        t.equal(err.code, 'INVALID_PACKAGE_MAIN');
+    }
+    t.end();
+});
+
+test('non-string "main" field in package.json', function (t) {
+    var dir = path.join(__dirname, 'resolver');
+    try {
+        var result = resolve.sync('./invalid_main', { basedir: dir });
+        t.equal(result, undefined, 'result should not exist');
+        t.fail('should not get here');
+    } catch (err) {
+        t.ok(err, 'errors on non-string main');
+        t.equal(err.message, 'package “invalid_main” `main` must be a string');
+        t.equal(err.code, 'INVALID_PACKAGE_MAIN');
+    }
+    t.end();
+});
+
+test('browser field in package.json', function (t) {
+    var dir = path.join(__dirname, 'resolver');
+    var res = resolve.sync('./browser_field', {
+        basedir: dir,
+        packageFilter: function packageFilter(pkg) {
+            if (pkg.browser) {
+                pkg.main = pkg.browser; // eslint-disable-line no-param-reassign
+                delete pkg.browser; // eslint-disable-line no-param-reassign
+            }
+            return pkg;
+        }
+    });
+    t.equal(res, path.join(dir, 'browser_field', 'b.js'));
+    t.end();
+});
+
+test('absolute paths', function (t) {
+    var extensionless = __filename.slice(0, -path.extname(__filename).length);
+
+    t.equal(
+        resolve.sync(__filename),
+        __filename,
+        'absolute path to this file resolves'
+    );
+    t.equal(
+        resolve.sync(__filename),
+        require.resolve(__filename),
+        'absolute path to this file: resolve.sync === require.resolve'
+    );
+
+    t.equal(
+        resolve.sync(extensionless),
+        __filename,
+        'extensionless absolute path to this file resolves'
+    );
+    t.equal(
+        resolve.sync(__filename),
+        require.resolve(__filename),
+        'absolute path to this file: resolve.sync === require.resolve'
+    );
+
+    t.equal(
+        resolve.sync(__filename, { basedir: process.cwd() }),
+        __filename,
+        'absolute path to this file with a basedir resolves'
+    );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync(__filename, { basedir: process.cwd() }),
+            require.resolve(__filename, { paths: [process.cwd()] }),
+            'absolute path to this file + basedir: resolve.sync === require.resolve'
+        );
+    }
+
+    t.equal(
+        resolve.sync(extensionless, { basedir: process.cwd() }),
+        __filename,
+        'extensionless absolute path to this file with a basedir resolves'
+    );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync(extensionless, { basedir: process.cwd() }),
+            require.resolve(extensionless, { paths: [process.cwd()] }),
+            'extensionless absolute path to this file + basedir: resolve.sync === require.resolve'
+        );
+    }
+
+    t.end();
+});
+
+var malformedDir = path.join(__dirname, 'resolver/malformed_package_json');
+test('malformed package.json', { skip: !fs.existsSync(malformedDir) }, function (t) {
+    t.plan(5 + (requireResolveSupportsPaths ? 1 : 0));
+
+    var basedir = malformedDir;
+    var expected = path.join(basedir, 'index.js');
+
+    t.equal(
+        resolve.sync('./index.js', { basedir: basedir }),
+        expected,
+        'malformed package.json is silently ignored'
+    );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./index.js', { basedir: basedir }),
+            require.resolve('./index.js', { paths: [basedir] }),
+            'malformed package.json: resolve.sync === require.resolve'
+        );
+    }
+
+    var res1 = resolve.sync(
+        './index.js',
+        {
+            basedir: basedir,
+            packageFilter: function (pkg, pkgfile, dir) {
+                t.fail('should not reach here');
+            }
+        }
+    );
+
+    t.equal(
+        res1,
+        expected,
+        'with packageFilter: malformed package.json is silently ignored'
+    );
+
+    var res2 = resolve.sync(
+        './index.js',
+        {
+            basedir: basedir,
+            readPackageSync: function (readFileSync, pkgfile) {
+                t.equal(pkgfile, path.join(basedir, 'package.json'), 'readPackageSync: `pkgfile` is package.json path');
+                var result = String(readFileSync(pkgfile));
+                try {
+                    return JSON.parse(result);
+                } catch (e) {
+                    t.ok(e instanceof SyntaxError, 'readPackageSync: malformed package.json parses as a syntax error');
+                }
+            }
+        }
+    );
+
+    t.equal(
+        res2,
+        expected,
+        'with readPackageSync: malformed package.json is silently ignored'
+    );
+});

node_modules/resolve/test/shadowed_core.js

@@ -0,0 +1,54 @@
+var test = require('tape');
+var resolve = require('../');
+var path = require('path');
+
+test('shadowed core modules still return core module', function (t) {
+    t.plan(2);
+
+    resolve('util', { basedir: path.join(__dirname, 'shadowed_core') }, function (err, res) {
+        t.ifError(err);
+        t.equal(res, 'util');
+    });
+});
+
+test('shadowed core modules still return core module [sync]', function (t) {
+    t.plan(1);
+
+    var res = resolve.sync('util', { basedir: path.join(__dirname, 'shadowed_core') });
+
+    t.equal(res, 'util');
+});
+
+test('shadowed core modules return shadow when appending `/`', function (t) {
+    t.plan(2);
+
+    resolve('util/', { basedir: path.join(__dirname, 'shadowed_core') }, function (err, res) {
+        t.ifError(err);
+        t.equal(res, path.join(__dirname, 'shadowed_core/node_modules/util/index.js'));
+    });
+});
+
+test('shadowed core modules return shadow when appending `/` [sync]', function (t) {
+    t.plan(1);
+
+    var res = resolve.sync('util/', { basedir: path.join(__dirname, 'shadowed_core') });
+
+    t.equal(res, path.join(__dirname, 'shadowed_core/node_modules/util/index.js'));
+});
+
+test('shadowed core modules return shadow with `includeCoreModules: false`', function (t) {
+    t.plan(2);
+
+    resolve('util', { basedir: path.join(__dirname, 'shadowed_core'), includeCoreModules: false }, function (err, res) {
+        t.ifError(err);
+        t.equal(res, path.join(__dirname, 'shadowed_core/node_modules/util/index.js'));
+    });
+});
+
+test('shadowed core modules return shadow with `includeCoreModules: false` [sync]', function (t) {
+    t.plan(1);
+
+    var res = resolve.sync('util', { basedir: path.join(__dirname, 'shadowed_core'), includeCoreModules: false });
+
+    t.equal(res, path.join(__dirname, 'shadowed_core/node_modules/util/index.js'));
+});

node_modules/resolve/test/subdirs.js

@@ -0,0 +1,13 @@
+var test = require('tape');
+var resolve = require('../');
+var path = require('path');
+
+test('subdirs', function (t) {
+    t.plan(2);
+
+    var dir = path.join(__dirname, '/subdirs');
+    resolve('a/b/c/x.json', { basedir: dir }, function (err, res) {
+        t.ifError(err);
+        t.equal(res, path.join(dir, 'node_modules/a/b/c/x.json'));
+    });
+});

node_modules/resolve/test/symlinks.js

@@ -0,0 +1,176 @@
+var path = require('path');
+var fs = require('fs');
+var test = require('tape');
+var map = require('array.prototype.map');
+var resolve = require('../');
+
+var symlinkDir = path.join(__dirname, 'resolver', 'symlinked', 'symlink');
+var packageDir = path.join(__dirname, 'resolver', 'symlinked', '_', 'node_modules', 'package');
+var modADir = path.join(__dirname, 'symlinks', 'source', 'node_modules', 'mod-a');
+var symlinkModADir = path.join(__dirname, 'symlinks', 'dest', 'node_modules', 'mod-a');
+try {
+    fs.unlinkSync(symlinkDir);
+} catch (err) {}
+try {
+    fs.unlinkSync(packageDir);
+} catch (err) {}
+try {
+    fs.unlinkSync(modADir);
+} catch (err) {}
+try {
+    fs.unlinkSync(symlinkModADir);
+} catch (err) {}
+
+try {
+    fs.symlinkSync('./_/symlink_target', symlinkDir, 'dir');
+} catch (err) {
+    // if fails then it is probably on Windows and lets try to create a junction
+    fs.symlinkSync(path.join(__dirname, 'resolver', 'symlinked', '_', 'symlink_target') + '\\', symlinkDir, 'junction');
+}
+try {
+    fs.symlinkSync('../../package', packageDir, 'dir');
+} catch (err) {
+    // if fails then it is probably on Windows and lets try to create a junction
+    fs.symlinkSync(path.join(__dirname, '..', '..', 'package') + '\\', packageDir, 'junction');
+}
+try {
+    fs.symlinkSync('../../source/node_modules/mod-a', symlinkModADir, 'dir');
+} catch (err) {
+    // if fails then it is probably on Windows and lets try to create a junction
+    fs.symlinkSync(path.join(__dirname, '..', '..', 'source', 'node_modules', 'mod-a') + '\\', symlinkModADir, 'junction');
+}
+
+test('symlink', function (t) {
+    t.plan(2);
+
+    resolve('foo', { basedir: symlinkDir, preserveSymlinks: false }, function (err, res, pkg) {
+        t.error(err);
+        t.equal(res, path.join(__dirname, 'resolver', 'symlinked', '_', 'node_modules', 'foo.js'));
+    });
+});
+
+test('sync symlink when preserveSymlinks = true', function (t) {
+    t.plan(4);
+
+    resolve('foo', { basedir: symlinkDir }, function (err, res, pkg) {
+        t.ok(err, 'there is an error');
+        t.notOk(res, 'no result');
+
+        t.equal(err && err.code, 'MODULE_NOT_FOUND', 'error code matches require.resolve');
+        t.equal(
+            err && err.message,
+            'Cannot find module \'foo\' from \'' + symlinkDir + '\'',
+            'can not find nonexistent module'
+        );
+    });
+});
+
+test('sync symlink', function (t) {
+    var start = new Date();
+    t.doesNotThrow(function () {
+        t.equal(
+            resolve.sync('foo', { basedir: symlinkDir, preserveSymlinks: false }),
+            path.join(__dirname, 'resolver', 'symlinked', '_', 'node_modules', 'foo.js')
+        );
+    });
+    t.ok(new Date() - start < 50, 'resolve.sync timedout');
+    t.end();
+});
+
+test('sync symlink when preserveSymlinks = true', function (t) {
+    t.throws(function () {
+        resolve.sync('foo', { basedir: symlinkDir });
+    }, /Cannot find module 'foo'/);
+    t.end();
+});
+
+test('sync symlink from node_modules to other dir when preserveSymlinks = false', function (t) {
+    var basedir = path.join(__dirname, 'resolver', 'symlinked', '_');
+    var fn = resolve.sync('package', { basedir: basedir, preserveSymlinks: false });
+
+    t.equal(fn, path.resolve(__dirname, 'resolver/symlinked/package/bar.js'));
+    t.end();
+});
+
+test('async symlink from node_modules to other dir when preserveSymlinks = false', function (t) {
+    t.plan(2);
+    var basedir = path.join(__dirname, 'resolver', 'symlinked', '_');
+    resolve('package', { basedir: basedir, preserveSymlinks: false }, function (err, result) {
+        t.notOk(err, 'no error');
+        t.equal(result, path.resolve(__dirname, 'resolver/symlinked/package/bar.js'));
+    });
+});
+
+test('packageFilter', function (t) {
+    function relative(x) {
+        return path.relative(__dirname, x);
+    }
+
+    function testPackageFilter(preserveSymlinks) {
+        return function (st) {
+            st.plan('is 1.x' ? 3 : 5); // eslint-disable-line no-constant-condition
+
+            var destMain = 'symlinks/dest/node_modules/mod-a/index.js';
+            var destPkg = 'symlinks/dest/node_modules/mod-a/package.json';
+            var sourceMain = 'symlinks/source/node_modules/mod-a/index.js';
+            var sourcePkg = 'symlinks/source/node_modules/mod-a/package.json';
+            var destDir = path.join(__dirname, 'symlinks', 'dest');
+
+            /* eslint multiline-comment-style: 0 */
+            /* v2.x will restore these tests
+            var packageFilterPath = [];
+            var actualPath = resolve.sync('mod-a', {
+                basedir: destDir,
+                preserveSymlinks: preserveSymlinks,
+                packageFilter: function (pkg, pkgfile, dir) {
+                    packageFilterPath.push(pkgfile);
+                }
+            });
+            st.equal(
+                relative(actualPath),
+                path.normalize(preserveSymlinks ? destMain : sourceMain),
+                'sync: actual path is correct'
+            );
+            st.deepEqual(
+                map(packageFilterPath, relative),
+                map(preserveSymlinks ? [destPkg, destPkg] : [sourcePkg, sourcePkg], path.normalize),
+                'sync: packageFilter pkgfile arg is correct'
+            );
+            */
+
+            var asyncPackageFilterPath = [];
+            resolve(
+                'mod-a',
+                {
+                    basedir: destDir,
+                    preserveSymlinks: preserveSymlinks,
+                    packageFilter: function (pkg, pkgfile) {
+                        asyncPackageFilterPath.push(pkgfile);
+                    }
+                },
+                function (err, actualPath) {
+                    st.error(err, 'no error');
+                    st.equal(
+                        relative(actualPath),
+                        path.normalize(preserveSymlinks ? destMain : sourceMain),
+                        'async: actual path is correct'
+                    );
+                    st.deepEqual(
+                        map(asyncPackageFilterPath, relative),
+                        map(
+                            preserveSymlinks ? [destPkg, destPkg, destPkg] : [sourcePkg, sourcePkg, sourcePkg],
+                            path.normalize
+                        ),
+                        'async: packageFilter pkgfile arg is correct'
+                    );
+                }
+            );
+        };
+    }
+
+    t.test('preserveSymlinks: false', testPackageFilter(false));
+
+    t.test('preserveSymlinks: true', testPackageFilter(true));
+
+    t.end();
+});