@rollup/plugin-node-resolve 9.0.0 → 11.1.0

package/dist/es/index.js

@@ -1,11 +1,12 @@
-import { dirname, resolve, extname, normalize, sep } from 'path';
+import path, { dirname, resolve, extname, normalize, sep } from 'path';
 import builtinList from 'builtin-modules';
 import deepMerge from 'deepmerge';
 import isModule from 'is-module';
 import fs, { realpathSync } from 'fs';
 import { promisify } from 'util';
+import { pathToFileURL, fileURLToPath } from 'url';
+import resolve$1 from 'resolve';
 import { createFilter } from '@rollup/pluginutils';
-import resolveModule from 'resolve';
 
 const exists = promisify(fs.exists);
 const readFile = promisify(fs.readFile);
@@ -66,8 +67,6 @@ const isFileCached = makeCache(async (file) => {
 
 const readCachedFile = makeCache(readFile);
 
-const resolveId = promisify(resolveModule);
-
 // returns the imported package name for bare module imports
 function getPackageName(id) {
   if (id.startsWith('.') || id.startsWith('/')) {
@@ -120,7 +119,7 @@ function getPackageInfo(options) {
 
   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,
@@ -218,44 +217,553 @@ function normalizeInput(input) {
   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();
+/* eslint-disable no-await-in-loop */
 
-  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 fileExists = promisify(fs.exists);
+
+function isModuleDir(current, moduleDirs) {
+  return moduleDirs.some((dir) => current.endsWith(dir));
+}
+
+async function findPackageJson(base, moduleDirs) {
+  const { root } = path.parse(base);
+  let current = base;
+
+  while (current !== root && !isModuleDir(current, moduleDirs)) {
+    const pkgJsonPath = path.join(current, 'package.json');
+    if (await fileExists(pkgJsonPath)) {
+      const pkgJsonString = fs.readFileSync(pkgJsonPath, 'utf-8');
+      return { pkgJson: JSON.parse(pkgJsonString), pkgPath: current, pkgJsonPath };
+    }
+    current = path.resolve(current, '..');
+  }
+  return null;
+}
+
+function isUrl(str) {
+  try {
+    return !!new URL(str);
+  } catch (_) {
+    return false;
+  }
+}
+
+function isConditions(exports) {
+  return typeof exports === 'object' && Object.keys(exports).every((k) => !k.startsWith('.'));
+}
+
+function isMappings(exports) {
+  return typeof exports === 'object' && !isConditions(exports);
+}
+
+function isMixedExports(exports) {
+  const keys = Object.keys(exports);
+  return keys.some((k) => k.startsWith('.')) && keys.some((k) => !k.startsWith('.'));
+}
+
+function createBaseErrorMsg(importSpecifier, importer) {
+  return `Could not resolve import "${importSpecifier}" in ${importer}`;
+}
+
+function createErrorMsg(context, reason, internal) {
+  const { importSpecifier, importer, pkgJsonPath } = context;
+  const base = createBaseErrorMsg(importSpecifier, importer);
+  const field = internal ? 'imports' : 'exports';
+  return `${base} using ${field} defined in ${pkgJsonPath}.${reason ? ` ${reason}` : ''}`;
+}
+
+class ResolveError extends Error {}
+
+class InvalidConfigurationError extends ResolveError {
+  constructor(context, reason) {
+    super(createErrorMsg(context, `Invalid "exports" field. ${reason}`));
+  }
+}
+
+class InvalidModuleSpecifierError extends ResolveError {
+  constructor(context, internal) {
+    super(createErrorMsg(context, internal));
+  }
+}
+
+class InvalidPackageTargetError extends ResolveError {
+  constructor(context, reason) {
+    super(createErrorMsg(context, reason));
+  }
+}
+
+/* eslint-disable no-await-in-loop, no-undefined */
+
+function includesInvalidSegments(pathSegments, moduleDirs) {
+  return pathSegments
+    .split('/')
+    .slice(1)
+    .some((t) => ['.', '..', ...moduleDirs].includes(t));
+}
+
+async function resolvePackageTarget(context, { target, subpath, pattern, internal }) {
+  if (typeof target === 'string') {
+    if (!pattern && subpath.length > 0 && !target.endsWith('/')) {
+      throw new InvalidModuleSpecifierError(context);
+    }
+
+    if (!target.startsWith('./')) {
+      if (internal && !['/', '../'].some((p) => target.startsWith(p)) && !isUrl(target)) {
+        // this is a bare package import, remap it and resolve it using regular node resolve
+        if (pattern) {
+          const result = await context.resolveId(
+            target.replace(/\*/g, subpath),
+            context.pkgURL.href
+          );
+          return result ? pathToFileURL(result.location) : null;
+        }
+
+        const result = await context.resolveId(`${target}${subpath}`, context.pkgURL.href);
+        return result ? pathToFileURL(result.location) : null;
+      }
+      throw new InvalidPackageTargetError(context, `Invalid mapping: "${target}".`);
+    }
+
+    if (includesInvalidSegments(target, context.moduleDirs)) {
+      throw new InvalidPackageTargetError(context, `Invalid mapping: "${target}".`);
+    }
+
+    const resolvedTarget = new URL(target, context.pkgURL);
+    if (!resolvedTarget.href.startsWith(context.pkgURL.href)) {
+      throw new InvalidPackageTargetError(
+        context,
+        `Resolved to ${resolvedTarget.href} which is outside package ${context.pkgURL.href}`
+      );
+    }
+
+    if (includesInvalidSegments(subpath, context.moduleDirs)) {
+      throw new InvalidModuleSpecifierError(context);
+    }
+
+    if (pattern) {
+      return resolvedTarget.href.replace(/\*/g, subpath);
+    }
+    return new URL(subpath, resolvedTarget).href;
+  }
+
+  if (Array.isArray(target)) {
+    let lastError;
+    for (const item of target) {
+      try {
+        const resolved = await resolvePackageTarget(context, {
+          target: item,
+          subpath,
+          pattern,
+          internal
+        });
+
+        // return if defined or null, but not undefined
+        if (resolved !== undefined) {
+          return resolved;
+        }
+      } catch (error) {
+        if (!(error instanceof InvalidPackageTargetError)) {
+          throw error;
+        } else {
+          lastError = error;
+        }
       }
+    }
 
-      return resolveId(importSpecifierList[i], resolveOptions).then((result) => {
-        if (!resolveOptions.preserveSymlinks) {
-          result = realpathSync(result);
+    if (lastError) {
+      throw lastError;
+    }
+    return null;
+  }
+
+  if (target && typeof target === 'object') {
+    for (const [key, value] of Object.entries(target)) {
+      if (key === 'default' || context.conditions.includes(key)) {
+        const resolved = await resolvePackageTarget(context, {
+          target: value,
+          subpath,
+          pattern,
+          internal
+        });
+
+        // return if defined or null, but not undefined
+        if (resolved !== undefined) {
+          return resolved;
         }
-        return result;
+      }
+    }
+    return undefined;
+  }
+
+  if (target === null) {
+    return null;
+  }
+
+  throw new InvalidPackageTargetError(context, `Invalid exports field.`);
+}
+
+/* eslint-disable no-await-in-loop */
+
+async function resolvePackageImportsExports(context, { matchKey, matchObj, internal }) {
+  if (!matchKey.endsWith('*') && matchKey in matchObj) {
+    const target = matchObj[matchKey];
+    const resolved = await resolvePackageTarget(context, { target, subpath: '', internal });
+    return resolved;
+  }
+
+  const expansionKeys = Object.keys(matchObj)
+    .filter((k) => k.endsWith('/') || k.endsWith('*'))
+    .sort((a, b) => b.length - a.length);
+
+  for (const expansionKey of expansionKeys) {
+    const prefix = expansionKey.substring(0, expansionKey.length - 1);
+
+    if (expansionKey.endsWith('*') && matchKey.startsWith(prefix)) {
+      const target = matchObj[expansionKey];
+      const subpath = matchKey.substring(expansionKey.length - 1);
+      const resolved = await resolvePackageTarget(context, {
+        target,
+        subpath,
+        pattern: true,
+        internal
       });
+      return resolved;
+    }
+
+    if (matchKey.startsWith(expansionKey)) {
+      const target = matchObj[expansionKey];
+      const subpath = matchKey.substring(expansionKey.length);
+
+      const resolved = await resolvePackageTarget(context, { target, subpath, internal });
+      return resolved;
+    }
+  }
+
+  throw new InvalidModuleSpecifierError(context, internal);
+}
+
+async function resolvePackageExports(context, subpath, exports) {
+  if (isMixedExports(exports)) {
+    throw new InvalidConfigurationError(
+      context,
+      'All keys must either start with ./, or without one.'
+    );
+  }
+
+  if (subpath === '.') {
+    let mainExport;
+    // If exports is a String or Array, or an Object containing no keys starting with ".", then
+    if (typeof exports === 'string' || Array.isArray(exports) || isConditions(exports)) {
+      mainExport = exports;
+    } else if (isMappings(exports)) {
+      mainExport = exports['.'];
+    }
+
+    if (mainExport) {
+      const resolved = await resolvePackageTarget(context, { target: mainExport, subpath: '' });
+      if (resolved) {
+        return resolved;
+      }
+    }
+  } else if (isMappings(exports)) {
+    const resolvedMatch = await resolvePackageImportsExports(context, {
+      matchKey: subpath,
+      matchObj: exports
     });
 
-    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') {
+    if (resolvedMatch) {
+      return resolvedMatch;
+    }
+  }
+
+  throw new InvalidModuleSpecifierError(context);
+}
+
+async function resolvePackageImports({
+  importSpecifier,
+  importer,
+  moduleDirs,
+  conditions,
+  resolveId
+}) {
+  const result = await findPackageJson(importer, moduleDirs);
+  if (!result) {
+    throw new Error(createBaseErrorMsg('. Could not find a parent package.json.'));
+  }
+
+  const { pkgPath, pkgJsonPath, pkgJson } = result;
+  const pkgURL = pathToFileURL(`${pkgPath}/`);
+  const context = {
+    importer,
+    importSpecifier,
+    moduleDirs,
+    pkgURL,
+    pkgJsonPath,
+    conditions,
+    resolveId
+  };
+
+  const { imports } = pkgJson;
+  if (!imports) {
+    throw new InvalidModuleSpecifierError(context, true);
+  }
+
+  if (importSpecifier === '#' || importSpecifier.startsWith('#/')) {
+    throw new InvalidModuleSpecifierError(context, 'Invalid import specifier.');
+  }
+
+  return resolvePackageImportsExports(context, {
+    matchKey: importSpecifier,
+    matchObj: imports,
+    internal: true
+  });
+}
+
+const resolveImportPath = promisify(resolve$1);
+const readFile$1 = promisify(fs.readFile);
+
+async function getPackageJson(importer, pkgName, resolveOptions, moduleDirectories) {
+  if (importer) {
+    const selfPackageJsonResult = await findPackageJson(importer, moduleDirectories);
+    if (selfPackageJsonResult && selfPackageJsonResult.pkgJson.name === pkgName) {
+      // the referenced package name is the current package
+      return selfPackageJsonResult;
+    }
+  }
+
+  try {
+    const pkgJsonPath = await resolveImportPath(`${pkgName}/package.json`, resolveOptions);
+    const pkgJson = JSON.parse(await readFile$1(pkgJsonPath, 'utf-8'));
+    return { pkgJsonPath, pkgJson };
+  } catch (_) {
+    return null;
+  }
+}
+
+async function resolveId({
+  importer,
+  importSpecifier,
+  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
+    });
+
+    ({ 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(importSpecifier);
+  if (importSpecifier.startsWith('#')) {
+    // this is a package internal import, resolve using package imports field
+    const resolveResult = await resolvePackageImports({
+      importSpecifier,
+      importer,
+      moduleDirs: moduleDirectories,
+      conditions: exportConditions,
+      resolveId(id, parent) {
+        return resolveId({
+          importSpecifier: id,
+          importer: parent,
+          exportConditions,
+          warn,
+          packageInfoCache,
+          extensions,
+          mainFields,
+          preserveSymlinks,
+          useBrowserOverrides,
+          baseDir,
+          moduleDirectories
+        });
+      }
+    });
+    location = fileURLToPath(resolveResult);
+  } else if (pkgName) {
+    // it's a bare import, find the package.json and resolve using package exports if available
+    const result = await getPackageJson(importer, pkgName, resolveOptions, moduleDirectories);
+
+    if (result && result.pkgJson.exports) {
+      const { pkgJson, pkgJsonPath } = result;
+      try {
+        const subpath =
+          pkgName === importSpecifier ? '.' : `.${importSpecifier.substring(pkgName.length)}`;
+        const pkgDr = pkgJsonPath.replace('package.json', '');
+        const pkgURL = pathToFileURL(pkgDr);
+
+        const context = {
+          importer,
+          importSpecifier,
+          moduleDirs: moduleDirectories,
+          pkgURL,
+          pkgJsonPath,
+          conditions: exportConditions
+        };
+        const resolvedPackageExport = await resolvePackageExports(
+          context,
+          subpath,
+          pkgJson.exports
+        );
+        location = fileURLToPath(resolvedPackageExport);
+      } catch (error) {
+        if (!(error instanceof ResolveError)) {
           throw error;
         }
-      });
+        warn(error);
+        return null;
+      }
+    }
+  }
+
+  if (!location) {
+    // package has no imports or exports, use classic node resolve
+    try {
+      location = await resolveImportPath(importSpecifier, 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,
+      importSpecifier: 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 nullFn = () => null;
 const deepFreeze = (object) => {
   Object.freeze(object);
 
@@ -267,20 +775,27 @@ const deepFreeze = (object) => {
 
   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, extensions, jail } = options;
-  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);
@@ -291,11 +806,6 @@ function nodeResolve(opts = {}) {
   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));
@@ -331,25 +841,28 @@ function nodeResolve(opts = {}) {
       isDirCached.clear();
     },
 
-    async resolveId(importee, importer) {
+    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;
 
-      // strip hash and query params from import
-      const [withoutHash, hash] = importee.split('#');
-      const [importPath, params] = withoutHash.split('?');
-      const importSuffix = `${params ? `?${params}` : ''}${hash ? `#${hash}` : ''}`;
+      if (/\0/.test(importer)) {
+        importer = undefined;
+      }
+
+      // strip query params from import
+      const [importPath, params] = importee.split('?');
+      const importSuffix = `${params ? `?${params}` : ''}`;
       importee = importPath;
 
-      const basedir = !importer || dedupe(importee) ? rootDir : dirname(importer);
+      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);
+        const resolvedImportee = resolve(baseDir, importee);
         if (browser[importee] === false || browser[resolvedImportee] === false) {
           return ES6_BROWSER_EMPTY;
         }
@@ -372,7 +885,7 @@ function nodeResolve(opts = {}) {
         id += `/${parts.shift()}`;
       } else if (id[0] === '.') {
         // an import relative to the parent dir of the importer
-        id = resolve(basedir, importee);
+        id = resolve(baseDir, importee);
         isRelativeImport = true;
       }
 
@@ -387,40 +900,6 @@ function nodeResolve(opts = {}) {
         return false;
       }
 
-      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, hasModuleSideEffects, hasPackageEntry, packageBrowserField } = info);
-
-        return info.cachedPkg;
-      };
-
-      let resolveOptions = {
-        basedir,
-        packageFilter: filter,
-        readFile: readCachedFile,
-        isFile: isFileCached,
-        isDirectory: isDirCached,
-        extensions
-      };
-
-      if (preserveSymlinks !== undefined) {
-        resolveOptions.preserveSymlinks = preserveSymlinks;
-      }
-
       const importSpecifierList = [];
 
       if (importer === undefined && !importee[0].match(/^\.?\.?\//)) {
@@ -435,7 +914,7 @@ function nodeResolve(opts = {}) {
 
       const importeeIsBuiltin = builtins.has(importee);
 
-      if (importeeIsBuiltin && (!preferBuiltins || !isPreferBuiltinsSet)) {
+      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
@@ -455,64 +934,89 @@ function nodeResolve(opts = {}) {
       }
 
       importSpecifierList.push(importee);
-      resolveOptions = Object.assign(resolveOptions, customResolveOptions);
 
-      try {
-        let resolved = await resolveImportSpecifiers(importSpecifierList, resolveOptions);
+      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 (resolved && packageBrowserField) {
-          if (Object.prototype.hasOwnProperty.call(packageBrowserField, resolved)) {
-            if (!packageBrowserField[resolved]) {
-              browserMapCache.set(resolved, packageBrowserField);
-              return ES6_BROWSER_EMPTY;
+      const resolved =
+        importeeIsBuiltin && preferBuiltins
+          ? {
+              packageInfo: undefined,
+              hasModuleSideEffects: () => null,
+              hasPackageEntry: true,
+              packageBrowserField: false
             }
-            resolved = packageBrowserField[resolved];
+          : resolvedWithoutBuiltins;
+      if (!resolved) {
+        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;
           }
-          browserMapCache.set(resolved, packageBrowserField);
+          location = packageBrowserField[location];
         }
+        browserMapCache.set(location, packageBrowserField);
+      }
 
-        if (hasPackageEntry && !preserveSymlinks && resolved) {
-          const fileExists = await exists(resolved);
-          if (fileExists) {
-            resolved = await realpath(resolved);
-          }
+      if (hasPackageEntry && !preserveSymlinks) {
+        const fileExists = await exists(location);
+        if (fileExists) {
+          location = await realpath(location);
         }
+      }
 
-        idToPackageInfo.set(resolved, packageInfo);
+      idToPackageInfo.set(location, 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`
-              );
-            }
-            return null;
-          } else if (jail && resolved.indexOf(normalize(jail.trim(sep))) !== 0) {
-            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;
         }
+      }
 
-        if (resolved && options.modulesOnly) {
-          const code = await readFile(resolved, 'utf-8');
-          if (isModule(code)) {
-            return {
-              id: `${resolved}${importSuffix}`,
-              moduleSideEffects: hasModuleSideEffects(resolved)
-            };
-          }
-          return null;
+      if (options.modulesOnly && (await exists(location))) {
+        const code = await readFile(location, 'utf-8');
+        if (isModule(code)) {
+          return {
+            id: `${location}${importSuffix}`,
+            moduleSideEffects: hasModuleSideEffects(location)
+          };
         }
-        const result = {
-          id: `${resolved}${importSuffix}`,
-          moduleSideEffects: hasModuleSideEffects(resolved)
-        };
-        return result;
-      } catch (error) {
         return null;
       }
+      const result = {
+        id: `${location}${importSuffix}`,
+        moduleSideEffects: hasModuleSideEffects(location)
+      };
+      return result;
     },
 
     load(importee) {