@rollup/plugin-node-resolve 6.0.0 → 7.1.1

package/dist/index.es.js

@@ -1,121 +1,152 @@
-import { dirname, join, resolve, normalize, sep, extname } from 'path';
-import fs, { realpathSync } from 'fs';
+import { dirname, resolve, extname, normalize, sep } from 'path';
 import builtinList from 'builtin-modules';
-import resolveId from 'resolve';
 import isModule from 'is-module';
+import fs, { realpathSync } from 'fs';
+import { promisify } from 'util';
 import { createFilter } from '@rollup/pluginutils';
+import resolveModule from 'resolve';
 
-function _slicedToArray(arr, i) {
-  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();
-}
-
-function _arrayWithHoles(arr) {
-  if (Array.isArray(arr)) return arr;
-}
-
-function _iterableToArrayLimit(arr, i) {
-  if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) {
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg);
+    var value = info.value;
+  } catch (error) {
+    reject(error);
     return;
   }
 
-  var _arr = [];
-  var _n = true;
-  var _d = false;
-  var _e = undefined;
+  if (info.done) {
+    resolve(value);
+  } else {
+    Promise.resolve(value).then(_next, _throw);
+  }
+}
 
-  try {
-    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
-      _arr.push(_s.value);
+function _asyncToGenerator(fn) {
+  return function () {
+    var self = this,
+        args = arguments;
+    return new Promise(function (resolve, reject) {
+      var gen = fn.apply(self, args);
 
-      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;
-    }
-  }
+      function _next(value) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+      }
 
-  return _arr;
-}
+      function _throw(err) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+      }
 
-function _nonIterableRest() {
-  throw new TypeError("Invalid attempt to destructure non-iterable instance");
+      _next(undefined);
+    });
+  };
 }
 
-var peerDependencies = {
-	rollup: "^1.20.0"
+const exists = promisify(fs.exists);
+const readFile = promisify(fs.readFile);
+const realpath = promisify(fs.realpath);
+const stat = promisify(fs.stat);
+
+const onError = error => {
+  if (error.code === 'ENOENT') {
+    return false;
+  }
+
+  throw error;
 };
 
-const builtins = new Set(builtinList);
-const ES6_BROWSER_EMPTY = '\0node-resolve:empty.js'; // It is important that .mjs occur before .js so that Rollup will interpret npm modules
-// which deploy both ESM .mjs and CommonJS .js files as ESM.
+const makeCache = fn => {
+  const cache = new Map();
 
-const DEFAULT_EXTS = ['.mjs', '.js', '.json', '.node'];
+  const wrapped =
+  /*#__PURE__*/
+  function () {
+    var _ref = _asyncToGenerator(function* (param, done) {
+      if (cache.has(param) === false) {
+        cache.set(param, fn(param).catch(err => {
+          cache.delete(param);
+          throw err;
+        }));
+      }
 
-const existsAsync = file => new Promise(fulfil => fs.exists(file, fulfil));
+      try {
+        const result = cache.get(param);
+        const value = yield result;
+        return done(null, value);
+      } catch (error) {
+        return done(error);
+      }
+    });
 
-const readFileAsync = file => new Promise((fulfil, reject) => fs.readFile(file, (err, contents) => err ? reject(err) : fulfil(contents)));
+    return function wrapped(_x, _x2) {
+      return _ref.apply(this, arguments);
+    };
+  }();
 
-const realpathAsync = file => new Promise((fulfil, reject) => fs.realpath(file, (err, contents) => err ? reject(err) : fulfil(contents)));
+  wrapped.clear = () => cache.clear();
 
-const statAsync = file => new Promise((fulfil, reject) => fs.stat(file, (err, contents) => err ? reject(err) : fulfil(contents)));
+  return wrapped;
+};
 
-const cache = fn => {
-  const cache = new Map();
+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 wrapped = (param, done) => {
-    if (cache.has(param) === false) {
-      cache.set(param, fn(param).catch(err => {
-        cache.delete(param);
-        throw err;
-      }));
+  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);
     }
+  });
 
-    return cache.get(param).then(result => done(null, result), done);
+  return function (_x4) {
+    return _ref3.apply(this, arguments);
   };
+}());
+const readCachedFile = makeCache(readFile);
 
-  wrapped.clear = () => cache.clear();
+const resolveId = promisify(resolveModule); // returns the imported package name for bare module imports
 
