@rollup/plugin-commonjs 15.0.0 → 17.1.0

package/dist/index.js

@@ -1,36 +1,99 @@
 'use strict';
 
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
-
 var path = require('path');
 var pluginutils = require('@rollup/pluginutils');
-var getCommonDir = _interopDefault(require('commondir'));
+var getCommonDir = require('commondir');
 var fs = require('fs');
+var glob = require('glob');
 var estreeWalker = require('estree-walker');
-var MagicString = _interopDefault(require('magic-string'));
+var MagicString = require('magic-string');
+var isReference = require('is-reference');
 var resolve = require('resolve');
-var isReference = _interopDefault(require('is-reference'));
-var glob = _interopDefault(require('glob'));
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var getCommonDir__default = /*#__PURE__*/_interopDefaultLegacy(getCommonDir);
+var glob__default = /*#__PURE__*/_interopDefaultLegacy(glob);
+var MagicString__default = /*#__PURE__*/_interopDefaultLegacy(MagicString);
+var isReference__default = /*#__PURE__*/_interopDefaultLegacy(isReference);
 
 var peerDependencies = {
-	rollup: "^2.22.0"
+	rollup: "^2.30.0"
 };
 
-const PROXY_SUFFIX = '?commonjs-proxy';
-const getProxyId = (id) => `\0${id}${PROXY_SUFFIX}`;
-const getIdFromProxyId = (proxyId) => proxyId.slice(1, -PROXY_SUFFIX.length);
+function tryParse(parse, code, id) {
+  try {
+    return parse(code, { allowReturnOutsideFunction: true });
+  } catch (err) {
+    err.message += ` in ${id}`;
+    throw err;
+  }
+}
 
-const EXTERNAL_SUFFIX = '?commonjs-external';
-const getExternalProxyId = (id) => `\0${id}${EXTERNAL_SUFFIX}`;
-const getIdFromExternalProxyId = (proxyId) => proxyId.slice(1, -EXTERNAL_SUFFIX.length);
+const firstpassGlobal = /\b(?:require|module|exports|global)\b/;
 
-const VIRTUAL_PATH_BASE = '/$$rollup_base$$';
-const getVirtualPathForDynamicRequirePath = (path, commonDir) => {
-  if (path.startsWith(commonDir)) return VIRTUAL_PATH_BASE + path.slice(commonDir.length);
-  return path;
-};
+const firstpassNoGlobal = /\b(?:require|module|exports)\b/;
+
+function hasCjsKeywords(code, ignoreGlobal) {
+  const firstpass = ignoreGlobal ? firstpassNoGlobal : firstpassGlobal;
+  return firstpass.test(code);
+}
+
+/* eslint-disable no-underscore-dangle */
+
+function analyzeTopLevelStatements(parse, code, id) {
+  const ast = tryParse(parse, code, id);
+
+  let isEsModule = false;
+  let hasDefaultExport = false;
+  let hasNamedExports = false;
+
+  for (const node of ast.body) {
+    switch (node.type) {
+      case 'ExportDefaultDeclaration':
+        isEsModule = true;
+        hasDefaultExport = true;
+        break;
+      case 'ExportNamedDeclaration':
+        isEsModule = true;
+        if (node.declaration) {
+          hasNamedExports = true;
+        } else {
+          for (const specifier of node.specifiers) {
+            if (specifier.exported.name === 'default') {
+              hasDefaultExport = true;
+            } else {
+              hasNamedExports = true;
+            }
+          }
+        }
+        break;
+      case 'ExportAllDeclaration':
+        isEsModule = true;
+        if (node.exported && node.exported.name === 'default') {
+          hasDefaultExport = true;
+        } else {
+          hasNamedExports = true;
+        }
+        break;
+      case 'ImportDeclaration':
+        isEsModule = true;
+        break;
+    }
+  }
+
+  return { isEsModule, hasDefaultExport, hasNamedExports, ast };
+}
+
+const isWrappedId = (id, suffix) => id.endsWith(suffix);
+const wrapId = (id, suffix) => `\0${id}${suffix}`;
+const unwrapId = (wrappedId, suffix) => wrappedId.slice(1, -suffix.length);
+
+const PROXY_SUFFIX = '?commonjs-proxy';
+const REQUIRE_SUFFIX = '?commonjs-require';
+const EXTERNAL_SUFFIX = '?commonjs-external';
 
-const DYNAMIC_REGISTER_PREFIX = '\0commonjs-dynamic-register:';
+const DYNAMIC_REGISTER_SUFFIX = '?commonjs-dynamic-register';
 const DYNAMIC_JSON_PREFIX = '\0commonjs-dynamic-json:';
 const DYNAMIC_PACKAGES_ID = '\0commonjs-dynamic-packages';
 
@@ -41,11 +104,6 @@ const HELPERS_ID = '\0commonjsHelpers.js';
 // This will no longer be necessary once Rollup switches to ES6 output, likely
 // in Rollup 3
 
-// The "hasOwnProperty" call in "getDefaultExportFromCjs" is technically not
-// needed, but for consumers that use Rollup's old interop pattern, it will fix
-// rollup/rollup-plugin-commonjs#224
-// We should remove it once Rollup core and this plugin are updated to not use
-// this pattern any more
 const HELPERS = `
 export var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
@@ -53,16 +111,6 @@ export function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
 
-export function createCommonjsModule(fn, basedir, module) {
-	return module = {
-	  path: basedir,
-	  exports: {},
-	  require: function (path, base) {
-      return commonjsRequire(path, (base === undefined || base === null) ? module.path : base);
-    }
-	}, fn(module, module.exports), module.exports;
-}
-
 export function getDefaultExportFromNamespaceIfPresent (n) {
 	return n && Object.prototype.hasOwnProperty.call(n, 'default') ? n['default'] : n;
 }
@@ -70,15 +118,45 @@ export function getDefaultExportFromNamespaceIfPresent (n) {
 export function getDefaultExportFromNamespaceIfNotNamed (n) {
 	return n && Object.prototype.hasOwnProperty.call(n, 'default') && Object.keys(n).length === 1 ? n['default'] : n;
 }
+
+export function getAugmentedNamespace(n) {
+	if (n.__esModule) return n;
+	var a = Object.defineProperty({}, '__esModule', {value: true});
+	Object.keys(n).forEach(function (k) {
+		var d = Object.getOwnPropertyDescriptor(n, k);
+		Object.defineProperty(a, k, d.get ? d : {
+			enumerable: true,
+			get: function () {
+				return n[k];
+			}
+		});
+	});
+	return a;
+}
 `;
 
 const HELPER_NON_DYNAMIC = `
-export function commonjsRequire () {
-	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
+export function createCommonjsModule(fn) {
+  var module = { exports: {} }
+	return fn(module, module.exports), module.exports;
+}
+
+export function commonjsRequire (target) {
+	throw new Error('Could not dynamically require "' + target + '". Please configure the dynamicRequireTargets option of @rollup/plugin-commonjs appropriately for this require call to behave properly.');
 }
 `;
 
 const HELPERS_DYNAMIC = `
+export function createCommonjsModule(fn, basedir, module) {
+	return module = {
+		path: basedir,
+		exports: {},
+		require: function (path, base) {
+			return commonjsRequire(path, (base === undefined || base === null) ? module.path : base);
+		}
+	}, fn(module, module.exports), module.exports;
+}
+
 export function commonjsRegister (path, loader) {
 	DYNAMIC_REQUIRE_LOADERS[path] = loader;
 }
@@ -165,10 +243,13 @@ function dirname (path) {
   return '.';
 }
 
-export function commonjsRequire (path, originalModuleDir) {
+export function commonjsResolveImpl (path, originalModuleDir, testCache) {
 	const shouldTryNodeModules = isPossibleNodeModulesPath(path);
 	path = normalize(path);
 	let relPath;
+	if (path[0] === '/') {
+		originalModuleDir = '/';
+	}
 	while (true) {
 		if (!shouldTryNodeModules) {
 			relPath = originalModuleDir ? normalize(originalModuleDir + '/' + path) : path;
@@ -177,33 +258,18 @@ export function commonjsRequire (path, originalModuleDir) {
 		} else {
 			relPath = normalize(join('node_modules', path));
 		}
+
+		if (relPath.endsWith('/..')) {
+			break; // Travelled too far up, avoid infinite loop
+		}
+
 		for (let extensionIndex = 0; extensionIndex < CHECKED_EXTENSIONS.length; extensionIndex++) {
 			const resolvedPath = relPath + CHECKED_EXTENSIONS[extensionIndex];
-			let cachedModule = DYNAMIC_REQUIRE_CACHE[resolvedPath];
-			if (cachedModule) return cachedModule.exports;
-			const loader = DYNAMIC_REQUIRE_LOADERS[resolvedPath];
-			if (loader) {
-				DYNAMIC_REQUIRE_CACHE[resolvedPath] = cachedModule = {
-					id: resolvedPath,
-					filename: resolvedPath,
-					path: dirname(resolvedPath),
-					exports: {},
-					parent: DEFAULT_PARENT_MODULE,
-					loaded: false,
-					children: [],
-					paths: [],
-					require: function (path, base) {
-					  return commonjsRequire(path, (base === undefined || base === null) ? cachedModule.path : base);
-					}
-				};
-				try {
-					loader.call(commonjsGlobal, cachedModule, cachedModule.exports);
-				} catch (error) {
-					delete DYNAMIC_REQUIRE_CACHE[resolvedPath];
-					throw error;
-				}
-				cachedModule.loaded = true;
-				return cachedModule.exports;
+			if (DYNAMIC_REQUIRE_CACHE[resolvedPath]) {
+				return resolvedPath;
+			};
+			if (DYNAMIC_REQUIRE_LOADERS[resolvedPath]) {
+				return resolvedPath;
 			};
 		}
 		if (!shouldTryNodeModules) break;
@@ -211,77 +277,74 @@ export function commonjsRequire (path, originalModuleDir) {
 		if (nextDir === originalModuleDir) break;
 		originalModuleDir = nextDir;
 	}
+	return null;
+}
+
+export function commonjsResolve (path, originalModuleDir) {
+	const resolvedPath = commonjsResolveImpl(path, originalModuleDir);
+	if (resolvedPath !== null) {
+		return resolvedPath;
+	}
+	return require.resolve(path);
+}
+
+export function commonjsRequire (path, originalModuleDir) {
+	const resolvedPath = commonjsResolveImpl(path, originalModuleDir, true);
+	if (resolvedPath !== null) {
+    let cachedModule = DYNAMIC_REQUIRE_CACHE[resolvedPath];
+    if (cachedModule) return cachedModule.exports;
+    const loader = DYNAMIC_REQUIRE_LOADERS[resolvedPath];
+    if (loader) {
+      DYNAMIC_REQUIRE_CACHE[resolvedPath] = cachedModule = {
+        id: resolvedPath,
+        filename: resolvedPath,
+        path: dirname(resolvedPath),
+        exports: {},
+        parent: DEFAULT_PARENT_MODULE,
+        loaded: false,
+        children: [],
+        paths: [],
+        require: function (path, base) {
+          return commonjsRequire(path, (base === undefined || base === null) ? cachedModule.path : base);
+        }
+      };
+      try {
+        loader.call(commonjsGlobal, cachedModule, cachedModule.exports);
+      } catch (error) {
+        delete DYNAMIC_REQUIRE_CACHE[resolvedPath];
+        throw error;
+      }
+      cachedModule.loaded = true;
+      return cachedModule.exports;
+    };
+	}
 	return require(path);
 }
 
 commonjsRequire.cache = DYNAMIC_REQUIRE_CACHE;
+commonjsRequire.resolve = commonjsResolve;
 `;
 
 function getHelpersModule(isDynamicRequireModulesEnabled) {
   return `${HELPERS}${isDynamicRequireModulesEnabled ? HELPERS_DYNAMIC : HELPER_NON_DYNAMIC}`;
 }
 
