@rollup/plugin-node-resolve 8.4.0 → 11.0.1

package/dist/es/index.js

@@ -1,310 +1,145 @@
-import { dirname, resolve, extname, normalize, sep } from 'path';
+import path, { dirname, resolve, extname, normalize, sep } from 'path';
 import builtinList from 'builtin-modules';
-import deepFreeze from 'deep-freeze';
 import deepMerge from 'deepmerge';
 import isModule from 'is-module';
 import fs, { realpathSync } from 'fs';
 import { promisify } from 'util';
+import resolve$1 from 'resolve';
 import { createFilter } from '@rollup/pluginutils';
-import resolveModule from 'resolve';
-
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
-  try {
-    var info = gen[key](arg);
-    var value = info.value;
-  } catch (error) {
-    reject(error);
-    return;
-  }
-
-  if (info.done) {
-    resolve(value);
-  } else {
-    Promise.resolve(value).then(_next, _throw);
-  }
-}
-
-function _asyncToGenerator(fn) {
-  return function () {
-    var self = this,
-        args = arguments;
-    return new Promise(function (resolve, reject) {
-      var gen = fn.apply(self, args);
-
-      function _next(value) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
-      }
-
-      function _throw(err) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
-      }
-
-      _next(undefined);
-    });
-  };
-}
-
-function _slicedToArray(arr, i) {
-  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
-}
-
-function _arrayWithHoles(arr) {
-  if (Array.isArray(arr)) return arr;
-}
-
-function _iterableToArrayLimit(arr, i) {
-  if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
-  var _arr = [];
-  var _n = true;
-  var _d = false;
-  var _e = undefined;
-
-  try {
-    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
-      _arr.push(_s.value);
-
-      if (i && _arr.length === i) break;
-    }
-  } catch (err) {
-    _d = true;
-    _e = err;
-  } finally {
-    try {
-      if (!_n && _i["return"] != null) _i["return"]();
-    } finally {
-      if (_d) throw _e;
-    }
-  }
-
-  return _arr;
-}
-
-function _unsupportedIterableToArray(o, minLen) {
-  if (!o) return;
-  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-  var n = Object.prototype.toString.call(o).slice(8, -1);
-  if (n === "Object" && o.constructor) n = o.constructor.name;
-  if (n === "Map" || n === "Set") return Array.from(n);
-  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
-}
-
-function _arrayLikeToArray(arr, len) {
-  if (len == null || len > arr.length) len = arr.length;
-
-  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-
-  return arr2;
-}
-
-function _nonIterableRest() {
-  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-
-function _createForOfIteratorHelper(o) {
-  if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
-    if (Array.isArray(o) || (o = _unsupportedIterableToArray(o))) {
-      var i = 0;
-
-      var F = function () {};
-
-      return {
-        s: F,
-        n: function () {
-          if (i >= o.length) return {
-            done: true
-          };
-          return {
-            done: false,
-            value: o[i++]
-          };
-        },
-        e: function (e) {
-          throw e;
-        },
-        f: F
-      };
-    }
-
-    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-  }
-
-  var it,
-      normalCompletion = true,
-      didErr = false,
-      err;
-  return {
-    s: function () {
-      it = o[Symbol.iterator]();
-    },
-    n: function () {
-      var step = it.next();
-      normalCompletion = step.done;
-      return step;
-    },
-    e: function (e) {
-      didErr = true;
-      err = e;
-    },
-    f: function () {
-      try {
-        if (!normalCompletion && it.return != null) it.return();
-      } finally {
-        if (didErr) throw err;
-      }
-    }
-  };
-}
 
 const exists = promisify(fs.exists);
 const readFile = promisify(fs.readFile);
 const realpath = promisify(fs.realpath);
 const stat = promisify(fs.stat);
 
