first commit

node_modules/resolve/.editorconfig

@@ -0,0 +1,35 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+max_line_length = 200
+
+[*.{d.ts,{,m}js}]
+block_comment_start = /*
+block_comment = *
+block_comment_end = */
+
+[*.yml]
+indent_style = space
+indent_size = 1
+
+[{package.json,*.mjs,.nycrc}]
+indent_style = tab
+
+[CHANGELOG.md]
+indent_style = space
+indent_size = 2
+
+[{*.json,Makefile,CONTRIBUTING.md,readme.markdown}]
+max_line_length = unset
+
+[test/{dotdot,resolver,module_dir,multirepo,node_path,pathfilter,precedence}/**/*]
+indent_style = unset
+indent_size = unset
+max_line_length = unset
+insert_final_newline = unset

node_modules/resolve/.github/FUNDING.yml

@@ -0,0 +1,12 @@
+# These are supported funding model platforms
+
+github: [ljharb]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: npm/resolve
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

node_modules/resolve/.github/INCIDENT_RESPONSE_PROCESS.md

@@ -0,0 +1,119 @@
+# Incident Response Process for **resolve**
+
+## Reporting a Vulnerability
+
+We take the security of **resolve** very seriously. If you believe you’ve found a security vulnerability, please inform us responsibly through coordinated disclosure.
+
+### How to Report
+
+> **Do not** report security vulnerabilities through public GitHub issues, discussions, or social media.
+
+Instead, please use one of these secure channels:
+
+1. **GitHub Security Advisories**
+   Use the **Report a vulnerability** button in the Security tab of the [browserify/resolve repository](https://github.com/browserify/resolve).
+
+2. **Email**
+   Follow the posted [Security Policy](https://github.com/browserify/resolve/security/policy).
+
+### What to Include
+
+**Required Information:**
+- Brief description of the vulnerability type
+- Affected version(s) and components
+- Steps to reproduce the issue
+- Impact assessment (what an attacker could achieve)
+- Confirm the issue is not present in test files (in other words, only via the official entry points in `exports`)
+
+**Helpful Additional Details:**
+- Full paths of affected source files
+- Specific commit or branch where the issue exists
+- Required configuration to reproduce
+- Proof-of-concept code (if available)
+- Suggested mitigation or fix
+
+## Our Response Process
+
+**Timeline Commitments:**
+- **Initial acknowledgment**: Within 24 hours
+- **Detailed response**: Within 3 business days
+- **Status updates**: Every 7 days until resolved
+- **Resolution target**: 90 days for most issues
+
+**What We’ll Do:**
+1. Acknowledge your report and assign a tracking ID
+2. Assess the vulnerability and determine severity
+3. Develop and test a fix
+4. Coordinate disclosure timeline with you
+5. Release a security update and publish an advisory and CVE
+6. Credit you in our security advisory (if desired)
+
+## Disclosure Policy
+
+- **Coordinated disclosure**: We’ll work with you on timing
+- **Typical timeline**: 90 days from report to public disclosure
+- **Early disclosure**: If actively exploited
+- **Delayed disclosure**: For complex issues
+
+## Scope
+
+**In Scope:**
+- **resolve** package (all supported versions)
+- Official examples and documentation
+- Core resolution APIs
+- Dependencies with direct security implications
+
+**Out of Scope:**
+- Third-party wrappers or extensions
+- Bundler-specific integrations
+- Social engineering or physical attacks
+- Theoretical vulnerabilities without practical exploitation
+- Issues in non-production files
+
+## Security Measures
+
+**Our Commitments:**
+- Regular vulnerability scanning via `npm audit`
+- Automated security checks in CI/CD (GitHub Actions)
+- Secure coding practices and mandatory code review
+- Prompt patch releases for critical issues
+
+**User Responsibilities:**
+- Keep **resolve** updated
+- Monitor dependency vulnerabilities
+- Follow secure configuration guidelines for module resolution
+
+## Legal Safe Harbor
+
+**We will NOT:**
+- Initiate legal action
+- Contact law enforcement
+- Suspend or terminate your access
+
+**You must:**
+- Only test against your own installations
+- Not access, modify, or delete user data
+- Not degrade service availability
+- Not publicly disclose before coordinated disclosure
+- Act in good faith
+
+## Recognition
+
+- **Advisory Credits**: Credit in GitHub Security Advisories (unless anonymous)
+
+## Security Updates
+
+**Stay Informed:**
+- Subscribe to npm updates for **resolve**
+- Enable GitHub Security Advisory notifications
+
+**Update Process:**
+- Patch releases (e.g., 1.22.10 → 1.22.11)
+- Out-of-band releases for critical issues
+- Advisories via GitHub Security Advisories
+
+## Contact Information
+
+- **Security reports**: Security tab of [browserify/resolve](https://github.com/browserify/resolve/security)
+- **General inquiries**: GitHub Discussions or Issues
+

node_modules/resolve/.github/THREAT_MODEL.md

@@ -0,0 +1,74 @@
+## Threat Model for resolve (module path resolution library)
+
+### 1. Library Overview
+
+- **Library Name:** resolve
+- **Brief Description:** Implements Node.js `require.resolve()` algorithm for synchronous and asynchronous file path resolution. Used to locate modules and files in Node.js projects.
+- **Key Public APIs/Functions:** `resolve.sync()` / `resolve/sync`, `resolve()` / `resolve/async`
+
+### 2. Define Scope
+
+This threat model focuses on the core path resolution algorithm, including filesystem interaction, option handling, and cache management.
+
+### 3. Conceptual System Diagram
+
+```
+Caller Application → resolve(id, options) → Resolution Algorithm → File System
+                           │
+                           └→ Options Handling
+                           └→ Cache System
+```
+
+**Trust Boundaries:**
+- **Input module IDs:** May come from untrusted sources (user input, configuration)
+- **Filesystem access:** The library interacts with the filesystem to resolve paths
+- **Options:** Provided by the caller
+- **Cache:** Used to improve performance, but could be a vector for tampering or information disclosure if not handled securely
+
+### 4. Identify Assets
+
+- **Integrity of resolution output:** Ensure correct and safe file path matching.
+- **Confidentiality of configuration:** Prevent sensitive path information from being leaked.
+- **Availability/performance for host application:** Prevent crashes or resource exhaustion.
+- **Security of host application:** Prevent path traversal or unintended filesystem access.
+- **Reputation of library:** Maintain trust by avoiding supply chain attacks and vulnerabilities[1][3][4].
+
+### 5. Identify Threats
+
+| Component / API / Interaction                       | S  | T  | R  | I  | D  | E  |
+|-----------------------------------------------------|----|----|----|----|----|----|
+| Public API Call (`resolve/async`, `resolve/sync`)   | ✓  | ✓  | –  | ✓  | –  | –  |
+| Filesystem Access                                   | –  | ✓  | –  | ✓  | ✓  | –  |
+| Options Handling                                    | ✓  | ✓  | –  | ✓  | –  | –  |
+| Cache System                                        | –  | ✓  | –  | ✓  | –  | –  |
+
+**Key Threats:**
+- **Spoofing:** Malicious module IDs mimicking legitimate packages, or spoofing configuration options[1].
+- **Tampering:** Caller-provided paths altering resolution order, or cache tampering leading to incorrect results[1][4].
+- **Information Disclosure:** Error messages revealing filesystem structure or sensitive paths[1].
+- **Denial of Service:** Recursive or excessive resolution exhausting filesystem handles or causing application crashes[1].
+- **Path Traversal:** Malicious input allowing access to files outside the intended directory[4].
+
+### 6. Mitigation/Countermeasures
+
+| Threat Identified                          | Proposed Mitigation |
+|--------------------------------------------|---------------------|
+| Spoofing (malicious module IDs/config)     | Sanitize input IDs; validate against known patterns; restrict `basedir` to app-controlled paths[1][4]. |
+| Tampering (path traversal, cache)          | Validate input IDs for directory escapes; secure cache reads/writes; restrict cache to trusted sources[1][4]. |
+| Information Disclosure (error messages)    | Generic "not found" errors without internal paths; avoid exposing sensitive configuration in errors[1]. |
+| Denial of Service (resource exhaustion)    | Limit recursive resolution depth; implement timeout; monitor for excessive filesystem operations[1]. |
+
+### 7. Risk Ranking
+
+- **High:** Path traversal via malicious IDs (if not properly mitigated)
+- **Medium:** Cache tampering or spoofing (if cache is not secured)
+- **Low:** Information disclosure in errors (if error handling is generic)
+
+### 8. Next Steps & Review
+
+1. **Implement input sanitization for module IDs and configuration.**
+2. **Add resolution depth limiting and timeout.**
+3. **Audit cache handling for race conditions and tampering.**
+4. **Regularly review dependencies for vulnerabilities.**
+5. **Keep documentation and threat model up to date.**
+6. **Monitor for new threats as the ecosystem and library evolve[1][3].**

node_modules/resolve/.nycrc

@@ -0,0 +1,16 @@
+{
+	"all": true,
+	"reporter": [
+		"html",
+		"text",
+		"lcov"
+	],
+	"exclude": [
+		"coverage",
+		"eslint.config.mjs",
+		"example",
+		"scripts",
+		"test",
+		"**/*.d.*ts"
+	]
+}

node_modules/resolve/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2012 James Halliday
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/resolve/SECURITY.md

@@ -0,0 +1,13 @@
+# Security
+
+Please [file a private vulnerability report](https://github.com/browserify/resolve/security/advisories/new),
+or email [@ljharb](https://github.com/ljharb),
+if you have a potential security vulnerability to report.
+
+## Incident Response
+
+See our [Incident Response Process](.github/INCIDENT_RESPONSE_PROCESS.md).
+
+## Threat Model
+
+See [THREAT_MODEL.md](./THREAT_MODEL.md).

node_modules/resolve/async.d.ts

@@ -0,0 +1,3 @@
+import type resolveAsync = require('./lib/async');
+
+export = resolveAsync;

node_modules/resolve/async.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./lib/async');

node_modules/resolve/bin/resolve

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+'use strict';
+
+var path = require('path');
+var fs = require('fs');
+
+if (
+    String(process.env.npm_lifecycle_script).slice(0, 8) !== 'resolve '
+    && (
+        !process.argv
+        || process.argv.length < 2
+        || (process.argv[1] !== __filename && fs.statSync(process.argv[1]).ino !== fs.statSync(__filename).ino)
+        || (process.env.npm_lifecycle_event !== 'npx' && process.env._ && fs.realpathSync(path.resolve(process.env._)) !== __filename)
+    )
+) {
+    console.error('Error: `resolve` must be run directly as an executable');
+    process.exit(1);
+}
+
+var supportsPreserveSymlinkFlag = require('supports-preserve-symlinks-flag');
+
+var preserveSymlinks = false;
+for (var i = 2; i < process.argv.length; i += 1) {
+    if (process.argv[i].slice(0, 2) === '--') {
+        if (supportsPreserveSymlinkFlag && process.argv[i] === '--preserve-symlinks') {
+            preserveSymlinks = true;
+        } else if (process.argv[i].length > 2) {
+            console.error('Unknown argument ' + process.argv[i].replace(/[=].*$/, ''));
+            process.exit(2);
+        }
+        process.argv.splice(i, 1);
+        i -= 1;
+        if (process.argv[i] === '--') { break; } // eslint-disable-line no-restricted-syntax
+    }
+}
+
+if (process.argv.length < 3) {
+    console.error('Error: `resolve` expects a specifier');
+    process.exit(2);
+}
+
+var resolve = require('../');
+
+var result = resolve.sync(process.argv[2], {
+    basedir: process.cwd(),
+    preserveSymlinks: preserveSymlinks
+});
+
+console.log(result);

node_modules/resolve/eslint.config.mjs

@@ -0,0 +1,82 @@
+import ljharb from '@ljharb/eslint-config/flat';
+
+export default [
+	...ljharb,
+	{
+		ignores: [
+			'test/resolver/malformed_package_json/package.json',
+			'test/list-exports/**',
+		],
+	},
+	{
+		rules: {
+			'array-bracket-newline': 'off',
+			complexity: 'off',
+			'consistent-return': 'off',
+			curly: 'off',
+			'dot-notation': ['error', { allowKeywords: true }],
+			eqeqeq: ['error', 'allow-null'],
+			'func-name-matching': 'off',
+			'func-style': 'off',
+			'global-require': 'warn',
+			'id-length': ['error', { min: 1, max: 40 }],
+			'max-depth': 'off',
+			'max-lines-per-function': 'off',
+			'max-lines': 'off',
+			'max-nested-callbacks': 'off',
+			'max-params': 'off',
+			'max-statements-per-line': ['error', { max: 2 }],
+			'max-statements': 'off',
+			'multiline-comment-style': 'off',
+			'no-extra-parens': 'off',
+			'no-magic-numbers': 'off',
+			'no-shadow': 'off',
+			'no-use-before-define': 'off',
+			'sort-keys': 'off',
+			strict: 'off',
+		},
+	},
+	{
+		files: ['**/*.js'],
+		rules: {
+			indent: ['error', 4],
+		},
+	},
+	{
+		files: ['bin/**'],
+		rules: {
+			'no-process-exit': 'off',
+		},
+	},
+	{
+		files: ['example/**'],
+		rules: {
+			'no-console': 'off',
+		},
+	},
+	{
+		files: ['test/resolver/nested_symlinks/mylib/*.js'],
+		rules: {
+			'no-throw-literal': 'off',
+		},
+	},
+	{
+		files: ['test/**'],
+		languageOptions: {
+			ecmaVersion: 5,
+			parserOptions: {
+				allowReserved: false,
+			},
+		},
+		rules: {
+			'dot-notation': ['error', { allowPattern: 'throws' }],
+			'max-lines': 'off',
+			'max-lines-per-function': 'off',
+			'no-unused-vars': ['error', {
+				vars: 'all',
+				args: 'none',
+				caughtErrors: 'none',
+			}],
+		},
+	},
+];

node_modules/resolve/example/async.js

@@ -0,0 +1,5 @@
+var resolve = require('../');
+resolve('tap', { basedir: __dirname }, function (err, res) {
+    if (err) console.error(err);
+    else console.log(res);
+});

node_modules/resolve/example/sync.js

@@ -0,0 +1,3 @@
+var resolve = require('../');
+var res = resolve.sync('tap', { basedir: __dirname });
+console.log(res);

node_modules/resolve/index.d.mts

@@ -0,0 +1,7 @@
+import type { default as resolve } from './index.js';
+
+/** Asynchronously resolve a module path, like `require.resolve()`, on behalf of files. */
+export declare const async: typeof resolve;
+
+/** Synchronously resolve a module path, like `require.resolve()`, on behalf of files. */
+export declare const sync: typeof resolve.sync;

node_modules/resolve/index.d.ts

@@ -0,0 +1,184 @@
+/**
+ * Asynchronously resolve a module path, like `require.resolve()`, on behalf of files.
+ *
+ * @param id - The module identifier to resolve.
+ * @param options - Resolution options.
+ * @param callback - Called with `(err, resolved, pkg)` when resolution completes.
+ */
+declare function resolve(id: string, callback: resolve.Callback): void;
+declare function resolve(id: string, options: resolve.AsyncOptions, callback: resolve.Callback): void;
+
+declare namespace resolve {
+  /** Asynchronously resolve a module path, like `require.resolve()`, on behalf of files. */
+  function async(id: string, callback: Callback): void;
+  function async(id: string, options: AsyncOptions, callback: Callback): void;
+
+  /**
+   * Synchronously resolve a module path, like `require.resolve()`, on behalf of files.
+   *
+   * @param id - The module identifier to resolve.
+   * @param options - Resolution options.
+   * @returns The resolved file path.
+   * @throws If the module cannot be found.
+   */
+  function sync(id: string, options?: SyncOptions): string;
+
+  /** A parsed package.json object. */
+  interface PackageJSON {
+    [key: string]: unknown;
+    name?: string;
+    main?: string;
+    exports?: unknown;
+    engines?: { node?: string };
+  }
+
+  /** Callback for asynchronous resolution. */
+  type Callback = (err: Error | null, resolved?: string, pkg?: PackageJSON) => void;
+
+  /** Options shared by both async and sync resolution. */
+  interface BaseOptions {
+    /** Directory to resolve from. Defaults to `__dirname` of the calling file. */
+    basedir?: string;
+    /** The `package.json` object associated with the calling module. */
+    package?: PackageJSON;
+    /** File extensions to search, in order. Defaults to `['.js']`. */
+    extensions?: ReadonlyArray<string>;
+    /** Whether to include core modules (e.g. `fs`, `path`) in results. Defaults to `true`. */
+    includeCoreModules?: boolean;
+    /** Whether to preserve symlinks instead of resolving them. Defaults to `false`. */
+    preserveSymlinks?: boolean;
+    /** Additional lookup paths. */
+    paths?: ReadonlyArray<string> | ((request: string, start: string, getNodeModulesDirs: () => string[], opts: BaseOptions) => string[]);
+    /** The filename used for error messages and as a fallback for basedir. */
+    filename?: string;
+    /** The directory name(s) to use for node_modules lookups. Defaults to `['node_modules']`. */
+    moduleDirectory?: string | ReadonlyArray<string>;
+    /**
+     * Transform a package.json object before its `main` field is used.
+     *
+     * @param pkg - The parsed package.json.
+     * @param pkgFile - The path to the package.json file.
+     * @param dir - The directory containing the package.json.
+     * @returns The (possibly modified) package.json object.
+     */
+    packageFilter?: (pkg: PackageJSON, pkgFile: string, dir: string) => PackageJSON;
+    /**
+     * Transform a resolved path before it is used.
+     *
+     * @param pkg - The parsed package.json.
+     * @param path - The resolved path.
+     * @param relativePath - The path relative to the package directory.
+     * @returns An alternative path, or undefined/falsy to use the original.
+     */
+    pathFilter?: (pkg: PackageJSON, path: string, relativePath: string) => string | undefined;
+    /**
+     * Override the default node_modules candidate iterator.
+     *
+     * @param request - The module being resolved.
+     * @param start - The starting directory.
+     * @param thunk - A function returning the default candidate directories.
+     * @param opts - The resolve options.
+     * @returns An array of candidate directories.
+     */
+    packageIterator?: (request: string, start: string, thunk: () => string[], opts: BaseOptions) => string[];
+    /**
+     * An exports category string, as defined by `node-exports-info`.
+     * Mutually exclusive with `engines`.
+     */
+    exportsCategory?: string;
+    /**
+     * When `true`, reads the consumer's `engines.node` to determine the exports category.
+     * When a string, it is treated as a semver range for engines.node.
+     * Mutually exclusive with `exportsCategory`.
+     */
+    engines?: boolean | string;
+    /** Custom conditions for package.json `exports` resolution. */
+    conditions?: ReadonlyArray<string>;
+  }
+
+  /** Options for asynchronous resolution. */
+  interface AsyncOptions extends BaseOptions {
+    /**
+     * Check whether a path is a file.
+     *
+     * @param file - The path to check.
+     * @param cb - Called with `(err, isFile)`.
+     */
+    isFile?: (file: string, cb: (err: Error | null, isFile?: boolean) => void) => void;
+    /**
+     * Check whether a path is a directory.
+     *
+     * @param dir - The path to check.
+     * @param cb - Called with `(err, isDirectory)`.
+     */
+    isDirectory?: (dir: string, cb: (err: Error | null, isDirectory?: boolean) => void) => void;
+    /**
+     * Resolve a path's real location, following symlinks.
+     *
+     * @param file - The path to resolve.
+     * @param cb - Called with `(err, realPath)`.
+     */
+    realpath?: (file: string, cb: (err: Error | null, realPath?: string) => void) => void;
+    /**
+     * Read a file's contents.
+     * Mutually exclusive with `readPackage`.
+     *
+     * @param file - The path to read.
+     * @param cb - Called with `(err, contents)`.
+     */
+    readFile?: (file: string, cb: (err: Error | null, contents?: string | Buffer) => void) => void;
+    /**
+     * Read and parse a package.json file.
+     * Mutually exclusive with `readFile`.
+     *
+     * @param readFile - The file-reading function.
+     * @param pkgFile - The path to the package.json.
+     * @param cb - Called with `(err, pkg)`.
+     */
+    readPackage?: (readFile: (file: string, cb: (err: Error | null, contents?: string | Buffer) => void) => void, pkgFile: string, cb: (err: Error | null, pkg?: PackageJSON) => void) => void;
+  }
+
+  /** Options for synchronous resolution. */
+  interface SyncOptions extends BaseOptions {
+    /**
+     * Check whether a path is a file.
+     *
+     * @param file - The path to check.
+     * @returns `true` if the path is a file.
+     */
+    isFile?: (file: string) => boolean;
+    /**
+     * Check whether a path is a directory.
+     *
+     * @param dir - The path to check.
+     * @returns `true` if the path is a directory.
+     */
+    isDirectory?: (dir: string) => boolean;
+    /**
+     * Resolve a path's real location, following symlinks.
+     *
+     * @param file - The path to resolve.
+     * @returns The resolved real path.
+     */
+    realpathSync?: (file: string) => string;
+    /**
+     * Read a file's contents synchronously.
+     * Mutually exclusive with `readPackageSync`.
+     *
+     * @param file - The path to read.
+     * @returns The file contents.
+     */
+    readFileSync?: (file: string) => string | Buffer;
+    /**
+     * Read and parse a package.json file synchronously.
+     * Mutually exclusive with `readFileSync`.
+     *
+     * @param readFileSync - The synchronous file-reading function.
+     * @param pkgFile - The path to the package.json.
+     * @returns The parsed package.json object.
+     */
+    readPackageSync?: (readFileSync: (file: string) => string | Buffer, pkgFile: string) => PackageJSON;
+  }
+}
+
+export = resolve;

node_modules/resolve/index.js

@@ -0,0 +1,4 @@
+var async = require('./lib/async');
+async.sync = require('./lib/sync');
+
+module.exports = async;

node_modules/resolve/index.mjs

@@ -0,0 +1,4 @@
+import async from 'resolve/async';
+import sync from 'resolve/sync';
+
+export { async, sync };

node_modules/resolve/lib/async.d.ts

@@ -0,0 +1,13 @@
+import type resolve = require('../index.js');
+
+/**
+ * Asynchronously resolve a module path, like `require.resolve()`, on behalf of files.
+ *
+ * @param id - The module identifier to resolve.
+ * @param options - Resolution options.
+ * @param callback - Called with `(err, resolved, pkg)` when resolution completes.
+ */
+declare function resolveAsync(id: string, callback: resolve.Callback): void;
+declare function resolveAsync(id: string, options: resolve.AsyncOptions, callback: resolve.Callback): void;
+
+export = resolveAsync;

node_modules/resolve/lib/async.js

@@ -0,0 +1,655 @@
+var fs = require('fs');
+var getHomedir = require('./homedir');
+var path = require('path');
+var caller = require('./caller');
+var nodeModulesPaths = require('./node-modules-paths');
+var normalizeOptions = require('./normalize-options');
+var isCore = require('is-core-module');
+var $Error = require('es-errors');
+var $TypeError = require('es-errors/type');
+var getCategoryInfo = require('node-exports-info/getCategoryInfo');
+var getCategoriesForRange = require('node-exports-info/getCategoriesForRange');
+
+var resolveExports = require('./exports-resolve');
+var parsePackageSpecifier = require('./parse-package-specifier');
+var getExportsCategory = require('./get-exports-category');
+var selectMostRestrictive = require('./select-most-restrictive');
+
+var realpathFS = process.platform !== 'win32' && fs.realpath && typeof fs.realpath.native === 'function' ? fs.realpath.native : fs.realpath;
+
+var relativePathRegex = /^(?:\.\.?(?:\/|$)|\/|([A-Za-z]:)?[/\\])/;
+var windowsDriveRegex = /^\w:[/\\]*$/;
+var nodeModulesRegex = /[/\\]node_modules[/\\]*$/;
+
+var homedir = getHomedir();
+function defaultPaths() {
+    if (!homedir) return [];
+    return [
+        path.join(homedir, '.node_modules'),
+        path.join(homedir, '.node_libraries')
+    ];
+}
+
+var defaultIsFile = function isFile(file, cb) {
+    fs.stat(file, function (err, stat) {
+        if (!err) {
+            return cb(null, stat.isFile() || stat.isFIFO());
+        }
+        if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return cb(null, false);
+        return cb(err);
+    });
+};
+
+var defaultIsDir = function isDirectory(dir, cb) {
+    fs.stat(dir, function (err, stat) {
+        if (!err) {
+            return cb(null, stat.isDirectory());
+        }
+        if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return cb(null, false);
+        return cb(err);
+    });
+};
+
+var defaultRealpath = function realpath(x, cb) {
+    realpathFS(x, function (realpathErr, realPath) {
+        if (realpathErr && realpathErr.code !== 'ENOENT') cb(realpathErr);
+        else cb(null, realpathErr ? x : realPath);
+    });
+};
+
+function maybeRealpath(realpath, x, opts, cb) {
+    if (!opts || !opts.preserveSymlinks) {
+        realpath(x, cb);
+    } else {
+        cb(null, x);
+    }
+}
+
+function defaultReadPackage(readFile, pkgfile, cb) {
+    readFile(pkgfile, function (readFileErr, body) {
+        if (readFileErr) cb(readFileErr);
+        else {
+            try {
+                var pkg = JSON.parse(body);
+                cb(null, pkg);
+            } catch (jsonErr) {
+                cb(jsonErr);
+            }
+        }
+    });
+}
+
+function getPackageCandidates(x, start, opts) {
+    var dirs = nodeModulesPaths(start, opts, x);
+    for (var i = 0; i < dirs.length; i++) {
+        dirs[i] = path.join(dirs[i], x);
+    }
+    return dirs;
+}
+
+function findUpConsumer(currentDir, isFile, readPackage, readFile, done) {
+    var pkgfile = path.join(currentDir, 'package.json');
+    isFile(pkgfile, function (err, exists) {
+        if (err) { return done(err); }
+        if (exists) {
+            readPackage(readFile, pkgfile, function (readErr, pkg) {
+                if (readErr && !(readErr instanceof SyntaxError)) { return done(readErr); }
+                done(null, pkg || null);
+            });
+        } else {
+            var parentDir = path.dirname(currentDir);
+            if (parentDir === currentDir) {
+                return done(null, null);
+            }
+            findUpConsumer(parentDir, isFile, readPackage, readFile, done);
+        }
+    });
+}
+
+function findConsumerPackage(startDir, isFile, readPackage, readFile, done) {
+    var dir = path.resolve(startDir);
+    findUpConsumer(dir, isFile, readPackage, readFile, done);
+}
+
+function findUpWithDir(currentDir, isFile, readPackage, readFile, done) {
+    // Stop at node_modules boundaries - can't self-reference across node_modules
+    if (nodeModulesRegex.test(currentDir)) {
+        return done(null, null);
+    }
+    var pkgfile = path.join(currentDir, 'package.json');
+    isFile(pkgfile, function (err, exists) {
+        if (err) { return done(err); }
+        if (exists) {
+            readPackage(readFile, pkgfile, function (readErr, pkg) {
+                if (readErr && !(readErr instanceof SyntaxError)) { return done(readErr); }
+                done(null, pkg ? {
+                    __proto__: null, pkg: pkg, dir: currentDir
+                } : null);
+            });
+        } else {
+            var parentDir = path.dirname(currentDir);
+            if (parentDir === currentDir) {
+                return done(null, null);
+            }
+            findUpWithDir(parentDir, isFile, readPackage, readFile, done);
+        }
+    });
+}
+
+module.exports = function resolve(x, options, callback) {
+    var cb = callback;
+    var opts = options;
+    if (typeof options === 'function') {
+        cb = opts;
+        opts = {};
+    }
+    if (typeof x !== 'string') {
+        var err = new $TypeError('Path must be a string.');
+        return process.nextTick(function () {
+            cb(err);
+        });
+    }
+
+    opts = normalizeOptions(x, opts);
+
+    var isFile = opts.isFile || defaultIsFile;
+    var isDirectory = opts.isDirectory || defaultIsDir;
+    var readFile = opts.readFile || fs.readFile;
+    var realpath = opts.realpath || defaultRealpath;
+    var readPackage = opts.readPackage || defaultReadPackage;
+    if (opts.readFile && opts.readPackage) {
+        var conflictErr = new $TypeError('`readFile` and `readPackage` are mutually exclusive.');
+        return process.nextTick(function () {
+            cb(conflictErr);
+        });
+    }
+    var packageIterator = opts.packageIterator;
+
+    if (typeof opts.moduleSystem !== 'undefined' && opts.moduleSystem !== 'require' && opts.moduleSystem !== 'import') {
+        var msErr = new $TypeError('`moduleSystem` must be `\'require\'` or `\'import\'`.');
+        return process.nextTick(function () {
+            cb(msErr);
+        });
+    }
+
+    var extensions = opts.extensions || ['.js'];
+    var includeCoreModules = opts.includeCoreModules !== false;
+    var basedir = opts.basedir || path.dirname(caller());
+    var parent = opts.filename || basedir;
+
+    opts.paths = opts.paths || defaultPaths();
+
+    // Determine exports category
+    var exportsCategory;
+    // hoist the caught error into a `var` rather than closing over the catch binding;
+    // old V8 (node < 4) drops the catch param when the inner closure is rewritten by nyc.
+    var catErr;
+    try {
+        exportsCategory = getExportsCategory(opts);
+    } catch (e) {
+        catErr = e;
+    }
+    if (catErr) {
+        return process.nextTick(function () {
+            cb(catErr);
+        });
+    }
+
+    // ensure that `basedir` is an absolute path at this point, resolving against the process' current working directory
+    var absoluteStart = path.resolve(basedir);
+
+    maybeRealpath(
+        realpath,
+        absoluteStart,
+        opts,
+        function (err, realStart) {
+            if (err) cb(err);
+            else if (exportsCategory === 'engines') {
+                // Need to read consumer's package.json for engines.node
+                findConsumerPackage(realStart, isFile, readPackage, readFile, function (findErr, consumerPkg) {
+                    if (findErr) return cb(findErr);
+                    if (consumerPkg && consumerPkg.engines && consumerPkg.engines.node) {
+                        var categories = getCategoriesForRange(consumerPkg.engines.node);
+                        exportsCategory = selectMostRestrictive(categories);
+                    } else {
+                        exportsCategory = null;
+                    }
+                    validateBasedir(realStart);
+                });
+            } else {
+                validateBasedir(realStart);
+            }
+        }
+    );
+
+    function findPackageWithDir(startDir, done) {
+        var dir = path.resolve(startDir);
+        findUpWithDir(dir, isFile, readPackage, readFile, done);
+    }
+
+    function resolveSelfReference(x, startDir, done) {
+        var parsed = parsePackageSpecifier(x);
+        findPackageWithDir(startDir, function (err, pkgInfo) {
+            if (err) return done(err);
+            if (!pkgInfo || !pkgInfo.pkg || pkgInfo.pkg.name !== parsed.name) {
+                return done(null, null); // Not a self-reference
+            }
+
+            var pkg = pkgInfo.pkg;
+            var pkgDir = pkgInfo.dir;
+
+            if (opts.packageFilter) {
+                pkg = opts.packageFilter(pkg, path.join(pkgDir, 'package.json'), pkgDir);
+            }
+
+            // If package has exports field, resolve via exports
+            if (typeof pkg.exports !== 'undefined') {
+                var categoryInfo = getCategoryInfo(exportsCategory, opts.moduleSystem || 'require');
+                var conditions = opts.conditions || categoryInfo.conditions;
+                var resolved;
+                try {
+                    resolved = resolveExports(pkg.exports, parsed.subpath, conditions, categoryInfo.flags);
+                } catch (exportsErr) {
+                    return done(exportsErr);
+                }
+                if (resolved) {
+                    var resolvedPath = path.resolve(pkgDir, resolved);
+                    isFile(resolvedPath, function (err, exists) {
+                        if (err) return done(err);
+                        if (exists) return done(null, resolvedPath, pkg);
+                        // File doesn't exist
+                        done(null, undefined);
+                    });
+                    return;
+                }
+                // exports field exists but didn't resolve
+                return done(null, undefined);
+            }
+
+            // No exports field - fall back to traditional resolution for self-reference
+            if (parsed.subpath === '.') {
+                loadAsDirectory(pkgDir, pkg, function (err, result, resultPkg) {
+                    done(err, result, resultPkg);
+                });
+            } else {
+                var subPath = path.join(pkgDir, parsed.subpath.slice(1));
+                loadAsFile(subPath, pkg, function (err, m, mPkg) {
+                    if (err) return done(err);
+                    if (m) return done(null, m, mPkg);
+                    loadAsDirectory(subPath, pkg, function (err, n, nPkg) {
+                        done(err, n, nPkg);
+                    });
+                });
+            }
+        });
+    }
+
+    function validateBasedir(basedir) {
+        if (opts.basedir) {
+            var dirError = new $TypeError('Provided basedir "' + basedir + '" is not a directory' + (opts.preserveSymlinks ? '' : ', or a symlink to a directory'));
+            dirError.code = 'INVALID_BASEDIR';
+            isDirectory(basedir, function (err, result) {
+                if (err) return cb(err);
+                if (!result) { return cb(dirError); }
+                validBasedir(basedir);
+            });
+        } else {
+            validBasedir(basedir);
+        }
+    }
+
+    var useExports = false;
+    var res;
+    function validBasedir(basedir) {
+        useExports = exportsCategory !== null && exportsCategory !== 'pre-exports';
+
+        if (relativePathRegex.test(x)) {
+            res = path.resolve(basedir, x);
+            if (x === '.' || x === '..' || x.slice(-1) === '/') res += '/';
+            if (x.slice(-1) === '/' && res === basedir) {
+                loadAsDirectory(res, opts.package, onfile);
+            } else loadAsFile(res, opts.package, onfile);
+        } else if (includeCoreModules && isCore(x)) {
+            return cb(null, x);
+        } else if (useExports) {
+            // Try self-reference resolution first
+            resolveSelfReference(x, basedir, function (selfErr, selfRef, selfPkg) {
+                if (selfErr) return cb(selfErr);
+                if (selfRef) {
+                    return maybeRealpath(realpath, selfRef, opts, function (err, realSelf) {
+                        if (err) cb(err);
+                        else cb(null, realSelf, selfPkg);
+                    });
+                }
+                if (selfRef === undefined) {
+                    // exports field exists but didn't resolve - error per Node semantics
+                    var moduleError = new $Error("Cannot find module '" + x + "' from '" + parent + "'");
+                    moduleError.code = 'MODULE_NOT_FOUND';
+                    return cb(moduleError);
+                }
+                loadNodeModulesWithExports(x, basedir, function (err, n, pkg) {
+                    if (err) cb(err);
+                    else if (n) {
+                        return maybeRealpath(realpath, n, opts, function (err, realN) {
+                            if (err) {
+                                cb(err);
+                            } else {
+                                cb(null, realN, pkg);
+                            }
+                        });
+                    } else {
+                        var moduleError = new $Error("Cannot find module '" + x + "' from '" + parent + "'");
+                        moduleError.code = 'MODULE_NOT_FOUND';
+                        cb(moduleError);
+                    }
+                });
+            });
+        } else {
+            loadNodeModules(x, basedir, function (err, n, pkg) {
+                if (err) cb(err);
+                else if (n) {
+                    return maybeRealpath(realpath, n, opts, function (err, realN) {
+                        if (err) {
+                            cb(err);
+                        } else {
+                            cb(null, realN, pkg);
+                        }
+                    });
+                } else {
+                    var moduleError = new $Error("Cannot find module '" + x + "' from '" + parent + "'");
+                    moduleError.code = 'MODULE_NOT_FOUND';
+                    cb(moduleError);
+                }
+            });
+        }
+    }
+
+    function onfile(err, m, pkg) {
+        if (err) cb(err);
+        else if (m) cb(null, m, pkg);
+        else loadAsDirectory(res, function (err, d, pkg) {
+            if (err) cb(err);
+            else if (d) {
+                maybeRealpath(realpath, d, opts, function (err, realD) {
+                    if (err) {
+                        cb(err);
+                    } else {
+                        cb(null, realD, pkg);
+                    }
+                });
+            } else {
+                var moduleError = new $Error("Cannot find module '" + x + "' from '" + parent + "'");
+                moduleError.code = 'MODULE_NOT_FOUND';
+                cb(moduleError);
+            }
+        });
+    }
+
+    function loadAsFile(x, thePackage, callback) {
+        var loadAsFilePackage = thePackage;
+        var cb = callback;
+        if (typeof loadAsFilePackage === 'function') {
+            cb = loadAsFilePackage;
+            loadAsFilePackage = undefined;
+        }
+
+        var exts = [''].concat(extensions);
+        load(exts, x, loadAsFilePackage);
+
+        function load(exts, x, loadPackage) {
+            if (exts.length === 0) return cb(null, undefined, loadPackage);
+            var file = x + exts[0];
+
+            var pkg = loadPackage;
+            if (pkg) onpkg(null, pkg);
+            else loadpkg(path.dirname(file), onpkg);
+
+            function onpkg(err, pkg_, dir) {
+                pkg = pkg_;
+                if (err) return cb(err);
+                if (dir && pkg && opts.pathFilter) {
+                    var rfile = path.relative(dir, file);
+                    var rel = rfile.slice(0, rfile.length - exts[0].length);
+                    var r = opts.pathFilter(pkg, x, rel);
+                    if (r) return load(
+                        [''].concat(extensions),
+                        path.resolve(dir, r),
+                        pkg
+                    );
+                }
+                isFile(file, onex);
+            }
+            function onex(err, ex) {
+                if (err) return cb(err);
+                if (ex) return cb(null, file, pkg);
+                load(exts.slice(1), x, pkg);
+            }
+        }
+    }
+
+    function loadpkg(dir, cb) {
+        if (dir === '' || dir === '/') return cb(null);
+        if (process.platform === 'win32' && windowsDriveRegex.test(dir)) {
+            return cb(null);
+        }
+        if (nodeModulesRegex.test(dir)) return cb(null);
+
+        maybeRealpath(realpath, dir, opts, function (unwrapErr, pkgdir) {
+            if (unwrapErr) return loadpkg(path.dirname(dir), cb);
+            var pkgfile = path.join(pkgdir, 'package.json');
+            isFile(pkgfile, function (err, ex) {
+                // on err, ex is false
+                if (!ex) return loadpkg(path.dirname(dir), cb);
+
+                readPackage(readFile, pkgfile, function (err, pkgParam) {
+                    if (err && !(err instanceof SyntaxError)) return cb(err);
+
+                    var pkg = pkgParam;
+
+                    if (pkg && opts.packageFilter) {
+                        pkg = opts.packageFilter(pkg, pkgfile, dir);
+                    }
+                    cb(null, pkg, dir);
+                });
+            });
+        });
+    }
+
+    function loadAsDirectory(x, loadAsDirectoryPackage, callback) {
+        var cb = callback;
+        var fpkg = loadAsDirectoryPackage;
+        if (typeof fpkg === 'function') {
+            cb = fpkg;
+            fpkg = opts.package;
+        }
+
+        maybeRealpath(realpath, x, opts, function (unwrapErr, pkgdir) {
+            if (unwrapErr) return loadAsDirectory(path.dirname(x), fpkg, cb);
+            var pkgfile = path.join(pkgdir, 'package.json');
+            isFile(pkgfile, function (err, ex) {
+                if (err) return cb(err);
+                if (!ex) return loadAsFile(path.join(x, 'index'), fpkg, cb);
+
+                readPackage(readFile, pkgfile, function (err, pkgParam) {
+                    if (err) return cb(err);
+
+                    var pkg = pkgParam;
+
+                    if (pkg && opts.packageFilter) {
+                        pkg = opts.packageFilter(pkg, pkgfile, pkgdir);
+                    }
+
+                    if (pkg && pkg.main) {
+                        if (typeof pkg.main !== 'string') {
+                            var mainError = new $TypeError('package “' + pkg.name + '” `main` must be a string');
+                            mainError.code = 'INVALID_PACKAGE_MAIN';
+                            return cb(mainError);
+                        }
+                        if (pkg.main === '.' || pkg.main === './') {
+                            pkg.main = 'index';
+                        }
+                        loadAsFile(path.resolve(x, pkg.main), pkg, function (err, m, pkg) {
+                            if (err) return cb(err);
+                            if (m) return cb(null, m, pkg);
+                            if (!pkg) return loadAsFile(path.join(x, 'index'), pkg, cb);
+
+                            var dir = path.resolve(x, pkg.main);
+                            loadAsDirectory(dir, pkg, function (err, n, pkg) {
+                                if (err) return cb(err);
+                                if (n) return cb(null, n, pkg);
+                                loadAsFile(path.join(x, 'index'), pkg, function (err, m, pkg) {
+                                    if (err) return cb(err);
+                                    if (m) return cb(null, m, pkg);
+                                    var incorrectMainError = new $Error("Cannot find module '" + path.resolve(x, pkg.main) + "'. Please verify that the package.json has a valid \"main\" entry");
+                                    incorrectMainError.code = 'INCORRECT_PACKAGE_MAIN';
+                                    return cb(incorrectMainError);
+                                });
+                            });
+                        });
+                        return;
+                    }
+
+                    loadAsFile(path.join(x, '/index'), pkg, cb);
+                });
+            });
+        });
+    }
+
+    function processDirs(cb, dirs) {
+        if (dirs.length === 0) return cb(null, undefined);
+        var dir = dirs[0];
+
+        isDirectory(path.dirname(dir), isdir);
+
+        function isdir(err, isdir) {
+            if (err) return cb(err);
+            if (!isdir) return processDirs(cb, dirs.slice(1));
+            loadAsFile(dir, opts.package, onfile);
+        }
+
+        function onfile(err, m, pkg) {
+            if (err) return cb(err);
+            if (m) return cb(null, m, pkg);
+            loadAsDirectory(dir, opts.package, ondir);
+        }
+
+        function ondir(err, n, pkg) {
+            if (err) return cb(err);
+            if (n) return cb(null, n, pkg);
+            processDirs(cb, dirs.slice(1));
+        }
+    }
+    function loadNodeModules(x, start, cb) {
+        var thunk = function () { return getPackageCandidates(x, start, opts); };
+        processDirs(
+            cb,
+            packageIterator ? packageIterator(x, start, thunk, opts) : thunk()
+        );
+    }
+
+    function loadNodeModulesWithExports(x, start, done) {
+        var parsed = parsePackageSpecifier(x);
+        var categoryInfo = getCategoryInfo(exportsCategory, opts.moduleSystem || 'require');
+        var conditions = opts.conditions || categoryInfo.conditions;
+
+        var thunk = function () { return getPackageCandidates(parsed.name, start, opts); };
+        var dirs = packageIterator ? packageIterator(parsed.name, start, thunk, opts) : thunk();
+
+        processExportsDirs(dirs, 0);
+
+        function processExportsDirs(dirs, idx) {
+            if (idx >= dirs.length) return done(null, undefined);
+            var pkgDir = dirs[idx];
+
+            isDirectory(pkgDir, function (err, isDir) {
+                if (err) return done(err);
+                if (!isDir) return processExportsDirs(dirs, idx + 1);
+
+                var pkgfile = path.join(pkgDir, 'package.json');
+                isFile(pkgfile, function (err, exists) {
+                    if (err) return done(err);
+                    if (!exists) {
+                        // No package.json, fall back to file/directory resolution
+                        if (parsed.subpath === '.') {
+                            loadAsFile(pkgDir, opts.package, function (err, m, pkg) {
+                                if (err) return done(err);
+                                if (m) return done(null, m, pkg);
+                                loadAsDirectory(pkgDir, opts.package, function (err, n, pkg) {
+                                    if (err) return done(err);
+                                    if (n) return done(null, n, pkg);
+                                    processExportsDirs(dirs, idx + 1);
+                                });
+                            });
+                        } else {
+                            var fullPath = path.join(pkgDir, parsed.subpath.slice(1));
+                            loadAsFile(fullPath, opts.package, function (err, m, pkg) {
+                                if (err) return done(err);
+                                if (m) return done(null, m, pkg);
+                                loadAsDirectory(fullPath, opts.package, function (err, n, pkg) {
+                                    if (err) return done(err);
+                                    if (n) return done(null, n, pkg);
+                                    processExportsDirs(dirs, idx + 1);
+                                });
+                            });
+                        }
+                        return;
+                    }
+
+                    readPackage(readFile, pkgfile, function (err, pkg) {
+                        if (err) {
+                            if (!(err instanceof SyntaxError)) return done(err);
+                            return processExportsDirs(dirs, idx + 1);
+                        }
+
+                        if (pkg && opts.packageFilter) {
+                            // eslint-disable-next-line no-param-reassign
+                            pkg = opts.packageFilter(pkg, pkgfile, pkgDir);
+                        }
+
+                        // If package has exports field, use exports resolution
+                        if (pkg && typeof pkg.exports !== 'undefined') {
+                            var resolved;
+                            try {
+                                resolved = resolveExports(pkg.exports, parsed.subpath, conditions, categoryInfo.flags);
+                            } catch (exportsErr) {
+                                return done(exportsErr);
+                            }
+                            if (resolved) {
+                                var resolvedPath = path.resolve(pkgDir, resolved);
+                                isFile(resolvedPath, function (err, exists) {
+                                    if (err) return done(err);
+                                    if (exists) return done(null, resolvedPath, pkg);
+                                    // File doesn't exist
+                                    done(null, undefined);
+                                });
+                                return;
+                            }
+                            // exports field exists but didn't resolve
+                            return done(null, undefined);
+                        }
+
+                        // No exports field, fall back to traditional resolution
+                        if (parsed.subpath === '.') {
+                            loadAsDirectory(pkgDir, pkg, function (err, result, resultPkg) {
+                                if (err) return done(err);
+                                if (result) return done(null, result, resultPkg);
+                                processExportsDirs(dirs, idx + 1);
+                            });
+                        } else {
+                            var subPath = path.join(pkgDir, parsed.subpath.slice(1));
+                            loadAsFile(subPath, pkg, function (err, m, mPkg) {
+                                if (err) return done(err);
+                                if (m) return done(null, m, mPkg);
+                                loadAsDirectory(subPath, pkg, function (err, n, nPkg) {
+                                    if (err) return done(err);
+                                    if (n) return done(null, n, nPkg);
+                                    processExportsDirs(dirs, idx + 1);
+                                });
+                            });
+                        }
+                    });
+                });
+            });
+        }
+    }
+};

node_modules/resolve/lib/caller.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var $Error = require('es-errors');
+
+module.exports = function () {
+    // see https://code.google.com/p/v8/wiki/JavaScriptStackTraceApi
+    var origPrepareStackTrace = $Error.prepareStackTrace;
+    $Error.prepareStackTrace = function (_, stack) { return stack; };
+    var stack = (new $Error()).stack;
+    $Error.prepareStackTrace = origPrepareStackTrace;
+    return stack[2].getFileName();
+};

node_modules/resolve/lib/exports-resolve.js

@@ -0,0 +1,273 @@
+'use strict';
+
+var objectKeys = require('object-keys');
+var $Error = require('es-errors');
+
+// Check if an exports map key looks like a subpath (starts with '.')
+function isSubpathKey(key) {
+    return key.length > 0 && key.charAt(0) === '.';
+}
+
+// Normalize the exports field into a map of subpath -> target
+function normalizeExports(exportsField) {
+    if (typeof exportsField === 'string') {
+        return { __proto__: null, '.': exportsField };
+    }
+    if (Array.isArray(exportsField)) {
+        return { __proto__: null, '.': exportsField };
+    }
+    if (typeof exportsField === 'object' && exportsField !== null) {
+        var keys = objectKeys(exportsField);
+        if (keys.length === 0) {
+            return { __proto__: null };
+        }
+        // If any key starts with '.', it's a subpath map
+        // If no key starts with '.', it's a conditions object for '.'
+        var hasSubpath = false;
+        for (var i = 0; !hasSubpath && i < keys.length; i++) {
+            if (isSubpathKey(keys[i])) {
+                hasSubpath = true;
+            }
+        }
+        // Copy to new object with null prototype
+        var result = { __proto__: null };
+        for (var j = 0; j < keys.length; j++) {
+            result[keys[j]] = exportsField[keys[j]];
+        }
+        if (hasSubpath) {
+            return result;
+        }
+        return { __proto__: null, '.': result };
+    }
+    return null;
+}
+
+// Resolve a target value through conditions
+// conditions: array of condition strings, or null (broken: string/array only)
+function resolveTarget(target, conditions) {
+    if (typeof target === 'string') {
+        return target;
+    }
+
+    if (target === null) {
+        return null;
+    }
+
+    if (Array.isArray(target)) {
+        for (var i = 0; i < target.length; i++) {
+            var resolved = resolveTarget(target[i], conditions);
+            if (resolved !== null && typeof resolved !== 'undefined') {
+                return resolved;
+            }
+        }
+        return null;
+    }
+
+    if (typeof target === 'object') {
+        // If no conditions supported (broken category), can't resolve objects
+        if (conditions === null) {
+            return null;
+        }
+        var keys = objectKeys(target);
+        for (var j = 0; j < keys.length; j++) {
+            var key = keys[j];
+            for (var k = 0; k < conditions.length; k++) {
+                if (key === conditions[k]) {
+                    var result = resolveTarget(target[key], conditions);
+                    if (result != null) {
+                        return result;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+
+    return null;
+}
+
+// Validate a resolved path
+function validateTarget(target) {
+    if (typeof target !== 'string') {
+        return false;
+    }
+    if (target.slice(0, 2) !== './') {
+        return false;
+    }
+    if (target.indexOf('/node_modules/') !== -1) {
+        return false;
+    }
+    // Check for '..' path traversal
+    var parts = target.split('/');
+    for (var i = 0; i < parts.length; i++) {
+        if (parts[i] === '..') {
+            return false;
+        }
+    }
+    return true;
+}
+
+// Find the best pattern match for a subpath among keys with '*'
+function findPatternMatch(subpath, exportsMap, allowPatternTrailers) {
+    var keys = objectKeys(exportsMap);
+    var bestKey = null;
+    var bestPrefixLen = -1;
+    var bestMatch = '';
+
+    for (var i = 0; i < keys.length; i++) {
+        var key = keys[i];
+        var starIndex = key.indexOf('*');
+        // Key must have exactly one '*'
+        if (starIndex !== -1 && key.indexOf('*', starIndex + 1) === -1) {
+            var prefix = key.slice(0, starIndex);
+            var suffix = key.slice(starIndex + 1);
+
+            // Pattern trailers: if suffix is non-empty after *, need allowPatternTrailers
+            if (suffix.length === 0 || allowPatternTrailers) {
+                if (
+                    subpath.length >= prefix.length + suffix.length
+                    && subpath.slice(0, prefix.length) === prefix
+                    && (suffix.length === 0 || subpath.slice(subpath.length - suffix.length) === suffix)
+                ) {
+                    // Longest prefix wins
+                    if (prefix.length > bestPrefixLen) {
+                        bestPrefixLen = prefix.length;
+                        bestKey = key;
+                        bestMatch = subpath.slice(prefix.length, subpath.length - suffix.length);
+                    }
+                }
+            }
+        }
+    }
+
+    if (bestKey !== null) {
+        return {
+            __proto__: null, key: bestKey, match: bestMatch
+        };
+    }
+    return null;
+}
+
+// Find directory slash match (for categories that support it)
+function findDirSlashMatch(subpath, exportsMap) {
+    var keys = objectKeys(exportsMap);
+    var bestKey = null;
+    var bestPrefixLen = -1;
+
+    for (var i = 0; i < keys.length; i++) {
+        var key = keys[i];
+        if (key.charAt(key.length - 1) === '/') {
+            if (subpath.slice(0, key.length) === key && key.length > bestPrefixLen) {
+                bestPrefixLen = key.length;
+                bestKey = key;
+            }
+        }
+    }
+
+    if (bestKey !== null) {
+        return {
+            __proto__: null, key: bestKey, remainder: subpath.slice(bestKey.length)
+        };
+    }
+    return null;
+}
+
+// Replace '*' in target string with match value
+function substitutePattern(target, match) {
+    if (typeof target === 'string') {
+        return target.split('*').join(match);
+    }
+    if (Array.isArray(target)) {
+        var result = [];
+        for (var i = 0; i < target.length; i++) {
+            result.push(substitutePattern(target[i], match));
+        }
+        return result;
+    }
+    if (typeof target === 'object' && target !== null) {
+        var obj = { __proto__: null };
+        var keys = objectKeys(target);
+        for (var j = 0; j < keys.length; j++) {
+            obj[keys[j]] = substitutePattern(target[keys[j]], match);
+        }
+        return obj;
+    }
+    return target;
+}
+
+// Main exports resolution function
+// exportsField: the value of package.json "exports"
+// subpath: the subpath to resolve (e.g., "." or "./foo/bar")
+// conditions: array of condition strings, or null for broken category
+// options: { patterns: boolean, patternTrailers: boolean, dirSlash: boolean }
+// Returns: resolved relative path string, or null if no exports field
+// Throws: when exports field exists but subpath is not exported
+module.exports = function resolveExports(exportsField, subpath, conditions, options) {
+    if (typeof exportsField === 'undefined') {
+        return null;
+    }
+
+    var exportsMap = normalizeExports(exportsField);
+    if (!exportsMap) {
+        return null;
+    }
+
+    var allowPatterns = options && options.patterns;
+    var allowPatternTrailers = options && options.patternTrailers;
+    var allowDirSlash = options && options.dirSlash;
+
+    // 1. Exact key match
+    if (typeof exportsMap[subpath] !== 'undefined') {
+        var resolved = resolveTarget(exportsMap[subpath], conditions);
+        if (resolved !== null && typeof resolved !== 'undefined') {
+            if (!validateTarget(resolved)) {
+                var invalidError = new $Error('Invalid "exports" target "' + resolved + '" for subpath "' + subpath + '"');
+                invalidError.code = 'ERR_INVALID_PACKAGE_CONFIG';
+                throw invalidError;
+            }
+            return resolved;
+        }
+        // Target exists but resolved to null (explicitly not exported)
+        var notExportedError = new $Error('Package subpath "' + subpath + '" is not defined by "exports"');
+        notExportedError.code = 'ERR_PACKAGE_PATH_NOT_EXPORTED';
+        throw notExportedError;
+    }
+
+    // 2. Pattern match (keys with '*')
+    if (allowPatterns) {
+        var patternResult = findPatternMatch(subpath, exportsMap, allowPatternTrailers);
+        if (patternResult) {
+            var substituted = substitutePattern(exportsMap[patternResult.key], patternResult.match);
+            var patternResolved = resolveTarget(substituted, conditions);
+            if (patternResolved !== null && typeof patternResolved !== 'undefined') {
+                if (!validateTarget(patternResolved)) {
+                    var patternInvalidError = new $Error('Invalid "exports" target "' + patternResolved + '" for subpath "' + subpath + '"');
+                    patternInvalidError.code = 'ERR_INVALID_PACKAGE_CONFIG';
+                    throw patternInvalidError;
+                }
+                return patternResolved;
+            }
+        }
+    }
+
+    // 3. Directory slash match (for older categories)
+    if (allowDirSlash) {
+        var dirResult = findDirSlashMatch(subpath, exportsMap);
+        if (dirResult) {
+            var dirTarget = resolveTarget(exportsMap[dirResult.key], conditions);
+            if (dirTarget !== null && typeof dirTarget !== 'undefined' && typeof dirTarget === 'string') {
+                var dirResolved = dirTarget + dirResult.remainder;
+                if (!validateTarget(dirResolved)) {
+                    var dirInvalidError = new $Error('Invalid "exports" target "' + dirResolved + '" for subpath "' + subpath + '"');
+                    dirInvalidError.code = 'ERR_INVALID_PACKAGE_CONFIG';
+                    throw dirInvalidError;
+                }
+                return dirResolved;
+            }
+        }
+    }
+
+    var err = new $Error('Package subpath "' + subpath + '" is not defined by "exports"');
+    err.code = 'ERR_PACKAGE_PATH_NOT_EXPORTED';
+    throw err;
+};

node_modules/resolve/lib/get-exports-category.js

@@ -0,0 +1,52 @@
+'use strict';
+
+var isCategory = require('node-exports-info/isCategory');
+var getCategoriesForRange = require('node-exports-info/getCategoriesForRange');
+var $TypeError = require('es-errors/type');
+
+var selectMostRestrictive = require('./select-most-restrictive');
+
+// Determine the active exports category from resolve options
+// Returns null if no exports resolution should be applied
+// Returns 'engines' if engines: true (needs consumer package.json lookup)
+// Throws TypeError if invalid options are provided
+/** @type {(opts?: { exportsCategory?: import('node-exports-info/getCategory').Category, engines?: boolean | string }) => null | import('node-exports-info/getCategory').Category} */
+module.exports = function getExportsCategory(opts) {
+    if (!opts) {
+        return null;
+    }
+
+    var hasCategory = typeof opts.exportsCategory !== 'undefined';
+    var engines = opts.engines;
+    var hasEngines = typeof engines !== 'undefined' && engines !== false;
+
+    if (hasCategory && hasEngines) {
+        throw new $TypeError('`exportsCategory` and `engines` are mutually exclusive.');
+    }
+
+    if (hasCategory) {
+        if (!isCategory(opts.exportsCategory)) {
+            var catError = new $TypeError('Invalid exports category: "' + opts.exportsCategory + '"');
+            catError.code = 'INVALID_EXPORTS_CATEGORY';
+            throw catError;
+        }
+        return opts.exportsCategory;
+    }
+
+    if (hasEngines) {
+        // engines: true means read from consumer's package.json
+        if (engines === true) {
+            return 'engines';
+        }
+
+        // engines must be a non-empty string (semver range)
+        if (typeof engines !== 'string' || engines === '') {
+            throw new $TypeError('`engines` must be `true`, `false`, or a non-empty string semver range.');
+        }
+
+        var categories = getCategoriesForRange(engines);
+        return selectMostRestrictive(categories);
+    }
+
+    return null;
+};

node_modules/resolve/lib/homedir.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var os = require('os');
+
+// adapted from https://github.com/sindresorhus/os-homedir/blob/11e089f4754db38bb535e5a8416320c4446e8cfd/index.js
+
+module.exports = os.homedir || function homedir() {
+    var home = process.env.HOME;
+    var user = process.env.LOGNAME || process.env.USER || process.env.LNAME || process.env.USERNAME;
+
+    if (process.platform === 'win32') {
+        return process.env.USERPROFILE
+            || (
+                process.env.HOMEDRIVE
+                && process.env.HOMEPATH
+                && (process.env.HOMEDRIVE + process.env.HOMEPATH)
+            )
+            || home
+            || null;
+    }
+
+    if (process.platform === 'darwin') {
+        return home || (user ? '/Users/' + user : null);
+    }
+
+    if (process.platform === 'linux') {
+        return home || (process.getuid() === 0 ? '/root' : (user ? '/home/' + user : null));
+    }
+
+    return home || null;
+};

node_modules/resolve/lib/node-modules-paths.js

@@ -0,0 +1,45 @@
+var path = require('path');
+var parse = path.parse || require('path-parse'); // eslint-disable-line global-require
+
+var driveLetterRegex = /^([A-Za-z]:)/;
+var uncPathRegex = /^\\\\/;
+
+function getNodeModulesDirs(absoluteStart, modules) {
+    var prefix = '/';
+    if (driveLetterRegex.test(absoluteStart)) {
+        prefix = '';
+    } else if (uncPathRegex.test(absoluteStart)) {
+        prefix = '\\\\';
+    }
+
+    var paths = [absoluteStart];
+    var parsed = parse(absoluteStart);
+    while (parsed.dir !== paths[paths.length - 1]) {
+        paths.push(parsed.dir);
+        parsed = parse(parsed.dir);
+    }
+
+    return paths.reduce(function (dirs, aPath) {
+        return dirs.concat(modules.map(function (moduleDir) {
+            return path.resolve(prefix, aPath, moduleDir);
+        }));
+    }, []);
+}
+
+module.exports = function nodeModulesPaths(start, opts, request) {
+    var modules = opts && opts.moduleDirectory
+        ? [].concat(opts.moduleDirectory)
+        : ['node_modules'];
+
+    if (opts && typeof opts.paths === 'function') {
+        return opts.paths(
+            request,
+            start,
+            function () { return getNodeModulesDirs(start, modules); },
+            opts
+        );
+    }
+
+    var dirs = getNodeModulesDirs(start, modules);
+    return opts && opts.paths ? dirs.concat(opts.paths) : dirs;
+};

node_modules/resolve/lib/normalize-options.js

@@ -0,0 +1,10 @@
+module.exports = function (x, opts) {
+    /**
+     * This file is purposefully a passthrough. It's expected that third-party
+     * environments will override it at runtime in order to inject special logic
+     * into `resolve` (by manipulating the options). One such example is the PnP
+     * code path in Yarn.
+     */
+
+    return opts || {};
+};

node_modules/resolve/lib/parse-package-specifier.js

@@ -0,0 +1,31 @@
+'use strict';
+
+/** @type {(x: string) => { __proto__: null, name: string, subpath: string }} */
+module.exports = function parsePackageSpecifier(x) {
+    if (x.charAt(0) === '@') {
+        var slashIndex = x.indexOf('/');
+        if (slashIndex === -1) {
+            return {
+                __proto__: null, name: x, subpath: '.'
+            };
+        }
+        var secondSlash = x.indexOf('/', slashIndex + 1);
+        if (secondSlash === -1) {
+            return {
+                __proto__: null, name: x, subpath: '.'
+            };
+        }
+        return {
+            __proto__: null, name: x.slice(0, secondSlash), subpath: '.' + x.slice(secondSlash)
+        };
+    }
+    var firstSlash = x.indexOf('/');
+    if (firstSlash === -1) {
+        return {
+            __proto__: null, name: x, subpath: '.'
+        };
+    }
+    return {
+        __proto__: null, name: x.slice(0, firstSlash), subpath: '.' + x.slice(firstSlash)
+    };
+};

node_modules/resolve/lib/select-most-restrictive.js

@@ -0,0 +1,42 @@
+'use strict';
+
+// Category ranking from most restrictive (lowest rank) to least restrictive (highest rank)
+// Lower rank = more restrictive = fewer features supported
+var categoryRank = /** @type {const} */ {
+    __proto__: null,
+    'pre-exports': /** @type {const} */ (0),
+    broken: /** @type {const} */ (1),
+    experimental: /** @type {const} */ (2),
+    conditions: /** @type {const} */ (3),
+    'broken-dir-slash-conditions': /** @type {const} */ (4),
+    patterns: /** @type {const} */ (5),
+    'pattern-trailers': /** @type {const} */ (6),
+    'pattern-trailers+json-imports': /** @type {const} */ (7),
+    'pattern-trailers-no-dir-slash': /** @type {const} */ (8),
+    'pattern-trailers-no-dir-slash+json-imports': /** @type {const} */ (9),
+    'require-esm': /** @type {const} */ (10),
+    'strips-types': /** @type {const} */ (11),
+    'subpath-imports-slash': /** @type {const} */ (12)
+};
+
+// Select the most restrictive category from an array of categories
+/** @type {(categories?: ReturnType<import('node-exports-info/getCategory')>[]) => import('node-exports-info/getCategory').Category | null} */
+module.exports = function selectMostRestrictive(categories) {
+    if (!categories || categories.length === 0) {
+        return null;
+    }
+
+    var mostRestrictive = null;
+    var lowestRank = Infinity;
+
+    for (var i = 0; i < categories.length; i++) {
+        var cat = categories[i];
+        var rank = categoryRank[cat];
+        if (typeof rank === 'number' && rank < lowestRank) {
+            lowestRank = rank;
+            mostRestrictive = cat;
+        }
+    }
+
+    return mostRestrictive;
+};

node_modules/resolve/lib/sync.d.ts

@@ -0,0 +1,13 @@
+import type resolve = require('../index.js');
+
+/**
+ * Synchronously resolve a module path, like `require.resolve()`, on behalf of files.
+ *
+ * @param id - The module identifier to resolve.
+ * @param options - Resolution options.
+ * @returns The resolved file path.
+ * @throws If the module cannot be found.
+ */
+declare function resolveSync(id: string, options?: resolve.SyncOptions): string;
+
+export = resolveSync;

node_modules/resolve/lib/sync.js

@@ -0,0 +1,423 @@
+var isCore = require('is-core-module');
+var fs = require('fs');
+var path = require('path');
+var $Error = require('es-errors');
+var $TypeError = require('es-errors/type');
+
+var getHomedir = require('./homedir');
+var caller = require('./caller');
+var nodeModulesPaths = require('./node-modules-paths');
+var normalizeOptions = require('./normalize-options');
+var resolveExports = require('./exports-resolve');
+var parsePackageSpecifier = require('./parse-package-specifier');
+var getExportsCategory = require('./get-exports-category');
+var getCategoryInfo = require('node-exports-info/getCategoryInfo');
+var getCategoriesForRange = require('node-exports-info/getCategoriesForRange');
+var selectMostRestrictive = require('./select-most-restrictive');
+
+var realpathFS = process.platform !== 'win32' && fs.realpathSync && typeof fs.realpathSync.native === 'function' ? fs.realpathSync.native : fs.realpathSync;
+
+var relativePathRegex = /^(?:\.\.?(?:\/|$)|\/|([A-Za-z]:)?[/\\])/;
+var windowsDriveRegex = /^\w:[/\\]*$/;
+var nodeModulesRegex = /[/\\]node_modules[/\\]*$/;
+
+var homedir = getHomedir();
+function defaultPaths() {
+    if (!homedir) return [];
+    return [
+        path.join(homedir, '.node_modules'),
+        path.join(homedir, '.node_libraries')
+    ];
+}
+
+var defaultIsFile = function isFile(file) {
+    try {
+        var stat = fs.statSync(file, { throwIfNoEntry: false });
+    } catch (e) {
+        if (e && (e.code === 'ENOENT' || e.code === 'ENOTDIR')) return false;
+        throw e;
+    }
+    return !!stat && (stat.isFile() || stat.isFIFO());
+};
+
+var defaultIsDir = function isDirectory(dir) {
+    try {
+        var stat = fs.statSync(dir, { throwIfNoEntry: false });
+    } catch (e) {
+        if (e && (e.code === 'ENOENT' || e.code === 'ENOTDIR')) return false;
+        throw e;
+    }
+    return !!stat && stat.isDirectory();
+};
+
+var defaultRealpathSync = function realpathSync(x) {
+    try {
+        return realpathFS(x);
+    } catch (realpathErr) {
+        if (realpathErr.code !== 'ENOENT') {
+            throw realpathErr;
+        }
+    }
+    return x;
+};
+
+function maybeRealpathSync(realpathSync, x, opts) {
+    if (!opts || !opts.preserveSymlinks) {
+        return realpathSync(x);
+    }
+    return x;
+}
+
+function defaultReadPackageSync(readFileSync, pkgfile) {
+    return JSON.parse(readFileSync(pkgfile));
+}
+
+function getPackageCandidates(x, start, opts) {
+    var dirs = nodeModulesPaths(start, opts, x);
+    for (var i = 0; i < dirs.length; i++) {
+        dirs[i] = path.join(dirs[i], x);
+    }
+    return dirs;
+}
+
+function findConsumerPackageSync(startDir, isFile, readPackageSync, readFileSync) {
+    var dir = path.resolve(startDir);
+    while (true) {
+        var pkgfile = path.join(dir, 'package.json');
+        if (isFile(pkgfile)) {
+            try {
+                return readPackageSync(readFileSync, pkgfile);
+            } catch (e) {
+                if (!(e instanceof SyntaxError)) {
+                    throw e;
+                }
+            }
+        }
+        var parentDir = path.dirname(dir);
+        if (parentDir === dir) {
+            return null;
+        }
+        dir = parentDir;
+    }
+}
+
+function findPackageWithDirSync(startDir, isFile, readPackageSync, readFileSync) {
+    var dir = path.resolve(startDir);
+    while (true) {
+        // Stop at node_modules boundaries - can't self-reference across node_modules
+        if (nodeModulesRegex.test(dir)) {
+            return null;
+        }
+        var pkgfile = path.join(dir, 'package.json');
+        if (isFile(pkgfile)) {
+            try {
+                var pkg = readPackageSync(readFileSync, pkgfile);
+                return {
+                    __proto__: null, pkg: pkg, dir: dir
+                };
+            } catch (e) {
+                if (!(e instanceof SyntaxError)) {
+                    throw e;
+                }
+            }
+        }
+        var parentDir = path.dirname(dir);
+        if (parentDir === dir) {
+            return null;
+        }
+        dir = parentDir;
+    }
+}
+
+module.exports = function resolveSync(x, options) {
+    if (typeof x !== 'string') {
+        throw new $TypeError('Path must be a string.');
+    }
+    var opts = normalizeOptions(x, options);
+
+    var isFile = opts.isFile || defaultIsFile;
+    var isDirectory = opts.isDirectory || defaultIsDir;
+    var readFileSync = opts.readFileSync || fs.readFileSync;
+    var realpathSync = opts.realpathSync || defaultRealpathSync;
+    var readPackageSync = opts.readPackageSync || defaultReadPackageSync;
+    if (opts.readFileSync && opts.readPackageSync) {
+        throw new $TypeError('`readFileSync` and `readPackageSync` are mutually exclusive.');
+    }
+    var packageIterator = opts.packageIterator;
+
+    if (typeof opts.moduleSystem !== 'undefined' && opts.moduleSystem !== 'require' && opts.moduleSystem !== 'import') {
+        throw new $TypeError('`moduleSystem` must be `\'require\'` or `\'import\'`.');
+    }
+
+    var extensions = opts.extensions || ['.js'];
+    var includeCoreModules = opts.includeCoreModules !== false;
+    var basedir = opts.basedir || path.dirname(caller());
+    var parent = opts.filename || basedir;
+
+    opts.paths = opts.paths || defaultPaths();
+
+    // Determine exports category
+    var exportsCategory = getExportsCategory(opts);
+    if (exportsCategory === 'engines') {
+        // Read consumer's package.json to get engines.node
+        var consumerPkg = findConsumerPackageSync(basedir, isFile, readPackageSync, readFileSync);
+        if (consumerPkg && consumerPkg.engines && consumerPkg.engines.node) {
+            var categories = getCategoriesForRange(consumerPkg.engines.node);
+            exportsCategory = selectMostRestrictive(categories);
+        } else {
+            exportsCategory = null;
+        }
+    }
+
+    var useExports = exportsCategory !== null && exportsCategory !== 'pre-exports';
+
+    // ensure that `basedir` is an absolute path at this point, resolving against the process' current working directory
+    var absoluteStart = maybeRealpathSync(realpathSync, path.resolve(basedir), opts);
+
+    if (opts.basedir && !isDirectory(absoluteStart)) {
+        var dirError = new $TypeError('Provided basedir "' + opts.basedir + '" is not a directory' + (opts.preserveSymlinks ? '' : ', or a symlink to a directory'));
+        dirError.code = 'INVALID_BASEDIR';
+        throw dirError;
+    }
+
+    if (relativePathRegex.test(x)) {
+        var res = path.resolve(absoluteStart, x);
+        if (x === '.' || x === '..' || x.slice(-1) === '/') res += '/';
+        var m = loadAsFileSync(res) || loadAsDirectorySync(res);
+        if (m) return maybeRealpathSync(realpathSync, m, opts);
+    } else if (includeCoreModules && isCore(x)) {
+        return x;
+    } else if (useExports) {
+        // Try self-reference resolution first
+        var selfRef = resolveSelfReferenceSync(x, absoluteStart);
+        if (selfRef) return maybeRealpathSync(realpathSync, selfRef, opts);
+        var nE = loadNodeModulesWithExportsSync(x, absoluteStart);
+        if (nE) return maybeRealpathSync(realpathSync, nE, opts);
+    } else {
+        var n = loadNodeModulesSync(x, absoluteStart);
+        if (n) return maybeRealpathSync(realpathSync, n, opts);
+    }
+
+    var err = new $Error("Cannot find module '" + x + "' from '" + parent + "'");
+    err.code = 'MODULE_NOT_FOUND';
+    throw err;
+
+    function resolveSelfReferenceSync(x, startDir) {
+        var parsed = parsePackageSpecifier(x);
+        var pkgInfo = findPackageWithDirSync(startDir, isFile, readPackageSync, readFileSync);
+
+        if (!pkgInfo || !pkgInfo.pkg || pkgInfo.pkg.name !== parsed.name) {
+            return null; // Not a self-reference
+        }
+
+        var pkg = pkgInfo.pkg;
+        var pkgDir = pkgInfo.dir;
+
+        if (opts.packageFilter) {
+            pkg = opts.packageFilter(pkg, path.join(pkgDir, 'package.json'), pkgDir);
+        }
+
+        // If package has exports field, resolve via exports
+        if (typeof pkg.exports !== 'undefined') {
+            var categoryInfo = getCategoryInfo(exportsCategory, opts.moduleSystem || 'require');
+            var conditions = opts.conditions || categoryInfo.conditions;
+            var resolved = resolveExports(pkg.exports, parsed.subpath, conditions, categoryInfo.flags);
+            if (resolved) {
+                var resolvedPath = path.resolve(pkgDir, resolved);
+                if (isFile(resolvedPath)) {
+                    return resolvedPath;
+                }
+            }
+            // exports field exists but didn't resolve - this is an error per Node semantics
+            return undefined;
+        }
+
+        // No exports field - fall back to traditional resolution for self-reference
+        // (Note: this matches Node's behavior where self-ref without exports uses main)
+        if (parsed.subpath === '.') {
+            return loadAsDirectorySync(pkgDir);
+        }
+        var subPath = path.join(pkgDir, parsed.subpath.slice(1));
+        var sm = loadAsFileSync(subPath);
+        if (sm) return sm;
+        return loadAsDirectorySync(subPath);
+    }
+
+    function loadAsFileSync(x) {
+        var pkg = loadpkg(path.dirname(x));
+
+        if (pkg && pkg.dir && pkg.pkg && opts.pathFilter) {
+            var rfile = path.relative(pkg.dir, x);
+            var r = opts.pathFilter(pkg.pkg, x, rfile);
+            if (r) {
+                x = path.resolve(pkg.dir, r); // eslint-disable-line no-param-reassign
+            }
+        }
+
+        if (isFile(x)) {
+            return x;
+        }
+
+        for (var i = 0; i < extensions.length; i++) {
+            var file = x + extensions[i];
+            if (isFile(file)) {
+                return file;
+            }
+        }
+    }
+
+    function loadpkg(dir) {
+        if (dir === '' || dir === '/') return;
+        if (process.platform === 'win32' && windowsDriveRegex.test(dir)) {
+            return;
+        }
+        if (nodeModulesRegex.test(dir)) return;
+
+        var pkgfile = path.join(isDirectory(dir) ? maybeRealpathSync(realpathSync, dir, opts) : dir, 'package.json');
+
+        if (!isFile(pkgfile)) {
+            return loadpkg(path.dirname(dir));
+        }
+
+        var pkg;
+        try {
+            pkg = readPackageSync(readFileSync, pkgfile);
+        } catch (e) {
+            if (!(e instanceof SyntaxError)) {
+                throw e;
+            }
+        }
+
+        if (pkg && opts.packageFilter) {
+            pkg = opts.packageFilter(pkg, pkgfile, dir);
+        }
+
+        return { pkg: pkg, dir: dir };
+    }
+
+    function loadAsDirectorySync(x) {
+        var pkgfile = path.join(isDirectory(x) ? maybeRealpathSync(realpathSync, x, opts) : x, '/package.json');
+        if (isFile(pkgfile)) {
+            try {
+                var pkg = readPackageSync(readFileSync, pkgfile);
+            } catch (e) {}
+
+            if (pkg && opts.packageFilter) {
+                pkg = opts.packageFilter(pkg, pkgfile, x);
+            }
+
+            if (pkg && pkg.main) {
+                if (typeof pkg.main !== 'string') {
+                    var mainError = new $TypeError('package “' + pkg.name + '” `main` must be a string');
+                    mainError.code = 'INVALID_PACKAGE_MAIN';
+                    throw mainError;
+                }
+                if (pkg.main === '.' || pkg.main === './') {
+                    pkg.main = 'index';
+                }
+                try {
+                    var mainPath = path.resolve(x, pkg.main);
+                    var m = loadAsFileSync(mainPath);
+                    if (m) return m;
+                    var n = loadAsDirectorySync(mainPath);
+                    if (n) return n;
+                    var checkIndex = loadAsFileSync(path.resolve(x, 'index'));
+                    if (checkIndex) return checkIndex;
+                } catch (e) { }
+                var incorrectMainError = new $Error("Cannot find module '" + path.resolve(x, pkg.main) + "'. Please verify that the package.json has a valid \"main\" entry");
+                incorrectMainError.code = 'INCORRECT_PACKAGE_MAIN';
+                throw incorrectMainError;
+            }
+        }
+
+        return loadAsFileSync(path.join(x, '/index'));
+    }
+
+    function loadNodeModulesSync(x, start) {
+        var thunk = function () { return getPackageCandidates(x, start, opts); };
+        var dirs = packageIterator ? packageIterator(x, start, thunk, opts) : thunk();
+
+        for (var i = 0; i < dirs.length; i++) {
+            var dir = dirs[i];
+            if (isDirectory(path.dirname(dir))) {
+                var m = loadAsFileSync(dir);
+                if (m) return m;
+                var n = loadAsDirectorySync(dir);
+                if (n) return n;
+            }
+        }
+    }
+
+    function loadNodeModulesWithExportsSync(x, start) {
+        var parsed = parsePackageSpecifier(x);
+        var categoryInfo = getCategoryInfo(exportsCategory, opts.moduleSystem || 'require');
+        var conditions = opts.conditions || categoryInfo.conditions;
+
+        // Get candidate directories for the package name
+        var thunk = function () { return getPackageCandidates(parsed.name, start, opts); };
+        var dirs = packageIterator ? packageIterator(parsed.name, start, thunk, opts) : thunk();
+
+        for (var i = 0; i < dirs.length; i++) {
+            var pkgDir = dirs[i];
+            if (isDirectory(pkgDir)) {
+                var pkgfile = path.join(pkgDir, 'package.json');
+                if (isFile(pkgfile)) {
+                    var pkg;
+                    try {
+                        pkg = readPackageSync(readFileSync, pkgfile);
+                    } catch (e) {
+                        if (!(e instanceof SyntaxError)) {
+                            throw e;
+                        }
+                        pkg = null;
+                    }
+
+                    if (pkg) {
+                        if (opts.packageFilter) {
+                            pkg = opts.packageFilter(pkg, pkgfile, pkgDir);
+                        }
+
+                        // If package has exports field, use exports resolution
+                        if (typeof pkg.exports !== 'undefined') {
+                            var resolved = resolveExports(pkg.exports, parsed.subpath, conditions, categoryInfo.flags);
+                            if (resolved) {
+                                var resolvedPath = path.resolve(pkgDir, resolved);
+                                if (isFile(resolvedPath)) {
+                                    return resolvedPath;
+                                }
+                            }
+                            // exports field exists but didn't resolve - this is an error per Node semantics
+                            // (don't fall through to main/index)
+                            return undefined;
+                        }
+
+                        // No exports field, fall back to traditional resolution
+                        if (parsed.subpath === '.') {
+                            var result = loadAsDirectorySync(pkgDir);
+                            if (result) { return result; }
+                        } else {
+                            var subPath = path.join(pkgDir, parsed.subpath.slice(1));
+                            var sm = loadAsFileSync(subPath);
+                            if (sm) { return sm; }
+                            var sn = loadAsDirectorySync(subPath);
+                            if (sn) { return sn; }
+                        }
+                    }
+                } else if (parsed.subpath === '.') {
+                    // No package.json, fall back to file/directory resolution
+                    var m = loadAsFileSync(pkgDir);
+                    if (m) { return m; }
+                    var n = loadAsDirectorySync(pkgDir);
+                    if (n) { return n; }
+                } else {
+                    // No package.json, fall back to file/directory resolution for subpath
+                    var fullPath = path.join(pkgDir, parsed.subpath.slice(1));
+                    var m2 = loadAsFileSync(fullPath);
+                    if (m2) { return m2; }
+                    var n2 = loadAsDirectorySync(fullPath);
+                    if (n2) { return n2; }
+                }
+            }
+        }
+    }
+};

node_modules/resolve/package.json

@@ -0,0 +1,99 @@
+{
+	"name": "resolve",
+	"description": "resolve like require.resolve() on behalf of files asynchronously and synchronously",
+	"version": "2.0.0-next.7",
+	"repository": {
+		"type": "git",
+		"url": "ssh://github.com/browserify/resolve.git"
+	},
+	"bin": {
+		"resolve": "./bin/resolve"
+	},
+	"main": "index.js",
+	"exports": {
+		".": [
+			{
+				"import": "./index.mjs",
+				"default": "./index.js"
+			},
+			"./index.js"
+		],
+		"./sync": "./lib/sync.js",
+		"./async": "./lib/async.js",
+		"./package.json": "./package.json"
+	},
+	"keywords": [
+		"resolve",
+		"require",
+		"node",
+		"module"
+	],
+	"scripts": {
+		"prepack": "npmignore --auto --commentLines=autogenerated",
+		"prepublishOnly": "safe-publish-latest",
+		"prepublish": "not-in-publish || npm run prepublishOnly",
+		"prelint": "eclint check $(git ls-files | grep -Ev test\\/list-exports$ | xargs find 2> /dev/null | grep -vE 'node_modules|\\.git')",
+		"lint": "eslint .",
+		"postlint": "tsc -p . && attw -P",
+		"pretests-only": "npm run submodule:update && cd ./test/resolver/nested_symlinks && node mylib/sync && node mylib/async",
+		"tests-only": "nyc tape test/*.js",
+		"pretest": "npm run lint",
+		"test": "npm run --silent tests-only",
+		"posttest": "npm run test:multirepo && npx npm@\">= 10.2\" audit --production",
+		"test:multirepo": "cd ./test/resolver/multirepo && npm install && npm test",
+		"submodule:update": "git submodule update --init --depth 1 && cd test/list-exports && git sparse-checkout init --cone && git sparse-checkout set packages/tests"
+	},
+	"license": "MIT",
+	"author": {
+		"name": "James Halliday",
+		"email": "mail@substack.net",
+		"url": "http://substack.net"
+	},
+	"funding": {
+		"url": "https://github.com/sponsors/ljharb"
+	},
+	"dependencies": {
+		"es-errors": "^1.3.0",
+		"is-core-module": "^2.16.2",
+		"node-exports-info": "^1.6.0",
+		"object-keys": "^1.1.1",
+		"path-parse": "^1.0.7",
+		"supports-preserve-symlinks-flag": "^1.0.0"
+	},
+	"devDependencies": {
+		"@arethetypeswrong/cli": "^0.18.2",
+		"@ljharb/eslint-config": "^22.2.3",
+		"@ljharb/tsconfig": "^0.3.2",
+		"@types/node": "^25.8.0",
+		"array.prototype.map": "^1.0.8",
+		"copy-dir": "^1.3.0",
+		"eclint": "^2.8.1",
+		"eslint": "^9.39.4",
+		"in-publish": "^2.0.1",
+		"jiti": "^0.0.0",
+		"mkdirp": "^0.5.6",
+		"mv": "^2.1.1",
+		"npmignore": "^0.3.5",
+		"nyc": "^10.3.2",
+		"rimraf": "^2.7.1",
+		"safe-publish-latest": "^2.0.0",
+		"tap": "^0.4.13",
+		"tape": "^5.9.0",
+		"tmp": "^0.0.31",
+		"typescript": "next"
+	},
+	"publishConfig": {
+		"ignore": [
+			".github/workflows",
+			".github/.well-known",
+			".gitmodules",
+			"appveyor.yml",
+			"CONTRIBUTING.md",
+			"test/resolver/malformed_package_json",
+			"test/list-exports"
+		]
+	},
+	"engines": {
+		"node": ">= 0.4"
+	}
+}

node_modules/resolve/readme.markdown

@@ -0,0 +1,326 @@
+# resolve <sup>[![Version Badge][2]][1]</sup>
+
+implements the [node `require.resolve()` algorithm](https://nodejs.org/api/modules.html#modules_all_together) such that you can `require.resolve()` on behalf of a file asynchronously and synchronously
+
+[![github actions][actions-image]][actions-url]
+[![coverage][codecov-image]][codecov-url]
+[![License][license-image]][license-url]
+[![Downloads][downloads-image]][downloads-url]
+[![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/10759/badge)](https://bestpractices.coreinfrastructure.org/projects/10759)
+
+[![npm badge][11]][1]
+
+# example
+
+asynchronously resolve:
+
+```js
+var resolve = require('resolve/async'); // or, require('resolve')
+resolve('tap', { basedir: __dirname }, function (err, res) {
+    if (err) console.error(err);
+    else console.log(res);
+});
+```
+
+```
+$ node example/async.js
+/home/substack/projects/node-resolve/node_modules/tap/lib/main.js
+```
+
+synchronously resolve:
+
+```js
+var resolve = require('resolve/sync'); // or, `require('resolve').sync
+var res = resolve('tap', { basedir: __dirname });
+console.log(res);
+```
+
+```
+$ node example/sync.js
+/home/substack/projects/node-resolve/node_modules/tap/lib/main.js
+```
+
+# methods
+
+```js
+var resolve = require('resolve');
+var async = require('resolve/async');
+var sync = require('resolve/sync');
+```
+
+For both the synchronous and asynchronous methods, errors may have any of the following `err.code` values:
+
+- `MODULE_NOT_FOUND`: the given path string (`id`) could not be resolved to a module
+- `INVALID_BASEDIR`: the specified `opts.basedir` doesn't exist, or is not a directory
+- `INVALID_PACKAGE_MAIN`: a `package.json` was encountered with an invalid `main` property (eg. not a string)
+- `ERR_PACKAGE_PATH_NOT_EXPORTED`: the requested subpath is not defined in the package's `exports` field
+- `ERR_INVALID_PACKAGE_CONFIG`: the package's `exports` field contains an invalid target
+- `INVALID_EXPORTS_CATEGORY`: an invalid `exportsCategory` was specified
+
+## resolve(id, opts={}, cb)
+
+Asynchronously resolve the module path string `id` into `cb(err, res [, pkg])`, where `pkg` (if defined) is the data from `package.json`.
+
+options are:
+
+* opts.basedir - directory to begin resolving from
+
+* opts.package - `package.json` data applicable to the module being loaded
+
+* opts.extensions - array of file extensions to search in order
+
+* opts.includeCoreModules - set to `false` to exclude node core modules (e.g. `fs`) from the search
+
+* opts.readFile - how to read files asynchronously
+
+* opts.isFile - function to asynchronously test whether a file exists
+
+* opts.isDirectory - function to asynchronously test whether a file exists and is a directory
+
+* opts.realpath - function to asynchronously resolve a potential symlink to its real path
+
+* `opts.readPackage(readFile, pkgfile, cb)` - function to asynchronously read and parse a package.json file
+  * readFile - the passed `opts.readFile` or `fs.readFile` if not specified
+  * pkgfile - path to package.json
+  * cb - callback. a SyntaxError error argument will be ignored, all other error arguments will be treated as an error.
+
+* `opts.packageFilter(pkg, pkgfile, dir)` - transform the parsed package.json contents before looking at the "main" field
+  * pkg - package data
+  * pkgfile - path to package.json
+  * dir - directory that contains package.json
+
+* `opts.pathFilter(pkg, path, relativePath)` - transform a path within a package
+  * pkg - package data
+  * path - the path being resolved
+  * relativePath - the path relative from the package.json location
+  * returns - a relative path that will be joined from the package.json location
+
+* opts.paths - require.paths array to use if nothing is found on the normal `node_modules` recursive walk (probably don't use this)
+
+  For advanced users, `paths` can also be a `opts.paths(request, start, opts)` function
+    * request - the import specifier being resolved
+    * start - lookup path
+    * getNodeModulesDirs - a thunk (no-argument function) that returns the paths using standard `node_modules` resolution
+    * opts - the resolution options
+
+* `opts.packageIterator(request, start, opts)` - return the list of candidate paths where the packages sources may be found (probably don't use this)
+    * request - the import specifier being resolved
+    * start - lookup path
+    * getPackageCandidates - a thunk (no-argument function) that returns the paths using standard `node_modules` resolution
+    * opts - the resolution options
+
+* opts.moduleDirectory - directory (or directories) in which to recursively look for modules. default: `"node_modules"`
+
+* opts.preserveSymlinks - if true, doesn't resolve `basedir` to real path before resolving.
+This is the way Node resolves dependencies when executed with the [--preserve-symlinks](https://nodejs.org/api/all.html#cli_preserve_symlinks) flag.
+
+* opts.exportsCategory - a [node-exports-info](https://npmjs.com/package/node-exports-info) category string (e.g. `'conditions'`, `'patterns'`, `'pre-exports'`) that determines which `exports` field semantics to use.
+When set, resolution will use the package's `exports` field according to that category's supported conditions and features.
+This also enables **self-reference** support, allowing a package to import itself by name (e.g., `require('my-package')` from within `my-package`).
+
+* opts.engines - determines `exports` field resolution based on Node.js version semantics:
+  * When a **string** (e.g. `'>= 14'`): treated as a semver range, mapped to the most restrictive [node-exports-info](https://npmjs.com/package/node-exports-info) category covering that range.
+  * When `true`: reads `engines.node` from the nearest `package.json` to `basedir` and uses the most restrictive category for that range.
+  * When `false` or omitted: no engine-based exports resolution.
+  * Throws if set to an empty string or non-boolean/non-string value.
+
+**Note:** `exportsCategory` and `engines` are mutually exclusive - only one can be specified.
+
+* opts.moduleSystem - either `'require'` or `'import'`. Determines which module system conditions are used when resolving the `exports` field. When `'require'` (the default), the conditions include `require`; when `'import'`, the conditions include `import` instead. This option only has effect when `exportsCategory` or `engines` is also set. For example, given a package with `exports: { ".": { "import": "./esm.js", "require": "./cjs.js" } }`, resolving with `moduleSystem: 'import'` returns `esm.js`, while `moduleSystem: 'require'` (or omitting it) returns `cjs.js`.
+
+* opts.conditions - an array of condition strings (e.g. `['require', 'node']`) to use when resolving the `exports` field.
+If specified, this overrides the conditions that would otherwise be derived from the category (including those from `moduleSystem`).
+This option only has effect when `exportsCategory` or `engines` is also set.
+
+default `opts` values:
+
+```js
+{
+    paths: [],
+    basedir: __dirname,
+    extensions: ['.js'],
+    includeCoreModules: true,
+    readFile: fs.readFile,
+    isFile: function isFile(file, cb) {
+        fs.stat(file, function (err, stat) {
+            if (!err) {
+                return cb(null, stat.isFile() || stat.isFIFO());
+            }
+            if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return cb(null, false);
+            return cb(err);
+        });
+    },
+    isDirectory: function isDirectory(dir, cb) {
+        fs.stat(dir, function (err, stat) {
+            if (!err) {
+                return cb(null, stat.isDirectory());
+            }
+            if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return cb(null, false);
+            return cb(err);
+        });
+    },
+    realpath: function realpath(file, cb) {
+        var realpath = typeof fs.realpath.native === 'function' ? fs.realpath.native : fs.realpath;
+        realpath(file, function (realPathErr, realPath) {
+            if (realPathErr && realPathErr.code !== 'ENOENT') cb(realPathErr);
+            else cb(null, realPathErr ? file : realPath);
+        });
+    },
+    readPackage: function defaultReadPackage(readFile, pkgfile, cb) {
+        readFile(pkgfile, function (readFileErr, body) {
+            if (readFileErr) cb(readFileErr);
+            else {
+                try {
+                    var pkg = JSON.parse(body);
+                    cb(null, pkg);
+                } catch (jsonErr) {
+                    cb(jsonErr);
+                }
+            }
+        });
+    },
+    moduleDirectory: 'node_modules',
+    preserveSymlinks: false
+}
+```
+
+## resolve.sync(id, opts)
+
+Synchronously resolve the module path string `id`, returning the result and
+throwing an error when `id` can't be resolved.
+
+options are:
+
+* opts.basedir - directory to begin resolving from
+
+* opts.extensions - array of file extensions to search in order
+
+* opts.includeCoreModules - set to `false` to exclude node core modules (e.g. `fs`) from the search
+
+* opts.readFileSync - how to read files synchronously
+
+* opts.isFile - function to synchronously test whether a file exists
+
+* opts.isDirectory - function to synchronously test whether a file exists and is a directory
+
+* opts.realpathSync - function to synchronously resolve a potential symlink to its real path
+
+* `opts.readPackageSync(readFileSync, pkgfile)` - function to synchronously read and parse a package.json file. a thrown SyntaxError will be ignored, all other exceptions will propagate.
+  * readFileSync - the passed `opts.readFileSync` or `fs.readFileSync` if not specified
+  * pkgfile - path to package.json
+
+* `opts.packageFilter(pkg, pkgfile, dir)` - transform the parsed package.json contents before looking at the "main" field
+  * pkg - package data
+  * pkgfile - path to package.json
+  * dir - directory that contains package.json
+
+* `opts.pathFilter(pkg, path, relativePath)` - transform a path within a package
+  * pkg - package data
+  * path - the path being resolved
+  * relativePath - the path relative from the package.json location
+  * returns - a relative path that will be joined from the package.json location
+
+* opts.paths - require.paths array to use if nothing is found on the normal `node_modules` recursive walk (probably don't use this)
+
+  For advanced users, `paths` can also be a `opts.paths(request, start, opts)` function
+    * request - the import specifier being resolved
+    * start - lookup path
+    * getNodeModulesDirs - a thunk (no-argument function) that returns the paths using standard `node_modules` resolution
+    * opts - the resolution options
+
+* `opts.packageIterator(request, start, opts)` - return the list of candidate paths where the packages sources may be found (probably don't use this)
+    * request - the import specifier being resolved
+    * start - lookup path
+    * getPackageCandidates - a thunk (no-argument function) that returns the paths using standard `node_modules` resolution
+    * opts - the resolution options
+
+* opts.moduleDirectory - directory (or directories) in which to recursively look for modules. default: `"node_modules"`
+
+* opts.preserveSymlinks - if true, doesn't resolve `basedir` to real path before resolving.
+This is the way Node resolves dependencies when executed with the [--preserve-symlinks](https://nodejs.org/api/all.html#cli_preserve_symlinks) flag.
+
+* opts.exportsCategory - a [node-exports-info](https://npmjs.com/package/node-exports-info) category string (e.g. `'conditions'`, `'patterns'`, `'pre-exports'`) that determines which `exports` field semantics to use. When set, resolution will use the package's `exports` field according to that category's supported conditions and features. This also enables **self-reference** support, allowing a package to import itself by name (e.g., `require('my-package')` from within `my-package`).
+
+* opts.enginesRange - a semver range string (e.g. `'>= 14'`) that will be mapped to the most restrictive [node-exports-info](https://npmjs.com/package/node-exports-info) category covering that range.
+
+* opts.engines - if `true`, reads `engines.node` from the nearest `package.json` to `basedir` and uses the most restrictive [node-exports-info](https://npmjs.com/package/node-exports-info) category for that range.
+
+**Note:** `exportsCategory`, `enginesRange`, and `engines` are mutually exclusive - only one can be specified.
+
+* opts.moduleSystem - either `'require'` or `'import'`. Determines which module system conditions are used when resolving the `exports` field. When `'require'` (the default), the conditions include `require`; when `'import'`, the conditions include `import` instead. This option only has effect when `exportsCategory` or `engines` is also set. For example, given a package with `exports: { ".": { "import": "./esm.js", "require": "./cjs.js" } }`, resolving with `moduleSystem: 'import'` returns `esm.js`, while `moduleSystem: 'require'` (or omitting it) returns `cjs.js`.
+
+* opts.conditions - an array of condition strings (e.g. `['require', 'node']`) to use when resolving the `exports` field. If specified, this overrides the conditions that would otherwise be derived from the category (including those from `moduleSystem`). This option only has effect when one of `exportsCategory`, `enginesRange`, or `engines` is also set.
+
+default `opts` values:
+
+```js
+{
+    paths: [],
+    basedir: __dirname,
+    extensions: ['.js'],
+    includeCoreModules: true,
+    readFileSync: fs.readFileSync,
+    isFile: function isFile(file) {
+        try {
+            var stat = fs.statSync(file);
+        } catch (e) {
+            if (e && (e.code === 'ENOENT' || e.code === 'ENOTDIR')) return false;
+            throw e;
+        }
+        return stat.isFile() || stat.isFIFO();
+    },
+    isDirectory: function isDirectory(dir) {
+        try {
+            var stat = fs.statSync(dir);
+        } catch (e) {
+            if (e && (e.code === 'ENOENT' || e.code === 'ENOTDIR')) return false;
+            throw e;
+        }
+        return stat.isDirectory();
+    },
+    realpathSync: function realpathSync(file) {
+        try {
+            var realpath = typeof fs.realpathSync.native === 'function' ? fs.realpathSync.native : fs.realpathSync;
+            return realpath(file);
+        } catch (realPathErr) {
+            if (realPathErr.code !== 'ENOENT') {
+                throw realPathErr;
+            }
+        }
+        return file;
+    },
+    readPackageSync: function defaultReadPackageSync(readFileSync, pkgfile) {
+        return JSON.parse(readFileSync(pkgfile));
+    },
+    moduleDirectory: 'node_modules',
+    preserveSymlinks: false
+}
+```
+
+# install
+
+With [npm](https://npmjs.org) do:
+
+```sh
+npm install resolve
+```
+
+# license
+
+MIT
+
+[1]: https://npmjs.org/package/resolve
+[2]: https://versionbadg.es/browserify/resolve.svg
+[5]: https://david-dm.org/browserify/resolve.svg
+[6]: https://david-dm.org/browserify/resolve
+[7]: https://david-dm.org/browserify/resolve/dev-status.svg
+[8]: https://david-dm.org/browserify/resolve#info=devDependencies
+[11]: https://nodei.co/npm/resolve.png?downloads=true&stars=true
+[license-image]: https://img.shields.io/npm/l/resolve.svg
+[license-url]: LICENSE
+[downloads-image]: https://img.shields.io/npm/dm/resolve.svg
+[downloads-url]: https://npm-stat.com/charts.html?package=resolve
+[codecov-image]: https://codecov.io/gh/browserify/resolve/branch/main/graphs/badge.svg
+[codecov-url]: https://app.codecov.io/gh/browserify/resolve/
+[actions-image]: https://img.shields.io/github/check-runs/browserify/resolve/main
+[actions-url]: https://github.com/browserify/resolve/actions

node_modules/resolve/sync.d.ts

@@ -0,0 +1,3 @@
+import type resolveSync = require('./lib/sync');
+
+export = resolveSync;

node_modules/resolve/sync.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./lib/sync');

node_modules/resolve/test/default_paths.js

@@ -0,0 +1,49 @@
+'use strict';
+
+var path = require('path');
+var test = require('tape');
+var mockProperty = require('mock-property');
+
+var homedirPath = require.resolve('../lib/homedir');
+var asyncPath = require.resolve('../async');
+var libAsyncPath = require.resolve('../lib/async');
+var syncPath = require.resolve('../sync');
+var libSyncPath = require.resolve('../lib/sync');
+
+function mockNullHomedir(t) {
+    t.teardown(mockProperty(require.cache, homedirPath, {
+        value: { id: homedirPath, filename: homedirPath, loaded: true, exports: function () { return null; } }
+    }));
+}
+
+test('async: null homedir does not throw', function (t) {
+    t.plan(2);
+
+    mockNullHomedir(t);
+    t.teardown(mockProperty(require.cache, asyncPath, { 'delete': true }));
+    t.teardown(mockProperty(require.cache, libAsyncPath, { 'delete': true }));
+
+    var resolve = require('../lib/async');
+
+    var dir = path.join(__dirname, 'resolver');
+
+    resolve('./baz', { basedir: dir }, function (err, res) {
+        t.error(err, 'no error');
+        t.equal(res, path.join(dir, 'baz', 'quux.js'), 'resolves correctly with null homedir');
+    });
+});
+
+test('sync: null homedir does not throw', function (t) {
+    mockNullHomedir(t);
+    t.teardown(mockProperty(require.cache, syncPath, { 'delete': true }));
+    t.teardown(mockProperty(require.cache, libSyncPath, { 'delete': true }));
+
+    var resolveSync = require('../lib/sync');
+
+    var dir = path.join(__dirname, 'resolver');
+
+    var res = resolveSync('./baz', { basedir: dir });
+    t.equal(res, path.join(dir, 'baz', 'quux.js'), 'resolves correctly with null homedir');
+
+    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/exports_sync.js

@@ -0,0 +1,955 @@
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+var test = require('tape');
+var resolve = require('../sync');
+
+var fixturesDir = path.join(__dirname, 'list-exports', 'packages', 'tests', 'fixtures');
+
+var categories = [
+    'broken',
+    'broken-dir-slash-conditions',
+    'conditions',
+    'experimental',
+    'pattern-trailers',
+    'pattern-trailers+json-imports',
+    'pattern-trailers-no-dir-slash',
+    'pattern-trailers-no-dir-slash+json-imports',
+    'patterns',
+    'require-esm',
+    'strips-types',
+    'subpath-imports-slash'
+    // 'pre-exports' is tested separately since it uses main/index resolution
+];
+
+// Fixtures that are symlinks pointing outside the fixture dir cause path confusion
+// ex-private is a private package whose expected files don't include exports data
+var skipFixtures = ['list-exports', 'ls-exports', 'ex-private'];
+
+function getFixtures() {
+    return fs.readdirSync(fixturesDir).filter(function (name) {
+        if (skipFixtures.indexOf(name) !== -1) {
+            return false;
+        }
+        var stat = fs.statSync(path.join(fixturesDir, name));
+        return stat.isDirectory();
+    });
+}
+
+function loadExpected(fixtureName, category) {
+    var expectedPath = path.join(fixturesDir, fixtureName, 'expected', category + '.json');
+    if (!fs.existsSync(expectedPath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(fs.readFileSync(expectedPath, 'utf8'));
+    } catch (e) {
+        return null;
+    }
+}
+
+function loadProjectPkg(fixtureName) {
+    var pkgPath = path.join(fixturesDir, fixtureName, 'project', 'package.json');
+    try {
+        return JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    } catch (e) {
+        return null;
+    }
+}
+
+test('exports resolution - exportsCategory option', function (t) {
+    var fixtures = getFixtures();
+
+    fixtures.forEach(function (fixtureName) {
+        var projectPkg = loadProjectPkg(fixtureName);
+        if (!projectPkg) {
+            return;
+        }
+        var projectDir = path.join(fixturesDir, fixtureName, 'project');
+        var pkgName = projectPkg.name;
+
+        categories.forEach(function (category) {
+            var expected = loadExpected(fixtureName, category);
+            if (!expected || !expected.exports || !expected.exports[category]) {
+                return;
+            }
+
+            var requireMap = expected.exports[category].require;
+            if (!requireMap || typeof requireMap !== 'object') {
+                return;
+            }
+
+            Object.keys(requireMap).forEach(function (subpath) {
+                var expectedFile = requireMap[subpath];
+                var specifier = subpath === '.' ? pkgName : pkgName + subpath.substring(1);
+
+                t.test(fixtureName + ' / ' + category + ' / ' + subpath, function (st) {
+                    st.plan(1);
+                    try {
+                        var result = resolve(specifier, {
+                            basedir: __dirname,
+                            exportsCategory: category,
+                            extensions: ['.js', '.json'],
+                            packageIterator: function () {
+                                return [projectDir];
+                            }
+                        });
+                        var relativeResult = './' + path.relative(projectDir, result).split(path.sep).join('/');
+                        st.equal(relativeResult, expectedFile, specifier + ' resolves to ' + expectedFile);
+                    } catch (e) {
+                        st.fail('Unexpected error for ' + specifier + ': ' + e.message);
+                    }
+                });
+            });
+        });
+    });
+
+    t.end();
+});
+
+test('exports resolution - pre-exports category uses main/index', function (t) {
+    var fixtures = getFixtures();
+
+    fixtures.forEach(function (fixtureName) {
+        var projectPkg = loadProjectPkg(fixtureName);
+        if (!projectPkg) {
+            return;
+        }
+        var projectDir = path.join(fixturesDir, fixtureName, 'project');
+        var pkgName = projectPkg.name;
+
+        var expected = loadExpected(fixtureName, 'pre-exports');
+        if (!expected || !expected.exports || !expected.exports['pre-exports']) {
+            return;
+        }
+
+        var requireMap = expected.exports['pre-exports'].require;
+        if (!requireMap || typeof requireMap !== 'object') {
+            return;
+        }
+
+        // For pre-exports, only test the main entry point (.)
+        var mainEntry = requireMap['.'];
+        if (!mainEntry) {
+            return;
+        }
+
+        t.test(fixtureName + ' / pre-exports / .', function (st) {
+            st.plan(1);
+            try {
+                var result = resolve(pkgName, {
+                    basedir: __dirname,
+                    exportsCategory: 'pre-exports',
+                    extensions: ['.js', '.json'],
+                    packageIterator: function () {
+                        return [projectDir];
+                    }
+                });
+                var relativeResult = './' + path.relative(projectDir, result).split(path.sep).join('/');
+                st.equal(relativeResult, mainEntry, pkgName + ' resolves to ' + mainEntry);
+            } catch (e) {
+                st.fail('Unexpected error for ' + pkgName + ': ' + e.message);
+            }
+        });
+    });
+
+    t.end();
+});
+
+test('exports resolution - mutual exclusivity of options', function (t) {
+    t.test('exportsCategory and engines (string) are mutually exclusive', function (st) {
+        st.plan(1);
+        try {
+            resolve('tape', {
+                basedir: __dirname,
+                exportsCategory: 'conditions',
+                engines: '>= 14'
+            });
+            st.fail('should have thrown');
+        } catch (e) {
+            st.ok((/mutually exclusive/).test(e.message), 'throws with mutually exclusive message');
+        }
+    });
+
+    t.test('exportsCategory and engines (true) are mutually exclusive', function (st) {
+        st.plan(1);
+        try {
+            resolve('tape', {
+                basedir: __dirname,
+                exportsCategory: 'conditions',
+                engines: true
+            });
+            st.fail('should have thrown');
+        } catch (e) {
+            st.ok((/mutually exclusive/).test(e.message), 'throws with mutually exclusive message');
+        }
+    });
+
+    t.end();
+});
+
+test('exports resolution - invalid category', function (t) {
+    t.plan(2);
+    try {
+        resolve('tape', {
+            basedir: __dirname,
+            exportsCategory: 'not-a-real-category'
+        });
+        t.fail('should have thrown');
+    } catch (e) {
+        t.equal(e.code, 'INVALID_EXPORTS_CATEGORY', 'has correct error code');
+        t.ok((/Invalid exports category/).test(e.message), 'has correct error message');
+    }
+});
+
+test('exports resolution - engines option', function (t) {
+    var projectDir = path.join(fixturesDir, 'ex-exports-string', 'project');
+
+    t.test('engines string maps to category', function (st) {
+        st.plan(1);
+        var result = resolve('ex-exports-string', {
+            basedir: __dirname,
+            engines: '>= 14',
+            packageIterator: function () {
+                return [projectDir];
+            }
+        });
+        st.ok(result.indexOf('index.js') > -1, 'resolves to index.js');
+    });
+
+    t.test('engines: false is same as omitting', function (st) {
+        st.plan(1);
+        var result = resolve('tape', {
+            basedir: __dirname,
+            engines: false
+        });
+        st.ok(result.indexOf('tape') > -1, 'resolves without exports resolution');
+    });
+
+    t.test('engines: empty string throws', function (st) {
+        st.plan(1);
+        try {
+            resolve('tape', {
+                basedir: __dirname,
+                engines: ''
+            });
+            st.fail('should have thrown');
+        } catch (e) {
+            st.ok((/must be.*true.*false.*non-empty string/i).test(e.message), 'throws with correct message');
+        }
+    });
+
+    t.test('engines: number throws', function (st) {
+        st.plan(1);
+        try {
+            resolve('tape', {
+                basedir: __dirname,
+                engines: 14
+            });
+            st.fail('should have thrown');
+        } catch (e) {
+            st.ok((/must be.*true.*false.*non-empty string/i).test(e.message), 'throws with correct message');
+        }
+    });
+
+    t.test('engines: object throws', function (st) {
+        st.plan(1);
+        try {
+            resolve('tape', {
+                basedir: __dirname,
+                engines: { node: '>= 14' }
+            });
+            st.fail('should have thrown');
+        } catch (e) {
+            st.ok((/must be.*true.*false.*non-empty string/i).test(e.message), 'throws with correct message');
+        }
+    });
+
+    t.end();
+});
+
+test('exports resolution - conditions override', function (t) {
+    var projectDir = path.join(fixturesDir, 'ex-conditions', 'project');
+
+    t.test('default category conditions resolve to require.js', function (st) {
+        st.plan(1);
+        var result = resolve('ex-conditions/rdni', {
+            basedir: __dirname,
+            exportsCategory: 'conditions',
+            packageIterator: function () {
+                return [projectDir];
+            }
+        });
+        st.ok(result.indexOf('require.js') > -1, 'resolves to require.js with default conditions');
+    });
+
+    t.test('conditions override to [default] resolves to default.js', function (st) {
+        st.plan(1);
+        var result = resolve('ex-conditions/rdni', {
+            basedir: __dirname,
+            exportsCategory: 'conditions',
+            conditions: ['default'],
+            packageIterator: function () {
+                return [projectDir];
+            }
+        });
+        st.ok(result.indexOf('default.js') > -1, 'resolves to default.js with conditions override');
+    });
+
+    t.test('conditions override to [node] resolves to node.js', function (st) {
+        st.plan(1);
+        var result = resolve('ex-conditions/rdni', {
+            basedir: __dirname,
+            exportsCategory: 'conditions',
+            conditions: ['node'],
+            packageIterator: function () {
+                return [projectDir];
+            }
+        });
+        st.ok(result.indexOf('node.js') > -1, 'resolves to node.js with conditions override');
+    });
+
+    t.end();
+});
+
+test('exports resolution - subpath not exported throws', function (t) {
+    var projectDir = path.join(fixturesDir, 'ex-exports-string', 'project');
+
+    t.plan(2);
+    try {
+        resolve('ex-exports-string/not-exported', {
+            basedir: __dirname,
+            exportsCategory: 'conditions',
+            packageIterator: function () {
+                return [projectDir];
+            }
+        });
+        t.fail('should have thrown');
+    } catch (e) {
+        t.equal(e.code, 'ERR_PACKAGE_PATH_NOT_EXPORTED', 'has correct error code');
+        t.ok((/not defined by "exports"/).test(e.message), 'has correct error message');
+    }
+});
+
+test('existing resolution without exports options still works', function (t) {
+    t.plan(1);
+    var result = resolve('tape', { basedir: __dirname });
+    t.ok(result.indexOf('tape') > -1, 'resolves tape without exports options');
+});
+
+test('all fixtures are tested', function (t) {
+    var fixtures = getFixtures();
+    var testedFixtures = [];
+
+    fixtures.forEach(function (fixtureName) {
+        var projectPkg = loadProjectPkg(fixtureName);
+        if (!projectPkg) {
+            t.fail('Fixture ' + fixtureName + ' has no loadable package.json');
+            return;
+        }
+
+        var hasAnyTests = false;
+
+        // Check if at least one category has expected results
+        categories.forEach(function (category) {
+            var expected = loadExpected(fixtureName, category);
+            if (expected && expected.exports && expected.exports[category]) {
+                var requireMap = expected.exports[category].require;
+                if (requireMap && typeof requireMap === 'object' && Object.keys(requireMap).length > 0) {
+                    hasAnyTests = true;
+                }
+            }
+        });
+
+        // Also check pre-exports
+        var preExpected = loadExpected(fixtureName, 'pre-exports');
+        if (preExpected && preExpected.exports && preExpected.exports['pre-exports']) {
+            var preRequireMap = preExpected.exports['pre-exports'].require;
+            if (preRequireMap && preRequireMap['.']) {
+                hasAnyTests = true;
+            }
+        }
+
+        if (hasAnyTests) {
+            testedFixtures.push(fixtureName);
+        } else {
+            t.fail('Fixture ' + fixtureName + ' has no testable entrypoints');
+        }
+    });
+
+    t.ok(testedFixtures.length > 0, 'At least one fixture is tested');
+    t.equal(testedFixtures.length, fixtures.length, 'All ' + fixtures.length + ' fixtures have testable entrypoints');
+
+    t.end();
+});
+
+test('exports resolution - moduleSystem: import uses import conditions', function (t) {
+    // ex-node-addons is skipped because getCategoryInfo includes node-addons in import
+    // conditions for some categories, but list-exports expected data does not
+    var skipImportFixtures = ['ex-node-addons'];
+    var fixtures = getFixtures().filter(function (n) { return skipImportFixtures.indexOf(n) === -1; });
+
+    fixtures.forEach(function (fixtureName) {
+        var projectPkg = loadProjectPkg(fixtureName);
+        if (!projectPkg) {
+            return;
+        }
+        var projectDir = path.join(fixturesDir, fixtureName, 'project');
+        var pkgName = projectPkg.name;
+
+        categories.forEach(function (category) {
+            var expected = loadExpected(fixtureName, category);
+            if (!expected || !expected.exports || !expected.exports[category]) {
+                return;
+            }
+
+            var importMap = expected.exports[category].import;
+            if (!importMap || typeof importMap !== 'object') {
+                return;
+            }
+
+            Object.keys(importMap).forEach(function (subpath) {
+                var expectedFile = importMap[subpath];
+                var specifier = subpath === '.' ? pkgName : pkgName + subpath.substring(1);
+
+                t.test(fixtureName + ' / ' + category + ' / import / ' + subpath, function (st) {
+                    st.plan(1);
+                    try {
+                        var result = resolve(specifier, {
+                            basedir: __dirname,
+                            exportsCategory: category,
+                            moduleSystem: 'import',
+                            extensions: ['.js', '.json', '.mjs'],
+                            packageIterator: function () {
+                                return [projectDir];
+                            }
+                        });
+                        var relativeResult = './' + path.relative(projectDir, result).split(path.sep).join('/');
+                        st.equal(relativeResult, expectedFile, specifier + ' with moduleSystem:import resolves to ' + expectedFile);
+                    } catch (e) {
+                        st.fail('Unexpected error for ' + specifier + ' with moduleSystem:import: ' + e.message);
+                    }
+                });
+            });
+        });
+    });
+
+    t.end();
+});
+
+test('exports resolution - moduleSystem: require matches default behavior', function (t) {
+    var fixtures = getFixtures();
+
+    fixtures.forEach(function (fixtureName) {
+        var projectPkg = loadProjectPkg(fixtureName);
+        if (!projectPkg) {
+            return;
+        }
+        var projectDir = path.join(fixturesDir, fixtureName, 'project');
+        var pkgName = projectPkg.name;
+
+        categories.forEach(function (category) {
+            var expected = loadExpected(fixtureName, category);
+            if (!expected || !expected.exports || !expected.exports[category]) {
+                return;
+            }
+
+            var requireMap = expected.exports[category].require;
+            if (!requireMap || typeof requireMap !== 'object') {
+                return;
+            }
+
+            Object.keys(requireMap).forEach(function (subpath) {
+                var expectedFile = requireMap[subpath];
+                var specifier = subpath === '.' ? pkgName : pkgName + subpath.substring(1);
+
+                t.test(fixtureName + ' / ' + category + ' / explicit require / ' + subpath, function (st) {
+                    st.plan(1);
+                    try {
+                        var result = resolve(specifier, {
+                            basedir: __dirname,
+                            exportsCategory: category,
+                            moduleSystem: 'require',
+                            extensions: ['.js', '.json'],
+                            packageIterator: function () {
+                                return [projectDir];
+                            }
+                        });
+                        var relativeResult = './' + path.relative(projectDir, result).split(path.sep).join('/');
+                        st.equal(relativeResult, expectedFile, specifier + ' with moduleSystem:require resolves to ' + expectedFile);
+                    } catch (e) {
+                        st.fail('Unexpected error for ' + specifier + ' with moduleSystem:require: ' + e.message);
+                    }
+                });
+            });
+        });
+    });
+
+    t.end();
+});
+
+test('exports resolution - moduleSystem import vs require produce different results', function (t) {
+    var projectDir = path.join(fixturesDir, 'ex-conditions', 'project');
+
+    t.test('./idnr: import resolves to import.mjs, require resolves to default.js', function (st) {
+        st.plan(2);
+        var importResult = resolve('ex-conditions/idnr', {
+            basedir: __dirname,
+            exportsCategory: 'conditions',
+            moduleSystem: 'import',
+            extensions: ['.js', '.mjs'],
+            packageIterator: function () { return [projectDir]; }
+        });
+        st.ok(importResult.indexOf('import.mjs') > -1, 'moduleSystem:import resolves to import.mjs');
+
+        var requireResult = resolve('ex-conditions/idnr', {
+            basedir: __dirname,
+            exportsCategory: 'conditions',
+            moduleSystem: 'require',
+            extensions: ['.js', '.mjs'],
+            packageIterator: function () { return [projectDir]; }
+        });
+        st.ok(requireResult.indexOf('default.js') > -1, 'moduleSystem:require resolves to default.js');
+    });
+
+    t.test('./rdni: import resolves to default.js, require resolves to require.js', function (st) {
+        st.plan(2);
+        var importResult = resolve('ex-conditions/rdni', {
+            basedir: __dirname,
+            exportsCategory: 'conditions',
+            moduleSystem: 'import',
+            extensions: ['.js', '.mjs'],
+            packageIterator: function () { return [projectDir]; }
+        });
+        st.ok(importResult.indexOf('default.js') > -1, 'moduleSystem:import resolves to default.js');
+
+        var requireResult = resolve('ex-conditions/rdni', {
+            basedir: __dirname,
+            exportsCategory: 'conditions',
+            moduleSystem: 'require',
+            extensions: ['.js', '.mjs'],
+            packageIterator: function () { return [projectDir]; }
+        });
+        st.ok(requireResult.indexOf('require.js') > -1, 'moduleSystem:require resolves to require.js');
+    });
+
+    t.test('./indr: import resolves to import.mjs, require resolves to node.js', function (st) {
+        st.plan(2);
+        var importResult = resolve('ex-conditions/indr', {
+            basedir: __dirname,
+            exportsCategory: 'conditions',
+            moduleSystem: 'import',
+            extensions: ['.js', '.mjs'],
+            packageIterator: function () { return [projectDir]; }
+        });
+        st.ok(importResult.indexOf('import.mjs') > -1, 'moduleSystem:import resolves to import.mjs');
+
+        var requireResult = resolve('ex-conditions/indr', {
+            basedir: __dirname,
+            exportsCategory: 'conditions',
+            moduleSystem: 'require',
+            extensions: ['.js', '.mjs'],
+            packageIterator: function () { return [projectDir]; }
+        });
+        st.ok(requireResult.indexOf('node.js') > -1, 'moduleSystem:require resolves to node.js');
+    });
+
+    t.test('./irdn: import resolves to import.mjs, require resolves to require.js', function (st) {
+        st.plan(2);
+        var importResult = resolve('ex-conditions/irdn', {
+            basedir: __dirname,
+            exportsCategory: 'conditions',
+            moduleSystem: 'import',
+            extensions: ['.js', '.mjs'],
+            packageIterator: function () { return [projectDir]; }
+        });
+        st.ok(importResult.indexOf('import.mjs') > -1, 'moduleSystem:import resolves to import.mjs');
+
+        var requireResult = resolve('ex-conditions/irdn', {
+            basedir: __dirname,
+            exportsCategory: 'conditions',
+            moduleSystem: 'require',
+            extensions: ['.js', '.mjs'],
+            packageIterator: function () { return [projectDir]; }
+        });
+        st.ok(requireResult.indexOf('require.js') > -1, 'moduleSystem:require resolves to require.js');
+    });
+
+    t.test('default (no moduleSystem) matches require behavior', function (st) {
+        st.plan(2);
+        var defaultResult = resolve('ex-conditions/rdni', {
+            basedir: __dirname,
+            exportsCategory: 'conditions',
+            extensions: ['.js', '.mjs'],
+            packageIterator: function () { return [projectDir]; }
+        });
+        var requireResult = resolve('ex-conditions/rdni', {
+            basedir: __dirname,
+            exportsCategory: 'conditions',
+            moduleSystem: 'require',
+            extensions: ['.js', '.mjs'],
+            packageIterator: function () { return [projectDir]; }
+        });
+        st.equal(defaultResult, requireResult, 'default and explicit require produce the same result');
+        st.ok(defaultResult.indexOf('require.js') > -1, 'both resolve to require.js');
+    });
+
+    t.end();
+});
+
+test('exports resolution - moduleSystem import with various fixtures', function (t) {
+    t.test('ex-conditions-in-folder: import resolves to mjs, require to cjs', function (st) {
+        var projectDir = path.join(fixturesDir, 'ex-conditions-in-folder', 'project');
+        st.plan(2);
+        var importResult = resolve('ex-conditions-in-folder', {
+            basedir: __dirname,
+            exportsCategory: 'conditions',
+            moduleSystem: 'import',
+            extensions: ['.js', '.mjs'],
+            packageIterator: function () { return [projectDir]; }
+        });
+        st.ok(importResult.indexOf('mjs/index.mjs') > -1, 'import resolves to mjs/index.mjs');
+
+        var requireResult = resolve('ex-conditions-in-folder', {
+            basedir: __dirname,
+            exportsCategory: 'conditions',
+            moduleSystem: 'require',
+            extensions: ['.js', '.mjs'],
+            packageIterator: function () { return [projectDir]; }
+        });
+        st.ok(requireResult.indexOf('cjs/index.js') > -1, 'require resolves to cjs/index.js');
+    });
+
+    t.test('ex-exports-TL-object: import resolves to index.mjs, require to file.js', function (st) {
+        var projectDir = path.join(fixturesDir, 'ex-exports-TL-object', 'project');
+        st.plan(2);
+        var importResult = resolve('ex-exports-TL-object', {
+            basedir: __dirname,
+            exportsCategory: 'conditions',
+            moduleSystem: 'import',
+            extensions: ['.js', '.mjs'],
+            packageIterator: function () { return [projectDir]; }
+        });
+        st.ok(importResult.indexOf('index.mjs') > -1, 'import resolves to index.mjs');
+
+        var requireResult = resolve('ex-exports-TL-object', {
+            basedir: __dirname,
+            exportsCategory: 'conditions',
+            moduleSystem: 'require',
+            extensions: ['.js', '.mjs'],
+            packageIterator: function () { return [projectDir]; }
+        });
+        st.ok(requireResult.indexOf('file.js') > -1, 'require resolves to file.js');
+    });
+
+    t.test('flatted-3: import resolves to esm/index.js, require to cjs/index.js', function (st) {
+        var projectDir = path.join(fixturesDir, 'flatted-3', 'project');
+        st.plan(2);
+        var importResult = resolve('flatted', {
+            basedir: __dirname,
+            exportsCategory: 'conditions',
+            moduleSystem: 'import',
+            extensions: ['.js', '.mjs'],
+            packageIterator: function () { return [projectDir]; }
+        });
+        st.ok(importResult.indexOf('esm/index.js') > -1, 'import resolves to esm/index.js');
+
+        var requireResult = resolve('flatted', {
+            basedir: __dirname,
+            exportsCategory: 'conditions',
+            moduleSystem: 'require',
+            extensions: ['.js', '.mjs'],
+            packageIterator: function () { return [projectDir]; }
+        });
+        st.ok(requireResult.indexOf('cjs/index.js') > -1, 'require resolves to cjs/index.js');
+    });
+
+    t.test('is-promise-2.2.1: import resolves to index.mjs, require to index.js', function (st) {
+        var projectDir = path.join(fixturesDir, 'is-promise-2.2.1', 'project');
+        st.plan(2);
+        var importResult = resolve('is-promise', {
+            basedir: __dirname,
+            exportsCategory: 'conditions',
+            moduleSystem: 'import',
+            extensions: ['.js', '.mjs'],
+            packageIterator: function () { return [projectDir]; }
+        });
+        st.ok(importResult.indexOf('index.mjs') > -1, 'import resolves to index.mjs');
+
+        var requireResult = resolve('is-promise', {
+            basedir: __dirname,
+            exportsCategory: 'conditions',
+            moduleSystem: 'require',
+            extensions: ['.js', '.mjs'],
+            packageIterator: function () { return [projectDir]; }
+        });
+        st.ok(requireResult.indexOf('index.js') > -1 && requireResult.indexOf('index.mjs') === -1, 'require resolves to index.js');
+    });
+
+    t.test('resolve-2: import resolves to index.mjs, require to index.js', function (st) {
+        var projectDir = path.join(fixturesDir, 'resolve-2', 'project');
+        st.plan(2);
+        var importResult = resolve('resolve', {
+            basedir: __dirname,
+            exportsCategory: 'conditions',
+            moduleSystem: 'import',
+            extensions: ['.js', '.mjs'],
+            packageIterator: function () { return [projectDir]; }
+        });
+        st.ok(importResult.indexOf('index.mjs') > -1, 'import resolves to index.mjs');
+
+        var requireResult = resolve('resolve', {
+            basedir: __dirname,
+            exportsCategory: 'conditions',
+            moduleSystem: 'require',
+            extensions: ['.js', '.mjs'],
+            packageIterator: function () { return [projectDir]; }
+        });
+        st.ok(requireResult.indexOf('index.js') > -1 && requireResult.indexOf('index.mjs') === -1, 'require resolves to index.js');
+    });
+
+    t.test('preact: import resolves to .mjs, require to .js', function (st) {
+        var projectDir = path.join(fixturesDir, 'preact', 'project');
+        st.plan(2);
+        var importResult = resolve('preact', {
+            basedir: __dirname,
+            exportsCategory: 'conditions',
+            moduleSystem: 'import',
+            extensions: ['.js', '.mjs'],
+            packageIterator: function () { return [projectDir]; }
+        });
+        st.ok(importResult.indexOf('preact.mjs') > -1, 'import resolves to preact.mjs');
+
+        var requireResult = resolve('preact', {
+            basedir: __dirname,
+            exportsCategory: 'conditions',
+            moduleSystem: 'require',
+            extensions: ['.js', '.mjs'],
+            packageIterator: function () { return [projectDir]; }
+        });
+        st.ok(requireResult.indexOf('preact.js') > -1 && requireResult.indexOf('preact.mjs') === -1, 'require resolves to preact.js');
+    });
+
+    t.end();
+});
+
+test('exports resolution - moduleSystem import with self-reference', function (t) {
+    t.test('self-reference with moduleSystem:import uses import conditions', function (st) {
+        var conditionsDir = path.join(fixturesDir, 'ex-conditions', 'project');
+        st.plan(2);
+        var importResult = resolve('ex-conditions/idnr', {
+            basedir: conditionsDir,
+            exportsCategory: 'conditions',
+            moduleSystem: 'import',
+            extensions: ['.js', '.mjs']
+        });
+        st.ok(importResult.indexOf('import.mjs') > -1, 'self-reference with import resolves to import.mjs');
+
+        var requireResult = resolve('ex-conditions/idnr', {
+            basedir: conditionsDir,
+            exportsCategory: 'conditions',
+            moduleSystem: 'require',
+            extensions: ['.js', '.mjs']
+        });
+        st.ok(requireResult.indexOf('default.js') > -1, 'self-reference with require resolves to default.js');
+    });
+
+    t.test('self-reference with moduleSystem:import on TL-object package', function (st) {
+        var projectDir = path.join(fixturesDir, 'ex-exports-TL-object', 'project');
+        st.plan(2);
+        var importResult = resolve('ex-exports-TL-object', {
+            basedir: projectDir,
+            exportsCategory: 'conditions',
+            moduleSystem: 'import',
+            extensions: ['.js', '.mjs']
+        });
+        st.ok(importResult.indexOf('index.mjs') > -1, 'self-ref import resolves to index.mjs');
+
+        var requireResult = resolve('ex-exports-TL-object', {
+            basedir: projectDir,
+            exportsCategory: 'conditions',
+            moduleSystem: 'require',
+            extensions: ['.js', '.mjs']
+        });
+        st.ok(requireResult.indexOf('file.js') > -1, 'self-ref require resolves to file.js');
+    });
+
+    t.end();
+});
+
+test('exports resolution - moduleSystem with engines option', function (t) {
+    var projectDir = path.join(fixturesDir, 'ex-conditions', 'project');
+
+    t.test('moduleSystem:import works with engines string', function (st) {
+        st.plan(1);
+        var result = resolve('ex-conditions/idnr', {
+            basedir: __dirname,
+            engines: '>= 14',
+            moduleSystem: 'import',
+            extensions: ['.js', '.mjs'],
+            packageIterator: function () { return [projectDir]; }
+        });
+        st.ok(result.indexOf('import.mjs') > -1, 'engines + moduleSystem:import resolves to import.mjs');
+    });
+
+    t.test('moduleSystem:require works with engines string', function (st) {
+        st.plan(1);
+        var result = resolve('ex-conditions/idnr', {
+            basedir: __dirname,
+            engines: '>= 14',
+            moduleSystem: 'require',
+            extensions: ['.js', '.mjs'],
+            packageIterator: function () { return [projectDir]; }
+        });
+        st.ok(result.indexOf('default.js') > -1, 'engines + moduleSystem:require resolves to default.js');
+    });
+
+    t.end();
+});
+
+test('exports resolution - invalid moduleSystem throws', function (t) {
+    t.test('moduleSystem: true throws', function (st) {
+        st.plan(1);
+        try {
+            resolve('tape', { basedir: __dirname, moduleSystem: true });
+            st.fail('should have thrown');
+        } catch (e) {
+            st.ok((/moduleSystem/).test(e.message), 'throws with moduleSystem message: ' + e.message);
+        }
+    });
+
+    t.test('moduleSystem: false throws', function (st) {
+        st.plan(1);
+        try {
+            resolve('tape', { basedir: __dirname, moduleSystem: false });
+            st.fail('should have thrown');
+        } catch (e) {
+            st.ok((/moduleSystem/).test(e.message), 'throws with moduleSystem message: ' + e.message);
+        }
+    });
+
+    t.test('moduleSystem: empty string throws', function (st) {
+        st.plan(1);
+        try {
+            resolve('tape', { basedir: __dirname, moduleSystem: '' });
+            st.fail('should have thrown');
+        } catch (e) {
+            st.ok((/moduleSystem/).test(e.message), 'throws with moduleSystem message: ' + e.message);
+        }
+    });
+
+    t.test('moduleSystem: number throws', function (st) {
+        st.plan(1);
+        try {
+            resolve('tape', { basedir: __dirname, moduleSystem: 42 });
+            st.fail('should have thrown');
+        } catch (e) {
+            st.ok((/moduleSystem/).test(e.message), 'throws with moduleSystem message: ' + e.message);
+        }
+    });
+
+    t.test('moduleSystem: random string throws', function (st) {
+        st.plan(1);
+        try {
+            resolve('tape', { basedir: __dirname, moduleSystem: 'cjs' });
+            st.fail('should have thrown');
+        } catch (e) {
+            st.ok((/moduleSystem/).test(e.message), 'throws with moduleSystem message: ' + e.message);
+        }
+    });
+
+    t.test('moduleSystem: object throws', function (st) {
+        st.plan(1);
+        try {
+            resolve('tape', { basedir: __dirname, moduleSystem: {} });
+            st.fail('should have thrown');
+        } catch (e) {
+            st.ok((/moduleSystem/).test(e.message), 'throws with moduleSystem message: ' + e.message);
+        }
+    });
+
+    t.test('moduleSystem: null throws', function (st) {
+        st.plan(1);
+        try {
+            resolve('tape', { basedir: __dirname, moduleSystem: null });
+            st.fail('should have thrown');
+        } catch (e) {
+            st.ok((/moduleSystem/).test(e.message), 'throws with moduleSystem message: ' + e.message);
+        }
+    });
+
+    t.test('moduleSystem: undefined does not throw', function (st) {
+        st.plan(1);
+        var result = resolve('tape', { basedir: __dirname, moduleSystem: undefined });
+        st.ok(result.indexOf('tape') > -1, 'undefined moduleSystem resolves normally');
+    });
+
+    t.end();
+});
+
+test('exports resolution - moduleSystem does not affect resolution without exports', function (t) {
+    t.plan(1);
+    var result = resolve('tape', {
+        basedir: __dirname,
+        moduleSystem: 'import'
+    });
+    t.ok(result.indexOf('tape') > -1, 'moduleSystem is ignored when no exports options are set');
+});
+
+test('exports resolution - self-reference', function (t) {
+    var projectDir = path.join(fixturesDir, 'ex-exports-string', 'project');
+
+    t.test('self-reference resolves via exports when inside package', function (st) {
+        st.plan(1);
+        // basedir is inside the package, specifier is the package name
+        var result = resolve('ex-exports-string', {
+            basedir: projectDir,
+            exportsCategory: 'conditions'
+        });
+        st.ok(result.indexOf('index.js') > -1, 'self-reference resolves to index.js via exports');
+    });
+
+    t.test('self-reference with subpath resolves via exports', function (st) {
+        var conditionsDir = path.join(fixturesDir, 'ex-conditions', 'project');
+        st.plan(1);
+        var result = resolve('ex-conditions/rdni', {
+            basedir: conditionsDir,
+            exportsCategory: 'conditions'
+        });
+        st.ok(result.indexOf('require.js') > -1, 'self-reference subpath resolves correctly');
+    });
+
+    t.test('self-reference without exports falls back to main', function (st) {
+        // Create a scenario where there's no exports field
+        var mainDotlessDir = path.join(fixturesDir, 'ex-main-dotless', 'project');
+        st.plan(1);
+        try {
+            var result = resolve('ex-main-dotless', {
+                basedir: mainDotlessDir,
+                exportsCategory: 'conditions'
+            });
+            st.ok(result.indexOf('main.js') > -1 || result.indexOf('index.js') > -1, 'self-reference without exports uses main/index');
+        } catch (e) {
+            // If it throws, that's also acceptable behavior (no exports means not exported)
+            st.ok(true, 'self-reference without exports throws or resolves');
+        }
+    });
+
+    t.test('self-reference does not cross node_modules boundary', function (st) {
+        // basedir is inside node_modules, should NOT self-reference parent package
+        var nodeModulesDir = path.join(__dirname, '..', 'node_modules', 'tape');
+        st.plan(1);
+        // Trying to resolve 'resolve' from inside node_modules/tape should NOT
+        // self-reference the root resolve package - it should use normal resolution
+        var result = resolve('resolve', {
+            basedir: nodeModulesDir,
+            exportsCategory: 'conditions'
+        });
+        // The result should be from node_modules, not from a self-reference
+        // (self-reference would give us the current working directory's resolve)
+        st.ok(result.indexOf('node_modules') > -1 || result === 'resolve', 'does not self-reference across node_modules');
+    });
+
+    t.end();
+});

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, 'INVALID_BASEDIR');
+        t.equal(res, undefined);
+    });
+});

node_modules/resolve/test/filter.js

@@ -0,0 +1,37 @@
+var path = require('path');
+var test = require('tape');
+var resolve = require('../');
+
+test('filter', function (t) {
+    t.plan(5);
+    var dir = path.join(__dirname, 'resolver');
+    var packageFilterArgs;
+    resolve('./baz', {
+        basedir: dir,
+        packageFilter: function (pkg, pkgfile, dir) {
+            pkg.main = 'doom'; // eslint-disable-line no-param-reassign
+            packageFilterArgs = [pkg, pkgfile, dir];
+            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"'
+        );
+
+        var packageFileDir = packageFilterArgs[2];
+        t.equal(packageFileDir, path.join(dir, 'baz'), 'third packageFilter argument is "dir"');
+
+        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,
+        packageFilter: function (pkg, pkgfile, dir) {
+            pkg.main = 'doom'; // eslint-disable-line no-param-reassign
+            packageFilterArgs = [pkg, pkgfile, dir];
+            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');
+
+    var packageFile = packageFilterArgs[1];
+    t.equal(
+        packageFile,
+        path.join(dir, 'baz/package.json'),
+        'second packageFilter argument is "pkgfile"'
+    );
+
+    var packageDir = packageFilterArgs[2];
+    t.equal(packageDir, path.join(dir, 'baz'), '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/homedir.js

@@ -0,0 +1,112 @@
+'use strict';
+
+var os = require('os');
+var test = require('tape');
+var mockProperty = require('mock-property');
+
+var envKeys = ['HOME', 'USERPROFILE', 'HOMEDRIVE', 'HOMEPATH', 'LOGNAME', 'USER', 'LNAME', 'USERNAME'];
+
+function mockEnv(t, key, value) {
+    var has = key in process.env;
+    var orig = process.env[key];
+    if (arguments.length > 2) {
+        process.env[key] = value;
+    } else {
+        delete process.env[key];
+    }
+    t.teardown(function () {
+        if (has) {
+            process.env[key] = orig;
+        } else {
+            delete process.env[key];
+        }
+    });
+}
+
+function clearEnv(t) {
+    for (var i = 0; i < envKeys.length; i++) {
+        mockEnv(t, envKeys[i]);
+    }
+}
+
+function getFallback(t) {
+    t.teardown(mockProperty(os, 'homedir', { value: undefined }));
+
+    var homedirPath = require.resolve('../lib/homedir');
+    t.teardown(mockProperty(require.cache, homedirPath, { 'delete': true }));
+
+    return require('../lib/homedir');
+}
+
+test('homedir fallback', function (t) {
+    t.test('win32: HOMEDRIVE without HOMEPATH does not produce a false concatenation', function (st) {
+        clearEnv(st);
+        st.teardown(mockProperty(process, 'platform', { value: 'win32' }));
+
+        var homedir = getFallback(st);
+
+        mockEnv(st, 'HOMEDRIVE', 'C:');
+
+        st.equal(homedir(), null, 'returns null when only HOMEDRIVE is set');
+
+        st.end();
+    });
+
+    t.test('win32: HOMEPATH without HOMEDRIVE does not produce a false concatenation', function (st) {
+        clearEnv(st);
+        st.teardown(mockProperty(process, 'platform', { value: 'win32' }));
+
+        var homedir = getFallback(st);
+
+        mockEnv(st, 'HOMEPATH', '\\Users\\foo');
+
+        st.equal(homedir(), null, 'returns null when only HOMEPATH is set');
+
+        st.end();
+    });
+
+    t.test('win32: HOMEDRIVE + HOMEPATH both set returns concatenation', function (st) {
+        clearEnv(st);
+        st.teardown(mockProperty(process, 'platform', { value: 'win32' }));
+
+        var homedir = getFallback(st);
+
+        mockEnv(st, 'HOMEDRIVE', 'C:');
+        mockEnv(st, 'HOMEPATH', '\\Users\\foo');
+
+        st.equal(homedir(), 'C:\\Users\\foo', 'returns concatenated drive and path');
+
+        st.end();
+    });
+
+    t.test('win32: USERPROFILE takes precedence over HOMEDRIVE+HOMEPATH', function (st) {
+        clearEnv(st);
+        st.teardown(mockProperty(process, 'platform', { value: 'win32' }));
+
+        var homedir = getFallback(st);
+
+        mockEnv(st, 'USERPROFILE', 'C:\\Users\\bar');
+        mockEnv(st, 'HOMEDRIVE', 'C:');
+        mockEnv(st, 'HOMEPATH', '\\Users\\foo');
+
+        st.equal(homedir(), 'C:\\Users\\bar', 'returns USERPROFILE');
+
+        st.end();
+    });
+
+    t.test('win32: falls back to HOME when HOMEDRIVE/HOMEPATH are partial', function (st) {
+        clearEnv(st);
+        st.teardown(mockProperty(process, 'platform', { value: 'win32' }));
+
+        var homedir = getFallback(st);
+
+        mockEnv(st, 'HOME', 'C:\\Users\\baz');
+        mockEnv(st, 'HOMEDRIVE', 'C:');
+
+        st.equal(homedir(), 'C:\\Users\\baz', 'falls back to HOME');
+
+        st.end();
+    });
+
+    t.end();
+});

node_modules/resolve/test/mock.js

@@ -0,0 +1,353 @@
+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(4);
+
+    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');
+        });
+    });
+
+    function readPackage(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');
+        });
+    });
+
+    t.test('readPackage error in loadpkg does not invoke callback twice', function (st) {
+        st.plan(1);
+
+        var callCount = 0;
+        var readPackageError = new Error('read package error');
+
+        function failReadPackage(rf, file, cb) {
+            cb(readPackageError);
+        }
+
+        var relFiles = {};
+        relFiles[path.resolve('/foo/bar/baz.js')] = 'beep';
+        relFiles[path.resolve('/foo/bar/package.json')] = '{}';
+
+        var relDirs = {};
+        relDirs[path.resolve('/foo/bar')] = true;
+
+        resolve('./baz', {
+            basedir: path.resolve('/foo/bar'),
+            isFile: function (file, cb) {
+                cb(null, Object.prototype.hasOwnProperty.call(relFiles, path.resolve(file)));
+            },
+            isDirectory: function (dir, cb) {
+                cb(null, !!relDirs[path.resolve(dir)]);
+            },
+            readPackage: failReadPackage,
+            realpath: function (file, cb) {
+                cb(null, file);
+            }
+        }, function () {
+            callCount += 1;
+        });
+
+        setTimeout(function () {
+            st.equal(callCount, 1, 'callback is invoked exactly once');
+        }, 50);
+    });
+});

node_modules/resolve/test/mock_sync.js

@@ -0,0 +1,235 @@
+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;
+    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('./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(4);
+
+    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')
+        );
+    });
+
+    function readPackageSync(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'
+        );
+    });
+
+    t.test('readPackageSync error propagates correctly', function (st) {
+        st.plan(1);
+
+        var readPackageError = new Error('read package error');
+
+        function failReadPackageSync() {
+            throw readPackageError;
+        }
+
+        var options = opts('/foo');
+        delete options.readFileSync;
+        options.readPackageSync = failReadPackageSync;
+
+        st.throws(
+            function () { resolve.sync('bar', options); },
+            readPackageError,
+            'readPackageSync error is thrown'
+        );
+    });
+});
+

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/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');
+
+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) {
+        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) {
+        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);
+
+    function isDir(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.replace('/node_modules/.vlt/··tap@0.4.13/', '/'), path.resolve(__dirname, '..', 'node_modules/tap', root), 'tap resolves');
+    });
+});

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');
+
+function pathFilterFactory(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/pathfilter_sync.js

@@ -0,0 +1,24 @@
+var test = require('tape');
+var path = require('path');
+var resolve = require('../');
+
+test('synchronous pathfilter', function (t) {
+    var res;
+    var resolverDir = __dirname + '/pathfilter/deep_ref';
+    function pathFilter(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';
+    }
+
+    res = resolve.sync('deep/ref', { basedir: resolverDir });
+    t.equal(res, path.join(resolverDir, 'node_modules', 'deep', 'ref.js'));
+
+    res = resolve.sync('deep/deeper/ref', { basedir: resolverDir });
+    t.equal(res, path.join(resolverDir, 'node_modules', 'deep', 'deeper', 'ref.js'));
+
+    res = resolve.sync('deep/ref', { basedir: resolverDir, pathFilter: pathFilter });
+    t.equal(res, path.join(resolverDir, 'node_modules', 'deep', 'alt.js'));
+    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/resolver.js

@@ -0,0 +1,613 @@
+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');
+
+    function exactIterator(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('empty main', function (t) {
+    t.plan(1);
+
+    var resolverDir = path.join(__dirname, 'resolver');
+    var dir = path.join(resolverDir, 'empty_main');
+
+    resolve('./empty_main', { basedir: resolverDir }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'index.js'));
+    });
+});
+
+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, 'INCORRECT_PACKAGE_MAIN', 'error has correct error code');
+    });
+});
+
+test('missing main', function (t) {
+    t.plan(1);
+
+    var resolverDir = path.join(__dirname, 'resolver');
+    var dir = path.join(resolverDir, 'missing_main');
+
+    resolve('./missing_main', { basedir: resolverDir }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'index.js'));
+    });
+});
+
+test('null main', function (t) {
+    t.plan(1);
+
+    var resolverDir = path.join(__dirname, 'resolver');
+    var dir = path.join(resolverDir, 'null_main');
+
+    resolve('./null_main', { basedir: resolverDir }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(res, path.join(dir, 'index.js'));
+    });
+});
+
+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, 'Provided basedir "' + __filename + '" is not a directory, or a symlink to a directory');
+        t.equal(err && err.code, 'INVALID_BASEDIR');
+    });
+});
+
+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(e);
+                    }
+                });
+            }
+        },
+        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/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/package.json

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

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

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

node_modules/resolve/test/resolver/empty_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/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/missing_index/package.json

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

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

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

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"
+  }
+}