-/* eslint-disable no-undefined */
-
-const operators = {
-  '==': (x) => equals(x.left, x.right, false),
-
-  '!=': (x) => not(operators['=='](x)),
-
-  '===': (x) => equals(x.left, x.right, true),
-
-  '!==': (x) => not(operators['==='](x)),
-
-  '!': (x) => isFalsy(x.argument),
-
-  '&&': (x) => isTruthy(x.left) && isTruthy(x.right),
-
-  '||': (x) => isTruthy(x.left) || isTruthy(x.right)
-};
-
-function flatten(node) {
-  const parts = [];
+/* eslint-disable import/prefer-default-export */
 
-  while (node.type === 'MemberExpression') {
-    if (node.computed) return null;
+function deconflict(scope, globals, identifier) {
+  let i = 1;
+  let deconflicted = pluginutils.makeLegalIdentifier(identifier);
 
-    parts.unshift(node.property.name);
-    // eslint-disable-next-line no-param-reassign
-    node = node.object;
+  while (scope.contains(deconflicted) || globals.has(deconflicted)) {
+    deconflicted = pluginutils.makeLegalIdentifier(`${identifier}_${i}`);
+    i += 1;
   }
+  // eslint-disable-next-line no-param-reassign
+  scope.declarations[deconflicted] = true;
 
-  if (node.type !== 'Identifier') return null;
-
-  const { name } = node;
-  parts.unshift(name);
-
-  return { name, keypath: parts.join('.') };
-}
-
-function isTruthy(node) {
-  if (node.type === 'Literal') return !!node.value;
-  if (node.type === 'ParenthesizedExpression') return isTruthy(node.expression);
-  if (node.operator in operators) return operators[node.operator](node);
-  return undefined;
-}
-
-function isFalsy(node) {
-  return not(isTruthy(node));
-}
-
-function not(value) {
-  return value === undefined ? value : !value;
-}
-
-function equals(a, b, strict) {
-  if (a.type !== b.type) return undefined;
-  // eslint-disable-next-line eqeqeq
-  if (a.type === 'Literal') return strict ? a.value === b.value : a.value == b.value;
-  return undefined;
+  return deconflicted;
 }
 
-/* eslint-disable import/prefer-default-export */
-
 function getName(id) {
   const name = pluginutils.makeLegalIdentifier(path.basename(id, path.extname(id)));
   if (name !== 'index') {
@@ -291,918 +354,1219 @@ function getName(id) {
   return pluginutils.makeLegalIdentifier(segments[segments.length - 1]);
 }
 
-/* eslint-disable no-param-reassign, no-shadow, no-underscore-dangle, no-continue */
+function normalizePathSlashes(path) {
+  return path.replace(/\\/g, '/');
+}
 
-const reserved = 'process location abstract arguments boolean break byte case catch char class const continue debugger default delete do double else enum eval export extends false final finally float for from function goto if implements import in instanceof int interface let long native new null package private protected public return short static super switch synchronized this throw throws transient true try typeof var void volatile while with yield'.split(
-  ' '
-);
-const blacklist = { __esModule: true };
-reserved.forEach((word) => (blacklist[word] = true));
+const VIRTUAL_PATH_BASE = '/$$rollup_base$$';
+const getVirtualPathForDynamicRequirePath = (path, commonDir) => {
+  const normalizedPath = normalizePathSlashes(path);
+  return normalizedPath.startsWith(commonDir)
+    ? VIRTUAL_PATH_BASE + normalizedPath.slice(commonDir.length)
+    : normalizedPath;
+};
 
-const exportsPattern = /^(?:module\.)?exports(?:\.([a-zA-Z_$][a-zA-Z_$0-9]*))?$/;
+function getPackageEntryPoint(dirPath) {
+  let entryPoint = 'index.js';
 
-const firstpassGlobal = /\b(?:require|module|exports|global)\b/;
-const firstpassNoGlobal = /\b(?:require|module|exports)\b/;
-const functionType = /^(?:FunctionDeclaration|FunctionExpression|ArrowFunctionExpression)$/;
+  try {
+    if (fs.existsSync(path.join(dirPath, 'package.json'))) {
+      entryPoint =
+        JSON.parse(fs.readFileSync(path.join(dirPath, 'package.json'), { encoding: 'utf8' })).main ||
+        entryPoint;
+    }
+  } catch (ignored) {
+    // ignored
+  }
 
-function deconflict(scope, globals, identifier) {
-  let i = 1;
-  let deconflicted = pluginutils.makeLegalIdentifier(identifier);
+  return entryPoint;
+}
 
-  while (scope.contains(deconflicted) || globals.has(deconflicted) || deconflicted in blacklist) {
-    deconflicted = `${identifier}_${i}`;
-    i += 1;
-  }
-  scope.declarations[deconflicted] = true;
+function getDynamicPackagesModule(dynamicRequireModuleDirPaths, commonDir) {
+  let code = `const commonjsRegister = require('${HELPERS_ID}?commonjsRegister');`;
+  for (const dir of dynamicRequireModuleDirPaths) {
+    const entryPoint = getPackageEntryPoint(dir);
 
-  return deconflicted;
+    code += `\ncommonjsRegister(${JSON.stringify(
+      getVirtualPathForDynamicRequirePath(dir, commonDir)
+    )}, function (module, exports) {
+  module.exports = require(${JSON.stringify(normalizePathSlashes(path.join(dir, entryPoint)))});
+});`;
+  }
+  return code;
 }
 
-function tryParse(parse, code, id) {
-  try {
-    return parse(code, { allowReturnOutsideFunction: true });
-  } catch (err) {
-    err.message += ` in ${id}`;
-    throw err;
+function getDynamicPackagesEntryIntro(
+  dynamicRequireModuleDirPaths,
+  dynamicRequireModuleSet
+) {
+  let dynamicImports = Array.from(
+    dynamicRequireModuleSet,
+    (dynamicId) => `require(${JSON.stringify(wrapModuleRegisterProxy(dynamicId))});`
+  ).join('\n');
+
+  if (dynamicRequireModuleDirPaths.length) {
+    dynamicImports += `require(${JSON.stringify(wrapModuleRegisterProxy(DYNAMIC_PACKAGES_ID))});`;
   }
+
+  return dynamicImports;
 }
 
-function normalizePathSlashes(path) {
-  return path.replace(/\\/g, '/');
+function wrapModuleRegisterProxy(id) {
+  return wrapId(id, DYNAMIC_REGISTER_SUFFIX);
 }
 
-function hasCjsKeywords(code, ignoreGlobal) {
-  const firstpass = ignoreGlobal ? firstpassNoGlobal : firstpassGlobal;
-  return firstpass.test(code);
+function unwrapModuleRegisterProxy(id) {
+  return unwrapId(id, DYNAMIC_REGISTER_SUFFIX);
 }
 
-function checkEsModule(parse, code, id) {
-  const ast = tryParse(parse, code, id);
+function isModuleRegisterProxy(id) {
+  return isWrappedId(id, DYNAMIC_REGISTER_SUFFIX);
+}
 
-  let isEsModule = false;
-  let hasDefaultExport = false;
-  let hasNamedExports = false;
-  for (const node of ast.body) {
-    if (node.type === 'ExportDefaultDeclaration') {
-      isEsModule = true;
-      hasDefaultExport = true;
-    } else if (node.type === 'ExportNamedDeclaration') {
-      isEsModule = true;
-      if (node.declaration) {
-        hasNamedExports = true;
-      } else {
-        for (const specifier of node.specifiers) {
-          if (specifier.exported.name === 'default') {
-            hasDefaultExport = true;
-          } else {
-            hasNamedExports = true;
-          }
-        }
-      }
-    } else if (node.type === 'ExportAllDeclaration') {
-      isEsModule = true;
-      if (node.exported && node.exported.name === 'default') {
-        hasDefaultExport = true;
-      } else {
-        hasNamedExports = true;
+function isDynamicModuleImport(id, dynamicRequireModuleSet) {
+  const normalizedPath = normalizePathSlashes(id);
+  return dynamicRequireModuleSet.has(normalizedPath) && !normalizedPath.endsWith('.json');
+}
+
+function isDirectory(path) {
+  try {
+    if (fs.statSync(path).isDirectory()) return true;
+  } catch (ignored) {
+    // Nothing to do here
+  }
+  return false;
+}
+
+function getDynamicRequirePaths(patterns) {
+  const dynamicRequireModuleSet = new Set();
+  for (const pattern of !patterns || Array.isArray(patterns) ? patterns || [] : [patterns]) {
+    const isNegated = pattern.startsWith('!');
+    const modifySet = Set.prototype[isNegated ? 'delete' : 'add'].bind(dynamicRequireModuleSet);
+    for (const path$1 of glob__default['default'].sync(isNegated ? pattern.substr(1) : pattern)) {
+      modifySet(normalizePathSlashes(path.resolve(path$1)));
+      if (isDirectory(path$1)) {
+        modifySet(normalizePathSlashes(path.resolve(path.join(path$1, getPackageEntryPoint(path$1)))));
       }
-    } else if (node.type === 'ImportDeclaration') {
-      isEsModule = true;
     }
   }
-
-  return { isEsModule, hasDefaultExport, hasNamedExports, ast };
+  const dynamicRequireModuleDirPaths = Array.from(dynamicRequireModuleSet.values()).filter((path) =>
+    isDirectory(path)
+  );
+  return { dynamicRequireModuleSet, dynamicRequireModuleDirPaths };
 }
 
-function getDefinePropertyCallName(node, targetName) {
-  if (node.type !== 'CallExpression') return;
+const isCjsPromises = new Map();
 
-  const {
-    callee: { object, property }
-  } = node;
+function getIsCjsPromise(id) {
+  let isCjsPromise = isCjsPromises.get(id);
+  if (isCjsPromise) return isCjsPromise.promise;
 
-  if (!object || object.type !== 'Identifier' || object.name !== 'Object') return;
+  const promise = new Promise((resolve) => {
+    isCjsPromise = {
+      resolve,
+      promise: null
+    };
+    isCjsPromises.set(id, isCjsPromise);
+  });
+  isCjsPromise.promise = promise;
 
-  if (!property || property.type !== 'Identifier' || property.name !== 'defineProperty') return;
+  return promise;
+}
 
-  if (node.arguments.length !== 3) return;
+function setIsCjsPromise(id, resolution) {
+  const isCjsPromise = isCjsPromises.get(id);
+  if (isCjsPromise) {
+    if (isCjsPromise.resolve) {
+      isCjsPromise.resolve(resolution);
+      isCjsPromise.resolve = null;
+    }
+  } else {
+    isCjsPromises.set(id, { promise: Promise.resolve(resolution), resolve: null });
+  }
+}
 
-  const [target, val] = node.arguments;
-  if (target.type !== 'Identifier' || target.name !== targetName) return;
-  // eslint-disable-next-line consistent-return
-  return val.value;
+// e.g. id === "commonjsHelpers?commonjsRegister"
+function getSpecificHelperProxy(id) {
+  return `export {${id.split('?')[1]} as default} from '${HELPERS_ID}';`;
 }
 
-function transformCommonjs(
-  parse,
-  code,
-  id,
-  isEsModule,
-  ignoreGlobal,
-  ignoreRequire,
-  sourceMap,
-  isDynamicRequireModulesEnabled,
-  dynamicRequireModuleSet,
-  commonDir,
-  astCache
-) {
-  const ast = astCache || tryParse(parse, code, id);
-
-  const magicString = new MagicString(code);
-
-  const required = {};
-  // Because objects have no guaranteed ordering, yet we need it,
-  // we need to keep track of the order in a array
-  const sources = [];
-
-  let uid = 0;
-
-  let scope = pluginutils.attachScopes(ast, 'scope');
-  const uses = { module: false, exports: false, global: false, require: false };
-
-  let lexicalDepth = 0;
-  let programDepth = 0;
-
-  const globals = new Set();
-
-  // TODO technically wrong since globals isn't populated yet, but ¯\_(ツ)_/¯
-  const HELPERS_NAME = deconflict(scope, globals, 'commonjsHelpers');
-
-  const namedExports = {};
-
-  // TODO handle transpiled modules
-  let shouldWrap = /__esModule/.test(code);
-  let usesCommonjsHelpers = false;
+function getUnknownRequireProxy(id, requireReturnsDefault) {
+  if (requireReturnsDefault === true || id.endsWith('.json')) {
+    return `export {default} from ${JSON.stringify(id)};`;
+  }
+  const name = getName(id);
+  const exported =
+    requireReturnsDefault === 'auto'
+      ? `import {getDefaultExportFromNamespaceIfNotNamed} from "${HELPERS_ID}"; export default /*@__PURE__*/getDefaultExportFromNamespaceIfNotNamed(${name});`
+      : requireReturnsDefault === 'preferred'
+      ? `import {getDefaultExportFromNamespaceIfPresent} from "${HELPERS_ID}"; export default /*@__PURE__*/getDefaultExportFromNamespaceIfPresent(${name});`
+      : !requireReturnsDefault
+      ? `import {getAugmentedNamespace} from "${HELPERS_ID}"; export default /*@__PURE__*/getAugmentedNamespace(${name});`
+      : `export default ${name};`;
+  return `import * as ${name} from ${JSON.stringify(id)}; ${exported}`;
+}
 
-  function isRequireStatement(node) {
-    if (!node) return false;
-    if (node.type !== 'CallExpression') return false;
+function getDynamicJsonProxy(id, commonDir) {
+  const normalizedPath = normalizePathSlashes(id.slice(DYNAMIC_JSON_PREFIX.length));
+  return `const commonjsRegister = require('${HELPERS_ID}?commonjsRegister');\ncommonjsRegister(${JSON.stringify(
+    getVirtualPathForDynamicRequirePath(normalizedPath, commonDir)
+  )}, function (module, exports) {
+  module.exports = require(${JSON.stringify(normalizedPath)});
+});`;
+}
 
-    // Weird case of `require()` or `module.require()` without arguments
-    if (node.arguments.length === 0) return false;
+function getDynamicRequireProxy(normalizedPath, commonDir) {
+  return `const commonjsRegister = require('${HELPERS_ID}?commonjsRegister');\ncommonjsRegister(${JSON.stringify(
+    getVirtualPathForDynamicRequirePath(normalizedPath, commonDir)
+  )}, function (module, exports) {
+  ${fs.readFileSync(normalizedPath, { encoding: 'utf8' })}
+});`;
+}
 
-    return isRequireIdentifier(node.callee);
+async function getStaticRequireProxy(
+  id,
+  requireReturnsDefault,
+  esModulesWithDefaultExport,
+  esModulesWithNamedExports
+) {
+  const name = getName(id);
+  const isCjs = await getIsCjsPromise(id);
+  if (isCjs) {
+    return `import { __moduleExports } from ${JSON.stringify(id)}; export default __moduleExports;`;
+  } else if (isCjs === null) {
+    return getUnknownRequireProxy(id, requireReturnsDefault);
+  } else if (!requireReturnsDefault) {
+    return `import {getAugmentedNamespace} from "${HELPERS_ID}"; import * as ${name} from ${JSON.stringify(
+      id
+    )}; export default /*@__PURE__*/getAugmentedNamespace(${name});`;
+  } else if (
+    requireReturnsDefault !== true &&
+    (requireReturnsDefault === 'namespace' ||
+      !esModulesWithDefaultExport.has(id) ||
+      (requireReturnsDefault === 'auto' && esModulesWithNamedExports.has(id)))
+  ) {
+    return `import * as ${name} from ${JSON.stringify(id)}; export default ${name};`;
   }
+  return `export {default} from ${JSON.stringify(id)};`;
+}
 
-  function isRequireIdentifier(node) {
-    if (!node) return false;
+/* eslint-disable no-param-reassign, no-undefined */
 
-    if (node.type === 'Identifier' && node.name === 'require' /* `require` */) {
-      // `require` is hidden by a variable in local scope
-      if (scope.contains('require')) return false;
+function getCandidatesForExtension(resolved, extension) {
+  return [resolved + extension, `${resolved}${path.sep}index${extension}`];
+}
 
-      return true;
-    } else if (node.type === 'MemberExpression' /* `[something].[something]` */) {
-      // `module.[something]`
-      if (node.object.type !== 'Identifier' || node.object.name !== 'module') return false;
+function getCandidates(resolved, extensions) {
+  return extensions.reduce(
+    (paths, extension) => paths.concat(getCandidatesForExtension(resolved, extension)),
+    [resolved]
+  );
+}
 
-      // `module` is hidden by a variable in local scope
-      if (scope.contains('module')) return false;
+function getResolveId(extensions) {
+  function resolveExtensions(importee, importer) {
+    // not our problem
+    if (importee[0] !== '.' || !importer) return undefined;
 
-      // `module.require(...)`
-      if (node.property.type !== 'Identifier' || node.property.name !== 'require') return false;
+    const resolved = path.resolve(path.dirname(importer), importee);
+    const candidates = getCandidates(resolved, extensions);
 
-      return true;
+    for (let i = 0; i < candidates.length; i += 1) {
+      try {
+        const stats = fs.statSync(candidates[i]);
+        if (stats.isFile()) return { id: candidates[i] };
+      } catch (err) {
+        /* noop */
+      }
     }
 
-    return false;
+    return undefined;
   }
 
-  function hasDynamicArguments(node) {
-    return (
-      node.arguments.length > 1 ||
-      (node.arguments[0].type !== 'Literal' &&
-        (node.arguments[0].type !== 'TemplateLiteral' || node.arguments[0].expressions.length > 0))
-    );
-  }
+  return function resolveId(importee, rawImporter) {
+    const importer =
+      rawImporter && isModuleRegisterProxy(rawImporter)
+        ? unwrapModuleRegisterProxy(rawImporter)
+        : rawImporter;
 
-  function isStaticRequireStatement(node) {
-    if (!isRequireStatement(node)) return false;
-    return !hasDynamicArguments(node);
-  }
+    // Proxies are only importing resolved ids, no need to resolve again
+    if (importer && isWrappedId(importer, PROXY_SUFFIX)) {
+      return importee;
+    }
 
-  function isNodeRequireStatement(parent) {
-    const reservedMethod = ['resolve', 'cache', 'main'];
-    return !!(parent && parent.property && reservedMethod.indexOf(parent.property.name) > -1);
-  }
+    const isProxyModule = isWrappedId(importee, PROXY_SUFFIX);
+    const isRequiredModule = isWrappedId(importee, REQUIRE_SUFFIX);
+    let isModuleRegistration = false;
 
-  function isIgnoredRequireStatement(requiredNode) {
-    return ignoreRequire(requiredNode.arguments[0].value);
-  }
-
-  function getRequireStringArg(node) {
-    return node.arguments[0].type === 'Literal'
-      ? node.arguments[0].value
-      : node.arguments[0].quasis[0].value.cooked;
-  }
+    if (isProxyModule) {
+      importee = unwrapId(importee, PROXY_SUFFIX);
+    } else if (isRequiredModule) {
+      importee = unwrapId(importee, REQUIRE_SUFFIX);
 
-  function getRequired(node, name) {
-    let sourceId = getRequireStringArg(node);
-    const isDynamicRegister = sourceId.startsWith(DYNAMIC_REGISTER_PREFIX);
-    if (isDynamicRegister) {
-      sourceId = sourceId.substr(DYNAMIC_REGISTER_PREFIX.length);
+      isModuleRegistration = isModuleRegisterProxy(importee);
+      if (isModuleRegistration) {
+        importee = unwrapModuleRegisterProxy(importee);
+      }
     }
 
-    const existing = required[sourceId];
-    // eslint-disable-next-line no-undefined
-    if (existing === undefined) {
-      const isDynamic = hasDynamicModuleForPath(sourceId);
+    if (
+      importee.startsWith(HELPERS_ID) ||
+      importee === DYNAMIC_PACKAGES_ID ||
+      importee.startsWith(DYNAMIC_JSON_PREFIX)
+    ) {
+      return importee;
+    }
 
-      if (!name) {
-        do {
-          name = `require$$${uid}`;
-          uid += 1;
-        } while (scope.contains(name));
-      }
+    if (importee.startsWith('\0')) {
+      return null;
+    }
 
-      if (isDynamicRegister && sourceId.endsWith('.json')) {
-        sourceId = DYNAMIC_JSON_PREFIX + sourceId;
+    return this.resolve(importee, importer, {
+      skipSelf: true,
+      custom: { 'node-resolve': { isRequire: isProxyModule || isRequiredModule } }
+    }).then((resolved) => {
+      if (!resolved) {
+        resolved = resolveExtensions(importee, importer);
       }
-
-      if (isDynamicRegister || !isDynamic || sourceId.endsWith('.json')) {
-        sources.push([sourceId, !isDynamicRegister]);
+      if (resolved && isProxyModule) {
+        resolved.id = wrapId(resolved.id, resolved.external ? EXTERNAL_SUFFIX : PROXY_SUFFIX);
+        resolved.external = false;
+      } else if (resolved && isModuleRegistration) {
+        resolved.id = wrapModuleRegisterProxy(resolved.id);
+      } else if (!resolved && (isProxyModule || isRequiredModule)) {
+        return { id: wrapId(importee, EXTERNAL_SUFFIX), external: false };
       }
+      return resolved;
+    });
+  };
+}
 
-      required[sourceId] = { source: sourceId, name, importsDefault: false, isDynamic };
+function validateRollupVersion(rollupVersion, peerDependencyVersion) {
+  const [major, minor] = rollupVersion.split('.').map(Number);
+  const versionRegexp = /\^(\d+\.\d+)\.\d+/g;
+  let minMajor = Infinity;
+  let minMinor = Infinity;
+  let foundVersion;
+  // eslint-disable-next-line no-cond-assign
+  while ((foundVersion = versionRegexp.exec(peerDependencyVersion))) {
+    const [foundMajor, foundMinor] = foundVersion[1].split('.').map(Number);
+    if (foundMajor < minMajor) {
+      minMajor = foundMajor;
+      minMinor = foundMinor;
     }
-
-    return required[sourceId];
   }
+  if (major < minMajor || (major === minMajor && minor < minMinor)) {
+    throw new Error(
+      `Insufficient Rollup version: "@rollup/plugin-commonjs" requires at least rollup@${minMajor}.${minMinor} but found rollup@${rollupVersion}.`
+    );
+  }
+}
 
-  function hasDynamicModuleForPath(source) {
-    if (!/[/\\]/.test(source)) {
-      try {
-        const resolvedPath = normalizePathSlashes(
-          resolve.sync(source, { basedir: path.dirname(id) })
-        );
-        if (dynamicRequireModuleSet.has(resolvedPath)) {
-          return true;
-        }
-      } catch (ex) {
-        // Probably a node.js internal module
-        return false;
-      }
-
-      return false;
-    }
+const operators = {
+  '==': (x) => equals(x.left, x.right, false),
 
-    for (const attemptExt of ['', '.js', '.json']) {
-      const resolvedPath = normalizePathSlashes(path.resolve(path.dirname(id), source + attemptExt));
-      if (dynamicRequireModuleSet.has(resolvedPath)) {
-        return true;
-      }
-    }
+  '!=': (x) => not(operators['=='](x)),
 
-    return false;
-  }
+  '===': (x) => equals(x.left, x.right, true),
 
-  function shouldUseSimulatedRequire(required) {
-    return (
-      hasDynamicModuleForPath(required.source) &&
-      // We only do `commonjsRequire` for json if it's the `commonjsRegister` call.
-      (required.source.startsWith(DYNAMIC_REGISTER_PREFIX) || !required.source.endsWith('.json'))
-    );
-  }
+  '!==': (x) => not(operators['==='](x)),
 
-  // do a first pass, see which names are assigned to. This is necessary to prevent
-  // illegally replacing `var foo = require('foo')` with `import foo from 'foo'`,
-  // where `foo` is later reassigned. (This happens in the wild. CommonJS, sigh)
-  const assignedTo = new Set();
-  estreeWalker.walk(ast, {
-    enter(node) {
-      if (node.type !== 'AssignmentExpression') return;
-      if (node.left.type === 'MemberExpression') return;
+  '!': (x) => isFalsy(x.argument),
 
-      pluginutils.extractAssignedNames(node.left).forEach((name) => {
-        assignedTo.add(name);
-      });
-    }
-  });
+  '&&': (x) => isTruthy(x.left) && isTruthy(x.right),
 
-  estreeWalker.walk(ast, {
-    enter(node, parent) {
-      if (sourceMap) {
-        magicString.addSourcemapLocation(node.start);
-        magicString.addSourcemapLocation(node.end);
-      }
+  '||': (x) => isTruthy(x.left) || isTruthy(x.right)
+};
 
-      // skip dead branches
-      if (parent && (parent.type === 'IfStatement' || parent.type === 'ConditionalExpression')) {
-        if (node === parent.consequent && isFalsy(parent.test)) {
-          this.skip();
-          return;
-        }
-        if (node === parent.alternate && isTruthy(parent.test)) {
-          this.skip();
-          return;
-        }
-      }
+function not(value) {
+  return value === null ? value : !value;
+}
 
-      if (node._skip) {
-        this.skip();
-        return;
-      }
+function equals(a, b, strict) {
+  if (a.type !== b.type) return null;
+  // eslint-disable-next-line eqeqeq
+  if (a.type === 'Literal') return strict ? a.value === b.value : a.value == b.value;
+  return null;
+}
 
-      programDepth += 1;
+function isTruthy(node) {
+  if (!node) return false;
+  if (node.type === 'Literal') return !!node.value;
+  if (node.type === 'ParenthesizedExpression') return isTruthy(node.expression);
+  if (node.operator in operators) return operators[node.operator](node);
+  return null;
+}
 
-      if (node.scope) ({ scope } = node);
-      if (functionType.test(node.type)) lexicalDepth += 1;
+function isFalsy(node) {
+  return not(isTruthy(node));
+}
 
-      // if toplevel return, we need to wrap it
-      if (node.type === 'ReturnStatement' && lexicalDepth === 0) {
-        shouldWrap = true;
-      }
+function getKeypath(node) {
+  const parts = [];
 
-      // rewrite `this` as `commonjsHelpers.commonjsGlobal`
-      if (node.type === 'ThisExpression' && lexicalDepth === 0) {
-        uses.global = true;
-        if (!ignoreGlobal) {
-          magicString.overwrite(node.start, node.end, `${HELPERS_NAME}.commonjsGlobal`, {
-            storeName: true
-          });
-          usesCommonjsHelpers = true;
-        }
-        return;
-      }
+  while (node.type === 'MemberExpression') {
+    if (node.computed) return null;
 
-      // rewrite `typeof module`, `typeof module.exports` and `typeof exports` (https://github.com/rollup/rollup-plugin-commonjs/issues/151)
-      if (node.type === 'UnaryExpression' && node.operator === 'typeof') {
-        const flattened = flatten(node.argument);
-        if (!flattened) return;
+    parts.unshift(node.property.name);
+    // eslint-disable-next-line no-param-reassign
+    node = node.object;
+  }
 
-        if (scope.contains(flattened.name)) return;
+  if (node.type !== 'Identifier') return null;
 
-        if (
-          flattened.keypath === 'module.exports' ||
-          flattened.keypath === 'module' ||
-          flattened.keypath === 'exports'
-        ) {
-          magicString.overwrite(node.start, node.end, `'object'`, { storeName: false });
-        }
-      }
+  const { name } = node;
+  parts.unshift(name);
 
-      // rewrite `require` (if not already handled) `global` and `define`, and handle free references to
-      // `module` and `exports` as these mean we need to wrap the module in commonjsHelpers.createCommonjsModule
-      if (node.type === 'Identifier') {
-        if (isReference(node, parent) && !scope.contains(node.name)) {
-          if (node.name in uses) {
-            if (isRequireIdentifier(node)) {
-              if (isNodeRequireStatement(parent)) {
-                return;
-              }
+  return { name, keypath: parts.join('.') };
+}
 
-              if (!isDynamicRequireModulesEnabled && isStaticRequireStatement(parent)) {
-                return;
-              }
+const KEY_COMPILED_ESM = '__esModule';
 
-              if (isDynamicRequireModulesEnabled && isRequireStatement(parent)) {
-                magicString.appendLeft(
-                  parent.end - 1,
-                  `,${JSON.stringify(
-                    path.dirname(id) === '.'
-                      ? null /* default behavior */
-                      : getVirtualPathForDynamicRequirePath(
-                          normalizePathSlashes(path.dirname(id)),
-                          commonDir
-                        )
-                  )}`
-                );
-              }
+function isDefineCompiledEsm(node) {
+  const definedProperty =
+    getDefinePropertyCallName(node, 'exports') || getDefinePropertyCallName(node, 'module.exports');
+  if (definedProperty && definedProperty.key === KEY_COMPILED_ESM) {
+    return isTruthy(definedProperty.value);
+  }
+  return false;
+}
 
-              magicString.overwrite(node.start, node.end, `${HELPERS_NAME}.commonjsRequire`, {
-                storeName: true
-              });
-              usesCommonjsHelpers = true;
-            }
+function getDefinePropertyCallName(node, targetName) {
+  const targetNames = targetName.split('.');
 
-            uses[node.name] = true;
-            if (node.name === 'global' && !ignoreGlobal) {
-              magicString.overwrite(node.start, node.end, `${HELPERS_NAME}.commonjsGlobal`, {
-                storeName: true
-              });
-              usesCommonjsHelpers = true;
-            }
+  const {
+    callee: { object, property }
+  } = node;
+  if (!object || object.type !== 'Identifier' || object.name !== 'Object') return;
+  if (!property || property.type !== 'Identifier' || property.name !== 'defineProperty') return;
+  if (node.arguments.length !== 3) return;
 
-            // if module or exports are used outside the context of an assignment
-            // expression, we need to wrap the module
-            if (node.name === 'module' || node.name === 'exports') {
-              shouldWrap = true;
-            }
-          }
+  const [target, key, value] = node.arguments;
+  if (targetNames.length === 1) {
+    if (target.type !== 'Identifier' || target.name !== targetNames[0]) {
+      return;
+    }
+  }
 
-          if (node.name === 'define') {
-            magicString.overwrite(node.start, node.end, 'undefined', { storeName: true });
-          }
+  if (targetNames.length === 2) {
+    if (
+      target.type !== 'MemberExpression' ||
+      target.object.name !== targetNames[0] ||
+      target.property.name !== targetNames[1]
+    ) {
+      return;
+    }
+  }
 
-          globals.add(node.name);
-        }
+  if (value.type !== 'ObjectExpression' || !value.properties) return;
 
-        return;
-      }
+  const valueProperty = value.properties.find((p) => p.key && p.key.name === 'value');
+  if (!valueProperty || !valueProperty.value) return;
 
-      // Is this an assignment to exports or module.exports?
-      if (node.type === 'AssignmentExpression') {
-        if (node.left.type !== 'MemberExpression') return;
+  // eslint-disable-next-line consistent-return
+  return { key: key.value, value: valueProperty.value };
+}
 
-        const flattened = flatten(node.left);
-        if (!flattened) return;
+function isLocallyShadowed(name, scope) {
+  while (scope.parent) {
+    if (scope.declarations[name]) {
+      return true;
+    }
+    // eslint-disable-next-line no-param-reassign
+    scope = scope.parent;
+  }
+  return false;
+}
 
-        if (scope.contains(flattened.name)) return;
+function isShorthandProperty(parent) {
+  return parent && parent.type === 'Property' && parent.shorthand;
+}
 
-        const match = exportsPattern.exec(flattened.keypath);
-        if (!match || flattened.keypath === 'exports') return;
+function wrapCode(magicString, uses, moduleName, HELPERS_NAME, virtualDynamicRequirePath) {
+  const args = `module${uses.exports ? ', exports' : ''}`;
 
-        uses[flattened.name] = true;
+  magicString
+    .trim()
+    .prepend(`var ${moduleName} = ${HELPERS_NAME}.createCommonjsModule(function (${args}) {\n`)
+    .append(
+      `\n}${virtualDynamicRequirePath ? `, ${JSON.stringify(virtualDynamicRequirePath)}` : ''});`
+    );
+}
 
-        // we're dealing with `module.exports = ...` or `[module.]exports.foo = ...` –
-        // if this isn't top-level, we'll need to wrap the module
-        if (programDepth > 3) shouldWrap = true;
+function rewriteExportsAndGetExportsBlock(
+  magicString,
+  moduleName,
+  wrapped,
+  topLevelModuleExportsAssignments,
+  topLevelExportsAssignmentsByName,
+  defineCompiledEsmExpressions,
+  deconflict,
+  isRestorableCompiledEsm,
+  code,
+  uses,
+  HELPERS_NAME
+) {
+  const namedExportDeclarations = [`export { ${moduleName} as __moduleExports };`];
+  const moduleExportsPropertyAssignments = [];
+  let deconflictedDefaultExportName;
+
+  if (!wrapped) {
+    let hasModuleExportsAssignment = false;
+    const namedExportProperties = [];
+
+    // Collect and rewrite module.exports assignments
+    for (const { left } of topLevelModuleExportsAssignments) {
+      hasModuleExportsAssignment = true;
+      magicString.overwrite(left.start, left.end, `var ${moduleName}`);
+    }
 
-        node.left._skip = true;
+    // Collect and rewrite named exports
+    for (const [exportName, node] of topLevelExportsAssignmentsByName) {
+      const deconflicted = deconflict(exportName);
+      magicString.overwrite(node.start, node.left.end, `var ${deconflicted}`);
 
-        if (flattened.keypath === 'module.exports' && node.right.type === 'ObjectExpression') {
-          node.right.properties.forEach((prop) => {
-            if (prop.computed || !('key' in prop) || prop.key.type !== 'Identifier') return;
-            const { name } = prop.key;
-            if (name === pluginutils.makeLegalIdentifier(name)) namedExports[name] = true;
-          });
-          return;
-        }
+      if (exportName === 'default') {
+        deconflictedDefaultExportName = deconflicted;
+      } else {
+        namedExportDeclarations.push(
+          exportName === deconflicted
+            ? `export { ${exportName} };`
+            : `export { ${deconflicted} as ${exportName} };`
+        );
+      }
 
-        if (match[1]) namedExports[match[1]] = true;
-        return;
+      if (hasModuleExportsAssignment) {
+        moduleExportsPropertyAssignments.push(`${moduleName}.${exportName} = ${deconflicted};`);
+      } else {
+        namedExportProperties.push(`\t${exportName}: ${deconflicted}`);
       }
+    }
 
-      const name = getDefinePropertyCallName(node, 'exports');
-      if (name && name === pluginutils.makeLegalIdentifier(name)) namedExports[name] = true;
+    // Regenerate CommonJS namespace
+    if (!hasModuleExportsAssignment) {
+      const moduleExports = `{\n${namedExportProperties.join(',\n')}\n}`;
+      magicString
+        .trim()
+        .append(
+          `\n\nvar ${moduleName} = ${
+            isRestorableCompiledEsm
+              ? `/*#__PURE__*/Object.defineProperty(${moduleExports}, '__esModule', {value: true})`
+              : moduleExports
+          };`
+        );
+    }
+  }
 
-      // if this is `var x = require('x')`, we can do `import x from 'x'`
-      if (
-        node.type === 'VariableDeclarator' &&
-        node.id.type === 'Identifier' &&
-        isStaticRequireStatement(node.init) &&
-        !isIgnoredRequireStatement(node.init)
-      ) {
-        // for now, only do this for top-level requires. maybe fix this in future
-        if (scope.parent) return;
+  // Generate default export
+  const defaultExport = [];
+  if (isRestorableCompiledEsm) {
+    defaultExport.push(`export default ${deconflictedDefaultExportName || moduleName};`);
+  } else if (
+    (wrapped || deconflictedDefaultExportName) &&
+    (defineCompiledEsmExpressions.length > 0 || code.indexOf('__esModule') >= 0)
+  ) {
+    // eslint-disable-next-line no-param-reassign
+    uses.commonjsHelpers = true;
+    defaultExport.push(
+      `export default /*@__PURE__*/${HELPERS_NAME}.getDefaultExportFromCjs(${moduleName});`
+    );
+  } else {
+    defaultExport.push(`export default ${moduleName};`);
+  }
 
-        // edge case — CJS allows you to assign to imports. ES doesn't
-        if (assignedTo.has(node.id.name)) return;
+  return `\n\n${defaultExport
+    .concat(namedExportDeclarations)
+    .concat(moduleExportsPropertyAssignments)
+    .join('\n')}`;
+}
 
-        const required = getRequired(node.init, node.id.name);
-        required.importsDefault = true;
+function isRequireStatement(node, scope) {
+  if (!node) return false;
+  if (node.type !== 'CallExpression') return false;
 
-        if (required.name === node.id.name && !required.isDynamic) {
-          node._shouldRemove = true;
-        }
-      }
+  // Weird case of `require()` or `module.require()` without arguments
+  if (node.arguments.length === 0) return false;
 
-      if (!isStaticRequireStatement(node) || isIgnoredRequireStatement(node)) {
-        return;
-      }
+  return isRequire(node.callee, scope);
+}
 
-      const required = getRequired(node);
+function isRequire(node, scope) {
+  return (
+    (node.type === 'Identifier' && node.name === 'require' && !scope.contains('require')) ||
+    (node.type === 'MemberExpression' && isModuleRequire(node, scope))
+  );
+}
 
-      if (parent.type === 'ExpressionStatement') {
-        // is a bare import, e.g. `require('foo');`
-        magicString.remove(parent.start, parent.end);
-      } else {
-        required.importsDefault = true;
-
-        if (shouldUseSimulatedRequire(required)) {
-          magicString.overwrite(
-            node.start,
-            node.end,
-            `${HELPERS_NAME}.commonjsRequire(${JSON.stringify(
-              getVirtualPathForDynamicRequirePath(normalizePathSlashes(required.source), commonDir)
-            )}, ${JSON.stringify(
-              path.dirname(id) === '.'
-                ? null /* default behavior */
-                : getVirtualPathForDynamicRequirePath(normalizePathSlashes(path.dirname(id)), commonDir)
-            )})`
-          );
-          usesCommonjsHelpers = true;
-        } else {
-          magicString.overwrite(node.start, node.end, required.name);
-        }
-      }
+function isModuleRequire({ object, property }, scope) {
+  return (
+    object.type === 'Identifier' &&
+    object.name === 'module' &&
+    property.type === 'Identifier' &&
+    property.name === 'require' &&
+    !scope.contains('module')
+  );
+}
 
-      node.callee._skip = true;
-    },
+function isStaticRequireStatement(node, scope) {
+  if (!isRequireStatement(node, scope)) return false;
+  return !hasDynamicArguments(node);
+}
 
-    leave(node) {
-      programDepth -= 1;
-      if (node.scope) scope = scope.parent;
-      if (functionType.test(node.type)) lexicalDepth -= 1;
+function hasDynamicArguments(node) {
+  return (
+    node.arguments.length > 1 ||
+    (node.arguments[0].type !== 'Literal' &&
+      (node.arguments[0].type !== 'TemplateLiteral' || node.arguments[0].expressions.length > 0))
+  );
+}
 
-      if (node.type === 'VariableDeclaration') {
-        let keepDeclaration = false;
-        let c = node.declarations[0].start;
+const reservedMethod = { resolve: true, cache: true, main: true };
 
-        for (let i = 0; i < node.declarations.length; i += 1) {
-          const declarator = node.declarations[i];
+function isNodeRequirePropertyAccess(parent) {
+  return parent && parent.property && reservedMethod[parent.property.name];
+}
 
-          if (declarator._shouldRemove) {
-            magicString.remove(c, declarator.end);
-          } else {
-            if (!keepDeclaration) {
-              magicString.remove(c, declarator.start);
-              keepDeclaration = true;
-            }
+function isIgnoredRequireStatement(requiredNode, ignoreRequire) {
+  return ignoreRequire(requiredNode.arguments[0].value);
+}
 
-            c = declarator.end;
-          }
-        }
+function getRequireStringArg(node) {
+  return node.arguments[0].type === 'Literal'
+    ? node.arguments[0].value
+    : node.arguments[0].quasis[0].value.cooked;
+}
 
-        if (!keepDeclaration) {
-          magicString.remove(node.start, node.end);
-        }
+function hasDynamicModuleForPath(source, id, dynamicRequireModuleSet) {
+  if (!/^(?:\.{0,2}[/\\]|[A-Za-z]:[/\\])/.test(source)) {
+    try {
+      const resolvedPath = normalizePathSlashes(resolve.sync(source, { basedir: path.dirname(id) }));
+      if (dynamicRequireModuleSet.has(resolvedPath)) {
+        return true;
       }
+    } catch (ex) {
+      // Probably a node.js internal module
+      return false;
     }
-  });
 
-  if (
-    !sources.length &&
-    !uses.module &&
-    !uses.exports &&
-    !uses.require &&
-    (ignoreGlobal || !uses.global)
-  ) {
-    // not a CommonJS module
-    return null;
+    return false;
   }
 
-  // If `isEsModule` is on, it means it has ES6 import/export statements,
-  //   which just can't be wrapped in a function.
-  if (isEsModule) shouldWrap = false;
-
-  usesCommonjsHelpers = usesCommonjsHelpers || shouldWrap;
-
-  const importBlock = `${(usesCommonjsHelpers
-    ? [`import * as ${HELPERS_NAME} from '${HELPERS_ID}';`]
-    : []
-  )
-    .concat(
-      sources.map(
-        ([source]) =>
-          // import the actual module before the proxy, so that we know
-          // what kind of proxy to build
-          `import '${source}';`
-      ),
-      sources
-        .filter(([, importProxy]) => importProxy)
-        .map(([source]) => {
-          const { name, importsDefault } = required[source];
-          return `import ${importsDefault ? `${name} from ` : ``}'${
-            source.startsWith('\0') ? source : getProxyId(source)
-          }';`;
-        })
-    )
-    .join('\n')}\n\n`;
-
-  const namedExportDeclarations = [];
-  let wrapperStart = '';
-  let wrapperEnd = '';
-
-  const moduleName = deconflict(scope, globals, getName(id));
-  if (!isEsModule) {
-    const exportModuleExports = {
-      str: `export { ${moduleName} as __moduleExports };`,
-      name: '__moduleExports'
-    };
-
-    namedExportDeclarations.push(exportModuleExports);
+  for (const attemptExt of ['', '.js', '.json']) {
+    const resolvedPath = normalizePathSlashes(path.resolve(path.dirname(id), source + attemptExt));
+    if (dynamicRequireModuleSet.has(resolvedPath)) {
+      return true;
+    }
   }
 
-  const defaultExportPropertyAssignments = [];
-  let hasDefaultExport = false;
+  return false;
+}
 
-  if (shouldWrap) {
-    const args = `module${uses.exports ? ', exports' : ''}`;
+function getRequireHandlers() {
+  const requiredSources = [];
+  const requiredBySource = Object.create(null);
+  const requiredByNode = new Map();
+  const requireExpressionsWithUsedReturnValue = [];
+
+  function addRequireStatement(sourceId, node, scope, usesReturnValue) {
+    const required = getRequired(sourceId);
+    requiredByNode.set(node, { scope, required });
+    if (usesReturnValue) {
+      required.nodesUsingRequired.push(node);
+      requireExpressionsWithUsedReturnValue.push(node);
+    }
+  }
 
-    wrapperStart = `var ${moduleName} = ${HELPERS_NAME}.createCommonjsModule(function (${args}) {\n`;
+  function getRequired(sourceId) {
+    if (!requiredBySource[sourceId]) {
+      requiredSources.push(sourceId);
 
-    wrapperEnd = `\n}`;
-    if (isDynamicRequireModulesEnabled) {
-      wrapperEnd += `, ${JSON.stringify(
-        getVirtualPathForDynamicRequirePath(normalizePathSlashes(path.dirname(id)), commonDir)
-      )}`;
+      requiredBySource[sourceId] = {
+        source: sourceId,
+        name: null,
+        nodesUsingRequired: []
+      };
     }
 
-    wrapperEnd += `);`;
-  } else {
-    const names = [];
+    return requiredBySource[sourceId];
+  }
 
-    for (const node of ast.body) {
-      if (node.type === 'ExpressionStatement' && node.expression.type === 'AssignmentExpression') {
-        const { left } = node.expression;
-        const flattened = flatten(left);
+  function rewriteRequireExpressionsAndGetImportBlock(
+    magicString,
+    topLevelDeclarations,
+    topLevelRequireDeclarators,
+    reassignedNames,
+    helpersNameIfUsed,
+    dynamicRegisterSources
+  ) {
+    const removedDeclarators = getDeclaratorsReplacedByImportsAndSetImportNames(
+      topLevelRequireDeclarators,
+      requiredByNode,
+      reassignedNames
+    );
+    setRemainingImportNamesAndRewriteRequires(
+      requireExpressionsWithUsedReturnValue,
+      requiredByNode,
+      magicString
+    );
+    removeDeclaratorsFromDeclarations(topLevelDeclarations, removedDeclarators, magicString);
+    const importBlock = `${(helpersNameIfUsed
+      ? [`import * as ${helpersNameIfUsed} from '${HELPERS_ID}';`]
+      : []
+    )
+      .concat(
+        // dynamic registers first, as the may be required in the other modules
+        [...dynamicRegisterSources].map((source) => `import '${wrapId(source, REQUIRE_SUFFIX)}';`),
+
+        // now the actual modules so that they are analyzed before creating the proxies;
+        // no need to do this for virtual modules as we never proxy them
+        requiredSources
+          .filter((source) => !source.startsWith('\0'))
+          .map((source) => `import '${wrapId(source, REQUIRE_SUFFIX)}';`),
+
+        // now the proxy modules
+        requiredSources.map((source) => {
+          const { name, nodesUsingRequired } = requiredBySource[source];
+          return `import ${nodesUsingRequired.length ? `${name} from ` : ``}'${
+            source.startsWith('\0') ? source : wrapId(source, PROXY_SUFFIX)
+          }';`;
+        })
+      )
+      .join('\n')}`;
+    return importBlock ? `${importBlock}\n\n` : '';
+  }
 
-        if (!flattened) {
-          continue;
-        }
+  return {
+    addRequireStatement,
+    requiredSources,
+    rewriteRequireExpressionsAndGetImportBlock
+  };
+}
 
-        const match = exportsPattern.exec(flattened.keypath);
-        if (!match) {
-          continue;
-        }
+function getDeclaratorsReplacedByImportsAndSetImportNames(
+  topLevelRequireDeclarators,
+  requiredByNode,
+  reassignedNames
+) {
+  const removedDeclarators = new Set();
+  for (const declarator of topLevelRequireDeclarators) {
+    const { required } = requiredByNode.get(declarator.init);
+    if (!required.name) {
+      const potentialName = declarator.id.name;
+      if (
+        !reassignedNames.has(potentialName) &&
+        !required.nodesUsingRequired.some((node) =>
+          isLocallyShadowed(potentialName, requiredByNode.get(node).scope)
+        )
+      ) {
+        required.name = potentialName;
+        removedDeclarators.add(declarator);
+      }
+    }
+  }
+  return removedDeclarators;
+}
 
-        if (flattened.keypath === 'module.exports') {
-          hasDefaultExport = true;
-          magicString.overwrite(left.start, left.end, `var ${moduleName}`);
-        } else {
-          const [, name] = match;
-          const deconflicted = deconflict(scope, globals, name);
+function setRemainingImportNamesAndRewriteRequires(
+  requireExpressionsWithUsedReturnValue,
+  requiredByNode,
+  magicString
+) {
+  let uid = 0;
+  for (const requireExpression of requireExpressionsWithUsedReturnValue) {
+    const { required } = requiredByNode.get(requireExpression);
+    if (!required.name) {
+      let potentialName;
+      const isUsedName = (node) => requiredByNode.get(node).scope.contains(potentialName);
+      do {
+        potentialName = `require$$${uid}`;
+        uid += 1;
+      } while (required.nodesUsingRequired.some(isUsedName));
+      required.name = potentialName;
+    }
+    magicString.overwrite(requireExpression.start, requireExpression.end, required.name);
+  }
+}
 
-          names.push({ name, deconflicted });
+function removeDeclaratorsFromDeclarations(topLevelDeclarations, removedDeclarators, magicString) {
+  for (const declaration of topLevelDeclarations) {
+    let keepDeclaration = false;
+    let [{ start }] = declaration.declarations;
+    for (const declarator of declaration.declarations) {
+      if (removedDeclarators.has(declarator)) {
+        magicString.remove(start, declarator.end);
+      } else if (!keepDeclaration) {
+        magicString.remove(start, declarator.start);
+        keepDeclaration = true;
+      }
+      start = declarator.end;
+    }
+    if (!keepDeclaration) {
+      magicString.remove(declaration.start, declaration.end);
+    }
+  }
+}
 
-          magicString.overwrite(node.start, left.end, `var ${deconflicted}`);
+/* eslint-disable no-param-reassign, no-shadow, no-underscore-dangle, no-continue */
 
-          const declaration =
-            name === deconflicted
-              ? `export { ${name} };`
-              : `export { ${deconflicted} as ${name} };`;
+const exportsPattern = /^(?:module\.)?exports(?:\.([a-zA-Z_$][a-zA-Z_$0-9]*))?$/;
 
-          if (name !== 'default') {
-            namedExportDeclarations.push({
-              str: declaration,
-              name
-            });
-          }
+const functionType = /^(?:FunctionDeclaration|FunctionExpression|ArrowFunctionExpression)$/;
 
-          defaultExportPropertyAssignments.push(`${moduleName}.${name} = ${deconflicted};`);
-        }
-      }
-    }
+function transformCommonjs(
+  parse,
+  code,
+  id,
+  isEsModule,
+  ignoreGlobal,
+  ignoreRequire,
+  getIgnoreTryCatchRequireStatementMode,
+  sourceMap,
+  isDynamicRequireModulesEnabled,
+  dynamicRequireModuleSet,
+  disableWrap,
+  commonDir,
+  astCache
+) {
+  const ast = astCache || tryParse(parse, code, id);
+  const magicString = new MagicString__default['default'](code);
+  const uses = {
+    module: false,
+    exports: false,
+    global: false,
+    require: false,
+    commonjsHelpers: false
+  };
+  const virtualDynamicRequirePath =
+    isDynamicRequireModulesEnabled && getVirtualPathForDynamicRequirePath(path.dirname(id), commonDir);
+  let scope = pluginutils.attachScopes(ast, 'scope');
+  let lexicalDepth = 0;
+  let programDepth = 0;
+  let currentTryBlockEnd = null;
+  let shouldWrap = false;
+  const defineCompiledEsmExpressions = [];
 
-    if (!(isEsModule || hasDefaultExport)) {
-      wrapperEnd = `\n\nvar ${moduleName} = {\n${names
-        .map(({ name, deconflicted }) => `\t${name}: ${deconflicted}`)
-        .join(',\n')}\n};`;
-    }
-  }
+  const globals = new Set();
 
-  magicString
-    .trim()
-    .prepend(importBlock + wrapperStart)
-    .trim()
-    .append(wrapperEnd);
-
-  const defaultExport =
-    code.indexOf('__esModule') >= 0
-      ? `export default /*@__PURE__*/${HELPERS_NAME}.getDefaultExportFromCjs(${moduleName});`
-      : `export default ${moduleName};`;
-
-  const named = namedExportDeclarations
-    .filter((x) => x.name !== 'default' || !hasDefaultExport)
-    .map((x) => x.str);
-
-  magicString.append(
-    `\n\n${(isEsModule ? [] : [defaultExport])
-      .concat(named)
-      .concat(hasDefaultExport ? defaultExportPropertyAssignments : [])
-      .join('\n')}`
-  );
+  // TODO technically wrong since globals isn't populated yet, but ¯\_(ツ)_/¯
+  const HELPERS_NAME = deconflict(scope, globals, 'commonjsHelpers');
+  const namedExports = {};
+  const dynamicRegisterSources = new Set();
+  let hasRemovedRequire = false;
 
-  code = magicString.toString();
-  const map = sourceMap ? magicString.generateMap() : null;
+  const {
+    addRequireStatement,
+    requiredSources,
+    rewriteRequireExpressionsAndGetImportBlock
+  } = getRequireHandlers();
 
-  return { code, map, syntheticNamedExports: isEsModule ? false : '__moduleExports' };
-}
+  // See which names are assigned to. This is necessary to prevent
+  // illegally replacing `var foo = require('foo')` with `import foo from 'foo'`,
+  // where `foo` is later reassigned. (This happens in the wild. CommonJS, sigh)
+  const reassignedNames = new Set();
+  const topLevelDeclarations = [];
+  const topLevelRequireDeclarators = new Set();
+  const skippedNodes = new Set();
+  const topLevelModuleExportsAssignments = [];
+  const topLevelExportsAssignmentsByName = new Map();
 
-function getDynamicPackagesModule(dynamicRequireModuleDirPaths, commonDir) {
-  let code = `const commonjsRegister = require('${HELPERS_ID}?commonjsRegister');`;
-  for (const dir of dynamicRequireModuleDirPaths) {
-    let entryPoint = 'index.js';
+  estreeWalker.walk(ast, {
+    enter(node, parent) {
+      if (skippedNodes.has(node)) {
+        this.skip();
+        return;
+      }
 
-    try {
-      if (fs.existsSync(path.join(dir, 'package.json'))) {
-        entryPoint =
-          JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), { encoding: 'utf8' })).main ||
-          entryPoint;
+      if (currentTryBlockEnd !== null && node.start > currentTryBlockEnd) {
+        currentTryBlockEnd = null;
       }
-    } catch (ignored) {
-      // ignored
-    }
 
-    code += `\ncommonjsRegister(${JSON.stringify(
-      getVirtualPathForDynamicRequirePath(dir, commonDir)
-    )}, function (module, exports) {
-  module.exports = require(${JSON.stringify(normalizePathSlashes(path.join(dir, entryPoint)))});
-});`;
-  }
-  return code;
-}
+      programDepth += 1;
+      if (node.scope) ({ scope } = node);
+      if (functionType.test(node.type)) lexicalDepth += 1;
+      if (sourceMap) {
+        magicString.addSourcemapLocation(node.start);
+        magicString.addSourcemapLocation(node.end);
+      }
 
-function getDynamicPackagesEntryIntro(
-  id,
-  dynamicRequireModuleDirPaths,
-  dynamicRequireModuleSet
-) {
-  try {
-    const code = fs.readFileSync(id, { encoding: 'utf8' });
-    let dynamicImports = Array.from(
-      dynamicRequireModuleSet,
-      (dynamicId) => `require(${JSON.stringify(DYNAMIC_REGISTER_PREFIX + dynamicId)});`
-    ).join('\n');
+      // eslint-disable-next-line default-case
+      switch (node.type) {
+        case 'TryStatement':
+          if (currentTryBlockEnd === null) {
+            currentTryBlockEnd = node.block.end;
+          }
+          return;
+        case 'AssignmentExpression':
+          if (node.left.type === 'MemberExpression') {
+            const flattened = getKeypath(node.left);
+            if (!flattened || scope.contains(flattened.name)) return;
 
-    if (dynamicRequireModuleDirPaths.length) {
-      dynamicImports += `require(${JSON.stringify(
-        DYNAMIC_REGISTER_PREFIX + DYNAMIC_PACKAGES_ID
-      )});`;
-    }
+            const exportsPatternMatch = exportsPattern.exec(flattened.keypath);
+            if (!exportsPatternMatch || flattened.keypath === 'exports') return;
 
-    return `${dynamicImports}\n${code}`;
-  } catch (ex) {
-    this.warn(`Failed to read file ${id}, dynamic modules might not work correctly`);
-    return null;
-  }
-}
+            const [, exportName] = exportsPatternMatch;
+            uses[flattened.name] = true;
 
-function getDynamicRequirePaths(patterns) {
-  const dynamicRequireModuleSet = new Set();
-  for (const pattern of !patterns || Array.isArray(patterns) ? patterns || [] : [patterns]) {
-    const isNegated = pattern.startsWith('!');
-    const modifySet = Set.prototype[isNegated ? 'delete' : 'add'].bind(dynamicRequireModuleSet);
-    for (const path$1 of glob.sync(isNegated ? pattern.substr(1) : pattern)) {
-      modifySet(normalizePathSlashes(path.resolve(path$1)));
-    }
-  }
-  const dynamicRequireModuleDirPaths = Array.from(dynamicRequireModuleSet.values()).filter(
-    (path) => {
-      try {
-        if (fs.statSync(path).isDirectory()) return true;
-      } catch (ignored) {
-        // Nothing to do here
-      }
-      return false;
-    }
-  );
-  return { dynamicRequireModuleSet, dynamicRequireModuleDirPaths };
-}
+            // we're dealing with `module.exports = ...` or `[module.]exports.foo = ...` –
+            if (programDepth > 3) {
+              shouldWrap = true;
+            } else if (exportName === KEY_COMPILED_ESM) {
+              defineCompiledEsmExpressions.push(parent);
+            } else if (flattened.keypath === 'module.exports') {
+              topLevelModuleExportsAssignments.push(node);
+            } else if (!topLevelExportsAssignmentsByName.has(exportName)) {
+              topLevelExportsAssignmentsByName.set(exportName, node);
+            } else {
+              shouldWrap = true;
+            }
 
-/* eslint-disable no-undefined */
-const isCjsPromises = new Map();
+            skippedNodes.add(node.left);
 
-function getIsCjsPromise(id) {
-  let isCjsPromise = isCjsPromises.get(id);
-  if (isCjsPromise) return isCjsPromise.promise;
+            if (flattened.keypath === 'module.exports' && node.right.type === 'ObjectExpression') {
+              node.right.properties.forEach((prop) => {
+                if (prop.computed || !('key' in prop) || prop.key.type !== 'Identifier') return;
+                const { name } = prop.key;
+                if (name === pluginutils.makeLegalIdentifier(name)) namedExports[name] = true;
+              });
+              return;
+            }
 
-  const promise = new Promise((resolve) => {
-    isCjsPromise = {
-      resolve,
-      promise: undefined
-    };
-    isCjsPromises.set(id, isCjsPromise);
-  });
-  isCjsPromise.promise = promise;
+            if (exportsPatternMatch[1]) namedExports[exportsPatternMatch[1]] = true;
+          } else {
+            for (const name of pluginutils.extractAssignedNames(node.left)) {
+              reassignedNames.add(name);
+            }
+          }
+          return;
+        case 'CallExpression': {
+          if (isDefineCompiledEsm(node)) {
+            if (programDepth === 3 && parent.type === 'ExpressionStatement') {
+              // skip special handling for [module.]exports until we know we render this
+              skippedNodes.add(node.arguments[0]);
+              defineCompiledEsmExpressions.push(parent);
+            } else {
+              shouldWrap = true;
+            }
+            return;
+          }
 
-  return promise;
-}
+          if (
+            node.callee.object &&
+            node.callee.object.name === 'require' &&
+            node.callee.property.name === 'resolve' &&
+            hasDynamicModuleForPath(id, '/', dynamicRequireModuleSet)
+          ) {
+            const requireNode = node.callee.object;
+            magicString.appendLeft(
+              node.end - 1,
+              `,${JSON.stringify(
+                path.dirname(id) === '.' ? null /* default behavior */ : virtualDynamicRequirePath
+              )}`
+            );
+            magicString.overwrite(
+              requireNode.start,
+              requireNode.end,
+              `${HELPERS_NAME}.commonjsRequire`,
+              {
+                storeName: true
+              }
+            );
+            uses.commonjsHelpers = true;
+            return;
+          }
 
-function setIsCjsPromise(id, resolution) {
-  const isCjsPromise = isCjsPromises.get(id);
-  if (isCjsPromise) {
-    if (isCjsPromise.resolve) {
-      isCjsPromise.resolve(resolution);
-      isCjsPromise.resolve = undefined;
-    }
-  } else {
-    isCjsPromises.set(id, { promise: Promise.resolve(resolution), resolve: undefined });
-  }
-}
+          if (!isStaticRequireStatement(node, scope)) return;
+          if (!isDynamicRequireModulesEnabled) {
+            skippedNodes.add(node.callee);
+          }
+          if (!isIgnoredRequireStatement(node, ignoreRequire)) {
+            skippedNodes.add(node.callee);
+            const usesReturnValue = parent.type !== 'ExpressionStatement';
 
-// e.g. id === "commonjsHelpers?commonjsRegister"
-function getSpecificHelperProxy(id) {
-  return `export {${id.split('?')[1]} as default} from '${HELPERS_ID}';`;
-}
+            let canConvertRequire = true;
+            let shouldRemoveRequireStatement = false;
 
-function getUnknownRequireProxy(id, requireReturnsDefault) {
-  if (requireReturnsDefault === true || id.endsWith('.json')) {
-    return `export {default} from ${JSON.stringify(id)};`;
-  }
-  const name = getName(id);
-  const exported =
-    requireReturnsDefault === 'auto'
-      ? `import {getDefaultExportFromNamespaceIfNotNamed} from "${HELPERS_ID}"; export default /*@__PURE__*/getDefaultExportFromNamespaceIfNotNamed(${name})`
-      : requireReturnsDefault === 'preferred'
-      ? `import {getDefaultExportFromNamespaceIfPresent} from "${HELPERS_ID}"; export default /*@__PURE__*/getDefaultExportFromNamespaceIfPresent(${name})`
-      : `export default ${name}`;
-  return `import * as ${name} from ${JSON.stringify(id)}; ${exported}`;
-}
+            if (currentTryBlockEnd !== null) {
+              ({
+                canConvertRequire,
+                shouldRemoveRequireStatement
+              } = getIgnoreTryCatchRequireStatementMode(node.arguments[0].value));
 
-function getDynamicJsonProxy(id, commonDir) {
-  const normalizedPath = normalizePathSlashes(id.slice(DYNAMIC_JSON_PREFIX.length));
-  return `const commonjsRegister = require('${HELPERS_ID}?commonjsRegister');\ncommonjsRegister(${JSON.stringify(
-    getVirtualPathForDynamicRequirePath(normalizedPath, commonDir)
-  )}, function (module, exports) {
-  module.exports = require(${JSON.stringify(normalizedPath)});
-});`;
-}
+              if (shouldRemoveRequireStatement) {
+                hasRemovedRequire = true;
+              }
+            }
 
-function getDynamicRequireProxy(normalizedPath, commonDir) {
-  return `const commonjsRegister = require('${HELPERS_ID}?commonjsRegister');\ncommonjsRegister(${JSON.stringify(
-    getVirtualPathForDynamicRequirePath(normalizedPath, commonDir)
-  )}, function (module, exports) {
-  ${fs.readFileSync(normalizedPath, { encoding: 'utf8' })}
-});`;
-}
+            let sourceId = getRequireStringArg(node);
+            const isDynamicRegister = isModuleRegisterProxy(sourceId);
+            if (isDynamicRegister) {
+              sourceId = unwrapModuleRegisterProxy(sourceId);
+              if (sourceId.endsWith('.json')) {
+                sourceId = DYNAMIC_JSON_PREFIX + sourceId;
+              }
+              dynamicRegisterSources.add(wrapModuleRegisterProxy(sourceId));
+            } else {
+              if (
+                !sourceId.endsWith('.json') &&
+                hasDynamicModuleForPath(sourceId, id, dynamicRequireModuleSet)
+              ) {
+                if (shouldRemoveRequireStatement) {
+                  magicString.overwrite(node.start, node.end, `undefined`);
+                } else if (canConvertRequire) {
+                  magicString.overwrite(
+                    node.start,
+                    node.end,
+                    `${HELPERS_NAME}.commonjsRequire(${JSON.stringify(
+                      getVirtualPathForDynamicRequirePath(sourceId, commonDir)
+                    )}, ${JSON.stringify(
+                      path.dirname(id) === '.' ? null /* default behavior */ : virtualDynamicRequirePath
+                    )})`
+                  );
+                  uses.commonjsHelpers = true;
+                }
+                return;
+              }
 
-async function getStaticRequireProxy(
-  id,
-  requireReturnsDefault,
-  esModulesWithDefaultExport,
-  esModulesWithNamedExports
-) {
-  const name = getName(id);
-  const isCjs = await getIsCjsPromise(id);
-  if (isCjs) {
-    return `import { __moduleExports } from ${JSON.stringify(id)}; export default __moduleExports;`;
-  } else if (isCjs === null) {
-    return getUnknownRequireProxy(id, requireReturnsDefault);
-  } else if (
-    requireReturnsDefault !== true &&
-    (!requireReturnsDefault ||
-      !esModulesWithDefaultExport.has(id) ||
-      (esModulesWithNamedExports.has(id) && requireReturnsDefault === 'auto'))
-  ) {
-    return `import * as ${name} from ${JSON.stringify(id)}; export default ${name};`;
-  }
-  return `export {default} from ${JSON.stringify(id)};`;
-}
+              if (canConvertRequire) {
+                addRequireStatement(sourceId, node, scope, usesReturnValue);
+              }
+            }
 
-/* eslint-disable no-param-reassign, no-undefined */
+            if (usesReturnValue) {
+              if (shouldRemoveRequireStatement) {
+                magicString.overwrite(node.start, node.end, `undefined`);
+                return;
+              }
 
-function getCandidatesForExtension(resolved, extension) {
-  return [resolved + extension, `${resolved}${path.sep}index${extension}`];
-}
+              if (
+                parent.type === 'VariableDeclarator' &&
+                !scope.parent &&
+                parent.id.type === 'Identifier'
+              ) {
+                // This will allow us to reuse this variable name as the imported variable if it is not reassigned
+                // and does not conflict with variables in other places where this is imported
+                topLevelRequireDeclarators.add(parent);
+              }
+            } else {
+              // This is a bare import, e.g. `require('foo');`
 
-function getCandidates(resolved, extensions) {
-  return extensions.reduce(
-    (paths, extension) => paths.concat(getCandidatesForExtension(resolved, extension)),
-    [resolved]
-  );
-}
+              if (!canConvertRequire && !shouldRemoveRequireStatement) {
+                return;
+              }
 
-function getResolveId(extensions) {
-  function resolveExtensions(importee, importer) {
-    // not our problem
-    if (importee[0] !== '.' || !importer) return undefined;
+              magicString.remove(parent.start, parent.end);
+            }
+          }
+          return;
+        }
+        case 'ConditionalExpression':
+        case 'IfStatement':
+          // skip dead branches
+          if (isFalsy(node.test)) {
+            skippedNodes.add(node.consequent);
+          } else if (node.alternate && isTruthy(node.test)) {
+            skippedNodes.add(node.alternate);
+          }
+          return;
+        case 'Identifier': {
+          const { name } = node;
+          if (!(isReference__default['default'](node, parent) && !scope.contains(name))) return;
+          switch (name) {
+            case 'require':
+              if (isNodeRequirePropertyAccess(parent)) {
+                if (hasDynamicModuleForPath(id, '/', dynamicRequireModuleSet)) {
+                  if (parent.property.name === 'cache') {
+                    magicString.overwrite(node.start, node.end, `${HELPERS_NAME}.commonjsRequire`, {
+                      storeName: true
+                    });
+                    uses.commonjsHelpers = true;
+                  }
+                }
 
-    const resolved = path.resolve(path.dirname(importer), importee);
-    const candidates = getCandidates(resolved, extensions);
+                return;
+              }
 
-    for (let i = 0; i < candidates.length; i += 1) {
-      try {
-        const stats = fs.statSync(candidates[i]);
-        if (stats.isFile()) return { id: candidates[i] };
-      } catch (err) {
-        /* noop */
+              if (isDynamicRequireModulesEnabled && isRequireStatement(parent, scope)) {
+                magicString.appendLeft(
+                  parent.end - 1,
+                  `,${JSON.stringify(
+                    path.dirname(id) === '.' ? null /* default behavior */ : virtualDynamicRequirePath
+                  )}`
+                );
+              }
+              if (isShorthandProperty(parent)) {
+                magicString.appendRight(node.end, `: ${HELPERS_NAME}.commonjsRequire`);
+              } else {
+                magicString.overwrite(node.start, node.end, `${HELPERS_NAME}.commonjsRequire`, {
+                  storeName: true
+                });
+              }
+
+              uses.commonjsHelpers = true;
+              return;
+            case 'module':
+            case 'exports':
+              shouldWrap = true;
+              uses[name] = true;
+              return;
+            case 'global':
+              uses.global = true;
+              if (!ignoreGlobal) {
+                magicString.overwrite(node.start, node.end, `${HELPERS_NAME}.commonjsGlobal`, {
+                  storeName: true
+                });
+                uses.commonjsHelpers = true;
+              }
+              return;
+            case 'define':
+              magicString.overwrite(node.start, node.end, 'undefined', { storeName: true });
+              return;
+            default:
+              globals.add(name);
+              return;
+          }
+        }
+        case 'MemberExpression':
+          if (!isDynamicRequireModulesEnabled && isModuleRequire(node, scope)) {
+            magicString.overwrite(node.start, node.end, `${HELPERS_NAME}.commonjsRequire`, {
+              storeName: true
+            });
+            uses.commonjsHelpers = true;
+            skippedNodes.add(node.object);
+            skippedNodes.add(node.property);
+          }
+          return;
+        case 'ReturnStatement':
+          // if top-level return, we need to wrap it
+          if (lexicalDepth === 0) {
+            shouldWrap = true;
+          }
+          return;
+        case 'ThisExpression':
+          // rewrite top-level `this` as `commonjsHelpers.commonjsGlobal`
+          if (lexicalDepth === 0) {
+            uses.global = true;
+            if (!ignoreGlobal) {
+              magicString.overwrite(node.start, node.end, `${HELPERS_NAME}.commonjsGlobal`, {
+                storeName: true
+              });
+              uses.commonjsHelpers = true;
+            }
+          }
+          return;
+        case 'UnaryExpression':
+          // rewrite `typeof module`, `typeof module.exports` and `typeof exports` (https://github.com/rollup/rollup-plugin-commonjs/issues/151)
+          if (node.operator === 'typeof') {
+            const flattened = getKeypath(node.argument);
+            if (!flattened) return;
+
+            if (scope.contains(flattened.name)) return;
+
+            if (
+              flattened.keypath === 'module.exports' ||
+              flattened.keypath === 'module' ||
+              flattened.keypath === 'exports'
+            ) {
+              magicString.overwrite(node.start, node.end, `'object'`, { storeName: false });
+            }
+          }
+          return;
+        case 'VariableDeclaration':
+          if (!scope.parent) {
+            topLevelDeclarations.push(node);
+          }
       }
+    },
+
+    leave(node) {
+      programDepth -= 1;
+      if (node.scope) scope = scope.parent;
+      if (functionType.test(node.type)) lexicalDepth -= 1;
     }
+  });
 
-    return undefined;
+  let isRestorableCompiledEsm = false;
+  if (defineCompiledEsmExpressions.length > 0) {
+    if (!shouldWrap && defineCompiledEsmExpressions.length === 1) {
+      isRestorableCompiledEsm = true;
+      magicString.remove(
+        defineCompiledEsmExpressions[0].start,
+        defineCompiledEsmExpressions[0].end
+      );
+    } else {
+      shouldWrap = true;
+      uses.exports = true;
+    }
   }
 
-  function resolveId(importee, importer) {
-    const isProxyModule = importee.endsWith(PROXY_SUFFIX);
-    if (isProxyModule) {
-      importee = getIdFromProxyId(importee);
-    }
-    if (importee.startsWith('\0')) {
-      if (
-        importee.startsWith(HELPERS_ID) ||
-        importee === DYNAMIC_PACKAGES_ID ||
-        importee.startsWith(DYNAMIC_JSON_PREFIX)
-      ) {
-        return importee;
-      }
-      if (!isProxyModule) {
-        return null;
-      }
-    }
+  // We cannot wrap ES/mixed modules
+  shouldWrap = shouldWrap && !disableWrap && !isEsModule;
+  uses.commonjsHelpers = uses.commonjsHelpers || shouldWrap;
 
-    if (importer && importer.endsWith(PROXY_SUFFIX)) {
-      importer = getIdFromProxyId(importer);
-    }
+  if (
+    !(
+      requiredSources.length ||
+      dynamicRegisterSources.size ||
+      uses.module ||
+      uses.exports ||
+      uses.require ||
+      uses.commonjsHelpers ||
+      hasRemovedRequire
+    ) &&
+    (ignoreGlobal || !uses.global)
+  ) {
+    return { meta: { commonjs: { isCommonJS: false } } };
+  }
 
-    return this.resolve(importee, importer, { skipSelf: true }).then((resolved) => {
-      if (!resolved) {
-        resolved = resolveExtensions(importee, importer);
-      }
-      if (isProxyModule) {
-        if (!resolved) {
-          return { id: getExternalProxyId(importee), external: false };
-        }
-        resolved.id = (resolved.external ? getExternalProxyId : getProxyId)(resolved.id);
-        resolved.external = false;
-        return resolved;
-      }
-      return resolved;
-    });
+  const moduleName = deconflict(scope, globals, getName(id));
+
+  let leadingComment = '';
+  if (code.startsWith('/*')) {
+    const commentEnd = code.indexOf('*/', 2) + 2;
+    leadingComment = `${code.slice(0, commentEnd)}\n`;
+    magicString.remove(0, commentEnd).trim();
   }
 
-  return resolveId;
+  const exportBlock = isEsModule
+    ? ''
+    : rewriteExportsAndGetExportsBlock(
+        magicString,
+        moduleName,
+        shouldWrap,
+        topLevelModuleExportsAssignments,
+        topLevelExportsAssignmentsByName,
+        defineCompiledEsmExpressions,
+        (name) => deconflict(scope, globals, name),
+        isRestorableCompiledEsm,
+        code,
+        uses,
+        HELPERS_NAME
+      );
+
+  const importBlock = rewriteRequireExpressionsAndGetImportBlock(
+    magicString,
+    topLevelDeclarations,
+    topLevelRequireDeclarators,
+    reassignedNames,
+    uses.commonjsHelpers && HELPERS_NAME,
+    dynamicRegisterSources
+  );
+
+  if (shouldWrap) {
+    wrapCode(magicString, uses, moduleName, HELPERS_NAME, virtualDynamicRequirePath);
+  }
+
+  magicString
+    .trim()
+    .prepend(leadingComment + importBlock)
+    .append(exportBlock);
+
+  return {
+    code: magicString.toString(),
+    map: sourceMap ? magicString.generateMap() : null,
+    syntheticNamedExports: isEsModule ? false : '__moduleExports',
+    meta: { commonjs: { isCommonJS: !isEsModule } }
+  };
 }
 
 function commonjs(options = {}) {
@@ -1230,7 +1594,7 @@ function commonjs(options = {}) {
   );
   const isDynamicRequireModulesEnabled = dynamicRequireModuleSet.size > 0;
   const commonDir = isDynamicRequireModulesEnabled
-    ? getCommonDir(null, Array.from(dynamicRequireModuleSet).concat(process.cwd()))
+    ? getCommonDir__default['default'](null, Array.from(dynamicRequireModuleSet).concat(process.cwd()))
     : null;
 
   const esModulesWithDefaultExport = new Set();
@@ -1243,12 +1607,31 @@ function commonjs(options = {}) {
       ? (id) => options.ignore.includes(id)
       : () => false;
 
+  const getIgnoreTryCatchRequireStatementMode = (id) => {
+    const mode =
+      typeof options.ignoreTryCatch === 'function'
+        ? options.ignoreTryCatch(id)
+        : Array.isArray(options.ignoreTryCatch)
+        ? options.ignoreTryCatch.includes(id)
+        : options.ignoreTryCatch || false;
+
+    return {
+      canConvertRequire: mode !== 'remove' && mode !== true,
+      shouldRemoveRequireStatement: mode === 'remove'
+    };
+  };
+
   const resolveId = getResolveId(extensions);
 
   const sourceMap = options.sourceMap !== false;
 
   function transformAndCheckExports(code, id) {
-    const { isEsModule, hasDefaultExport, hasNamedExports, ast } = checkEsModule(
+    if (isDynamicRequireModulesEnabled && this.getModuleInfo(id).isEntry) {
+      code =
+        getDynamicPackagesEntryIntro(dynamicRequireModuleDirPaths, dynamicRequireModuleSet) + code;
+    }
+
+    const { isEsModule, hasDefaultExport, hasNamedExports, ast } = analyzeTopLevelStatements(
       this.parse,
       code,
       id
@@ -1264,46 +1647,44 @@ function commonjs(options = {}) {
       !dynamicRequireModuleSet.has(normalizePathSlashes(id)) &&
       (!hasCjsKeywords(code, ignoreGlobal) || (isEsModule && !options.transformMixedEsModules))
     ) {
-      setIsCjsPromise(id, false);
-      return null;
+      return { meta: { commonjs: { isCommonJS: false } } };
     }
 
-    const transformed = transformCommonjs(
+    let disableWrap = false;
+
+    // avoid wrapping in createCommonjsModule, as this is a commonjsRegister call
+    if (isModuleRegisterProxy(id)) {
+      disableWrap = true;
+      id = unwrapModuleRegisterProxy(id);
+    }
+
+    return transformCommonjs(
       this.parse,
       code,
       id,
       isEsModule,
       ignoreGlobal || isEsModule,
       ignoreRequire,
+      getIgnoreTryCatchRequireStatementMode,
       sourceMap,
       isDynamicRequireModulesEnabled,
       dynamicRequireModuleSet,
+      disableWrap,
       commonDir,
       ast
     );
-
-    setIsCjsPromise(id, isEsModule ? false : Boolean(transformed));
-    return transformed;
   }
 
   return {
     name: 'commonjs',
 
     buildStart() {
+      validateRollupVersion(this.meta.rollupVersion, peerDependencies.rollup);
       if (options.namedExports != null) {
         this.warn(
           'The namedExports option from "@rollup/plugin-commonjs" is deprecated. Named exports are now handled automatically.'
         );
       }
-
-      const [major, minor] = this.meta.rollupVersion.split('.').map(Number);
-      const minVersion = peerDependencies.rollup.slice(2);
-      const [minMajor, minMinor] = minVersion.split('.').map(Number);
-      if (major < minMajor || (major === minMajor && minor < minMinor)) {
-        this.error(
-          `Insufficient Rollup version: "@rollup/plugin-commonjs" requires at least rollup@${minVersion} but found rollup@${this.meta.rollupVersion}.`
-        );
-      }
     },
 
     resolveId,
@@ -1317,8 +1698,8 @@ function commonjs(options = {}) {
         return getSpecificHelperProxy(id);
       }
 
-      if (id.endsWith(EXTERNAL_SUFFIX)) {
-        const actualId = getIdFromExternalProxyId(id);
+      if (isWrappedId(id, EXTERNAL_SUFFIX)) {
+        const actualId = unwrapId(id, EXTERNAL_SUFFIX);
         return getUnknownRequireProxy(
           actualId,
           isEsmExternal(actualId) ? getRequireReturnsDefault(actualId) : true
@@ -1333,13 +1714,19 @@ function commonjs(options = {}) {
         return getDynamicJsonProxy(id, commonDir);
       }
 
-      const normalizedPath = normalizePathSlashes(id);
-      if (dynamicRequireModuleSet.has(normalizedPath) && !normalizedPath.endsWith('.json')) {
-        return getDynamicRequireProxy(normalizedPath, commonDir);
+      if (isDynamicModuleImport(id, dynamicRequireModuleSet)) {
+        return `export default require(${JSON.stringify(normalizePathSlashes(id))});`;
+      }
+
+      if (isModuleRegisterProxy(id)) {
+        return getDynamicRequireProxy(
+          normalizePathSlashes(unwrapModuleRegisterProxy(id)),
+          commonDir
+        );
       }
 
-      if (id.endsWith(PROXY_SUFFIX)) {
-        const actualId = getIdFromProxyId(id);
+      if (isWrappedId(id, PROXY_SUFFIX)) {
+        const actualId = unwrapId(id, PROXY_SUFFIX);
         return getStaticRequireProxy(
           actualId,
           getRequireReturnsDefault(actualId),
@@ -1348,36 +1735,42 @@ function commonjs(options = {}) {
         );
       }
 
-      if (isDynamicRequireModulesEnabled && this.getModuleInfo(id).isEntry) {
-        return getDynamicPackagesEntryIntro(
-          id,
-          dynamicRequireModuleDirPaths,
-          dynamicRequireModuleSet
-        );
-      }
-
       return null;
     },
 
-    transform(code, id) {
+    transform(code, rawId) {
+      let id = rawId;
+
+      if (isModuleRegisterProxy(id)) {
+        id = unwrapModuleRegisterProxy(id);
+      }
+
       const extName = path.extname(id);
-      if (extName !== '.cjs' && id !== DYNAMIC_PACKAGES_ID && !id.startsWith(DYNAMIC_JSON_PREFIX)) {
-        if (!filter(id) || !extensions.includes(extName)) {
-          setIsCjsPromise(id, null);
-          return null;
-        }
+      if (
+        extName !== '.cjs' &&
+        id !== DYNAMIC_PACKAGES_ID &&
+        !id.startsWith(DYNAMIC_JSON_PREFIX) &&
+        (!filter(id) || !extensions.includes(extName))
+      ) {
+        return null;
       }
 
-      let transformed;
       try {
-        transformed = transformAndCheckExports.call(this, code, id);
+        return transformAndCheckExports.call(this, code, rawId);
       } catch (err) {
-        transformed = null;
-        setIsCjsPromise(id, false);
-        this.error(err, err.loc);
+        return this.error(err, err.loc);
       }
+    },
 
-      return transformed;
+    moduleParsed({ id, meta: { commonjs } }) {
+      if (commonjs) {
+        const isCjs = commonjs.isCommonJS;
+        if (isCjs != null) {
+          setIsCjsPromise(id, isCjs);
+          return;
+        }
+      }
+      setIsCjsPromise(id, null);
     }
   };
 }