-const onError = error => {
+const onError = (error) => {
   if (error.code === 'ENOENT') {
     return false;
   }
-
   throw error;
 };
 
-const makeCache = fn => {
+const makeCache = (fn) => {
   const cache = new Map();
-
-  const wrapped = /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator(function* (param, done) {
-      if (cache.has(param) === false) {
-        cache.set(param, fn(param).catch(err => {
+  const wrapped = async (param, done) => {
+    if (cache.has(param) === false) {
+      cache.set(
+        param,
+        fn(param).catch((err) => {
           cache.delete(param);
           throw err;
-        }));
-      }
-
-      try {
-        const result = cache.get(param);
-        const value = yield result;
-        return done(null, value);
-      } catch (error) {
-        return done(error);
-      }
-    });
+        })
+      );
+    }
 
-    return function wrapped(_x, _x2) {
-      return _ref.apply(this, arguments);
-    };
-  }();
+    try {
+      const result = cache.get(param);
+      const value = await result;
+      return done(null, value);
+    } catch (error) {
+      return done(error);
+    }
+  };
 
   wrapped.clear = () => cache.clear();
 
   return wrapped;
 };
 
-const isDirCached = makeCache( /*#__PURE__*/function () {
-  var _ref2 = _asyncToGenerator(function* (file) {
-    try {
-      const stats = yield stat(file);
-      return stats.isDirectory();
-    } catch (error) {
-      return onError(error);
-    }
-  });
+const isDirCached = makeCache(async (file) => {
+  try {
+    const stats = await stat(file);
+    return stats.isDirectory();
+  } catch (error) {
+    return onError(error);
+  }
+});
 
-  return function (_x3) {
-    return _ref2.apply(this, arguments);
-  };
-}());
-const isFileCached = makeCache( /*#__PURE__*/function () {
-  var _ref3 = _asyncToGenerator(function* (file) {
-    try {
-      const stats = yield stat(file);
-      return stats.isFile();
-    } catch (error) {
-      return onError(error);
-    }
-  });
+const isFileCached = makeCache(async (file) => {
+  try {
+    const stats = await stat(file);
+    return stats.isFile();
+  } catch (error) {
+    return onError(error);
+  }
+});
 
-  return function (_x4) {
-    return _ref3.apply(this, arguments);
-  };
-}());
 const readCachedFile = makeCache(readFile);
 
-const resolveId = promisify(resolveModule); // returns the imported package name for bare module imports
-
+// returns the imported package name for bare module imports
 function getPackageName(id) {
   if (id.startsWith('.') || id.startsWith('/')) {
     return null;
   }
 
-  const split = id.split('/'); // @my-scope/my-package/foo.js -> @my-scope/my-package
-  // @my-scope/my-package -> @my-scope/my-package
+  const split = id.split('/');
 
+  // @my-scope/my-package/foo.js -> @my-scope/my-package
+  // @my-scope/my-package -> @my-scope/my-package
   if (split[0][0] === '@') {
     return `${split[0]}/${split[1]}`;
-  } // my-package/foo.js -> my-package
-  // my-package -> my-package
-
+  }
 
+  // my-package/foo.js -> my-package
+  // my-package -> my-package
   return split[0];
 }
+
 function getMainFields(options) {
   let mainFields;
-
   if (options.mainFields) {
-    mainFields = options.mainFields;
+    ({ mainFields } = options);
   } else {
     mainFields = ['module', 'main'];
   }
-
   if (options.browser && mainFields.indexOf('browser') === -1) {
     return ['browser'].concat(mainFields);
   }
-
   if (!mainFields.length) {
     throw new Error('Please ensure at least one `mainFields` value is specified');
   }
-
   return mainFields;
 }
+
 function getPackageInfo(options) {
-  const cache = options.cache,
-        extensions = options.extensions,
-        pkg = options.pkg,
-        mainFields = options.mainFields,
-        preserveSymlinks = options.preserveSymlinks,
-        useBrowserOverrides = options.useBrowserOverrides;
-  let pkgPath = options.pkgPath;
+  const { cache, extensions, pkg, mainFields, preserveSymlinks, useBrowserOverrides } = options;
+  let { pkgPath } = options;
 
   if (cache.has(pkgPath)) {
     return cache.get(pkgPath);
-  } // browserify/resolve doesn't realpath paths returned in its packageFilter callback
-
+  }
 
+  // browserify/resolve doesn't realpath paths returned in its packageFilter callback
   if (!preserveSymlinks) {
     pkgPath = realpathSync(pkgPath);
   }
 
   const pkgRoot = dirname(pkgPath);
+
   const packageInfo = {
     // copy as we are about to munge the `main` field of `pkg`.
-    packageJson: Object.assign({}, pkg),
+    packageJson: { ...pkg },
+
     // path to package.json file
     packageJsonPath: pkgPath,
+
     // directory containing the package.json
     root: pkgRoot,
+
     // which main field was used during resolution of this module (main, module, or browser)
     resolvedMainField: 'main',
+
     // whether the browser map was used to resolve the entry point to this module
     browserMappedMain: false,
+
     // the entry point of the module with respect to the selected main field and any
     // relevant browser mappings.
     resolvedEntryPoint: ''
   };
-  let overriddenMain = false;
 