-  return wrapped;
-};
+function getPackageName(id) {
+  if (id.startsWith('.') || id.startsWith('/')) {
+    return null;
+  }
 
-const ignoreENOENT = err => {
-  if (err.code === 'ENOENT') return false;
-  throw err;
-};
+  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
 
-const readFileCached = cache(readFileAsync);
-const isDirCached = cache(file => statAsync(file).then(stat => stat.isDirectory(), ignoreENOENT));
-const isFileCached = cache(file => statAsync(file).then(stat => stat.isFile(), ignoreENOENT));
 
+  return split[0];
+}
 function getMainFields(options) {
   let mainFields;
 
   if (options.mainFields) {
-    if ('module' in options || 'main' in options || 'jsnext' in options) {
-      throw new Error(`node-resolve: do not use deprecated 'module', 'main', 'jsnext' options with 'mainFields'`);
-    }
-
     mainFields = options.mainFields;
   } else {
-    mainFields = [];
-    [['module', 'module', true], ['jsnext', 'jsnext:main', false], ['main', 'main', true]].forEach(([option, field, defaultIncluded]) => {
-      if (option in options) {
-        // eslint-disable-next-line no-console
-        console.warn(`node-resolve: setting options.${option} is deprecated, please override options.mainFields instead`);
-
-        if (options[option]) {
-          mainFields.push(field);
-        }
-      } else if (defaultIncluded) {
-        mainFields.push(field);
-      }
-    });
+    mainFields = ['module', 'main'];
   }
 
   if (options.browser && mainFields.indexOf('browser') === -1) {
@@ -123,331 +154,411 @@ function getMainFields(options) {
   }
 
   if (!mainFields.length) {
-    throw new Error(`Please ensure at least one 'mainFields' value is specified`);
+    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;
+
+  if (cache.has(pkgPath)) {
+    return cache.get(pkgPath);
+  } // 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),
+    // 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;
+
+  for (let i = 0; i < mainFields.length; i++) {
+    const field = mainFields[i];
+
+    if (typeof pkg[field] === 'string') {
+      pkg.main = pkg[field];
+      packageInfo.resolvedMainField = field;
+      overriddenMain = true;
+      break;
+    }
+  }
+
+  const internalPackageInfo = {
+    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 */
+
 
-const alwaysNull = () => null;
+      browser[key] = resolved;
 
-const resolveIdAsync = (file, opts) => new Promise((fulfil, reject) => resolveId(file, opts, (err, contents) => err ? reject(err) : fulfil(contents))); // 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.
+      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)) {
+    packageInfo.resolvedEntryPoint = browserMap[pkg.main];
+    packageInfo.browserMappedMain = true;
+  } else {
+    // index.node is technically a valid default entrypoint as well...
+    packageInfo.resolvedEntryPoint = resolve(pkgRoot, pkg.main || 'index.js');
+    packageInfo.browserMappedMain = false;
+  }
+
+  const packageSideEffects = pkg.sideEffects;
+
+  if (typeof packageSideEffects === 'boolean') {
+    internalPackageInfo.hasModuleSideEffects = () => packageSideEffects;
+  } else if (Array.isArray(packageSideEffects)) {
+    internalPackageInfo.hasModuleSideEffects = createFilter(packageSideEffects, null, {
+      resolve: pkgRoot
+    });
+  }
+
+  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
+
+
+  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 p = Promise.resolve();
+  let promise = Promise.resolve();
 
   for (let i = 0; i < importSpecifierList.length; i++) {
-    p = p.then(v => {
+    promise = promise.then(value => {
       // if we've already resolved to something, just return it.
-      if (v) return v;
-      return resolveIdAsync(importSpecifierList[i], resolveOptions);
+      if (value) {
+        return value;
+      }
+
+      return resolveId(importSpecifierList[i], resolveOptions);
     });
 
     if (i < importSpecifierList.length - 1) {
       // swallow MODULE_NOT_FOUND errors from all but the last resolution
-      p = p.catch(err => {
-        if (err.code !== 'MODULE_NOT_FOUND') {
-          throw err;
+      promise = promise.catch(error => {
+        if (error.code !== 'MODULE_NOT_FOUND') {
+          throw error;
         }
       });
     }
   }
 
-  return p;
+  return promise;
 }
 
-function nodeResolve(options = {}) {
+const builtins = new Set(builtinList);
+const ES6_BROWSER_EMPTY = '\0node-resolve:empty.js';
+
+const nullFn = () => null;
+
+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: []
+};
+function nodeResolve(opts = {}) {
+  const options = Object.assign({}, defaults, opts);
+  const customResolveOptions = options.customResolveOptions,
+        extensions = options.extensions,
+        jail = options.jail;
+  const warnings = [];
+  const packageInfoCache = new Map();
+  const idToPackageInfo = new Map();
   const mainFields = getMainFields(options);
   const useBrowserOverrides = mainFields.indexOf('browser') !== -1;
-  const dedupe = options.dedupe || [];
   const isPreferBuiltinsSet = options.preferBuiltins === true || options.preferBuiltins === false;
   const preferBuiltins = isPreferBuiltinsSet ? options.preferBuiltins : true;
-  const customResolveOptions = options.customResolveOptions || {};
-  const jail = options.jail;
-  const only = Array.isArray(options.only) ? options.only.map(o => o instanceof RegExp ? o : new RegExp(`^${String(o).replace(/[\\^$*+?.()|[\]{}]/g, '\\$&')}$`)) : null;
-  const browserMapCache = new Map();
-  let preserveSymlinks;
+  const rootDir = options.rootDir || process.cwd();
+  let dedupe = options.dedupe;
+  let rollupOptions;
 
-  if (options.skip) {
-    throw new Error('options.skip is no longer supported — you should use the main Rollup `external` option instead');
+  if (options.only) {
+    warnings.push('node-resolve: The `only` options is deprecated, please use `resolveOnly`');
+    options.resolveOnly = options.only;
   }
 
-  const extensions = options.extensions || DEFAULT_EXTS;
-  const packageInfoCache = new Map();
-  const idToPackageInfo = new Map();
-  const shouldDedupe = typeof dedupe === 'function' ? dedupe : importee => dedupe.includes(importee);
-
-  function getCachedPackageInfo(pkg, pkgPath) {
-    if (packageInfoCache.has(pkgPath)) {
-      return packageInfoCache.get(pkgPath);
-    } // 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),
-      // 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;
-
-    for (let i = 0; i < mainFields.length; i++) {
-      const field = mainFields[i];
+  if (typeof dedupe !== 'function') {
+    dedupe = importee => options.dedupe.includes(importee) || options.dedupe.includes(getPackageName(importee));
+  }
 
-      if (typeof pkg[field] === 'string') {
-        pkg.main = pkg[field];
-        packageInfo.resolvedMainField = field;
-        overriddenMain = true;
-        break;
-      }
+  const resolveOnly = options.resolveOnly.map(pattern => {
+    if (pattern instanceof RegExp) {
+      return pattern;
     }
 
-    const internalPackageInfo = {
-      cachedPkg: pkg,
-      hasModuleSideEffects: alwaysNull,
-      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];
+    const normalized = pattern.replace(/[\\^$*+?.()|[\]{}]/g, '\\$&');
+    return new RegExp(`^${normalized}$`);
+  });
+  const browserMapCache = new Map();
+  let preserveSymlinks;
+  return {
+    name: 'node-resolve',
 
-        if (resolved && resolved[0] === '.') {
-          resolved = resolve(pkgRoot, resolved);
+    buildStart(options) {
+      rollupOptions = options;
+      var _iteratorNormalCompletion = true;
+      var _didIteratorError = false;
+      var _iteratorError = undefined;
+
+      try {
+        for (var _iterator = warnings[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          const warning = _step.value;
+          this.warn(warning);
         }
-
-        browser[key] = resolved;
-
-        if (key[0] === '.') {
-          const absoluteKey = resolve(pkgRoot, key);
-          browser[absoluteKey] = resolved;
-
-          if (!extname(key)) {
-            extensions.reduce((browser, ext) => {
-              browser[absoluteKey + ext] = browser[key];
-              return browser;
-            }, browser);
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return != null) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
           }
         }
+      }
 
-        return browser;
-      }, {}),
-      packageInfo
-    };
-    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 {
-      // index.node is technically a valid default entrypoint as well...
-      packageInfo.resolvedEntryPoint = resolve(pkgRoot, pkg.main || 'index.js');
-      packageInfo.browserMappedMain = false;
-    }
+      preserveSymlinks = options.preserveSymlinks;
+    },
 
-    const packageSideEffects = pkg.sideEffects;
+    generateBundle() {
+      readCachedFile.clear();
+      isFileCached.clear();
+      isDirCached.clear();
+    },
 
-    if (typeof packageSideEffects === 'boolean') {
-      internalPackageInfo.hasModuleSideEffects = () => packageSideEffects;
-    } else if (Array.isArray(packageSideEffects)) {
-      internalPackageInfo.hasModuleSideEffects = createFilter(packageSideEffects, null, {
-        resolve: pkgRoot
-      });
-    }
+    resolveId(importee, importer) {
+      var _this = this;
 
-    packageInfoCache.set(pkgPath, internalPackageInfo);
-    return internalPackageInfo;
-  }
+      return _asyncToGenerator(function* () {
+        if (importee === ES6_BROWSER_EMPTY) {
+          return importee;
+        } // ignore IDs with null character, these belong to other plugins
 
-  return {
-    name: 'node-resolve',
 
-    buildStart(options) {
-      preserveSymlinks = options.preserveSymlinks;
+        if (/\0/.test(importee)) return null;
+        const basedir = !importer || dedupe(importee) ? rootDir : dirname(importer); // https://github.com/defunctzombie/package-browser-field-spec
 
-      const _this$meta$rollupVers = this.meta.rollupVersion.split('.').map(Number),
-            _this$meta$rollupVers2 = _slicedToArray(_this$meta$rollupVers, 2),
-            major = _this$meta$rollupVers2[0],
-            minor = _this$meta$rollupVers2[1];
+        const browser = browserMapCache.get(importer);
 
-      const minVersion = peerDependencies.rollup.slice(2);
+        if (useBrowserOverrides && browser) {
+          const resolvedImportee = resolve(basedir, importee);
 
-      const _minVersion$split$map = minVersion.split('.').map(Number),
-            _minVersion$split$map2 = _slicedToArray(_minVersion$split$map, 2),
-            minMajor = _minVersion$split$map2[0],
-            minMinor = _minVersion$split$map2[1];
+          if (browser[importee] === false || browser[resolvedImportee] === false) {
+            return ES6_BROWSER_EMPTY;
+          }
 
-      if (major < minMajor || major === minMajor && minor < minMinor) {
-        this.error(`Insufficient Rollup version: "rollup-plugin-node-resolve" requires at least rollup@${minVersion} but found rollup@${this.meta.rollupVersion}.`);
-      }
-    },
+          const browserImportee = browser[importee] || browser[resolvedImportee] || browser[`${resolvedImportee}.js`] || browser[`${resolvedImportee}.json`];
 
-    generateBundle() {
-      readFileCached.clear();
-      isFileCached.clear();
-      isDirCached.clear();
-    },
+          if (browserImportee) {
+            importee = browserImportee;
+          }
+        }
 
-    resolveId(importee, importer) {
-      if (importee === ES6_BROWSER_EMPTY) {
-        return importee;
-      } // ignore IDs with null character, these belong to other plugins
+        const parts = importee.split(/[/\\]/);
+        let id = parts.shift();
 
+        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);
+        }
 
-      if (/\0/.test(importee)) return null;
-      const basedir = importer ? dirname(importer) : process.cwd();
+        const input = normalizeInput(rollupOptions.input);
 
-      if (shouldDedupe(importee)) {
-        importee = join(process.cwd(), 'node_modules', importee);
-      } // https://github.com/defunctzombie/package-browser-field-spec
+        if (resolveOnly.length && !resolveOnly.some(pattern => pattern.test(id))) {
+          if (input.includes(id)) {
+            return null;
+          }
 
+          return false;
+        }
 
-      const browser = browserMapCache.get(importer);
+        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;
+        };
 
-      if (useBrowserOverrides && browser) {
-        const resolvedImportee = resolve(basedir, importee);
+        let resolveOptions = {
+          basedir,
+          packageFilter: filter,
+          readFile: readCachedFile,
+          isFile: isFileCached,
+          isDirectory: isDirCached,
+          extensions
+        };
 
-        if (browser[importee] === false || browser[resolvedImportee] === false) {
-          return ES6_BROWSER_EMPTY;
+        if (preserveSymlinks !== undefined) {
+          resolveOptions.preserveSymlinks = preserveSymlinks;
         }
 
-        const browserImportee = browser[importee] || browser[resolvedImportee] || browser[`${resolvedImportee}.js`] || browser[`${resolvedImportee}.json`];
+        const importSpecifierList = [];
 
-        if (browserImportee) {
-          importee = browserImportee;
+        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 parts = importee.split(/[/\\]/);
-      let id = parts.shift();
+        const importeeIsBuiltin = builtins.has(importee);
 
-      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);
-      }
+        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}/`);
+        }
 
-      if (only && !only.some(pattern => pattern.test(id))) return null;
-      let hasModuleSideEffects = alwaysNull;
-      let hasPackageEntry = true;
-      let packageBrowserField = false;
-      let packageInfo;
-      const resolveOptions = {
-        basedir,
-
-        packageFilter(pkg, pkgPath) {
-          let cachedPkg;
-
-          var _getCachedPackageInfo = getCachedPackageInfo(pkg, pkgPath);
-
-          packageInfo = _getCachedPackageInfo.packageInfo;
-          cachedPkg = _getCachedPackageInfo.cachedPkg;
-          hasModuleSideEffects = _getCachedPackageInfo.hasModuleSideEffects;
-          hasPackageEntry = _getCachedPackageInfo.hasPackageEntry;
-          packageBrowserField = _getCachedPackageInfo.packageBrowserField;
-          return cachedPkg;
-        },
-
-        readFile: readFileCached,
-        isFile: isFileCached,
-        isDirectory: isDirCached,
-        extensions
-      };
-
-      if (preserveSymlinks !== undefined) {
-        resolveOptions.preserveSymlinks = preserveSymlinks;
-      }
+        importSpecifierList.push(importee);
+        resolveOptions = Object.assign(resolveOptions, customResolveOptions);
 
-      const importSpecifierList = [];
+        try {
+          let resolved = yield resolveImportSpecifiers(importSpecifierList, resolveOptions);
 
-      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 (resolved && packageBrowserField) {
+            if (Object.prototype.hasOwnProperty.call(packageBrowserField, resolved)) {
+              if (!packageBrowserField[resolved]) {
+                browserMapCache.set(resolved, packageBrowserField);
+                return ES6_BROWSER_EMPTY;
+              }
 
-      const importeeIsBuiltin = builtins.has(importee);
+              resolved = packageBrowserField[resolved];
+            }
 
-      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}/`);
-      }
+            browserMapCache.set(resolved, packageBrowserField);
+          }
 
-      importSpecifierList.push(importee);
-      return resolveImportSpecifiers(importSpecifierList, Object.assign(resolveOptions, customResolveOptions)).then(resolved => {
-        if (resolved && packageBrowserField) {
-          if (Object.prototype.hasOwnProperty.call(packageBrowserField, resolved)) {
-            if (!packageBrowserField[resolved]) {
-              browserMapCache.set(resolved, packageBrowserField);
-              return ES6_BROWSER_EMPTY;
-            }
+          if (hasPackageEntry && !preserveSymlinks && resolved) {
+            const fileExists = yield exists(resolved);
 
-            resolved = packageBrowserField[resolved];
+            if (fileExists) {
+              resolved = yield realpath(resolved);
+            }
           }
 
-          browserMapCache.set(resolved, packageBrowserField);
-        }
+          idToPackageInfo.set(resolved, packageInfo);
 
-        if (hasPackageEntry && !preserveSymlinks && resolved) {
-          return existsAsync(resolved).then(exists => exists ? realpathAsync(resolved) : resolved);
-        }
+          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`);
+              }
 
-        return resolved;
-      }).then(resolved => {
-        idToPackageInfo.set(resolved, packageInfo);
+              return null;
+            } else if (jail && resolved.indexOf(normalize(jail.trim(sep))) !== 0) {
+              return null;
+            }
+          }
 
-        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`);
+          if (resolved && options.modulesOnly) {
+            const code = yield readFile(resolved, 'utf-8');
+
+            if (isModule(code)) {
+              return {
+                id: resolved,
+                moduleSideEffects: hasModuleSideEffects(resolved)
+              };
             }
 
-            return null;
-          } else if (jail && resolved.indexOf(normalize(jail.trim(sep))) !== 0) {
             return null;
           }
-        }
 
-        if (resolved && options.modulesOnly) {
-          return readFileAsync(resolved).then(code => isModule(code) ? {
+          const result = {
             id: resolved,
             moduleSideEffects: hasModuleSideEffects(resolved)
-          } : null);
+          };
+          return result;
+        } catch (error) {
+          return null;
         }
-
-        return {
-          id: resolved,
-          moduleSideEffects: hasModuleSideEffects(resolved)
-        };
-      }).catch(() => null);
+      })();
     },
 
     load(importee) {