+  let overriddenMain = false;
   for (let i = 0; i < mainFields.length; i++) {
     const field = mainFields[i];
-
     if (typeof pkg[field] === 'string') {
       pkg.main = pkg[field];
       packageInfo.resolvedMainField = field;
@@ -317,37 +152,38 @@ function getPackageInfo(options) {
     cachedPkg: pkg,
     hasModuleSideEffects: () => null,
     hasPackageEntry: overriddenMain !== false || mainFields.indexOf('main') !== -1,
-    packageBrowserField: useBrowserOverrides && typeof pkg.browser === 'object' && Object.keys(pkg.browser).reduce((browser, key) => {
-      let resolved = pkg.browser[key];
-
-      if (resolved && resolved[0] === '.') {
-        resolved = resolve(pkgRoot, resolved);
-      }
-      /* eslint-disable no-param-reassign */
-
-
-      browser[key] = resolved;
-
-      if (key[0] === '.') {
-        const absoluteKey = resolve(pkgRoot, key);
-        browser[absoluteKey] = resolved;
-
-        if (!extname(key)) {
-          extensions.reduce((subBrowser, ext) => {
-            subBrowser[absoluteKey + ext] = subBrowser[key];
-            return subBrowser;
-          }, browser);
+    packageBrowserField:
+      useBrowserOverrides &&
+      typeof pkg.browser === 'object' &&
+      Object.keys(pkg.browser).reduce((browser, key) => {
+        let resolved = pkg.browser[key];
+        if (resolved && resolved[0] === '.') {
+          resolved = resolve(pkgRoot, resolved);
         }
-      }
-
-      return browser;
-    }, {}),
+        /* eslint-disable no-param-reassign */
+        browser[key] = resolved;
+        if (key[0] === '.') {
+          const absoluteKey = resolve(pkgRoot, key);
+          browser[absoluteKey] = resolved;
+          if (!extname(key)) {
+            extensions.reduce((subBrowser, ext) => {
+              subBrowser[absoluteKey + ext] = subBrowser[key];
+              return subBrowser;
+            }, browser);
+          }
+        }
+        return browser;
+      }, {}),
     packageInfo
   };
-  const browserMap = internalPackageInfo.packageBrowserField;
 
-  if (useBrowserOverrides && typeof pkg.browser === 'object' && // eslint-disable-next-line no-prototype-builtins
-  browserMap.hasOwnProperty(pkg.main)) {
+  const browserMap = internalPackageInfo.packageBrowserField;
+  if (
+    useBrowserOverrides &&
+    typeof pkg.browser === 'object' &&
+    // eslint-disable-next-line no-prototype-builtins
+    browserMap.hasOwnProperty(pkg.main)
+  ) {
     packageInfo.resolvedEntryPoint = browserMap[pkg.main];
     packageInfo.browserMappedMain = true;
   } else {
@@ -357,7 +193,6 @@ function getPackageInfo(options) {
   }
 
   const packageSideEffects = pkg.sideEffects;
-
   if (typeof packageSideEffects === 'boolean') {
     internalPackageInfo.hasModuleSideEffects = () => packageSideEffects;
   } else if (Array.isArray(packageSideEffects)) {
@@ -369,70 +204,403 @@ function getPackageInfo(options) {
   cache.set(pkgPath, internalPackageInfo);
   return internalPackageInfo;
 }
+
 function normalizeInput(input) {
   if (Array.isArray(input)) {
     return input;
   } else if (typeof input === 'object') {
     return Object.values(input);
-  } // otherwise it's a string
-
+  }
 
+  // otherwise it's a string
   return [input];
-} // Resolve module specifiers in order. Promise resolves to the first module that resolves
-// successfully, or the error that resulted from the last attempted module resolution.
+}
 
-function resolveImportSpecifiers(importSpecifierList, resolveOptions) {
-  let promise = Promise.resolve();
+const resolveImportPath = promisify(resolve$1);
+const readFile$1 = promisify(fs.readFile);
 
-  for (let i = 0; i < importSpecifierList.length; i++) {
-    promise = promise.then(value => {
-      // if we've already resolved to something, just return it.
-      if (value) {
-        return value;
+const pathNotFoundError = (importPath, importer, subPath, pkgPath) =>
+  new Error(
+    `Could not resolve import "${importPath}" in "${importer}".` +
+      ` Package subpath "${subPath}" is not defined by "exports" in ${pkgPath}`
+  );
+
+function findExportKeyMatch(exportMap, subPath) {
+  if (subPath in exportMap) {
+    return subPath;
+  }
+
+  const matchKeys = Object.keys(exportMap)
+    .filter((key) => key.endsWith('/') || key.endsWith('*'))
+    .sort((a, b) => b.length - a.length);
+
+  for (const key of matchKeys) {
+    if (key.endsWith('*')) {
+      // star match: "./foo/*": "./foo/*.js"
+      const keyWithoutStar = key.substring(0, key.length - 1);
+      if (subPath.startsWith(keyWithoutStar)) {
+        return key;
       }
+    }
 
-      return resolveId(importSpecifierList[i], resolveOptions).then(result => {
-        if (!resolveOptions.preserveSymlinks) {
-          result = realpathSync(result);
-        }
+    if (key.endsWith('/') && subPath.startsWith(key)) {
+      // directory match (deprecated by node): "./foo/": "./foo/.js"
+      return key;
+    }
+
+    if (key === subPath) {
+      // literal match
+      return key;
+    }
+  }
+  return null;
+}
+
+function mapSubPath({ importPath, importer, pkgJsonPath, subPath, key, value }) {
+  if (typeof value === 'string') {
+    if (typeof key === 'string' && key.endsWith('*')) {
+      // star match: "./foo/*": "./foo/*.js"
+      const keyWithoutStar = key.substring(0, key.length - 1);
+      const subPathAfterKey = subPath.substring(keyWithoutStar.length);
+      return value.replace(/\*/g, subPathAfterKey);
+    }
+
+    if (value.endsWith('/')) {
+      // directory match (deprecated by node): "./foo/": "./foo/.js"
+      return `${value}${subPath.substring(key.length)}`;
+    }
+
+    // mapping is a string, for example { "./foo": "./dist/foo.js" }
+    return value;
+  }
+
+  if (Array.isArray(value)) {
+    // mapping is an array with fallbacks, for example { "./foo": ["foo:bar", "./dist/foo.js"] }
+    return value.find((v) => v.startsWith('./'));
+  }
+
+  throw pathNotFoundError(importPath, importer, subPath, pkgJsonPath);
+}
 
-        return result;
+function findEntrypoint({
+  importPath,
+  importer,
+  pkgJsonPath,
+  subPath,
+  exportMap,
+  conditions,
+  key
+}) {
+  if (typeof exportMap !== 'object') {
+    return mapSubPath({ importPath, importer, pkgJsonPath, subPath, key, value: exportMap });
+  }
+
+  // iterate conditions recursively, find the first that matches all conditions
+  for (const [condition, subExportMap] of Object.entries(exportMap)) {
+    if (conditions.includes(condition)) {
+      const mappedSubPath = findEntrypoint({
+        importPath,
+        importer,
+        pkgJsonPath,
+        subPath,
+        exportMap: subExportMap,
+        conditions,
+        key
       });
+      if (mappedSubPath) {
+        return mappedSubPath;
+      }
+    }
+  }
+  throw pathNotFoundError(importer, subPath, pkgJsonPath);
+}
+
+function findEntrypointTopLevel({
+  importPath,
+  importer,
+  pkgJsonPath,
+  subPath,
+  exportMap,
+  conditions
+}) {
+  if (typeof exportMap !== 'object') {
+    // the export map shorthand, for example { exports: "./index.js" }
+    if (subPath !== '.') {
+      // shorthand only supports a main entrypoint
+      throw pathNotFoundError(importPath, importer, subPath, pkgJsonPath);
+    }
+    return mapSubPath({ importPath, importer, pkgJsonPath, subPath, key: null, value: exportMap });
+  }
+
+  // export map is an object, the top level can be either conditions or sub path mappings
+  const keys = Object.keys(exportMap);
+  const isConditions = keys.every((k) => !k.startsWith('.'));
+  const isMappings = keys.every((k) => k.startsWith('.'));
+
+  if (!isConditions && !isMappings) {
+    throw new Error(
+      `Invalid package config ${pkgJsonPath}, "exports" cannot contain some keys starting with '.'` +
+        ' and some not. The exports object must either be an object of package subpath keys or an object of main entry' +
+        ' condition name keys only.'
+    );
+  }
+
+  let key = null;
+  let exportMapForSubPath;
+
+  if (isConditions) {
+    // top level is conditions, for example { "import": ..., "require": ..., "module": ... }
+    if (subPath !== '.') {
+      // package with top level conditions means it only supports a main entrypoint
+      throw pathNotFoundError(importPath, importer, subPath, pkgJsonPath);
+    }
+    exportMapForSubPath = exportMap;
+  } else {
+    // top level is sub path mappings, for example { ".": ..., "./foo": ..., "./bar": ... }
+    key = findExportKeyMatch(exportMap, subPath);
+    if (!key) {
+      throw pathNotFoundError(importPath, importer, subPath, pkgJsonPath);
+    }
+    exportMapForSubPath = exportMap[key];
+  }
+
+  return findEntrypoint({
+    importPath,
+    importer,
+    pkgJsonPath,
+    subPath,
+    exportMap: exportMapForSubPath,
+    conditions,
+    key
+  });
+}
+
+async function resolveId({
+  importer,
+  importPath,
+  exportConditions,
+  warn,
+  packageInfoCache,
+  extensions,
+  mainFields,
+  preserveSymlinks,
+  useBrowserOverrides,
+  baseDir,
+  moduleDirectories
+}) {
+  let hasModuleSideEffects = () => null;
+  let hasPackageEntry = true;
+  let packageBrowserField = false;
+  let packageInfo;
+
+  const filter = (pkg, pkgPath) => {
+    const info = getPackageInfo({
+      cache: packageInfoCache,
+      extensions,
+      pkg,
+      pkgPath,
+      mainFields,
+      preserveSymlinks,
+      useBrowserOverrides
     });
 
-    if (i < importSpecifierList.length - 1) {
-      // swallow MODULE_NOT_FOUND errors from all but the last resolution
-      promise = promise.catch(error => {
-        if (error.code !== 'MODULE_NOT_FOUND') {
-          throw error;
-        }
-      });
+    ({ packageInfo, hasModuleSideEffects, hasPackageEntry, packageBrowserField } = info);
+
+    return info.cachedPkg;
+  };
+
+  const resolveOptions = {
+    basedir: baseDir,
+    readFile: readCachedFile,
+    isFile: isFileCached,
+    isDirectory: isDirCached,
+    extensions,
+    includeCoreModules: false,
+    moduleDirectory: moduleDirectories,
+    preserveSymlinks,
+    packageFilter: filter
+  };
+
+  let location;
+
+  const pkgName = getPackageName(importPath);
+  if (pkgName) {
+    let pkgJsonPath;
+    let pkgJson;
+    try {
+      pkgJsonPath = await resolveImportPath(`${pkgName}/package.json`, resolveOptions);
+      pkgJson = JSON.parse(await readFile$1(pkgJsonPath, 'utf-8'));
+    } catch (_) {
+      // if there is no package.json we defer to regular resolve behavior
+    }
+
+    if (pkgJsonPath && pkgJson && pkgJson.exports) {
+      try {
+        const packageSubPath =
+          pkgName === importPath ? '.' : `.${importPath.substring(pkgName.length)}`;
+        const mappedSubPath = findEntrypointTopLevel({
+          importer,
+          importPath,
+          pkgJsonPath,
+          subPath: packageSubPath,
+          exportMap: pkgJson.exports,
+          conditions: exportConditions
+        });
+        const pkgDir = path.dirname(pkgJsonPath);
+        location = path.join(pkgDir, mappedSubPath);
+      } catch (error) {
+        warn(error);
+        return null;
+      }
+    }
+  }
+
+  if (!location) {
+    try {
+      location = await resolveImportPath(importPath, resolveOptions);
+    } catch (error) {
+      if (error.code !== 'MODULE_NOT_FOUND') {
+        throw error;
+      }
+      return null;
     }
   }
 
-  return promise;
+  if (!preserveSymlinks) {
+    if (await exists(location)) {
+      location = await realpath(location);
+    }
+  }
+
+  return {
+    location,
+    hasModuleSideEffects,
+    hasPackageEntry,
+    packageBrowserField,
+    packageInfo
+  };
 }
 
+// Resolve module specifiers in order. Promise resolves to the first module that resolves
+// successfully, or the error that resulted from the last attempted module resolution.
+async function resolveImportSpecifiers({
+  importer,
+  importSpecifierList,
+  exportConditions,
+  warn,
+  packageInfoCache,
+  extensions,
+  mainFields,
+  preserveSymlinks,
+  useBrowserOverrides,
+  baseDir,
+  moduleDirectories
+}) {
+  for (let i = 0; i < importSpecifierList.length; i++) {
+    // eslint-disable-next-line no-await-in-loop
+    const resolved = await resolveId({
+      importer,
+      importPath: importSpecifierList[i],
+      exportConditions,
+      warn,
+      packageInfoCache,
+      extensions,
+      mainFields,
+      preserveSymlinks,
+      useBrowserOverrides,
+      baseDir,
+      moduleDirectories
+    });
+    if (resolved) {
+      return resolved;
+    }
+  }
+  return null;
+}
+
+function handleDeprecatedOptions(opts) {
+  const warnings = [];
+
+  if (opts.customResolveOptions) {
+    const { customResolveOptions } = opts;
+    if (customResolveOptions.moduleDirectory) {
+      // eslint-disable-next-line no-param-reassign
+      opts.moduleDirectories = Array.isArray(customResolveOptions.moduleDirectory)
+        ? customResolveOptions.moduleDirectory
+        : [customResolveOptions.moduleDirectory];
+
+      warnings.push(
+        'node-resolve: The `customResolveOptions.moduleDirectory` option has been deprecated. Use `moduleDirectories`, which must be an array.'
+      );
+    }
+
+    if (customResolveOptions.preserveSymlinks) {
+      throw new Error(
+        'node-resolve: `customResolveOptions.preserveSymlinks` is no longer an option. We now always use the rollup `preserveSymlinks` option.'
+      );
+    }
+
+    [
+      'basedir',
+      'package',
+      'extensions',
+      'includeCoreModules',
+      'readFile',
+      'isFile',
+      'isDirectory',
+      'realpath',
+      'packageFilter',
+      'pathFilter',
+      'paths',
+      'packageIterator'
+    ].forEach((resolveOption) => {
+      if (customResolveOptions[resolveOption]) {
+        throw new Error(
+          `node-resolve: \`customResolveOptions.${resolveOption}\` is no longer an option. If you need this, please open an issue.`
+        );
+      }
+    });
+  }
+
+  return { warnings };
+}
+
+/* eslint-disable no-param-reassign, no-shadow, no-undefined */
+
 const builtins = new Set(builtinList);
 const ES6_BROWSER_EMPTY = '\0node-resolve:empty.js';
+const deepFreeze = (object) => {
+  Object.freeze(object);
 
-const nullFn = () => null;
+  for (const value of Object.values(object)) {
+    if (typeof value === 'object' && !Object.isFrozen(value)) {
+      deepFreeze(value);
+    }
+  }
 
+  return object;
+};
+
+const baseConditions = ['default', 'module'];
+const baseConditionsEsm = [...baseConditions, 'import'];
+const baseConditionsCjs = [...baseConditions, 'require'];
 const defaults = {
-  customResolveOptions: {},
   dedupe: [],
   // It's important that .mjs is listed before .js so that Rollup will interpret npm modules
   // which deploy both ESM .mjs and CommonJS .js files as ESM.
   extensions: ['.mjs', '.js', '.json', '.node'],
-  resolveOnly: []
+  resolveOnly: [],
+  moduleDirectories: ['node_modules']
 };
 const DEFAULTS = deepFreeze(deepMerge({}, defaults));
+
 function nodeResolve(opts = {}) {
-  const options = Object.assign({}, defaults, opts);
-  const customResolveOptions = options.customResolveOptions,
-        extensions = options.extensions,
-        jail = options.jail;
-  const warnings = [];
+  const { warnings } = handleDeprecatedOptions(opts);
+
+  const options = { ...defaults, ...opts };
+  const { extensions, jail, moduleDirectories } = options;
+  const conditionsEsm = [...baseConditionsEsm, ...(options.exportConditions || [])];
+  const conditionsCjs = [...baseConditionsCjs, ...(options.exportConditions || [])];
   const packageInfoCache = new Map();
   const idToPackageInfo = new Map();
   const mainFields = getMainFields(options);
@@ -440,49 +608,36 @@ function nodeResolve(opts = {}) {
   const isPreferBuiltinsSet = options.preferBuiltins === true || options.preferBuiltins === false;
   const preferBuiltins = isPreferBuiltinsSet ? options.preferBuiltins : true;
   const rootDir = options.rootDir || process.cwd();
-  let dedupe = options.dedupe;
+  let { dedupe } = options;
   let rollupOptions;
 
-  if (options.only) {
-    warnings.push('node-resolve: The `only` options is deprecated, please use `resolveOnly`');
-    options.resolveOnly = options.only;
-  }
-
   if (typeof dedupe !== 'function') {
-    dedupe = importee => options.dedupe.includes(importee) || options.dedupe.includes(getPackageName(importee));
+    dedupe = (importee) =>
+      options.dedupe.includes(importee) || options.dedupe.includes(getPackageName(importee));
   }
 
-  const resolveOnly = options.resolveOnly.map(pattern => {
+  const resolveOnly = options.resolveOnly.map((pattern) => {
     if (pattern instanceof RegExp) {
       return pattern;
     }
-
     const normalized = pattern.replace(/[\\^$*+?.()|[\]{}]/g, '\\$&');
     return new RegExp(`^${normalized}$`);
   });
+
   const browserMapCache = new Map();
   let preserveSymlinks;
+
   return {
     name: 'node-resolve',
 
     buildStart(options) {
       rollupOptions = options;
 
-      var _iterator = _createForOfIteratorHelper(warnings),
-          _step;
-
-      try {
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          const warning = _step.value;
-          this.warn(warning);
-        }
-      } catch (err) {
-        _iterator.e(err);
-      } finally {
-        _iterator.f();
+      for (const warning of warnings) {
+        this.warn(warning);
       }
 
-      preserveSymlinks = options.preserveSymlinks;
+      ({ preserveSymlinks } = options);
     },
 
     generateBundle() {
@@ -491,217 +646,194 @@ function nodeResolve(opts = {}) {
       isDirCached.clear();
     },
 
-    resolveId(importee, importer) {
-      var _this = this;
-
-      return _asyncToGenerator(function* () {
-        if (importee === ES6_BROWSER_EMPTY) {
-          return importee;
-        } // ignore IDs with null character, these belong to other plugins
-
-
-        if (/\0/.test(importee)) return null; // strip hash and query params from import
-
-        const _importee$split = importee.split('#'),
-              _importee$split2 = _slicedToArray(_importee$split, 2),
-              withoutHash = _importee$split2[0],
-              hash = _importee$split2[1];
-
-        const _withoutHash$split = withoutHash.split('?'),
-              _withoutHash$split2 = _slicedToArray(_withoutHash$split, 2),
-              importPath = _withoutHash$split2[0],
-              params = _withoutHash$split2[1];
-
-        const importSuffix = `${params ? `?${params}` : ''}${hash ? `#${hash}` : ''}`;
-        importee = importPath;
-        const basedir = !importer || dedupe(importee) ? rootDir : dirname(importer); // https://github.com/defunctzombie/package-browser-field-spec
-
-        const browser = browserMapCache.get(importer);
-
-        if (useBrowserOverrides && browser) {
-          const resolvedImportee = resolve(basedir, importee);
-
-          if (browser[importee] === false || browser[resolvedImportee] === false) {
-            return ES6_BROWSER_EMPTY;
-          }
-
-          const browserImportee = browser[importee] || browser[resolvedImportee] || browser[`${resolvedImportee}.js`] || browser[`${resolvedImportee}.json`];
+    async resolveId(importee, importer, opts) {
+      if (importee === ES6_BROWSER_EMPTY) {
+        return importee;
+      }
+      // ignore IDs with null character, these belong to other plugins
+      if (/\0/.test(importee)) return null;
 
-          if (browserImportee) {
-            importee = browserImportee;
-          }
-        }
+      if (/\0/.test(importer)) {
+        importer = undefined;
+      }
 
-        const parts = importee.split(/[/\\]/);
-        let id = parts.shift();
-        let isRelativeImport = false;
-
-        if (id[0] === '@' && parts.length > 0) {
-          // scoped packages
-          id += `/${parts.shift()}`;
-        } else if (id[0] === '.') {
-          // an import relative to the parent dir of the importer
-          id = resolve(basedir, importee);
-          isRelativeImport = true;
-        }
+      // strip query params from import
+      const [importPath, params] = importee.split('?');
+      const importSuffix = `${params ? `?${params}` : ''}`;
+      importee = importPath;
 
-        if (!isRelativeImport && resolveOnly.length && !resolveOnly.some(pattern => pattern.test(id))) {
-          if (normalizeInput(rollupOptions.input).includes(importee)) {
-            return null;
-          }
+      const baseDir = !importer || dedupe(importee) ? rootDir : dirname(importer);
 
-          return false;
+      // https://github.com/defunctzombie/package-browser-field-spec
+      const browser = browserMapCache.get(importer);
+      if (useBrowserOverrides && browser) {
+        const resolvedImportee = resolve(baseDir, importee);
+        if (browser[importee] === false || browser[resolvedImportee] === false) {
+          return ES6_BROWSER_EMPTY;
         }
-
-        let hasModuleSideEffects = nullFn;
-        let hasPackageEntry = true;
-        let packageBrowserField = false;
-        let packageInfo;
-
-        const filter = (pkg, pkgPath) => {
-          const info = getPackageInfo({
-            cache: packageInfoCache,
-            extensions,
-            pkg,
-            pkgPath,
-            mainFields,
-            preserveSymlinks,
-            useBrowserOverrides
-          });
-          packageInfo = info.packageInfo;
-          hasModuleSideEffects = info.hasModuleSideEffects;
-          hasPackageEntry = info.hasPackageEntry;
-          packageBrowserField = info.packageBrowserField;
-          return info.cachedPkg;
-        };
-
-        let resolveOptions = {
-          basedir,
-          packageFilter: filter,
-          readFile: readCachedFile,
-          isFile: isFileCached,
-          isDirectory: isDirCached,
-          extensions
-        };
-
-        if (preserveSymlinks !== undefined) {
-          resolveOptions.preserveSymlinks = preserveSymlinks;
+        const browserImportee =
+          browser[importee] ||
+          browser[resolvedImportee] ||
+          browser[`${resolvedImportee}.js`] ||
+          browser[`${resolvedImportee}.json`];
+        if (browserImportee) {
+          importee = browserImportee;
         }
+      }
 
-        const importSpecifierList = [];
+      const parts = importee.split(/[/\\]/);
+      let id = parts.shift();
+      let isRelativeImport = false;
+
+      if (id[0] === '@' && parts.length > 0) {
+        // scoped packages
+        id += `/${parts.shift()}`;
+      } else if (id[0] === '.') {
+        // an import relative to the parent dir of the importer
+        id = resolve(baseDir, importee);
+        isRelativeImport = true;
+      }
 
-        if (importer === undefined && !importee[0].match(/^\.?\.?\//)) {
-          // For module graph roots (i.e. when importer is undefined), we
-          // need to handle 'path fragments` like `foo/bar` that are commonly
-          // found in rollup config files. If importee doesn't look like a
-          // relative or absolute path, we make it relative and attempt to
-          // resolve it. If we don't find anything, we try resolving it as we
-          // got it.
-          importSpecifierList.push(`./${importee}`);
+      if (
+        !isRelativeImport &&
+        resolveOnly.length &&
+        !resolveOnly.some((pattern) => pattern.test(id))
+      ) {
+        if (normalizeInput(rollupOptions.input).includes(importee)) {
+          return null;
         }
+        return false;
+      }
 
-        const importeeIsBuiltin = builtins.has(importee);
+      const importSpecifierList = [];
 
-        if (importeeIsBuiltin && (!preferBuiltins || !isPreferBuiltinsSet)) {
-          // The `resolve` library will not resolve packages with the same
-          // name as a node built-in module. If we're resolving something
-          // that's a builtin, and we don't prefer to find built-ins, we
-          // first try to look up a local module with that name. If we don't
-          // find anything, we resolve the builtin which just returns back
-          // the built-in's name.
-          importSpecifierList.push(`${importee}/`);
-        } // TypeScript files may import '.js' to refer to either '.ts' or '.tsx'
+      if (importer === undefined && !importee[0].match(/^\.?\.?\//)) {
+        // For module graph roots (i.e. when importer is undefined), we
+        // need to handle 'path fragments` like `foo/bar` that are commonly
+        // found in rollup config files. If importee doesn't look like a
+        // relative or absolute path, we make it relative and attempt to
+        // resolve it. If we don't find anything, we try resolving it as we
+        // got it.
+        importSpecifierList.push(`./${importee}`);
+      }
 
+      const importeeIsBuiltin = builtins.has(importee);
 
-        if (importer && importee.endsWith('.js')) {
-          for (var _i = 0, _arr = ['.ts', '.tsx']; _i < _arr.length; _i++) {
-            const ext = _arr[_i];
+      if (importeeIsBuiltin) {
+        // The `resolve` library will not resolve packages with the same
+        // name as a node built-in module. If we're resolving something
+        // that's a builtin, and we don't prefer to find built-ins, we
+        // first try to look up a local module with that name. If we don't
+        // find anything, we resolve the builtin which just returns back
+        // the built-in's name.
+        importSpecifierList.push(`${importee}/`);
+      }
 
-            if (importer.endsWith(ext) && extensions.includes(ext)) {
-              importSpecifierList.push(importee.replace(/.js$/, ext));
-            }
+      // TypeScript files may import '.js' to refer to either '.ts' or '.tsx'
+      if (importer && importee.endsWith('.js')) {
+        for (const ext of ['.ts', '.tsx']) {
+          if (importer.endsWith(ext) && extensions.includes(ext)) {
+            importSpecifierList.push(importee.replace(/.js$/, ext));
           }
         }
+      }
 
-        importSpecifierList.push(importee);
-        resolveOptions = Object.assign(resolveOptions, customResolveOptions);
-
-        try {
-          let resolved = yield resolveImportSpecifiers(importSpecifierList, resolveOptions);
-
-          if (resolved && packageBrowserField) {
-            if (Object.prototype.hasOwnProperty.call(packageBrowserField, resolved)) {
-              if (!packageBrowserField[resolved]) {
-                browserMapCache.set(resolved, packageBrowserField);
-                return ES6_BROWSER_EMPTY;
-              }
-
-              resolved = packageBrowserField[resolved];
-            }
-
-            browserMapCache.set(resolved, packageBrowserField);
-          }
-
-          if (hasPackageEntry && !preserveSymlinks && resolved) {
-            const fileExists = yield exists(resolved);
+      importSpecifierList.push(importee);
+
+      const warn = (...args) => this.warn(...args);
+      const isRequire =
+        opts && opts.custom && opts.custom['node-resolve'] && opts.custom['node-resolve'].isRequire;
+      const exportConditions = isRequire ? conditionsCjs : conditionsEsm;
+
+      const resolvedWithoutBuiltins = await resolveImportSpecifiers({
+        importer,
+        importSpecifierList,
+        exportConditions,
+        warn,
+        packageInfoCache,
+        extensions,
+        mainFields,
+        preserveSymlinks,
+        useBrowserOverrides,
+        baseDir,
+        moduleDirectories
+      });
 
-            if (fileExists) {
-              resolved = yield realpath(resolved);
+      const resolved =
+        importeeIsBuiltin && preferBuiltins
+          ? {
+              packageInfo: undefined,
+              hasModuleSideEffects: () => null,
+              hasPackageEntry: true,
+              packageBrowserField: false
             }
-          }
-
-          idToPackageInfo.set(resolved, packageInfo);
-
-          if (hasPackageEntry) {
-            if (builtins.has(resolved) && preferBuiltins && isPreferBuiltinsSet) {
-              return null;
-            } else if (importeeIsBuiltin && preferBuiltins) {
-              if (!isPreferBuiltinsSet) {
-                _this.warn(`preferring built-in module '${importee}' over local alternative at '${resolved}', pass 'preferBuiltins: false' to disable this behavior or 'preferBuiltins: true' to disable this warning`);
-              }
+          : resolvedWithoutBuiltins;
+      if (!resolved) {
+        return null;
+      }
 
-              return null;
-            } else if (jail && resolved.indexOf(normalize(jail.trim(sep))) !== 0) {
-              return null;
-            }
+      const { packageInfo, hasModuleSideEffects, hasPackageEntry, packageBrowserField } = resolved;
+      let { location } = resolved;
+      if (packageBrowserField) {
+        if (Object.prototype.hasOwnProperty.call(packageBrowserField, location)) {
+          if (!packageBrowserField[location]) {
+            browserMapCache.set(location, packageBrowserField);
+            return ES6_BROWSER_EMPTY;
           }
+          location = packageBrowserField[location];
+        }
+        browserMapCache.set(location, packageBrowserField);
+      }
 
-          if (resolved && options.modulesOnly) {
-            const code = yield readFile(resolved, 'utf-8');
+      if (hasPackageEntry && !preserveSymlinks) {
+        const fileExists = await exists(location);
+        if (fileExists) {
+          location = await realpath(location);
+        }
+      }
 
-            if (isModule(code)) {
-              return {
-                id: `${resolved}${importSuffix}`,
-                moduleSideEffects: hasModuleSideEffects(resolved)
-              };
-            }
+      idToPackageInfo.set(location, packageInfo);
 
-            return null;
+      if (hasPackageEntry) {
+        if (importeeIsBuiltin && preferBuiltins) {
+          if (!isPreferBuiltinsSet && resolvedWithoutBuiltins && resolved !== importee) {
+            this.warn(
+              `preferring built-in module '${importee}' over local alternative at '${resolvedWithoutBuiltins.location}', pass 'preferBuiltins: false' to disable this behavior or 'preferBuiltins: true' to disable this warning`
+            );
           }
+          return false;
+        } else if (jail && location.indexOf(normalize(jail.trim(sep))) !== 0) {
+          return null;
+        }
+      }
 
-          const result = {
-            id: `${resolved}${importSuffix}`,
-            moduleSideEffects: hasModuleSideEffects(resolved)
+      if (options.modulesOnly && (await exists(location))) {
+        const code = await readFile(location, 'utf-8');
+        if (isModule(code)) {
+          return {
+            id: `${location}${importSuffix}`,
+            moduleSideEffects: hasModuleSideEffects(location)
           };
-          return result;
-        } catch (error) {
-          return null;
         }
-      })();
+        return null;
+      }
+      const result = {
+        id: `${location}${importSuffix}`,
+        moduleSideEffects: hasModuleSideEffects(location)
+      };
+      return result;
     },
 
     load(importee) {
       if (importee === ES6_BROWSER_EMPTY) {
         return 'export default {};';
       }
-
       return null;
     },
 
     getPackageInfoForId(id) {
       return idToPackageInfo.get(id);
     }
-
   };
 }