@rollup/plugin-commonjs 21.0.0 → 22.0.0-10

package/dist/{index.js → cjs/index.js}

@@ -2,13 +2,12 @@
 
 var path = require('path');
 var pluginutils = require('@rollup/pluginutils');
-var getCommonDir = require('commondir');
 var fs = require('fs');
+var getCommonDir = require('commondir');
 var glob = require('glob');
 var estreeWalker = require('estree-walker');
 var MagicString = require('magic-string');
 var isReference = require('is-reference');
-var resolve = require('resolve');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -17,8 +16,9 @@ var glob__default = /*#__PURE__*/_interopDefaultLegacy(glob);
 var MagicString__default = /*#__PURE__*/_interopDefaultLegacy(MagicString);
 var isReference__default = /*#__PURE__*/_interopDefaultLegacy(isReference);
 
+var version = " 22.0.0-10";
 var peerDependencies = {
-	rollup: "^2.38.3"
+	rollup: "^2.67.0"
 };
 
 function tryParse(parse, code, id) {
@@ -85,271 +85,6 @@ function analyzeTopLevelStatements(parse, code, id) {
   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 EXPORTS_SUFFIX = '?commonjs-exports';
-const MODULE_SUFFIX = '?commonjs-module';
-
-const DYNAMIC_REGISTER_SUFFIX = '?commonjs-dynamic-register';
-const DYNAMIC_JSON_PREFIX = '\0commonjs-dynamic-json:';
-const DYNAMIC_PACKAGES_ID = '\0commonjs-dynamic-packages';
-
-const HELPERS_ID = '\0commonjsHelpers.js';
-
-// `x['default']` is used instead of `x.default` for backward compatibility with ES3 browsers.
-// Minifiers like uglify will usually transpile it back if compatibility with ES3 is not enabled.
-// This will no longer be necessary once Rollup switches to ES6 output, likely
-// in Rollup 3
-
-const HELPERS = `
-export var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
-export function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
-
-export function getDefaultExportFromNamespaceIfPresent (n) {
-	return n && Object.prototype.hasOwnProperty.call(n, 'default') ? n['default'] : 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 FAILED_REQUIRE_ERROR = `throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');`;
-
-const HELPER_NON_DYNAMIC = `
-export function commonjsRequire (path) {
-	${FAILED_REQUIRE_ERROR}
-}
-`;
-
-const getDynamicHelpers = (ignoreDynamicRequires) => `
-export function createModule(modulePath) {
-	return {
-		path: modulePath,
-		exports: {},
-		require: function (path, base) {
-			return commonjsRequire(path, base == null ? modulePath : base);
-		}
-	};
-}
-
-export function commonjsRegister (path, loader) {
-	DYNAMIC_REQUIRE_LOADERS[path] = loader;
-}
-
-export function commonjsRegisterOrShort (path, to) {
-	const resolvedPath = commonjsResolveImpl(path, null, true);
-	if (resolvedPath !== null && DYNAMIC_REQUIRE_CACHE[resolvedPath]) {
-	  DYNAMIC_REQUIRE_CACHE[path] = DYNAMIC_REQUIRE_CACHE[resolvedPath];
-	} else {
-	  DYNAMIC_REQUIRE_SHORTS[path] = to;
-	}
-}
-
-const DYNAMIC_REQUIRE_LOADERS = Object.create(null);
-const DYNAMIC_REQUIRE_CACHE = Object.create(null);
-const DYNAMIC_REQUIRE_SHORTS = Object.create(null);
-const DEFAULT_PARENT_MODULE = {
-	id: '<' + 'rollup>', exports: {}, parent: undefined, filename: null, loaded: false, children: [], paths: []
-};
-const CHECKED_EXTENSIONS = ['', '.js', '.json'];
-
-function normalize (path) {
-	path = path.replace(/\\\\/g, '/');
-	const parts = path.split('/');
-	const slashed = parts[0] === '';
-	for (let i = 1; i < parts.length; i++) {
-		if (parts[i] === '.' || parts[i] === '') {
-			parts.splice(i--, 1);
-		}
-	}
-	for (let i = 1; i < parts.length; i++) {
-		if (parts[i] !== '..') continue;
-		if (i > 0 && parts[i - 1] !== '..' && parts[i - 1] !== '.') {
-			parts.splice(--i, 2);
-			i--;
-		}
-	}
-	path = parts.join('/');
-	if (slashed && path[0] !== '/')
-	  path = '/' + path;
-	else if (path.length === 0)
-	  path = '.';
-	return path;
-}
-
-function join () {
-	if (arguments.length === 0)
-	  return '.';
-	let joined;
-	for (let i = 0; i < arguments.length; ++i) {
-	  let arg = arguments[i];
-	  if (arg.length > 0) {
-		if (joined === undefined)
-		  joined = arg;
-		else
-		  joined += '/' + arg;
-	  }
-	}
-	if (joined === undefined)
-	  return '.';
-
-	return joined;
-}
-
-function isPossibleNodeModulesPath (modulePath) {
-	let c0 = modulePath[0];
-	if (c0 === '/' || c0 === '\\\\') return false;
-	let c1 = modulePath[1], c2 = modulePath[2];
-	if ((c0 === '.' && (!c1 || c1 === '/' || c1 === '\\\\')) ||
-		(c0 === '.' && c1 === '.' && (!c2 || c2 === '/' || c2 === '\\\\'))) return false;
-	if (c1 === ':' && (c2 === '/' || c2 === '\\\\'))
-		return false;
-	return true;
-}
-
-function dirname (path) {
-  if (path.length === 0)
-    return '.';
-
-  let i = path.length - 1;
-  while (i > 0) {
-    const c = path.charCodeAt(i);
-    if ((c === 47 || c === 92) && i !== path.length - 1)
-      break;
-    i--;
-  }
-
-  if (i > 0)
-    return path.substr(0, i);
-
-  if (path.chartCodeAt(0) === 47 || path.chartCodeAt(0) === 92)
-    return path.charAt(0);
-
-  return '.';
-}
-
-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;
-		} else if (originalModuleDir) {
-			relPath = normalize(originalModuleDir + '/node_modules/' + path);
-		} 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];
-			if (DYNAMIC_REQUIRE_CACHE[resolvedPath]) {
-				return resolvedPath;
-			}
-			if (DYNAMIC_REQUIRE_SHORTS[resolvedPath]) {
-			  return resolvedPath;
-			}
-			if (DYNAMIC_REQUIRE_LOADERS[resolvedPath]) {
-				return resolvedPath;
-			}
-		}
-		if (!shouldTryNodeModules) break;
-		const nextDir = normalize(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) {
-	let resolvedPath = commonjsResolveImpl(path, originalModuleDir, true);
-	if (resolvedPath !== null) {
-    let cachedModule = DYNAMIC_REQUIRE_CACHE[resolvedPath];
-    if (cachedModule) return cachedModule.exports;
-    let shortTo = DYNAMIC_REQUIRE_SHORTS[resolvedPath];
-    if (shortTo) {
-      cachedModule = DYNAMIC_REQUIRE_CACHE[shortTo];
-      if (cachedModule)
-        return cachedModule.exports;
-      resolvedPath = commonjsResolveImpl(shortTo, null, true);
-    }
-    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;
-    };
-	}
-	${ignoreDynamicRequires ? 'return require(path);' : FAILED_REQUIRE_ERROR}
-}
-
-commonjsRequire.cache = DYNAMIC_REQUIRE_CACHE;
-commonjsRequire.resolve = commonjsResolve;
-`;
-
-function getHelpersModule(isDynamicRequireModulesEnabled, ignoreDynamicRequires) {
-  return `${HELPERS}${
-    isDynamicRequireModulesEnabled ? getDynamicHelpers(ignoreDynamicRequires) : HELPER_NON_DYNAMIC
-  }`;
-}
-
 /* eslint-disable import/prefer-default-export */
 
 function deconflict(scopes, globals, identifier) {
@@ -382,13 +117,35 @@ function normalizePathSlashes(path) {
   return path.replace(/\\/g, '/');
 }
 
-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 getVirtualPathForDynamicRequirePath = (path$1, commonDir) =>
+  `/${normalizePathSlashes(path.relative(commonDir, path$1))}`;
+
+function capitalize(name) {
+  return name[0].toUpperCase() + name.slice(1);
+}
+
+function getStrictRequiresFilter({ strictRequires }) {
+  switch (strictRequires) {
+    case true:
+      return { strictRequiresFilter: () => true, detectCyclesAndConditional: false };
+    // eslint-disable-next-line no-undefined
+    case undefined:
+    case 'auto':
+    case 'debug':
+    case null:
+      return { strictRequiresFilter: () => false, detectCyclesAndConditional: true };
+    case false:
+      return { strictRequiresFilter: () => false, detectCyclesAndConditional: false };
+    default:
+      if (typeof strictRequires === 'string' || Array.isArray(strictRequires)) {
+        return {
+          strictRequiresFilter: pluginutils.createFilter(strictRequires),
+          detectCyclesAndConditional: false
+        };
+      }
+      throw new Error('Unexpected value for "strictRequires" option.');
+  }
+}
 
 function getPackageEntryPoint(dirPath) {
   let entryPoint = 'index.js';
@@ -406,41 +163,6 @@ function getPackageEntryPoint(dirPath) {
   return entryPoint;
 }
 
-function getDynamicPackagesModule(dynamicRequireModuleDirPaths, commonDir) {
-  let code = `const commonjsRegisterOrShort = require('${HELPERS_ID}?commonjsRegisterOrShort');`;
-  for (const dir of dynamicRequireModuleDirPaths) {
-    const entryPoint = getPackageEntryPoint(dir);
-
-    code += `\ncommonjsRegisterOrShort(${JSON.stringify(
-      getVirtualPathForDynamicRequirePath(dir, commonDir)
-    )}, ${JSON.stringify(getVirtualPathForDynamicRequirePath(path.join(dir, entryPoint), commonDir))});`;
-  }
-  return code;
-}
-
-function getDynamicPackagesEntryIntro(
-  dynamicRequireModuleDirPaths,
-  dynamicRequireModuleSet
-) {
-  let dynamicImports = Array.from(
-    dynamicRequireModuleSet,
-    (dynamicId) => `require(${JSON.stringify(wrapId(dynamicId, DYNAMIC_REGISTER_SUFFIX))});`
-  ).join('\n');
-
-  if (dynamicRequireModuleDirPaths.length) {
-    dynamicImports += `require(${JSON.stringify(
-      wrapId(DYNAMIC_PACKAGES_ID, DYNAMIC_REGISTER_SUFFIX)
-    )});`;
-  }
-
-  return dynamicImports;
-}
-
-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;
@@ -450,103 +172,249 @@ function isDirectory(path) {
   return false;
 }
 
-function getDynamicRequirePaths(patterns) {
-  const dynamicRequireModuleSet = new Set();
+function getDynamicRequireModules(patterns, dynamicRequireRoot) {
+  const dynamicRequireModules = new Map();
+  const dirNames = 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)))));
+    const modifyMap = (targetPath, resolvedPath) =>
+      isNegated
+        ? dynamicRequireModules.delete(targetPath)
+        : dynamicRequireModules.set(targetPath, resolvedPath);
+    for (const path$1 of glob__default["default"].sync(isNegated ? pattern.substr(1) : pattern)) {
+      const resolvedPath = path.resolve(path$1);
+      const requirePath = normalizePathSlashes(resolvedPath);
+      if (isDirectory(resolvedPath)) {
+        dirNames.add(resolvedPath);
+        const modulePath = path.resolve(path.join(resolvedPath, getPackageEntryPoint(path$1)));
+        modifyMap(requirePath, modulePath);
+        modifyMap(normalizePathSlashes(modulePath), modulePath);
+      } else {
+        dirNames.add(path.dirname(resolvedPath));
+        modifyMap(requirePath, resolvedPath);
       }
     }
   }
-  const dynamicRequireModuleDirPaths = Array.from(dynamicRequireModuleSet.values()).filter((path) =>
-    isDirectory(path)
-  );
-  return { dynamicRequireModuleSet, dynamicRequireModuleDirPaths };
+  return {
+    commonDir: dirNames.size ? getCommonDir__default["default"]([...dirNames, dynamicRequireRoot]) : null,
+    dynamicRequireModules
+  };
 }
 
-function getCommonJSMetaPromise(commonJSMetaPromises, id) {
-  let commonJSMetaPromise = commonJSMetaPromises.get(id);
-  if (commonJSMetaPromise) return commonJSMetaPromise.promise;
+const FAILED_REQUIRE_ERROR = `throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');`;
 
-  const promise = new Promise((resolve) => {
-    commonJSMetaPromise = {
-      resolve,
-      promise: null
-    };
-    commonJSMetaPromises.set(id, commonJSMetaPromise);
-  });
-  commonJSMetaPromise.promise = promise;
+const COMMONJS_REQUIRE_EXPORT = 'commonjsRequire';
+const CREATE_COMMONJS_REQUIRE_EXPORT = 'createCommonjsRequire';
 
-  return promise;
+function getDynamicModuleRegistry(
+  isDynamicRequireModulesEnabled,
+  dynamicRequireModules,
+  commonDir,
+  ignoreDynamicRequires
+) {
+  if (!isDynamicRequireModulesEnabled) {
+    return `export function ${COMMONJS_REQUIRE_EXPORT}(path) {
+	${FAILED_REQUIRE_ERROR}
+}`;
+  }
+  const dynamicModuleImports = [...dynamicRequireModules.values()]
+    .map(
+      (id, index) =>
+        `import ${
+          id.endsWith('.json') ? `json${index}` : `{ __require as require${index} }`
+        } from ${JSON.stringify(id)};`
+    )
+    .join('\n');
+  const dynamicModuleProps = [...dynamicRequireModules.keys()]
+    .map(
+      (id, index) =>
+        `\t\t${JSON.stringify(getVirtualPathForDynamicRequirePath(id, commonDir))}: ${
+          id.endsWith('.json') ? `function () { return json${index}; }` : `require${index}`
+        }`
+    )
+    .join(',\n');
+  return `${dynamicModuleImports}
+
+var dynamicModules;
+
+function getDynamicModules() {
+	return dynamicModules || (dynamicModules = {
+${dynamicModuleProps}
+	});
 }
 
-function setCommonJSMetaPromise(commonJSMetaPromises, id, commonjsMeta) {
-  const commonJSMetaPromise = commonJSMetaPromises.get(id);
-  if (commonJSMetaPromise) {
-    if (commonJSMetaPromise.resolve) {
-      commonJSMetaPromise.resolve(commonjsMeta);
-      commonJSMetaPromise.resolve = null;
-    }
-  } else {
-    commonJSMetaPromises.set(id, { promise: Promise.resolve(commonjsMeta), resolve: null });
-  }
+export function ${CREATE_COMMONJS_REQUIRE_EXPORT}(originalModuleDir) {
+	function handleRequire(path) {
+		var resolvedPath = commonjsResolve(path, originalModuleDir);
+		if (resolvedPath !== null) {
+			return getDynamicModules()[resolvedPath]();
+		}
+		${ignoreDynamicRequires ? 'return require(path);' : FAILED_REQUIRE_ERROR}
+	}
+	handleRequire.resolve = function (path) {
+		var resolvedPath = commonjsResolve(path, originalModuleDir);
+		if (resolvedPath !== null) {
+			return resolvedPath;
+		}
+		return require.resolve(path);
+	}
+	return handleRequire;
+}
+
+function commonjsResolve (path, originalModuleDir) {
+	var shouldTryNodeModules = isPossibleNodeModulesPath(path);
+	path = normalize(path);
+	var relPath;
+	if (path[0] === '/') {
+		originalModuleDir = '';
+	}
+	var modules = getDynamicModules();
+	var checkedExtensions = ['', '.js', '.json'];
+	while (true) {
+		if (!shouldTryNodeModules) {
+			relPath = normalize(originalModuleDir + '/' + path);
+		} else {
+			relPath = normalize(originalModuleDir + '/node_modules/' + path);
+		}
+
+		if (relPath.endsWith('/..')) {
+			break; // Travelled too far up, avoid infinite loop
+		}
+
+		for (var extensionIndex = 0; extensionIndex < checkedExtensions.length; extensionIndex++) {
+			var resolvedPath = relPath + checkedExtensions[extensionIndex];
+			if (modules[resolvedPath]) {
+				return resolvedPath;
+			}
+		}
+		if (!shouldTryNodeModules) break;
+		var nextDir = normalize(originalModuleDir + '/..');
+		if (nextDir === originalModuleDir) break;
+		originalModuleDir = nextDir;
+	}
+	return null;
+}
+
+function isPossibleNodeModulesPath (modulePath) {
+	var c0 = modulePath[0];
+	if (c0 === '/' || c0 === '\\\\') return false;
+	var c1 = modulePath[1], c2 = modulePath[2];
+	if ((c0 === '.' && (!c1 || c1 === '/' || c1 === '\\\\')) ||
+		(c0 === '.' && c1 === '.' && (!c2 || c2 === '/' || c2 === '\\\\'))) return false;
+	if (c1 === ':' && (c2 === '/' || c2 === '\\\\')) return false;
+	return true;
+}
+
+function normalize (path) {
+	path = path.replace(/\\\\/g, '/');
+	var parts = path.split('/');
+	var slashed = parts[0] === '';
+	for (var i = 1; i < parts.length; i++) {
+		if (parts[i] === '.' || parts[i] === '') {
+			parts.splice(i--, 1);
+		}
+	}
+	for (var i = 1; i < parts.length; i++) {
+		if (parts[i] !== '..') continue;
+		if (i > 0 && parts[i - 1] !== '..' && parts[i - 1] !== '.') {
+			parts.splice(--i, 2);
+			i--;
+		}
+	}
+	path = parts.join('/');
+	if (slashed && path[0] !== '/') path = '/' + path;
+	else if (path.length === 0) path = '.';
+	return path;
+}`;
+}
+
+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 WRAPPED_SUFFIX = '?commonjs-wrapped';
+const EXTERNAL_SUFFIX = '?commonjs-external';
+const EXPORTS_SUFFIX = '?commonjs-exports';
+const MODULE_SUFFIX = '?commonjs-module';
+const ENTRY_SUFFIX = '?commonjs-entry';
+const ES_IMPORT_SUFFIX = '?commonjs-es-import';
+
+const DYNAMIC_MODULES_ID = '\0commonjs-dynamic-modules';
+const HELPERS_ID = '\0commonjsHelpers.js';
+
+const IS_WRAPPED_COMMONJS = 'withRequireFunction';
+
+// `x['default']` is used instead of `x.default` for backward compatibility with ES3 browsers.
+// Minifiers like uglify will usually transpile it back if compatibility with ES3 is not enabled.
+// This could be improved by inspecting Rollup's "generatedCode" option
+
+const HELPERS = `
+export var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+export function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+export function getDefaultExportFromNamespaceIfPresent (n) {
+	return n && Object.prototype.hasOwnProperty.call(n, 'default') ? n['default'] : 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) {
+  var f = n.default;
+	if (typeof f == "function") {
+		var a = function () {
+			return f.apply(this, arguments);
+		};
+		a.prototype = f.prototype;
+  } else a = {};
+  Object.defineProperty(a, '__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;
 }
+`;
 
-// e.g. id === "commonjsHelpers?commonjsRegister"
-function getSpecificHelperProxy(id) {
-  return `export {${id.split('?')[1]} as default} from "${HELPERS_ID}";`;
+function getHelpersModule() {
+  return HELPERS;
 }
 
 function getUnknownRequireProxy(id, requireReturnsDefault) {
   if (requireReturnsDefault === true || id.endsWith('.json')) {
-    return `export {default} from ${JSON.stringify(id)};`;
+    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});`
+      ? `import { getDefaultExportFromNamespaceIfNotNamed } from "${HELPERS_ID}"; export default /*@__PURE__*/getDefaultExportFromNamespaceIfNotNamed(${name});`
       : requireReturnsDefault === 'preferred'
-      ? `import {getDefaultExportFromNamespaceIfPresent} from "${HELPERS_ID}"; export default /*@__PURE__*/getDefaultExportFromNamespaceIfPresent(${name});`
+      ? `import { getDefaultExportFromNamespaceIfPresent } from "${HELPERS_ID}"; export default /*@__PURE__*/getDefaultExportFromNamespaceIfPresent(${name});`
       : !requireReturnsDefault
-      ? `import {getAugmentedNamespace} from "${HELPERS_ID}"; export default /*@__PURE__*/getAugmentedNamespace(${name});`
+      ? `import { getAugmentedNamespace } from "${HELPERS_ID}"; export default /*@__PURE__*/getAugmentedNamespace(${name});`
       : `export default ${name};`;
   return `import * as ${name} from ${JSON.stringify(id)}; ${exported}`;
 }
 
-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)});
-});`;
-}
-
-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' })}
-});`;
-}
-
-async function getStaticRequireProxy(
-  id,
-  requireReturnsDefault,
-  esModulesWithDefaultExport,
-  esModulesWithNamedExports,
-  commonJsMetaPromises
-) {
+async function getStaticRequireProxy(id, requireReturnsDefault, loadModule) {
   const name = getName(id);
-  const commonjsMeta = await getCommonJSMetaPromise(commonJsMetaPromises, id);
-  if (commonjsMeta && commonjsMeta.isCommonJS) {
-    return `export { __moduleExports as default } from ${JSON.stringify(id)};`;
-  } else if (commonjsMeta === null) {
+  const {
+    meta: { commonjs: commonjsMeta }
+  } = await loadModule({ id });
+  if (!commonjsMeta) {
     return getUnknownRequireProxy(id, requireReturnsDefault);
+  } else if (commonjsMeta.isCommonJS) {
+    return `export { __moduleExports as default } from ${JSON.stringify(id)};`;
   } else if (!requireReturnsDefault) {
     return `import { getAugmentedNamespace } from "${HELPERS_ID}"; import * as ${name} from ${JSON.stringify(
       id
@@ -554,14 +422,51 @@ async function getStaticRequireProxy(
   } else if (
     requireReturnsDefault !== true &&
     (requireReturnsDefault === 'namespace' ||
-      !esModulesWithDefaultExport.has(id) ||
-      (requireReturnsDefault === 'auto' && esModulesWithNamedExports.has(id)))
+      !commonjsMeta.hasDefaultExport ||
+      (requireReturnsDefault === 'auto' && commonjsMeta.hasNamedExports))
   ) {
     return `import * as ${name} from ${JSON.stringify(id)}; export default ${name};`;
   }
   return `export { default } from ${JSON.stringify(id)};`;
 }
 
+function getEntryProxy(id, defaultIsModuleExports, getModuleInfo) {
+  const {
+    meta: { commonjs: commonjsMeta },
+    hasDefaultExport
+  } = getModuleInfo(id);
+  if (!commonjsMeta || commonjsMeta.isCommonJS !== IS_WRAPPED_COMMONJS) {
+    const stringifiedId = JSON.stringify(id);
+    let code = `export * from ${stringifiedId};`;
+    if (hasDefaultExport) {
+      code += `export { default } from ${stringifiedId};`;
+    }
+    return code;
+  }
+  return getEsImportProxy(id, defaultIsModuleExports);
+}
+
+function getEsImportProxy(id, defaultIsModuleExports) {
+  const name = getName(id);
+  const exportsName = `${name}Exports`;
+  const requireModule = `require${capitalize(name)}`;
+  let code =
+    `import { getDefaultExportFromCjs } from "${HELPERS_ID}";\n` +
+    `import { __require as ${requireModule} } from ${JSON.stringify(id)};\n` +
+    `var ${exportsName} = ${requireModule}();\n` +
+    `export { ${exportsName} as __moduleExports };`;
+  if (defaultIsModuleExports) {
+    code += `\nexport { ${exportsName} as default };`;
+  } else {
+    code += `export default /*@__PURE__*/getDefaultExportFromCjs(${exportsName});`;
+  }
+  return {
+    code,
+    syntheticNamedExports: '__moduleExports',
+    meta: { commonjs: { isCommonJS: false } }
+  };
+}
+
 /* eslint-disable no-param-reassign, no-undefined */
 
 function getCandidatesForExtension(resolved, extension) {
@@ -575,106 +480,280 @@ function getCandidates(resolved, extensions) {
   );
 }
 
+function resolveExtensions(importee, importer, extensions) {
+  // not our problem
+  if (importee[0] !== '.' || !importer) return undefined;
+
+  const resolved = path.resolve(path.dirname(importer), importee);
+  const candidates = getCandidates(resolved, extensions);
+
+  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 undefined;
+}
+
 function getResolveId(extensions) {
-  function resolveExtensions(importee, importer) {
-    // not our problem
-    if (importee[0] !== '.' || !importer) return undefined;
+  return async function resolveId(importee, importer, resolveOptions) {
+    // We assume that all requires are pre-resolved
+    const customOptions = resolveOptions.custom;
+    if (customOptions && customOptions['node-resolve'] && customOptions['node-resolve'].isRequire) {
+      return null;
+    }
+    if (isWrappedId(importee, WRAPPED_SUFFIX)) {
+      return unwrapId(importee, WRAPPED_SUFFIX);
+    }
 
-    const resolved = path.resolve(path.dirname(importer), importee);
-    const candidates = getCandidates(resolved, extensions);
+    if (
+      importee.endsWith(ENTRY_SUFFIX) ||
+      isWrappedId(importee, MODULE_SUFFIX) ||
+      isWrappedId(importee, EXPORTS_SUFFIX) ||
+      isWrappedId(importee, PROXY_SUFFIX) ||
+      isWrappedId(importee, ES_IMPORT_SUFFIX) ||
+      isWrappedId(importee, EXTERNAL_SUFFIX) ||
+      importee.startsWith(HELPERS_ID) ||
+      importee === DYNAMIC_MODULES_ID
+    ) {
+      return importee;
+    }
 
-    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 (importer) {
+      if (
+        importer === DYNAMIC_MODULES_ID ||
+        // Proxies are only importing resolved ids, no need to resolve again
+        isWrappedId(importer, PROXY_SUFFIX) ||
+        isWrappedId(importer, ES_IMPORT_SUFFIX) ||
+        importer.endsWith(ENTRY_SUFFIX)
+      ) {
+        return importee;
+      }
+      if (isWrappedId(importer, EXTERNAL_SUFFIX)) {
+        // We need to return null for unresolved imports so that the proper warning is shown
+        if (!(await this.resolve(importee, importer, { skipSelf: true }))) {
+          return null;
+        }
+        // For other external imports, we need to make sure they are handled as external
+        return { id: importee, external: true };
       }
     }
-
-    return undefined;
-  }
-
-  return function resolveId(importee, rawImporter) {
-    if (isWrappedId(importee, MODULE_SUFFIX) || isWrappedId(importee, EXPORTS_SUFFIX)) {
-      return importee;
+
+    if (importee.startsWith('\0')) {
+      return null;
+    }
+
+    // If this is an entry point or ESM import, we need to figure out if the importee is wrapped and
+    // if that is the case, we need to add a proxy.
+    const resolved =
+      (await this.resolve(importee, importer, Object.assign({ skipSelf: true }, resolveOptions))) ||
+      resolveExtensions(importee, importer, extensions);
+    // Make sure that even if other plugins resolve again, we ignore our own proxies
+    if (
+      !resolved ||
+      resolved.external ||
+      resolved.id.endsWith(ENTRY_SUFFIX) ||
+      isWrappedId(resolved.id, ES_IMPORT_SUFFIX)
+    ) {
+      return resolved;
+    }
+    const moduleInfo = await this.load(resolved);
+    if (resolveOptions.isEntry) {
+      moduleInfo.moduleSideEffects = true;
+      // We must not precede entry proxies with a `\0` as that will mess up relative external resolution
+      return resolved.id + ENTRY_SUFFIX;
+    }
+    const {
+      meta: { commonjs: commonjsMeta }
+    } = moduleInfo;
+    if (commonjsMeta && commonjsMeta.isCommonJS === IS_WRAPPED_COMMONJS) {
+      return wrapId(resolved.id, ES_IMPORT_SUFFIX);
     }
+    return resolved;
+  };
+}
 
-    const importer =
-      rawImporter && isWrappedId(rawImporter, DYNAMIC_REGISTER_SUFFIX)
-        ? unwrapId(rawImporter, DYNAMIC_REGISTER_SUFFIX)
-        : rawImporter;
+function getRequireResolver(extensions, detectCyclesAndConditional) {
+  const knownCjsModuleTypes = Object.create(null);
+  const requiredIds = Object.create(null);
+  const unconditionallyRequiredIds = Object.create(null);
+  const dependencies = Object.create(null);
+  const getDependencies = (id) => dependencies[id] || (dependencies[id] = new Set());
 
-    // Except for exports, proxies are only importing resolved ids,
-    // no need to resolve again
-    if (importer && isWrappedId(importer, PROXY_SUFFIX)) {
-      return importee;
+  const isCyclic = (id) => {
+    const dependenciesToCheck = new Set(getDependencies(id));
+    for (const dependency of dependenciesToCheck) {
+      if (dependency === id) {
+        return true;
+      }
+      for (const childDependency of getDependencies(dependency)) {
+        dependenciesToCheck.add(childDependency);
+      }
     }
+    return false;
+  };
 
-    const isProxyModule = isWrappedId(importee, PROXY_SUFFIX);
-    const isRequiredModule = isWrappedId(importee, REQUIRE_SUFFIX);
-    let isModuleRegistration = false;
-
-    if (isProxyModule) {
-      importee = unwrapId(importee, PROXY_SUFFIX);
-    } else if (isRequiredModule) {
-      importee = unwrapId(importee, REQUIRE_SUFFIX);
+  const fullyAnalyzedModules = Object.create(null);
 
-      isModuleRegistration = isWrappedId(importee, DYNAMIC_REGISTER_SUFFIX);
-      if (isModuleRegistration) {
-        importee = unwrapId(importee, DYNAMIC_REGISTER_SUFFIX);
-      }
+  const getTypeForFullyAnalyzedModule = (id) => {
+    const knownType = knownCjsModuleTypes[id];
+    if (knownType !== true || !detectCyclesAndConditional || fullyAnalyzedModules[id]) {
+      return knownType;
     }
+    fullyAnalyzedModules[id] = true;
+    if (isCyclic(id)) {
+      return (knownCjsModuleTypes[id] = IS_WRAPPED_COMMONJS);
+    }
+    return knownType;
+  };
 
+  const setInitialParentType = (id, initialCommonJSType) => {
+    // It is possible a transformed module is already fully analyzed when using
+    // the cache and one dependency introduces a new cycle. Then transform is
+    // run for a fully analzyed module again. Fully analyzed modules may never
+    // change their type as importers already trust their type.
+    knownCjsModuleTypes[id] = fullyAnalyzedModules[id]
+      ? knownCjsModuleTypes[id]
+      : initialCommonJSType;
     if (
-      importee.startsWith(HELPERS_ID) ||
-      importee === DYNAMIC_PACKAGES_ID ||
-      importee.startsWith(DYNAMIC_JSON_PREFIX)
+      detectCyclesAndConditional &&
+      knownCjsModuleTypes[id] === true &&
+      requiredIds[id] &&
+      !unconditionallyRequiredIds[id]
     ) {
-      return importee;
+      knownCjsModuleTypes[id] = IS_WRAPPED_COMMONJS;
     }
+  };
 
-    if (importee.startsWith('\0')) {
-      return null;
+  const setTypesForRequiredModules = async (parentId, resolved, isConditional, loadModule) => {
+    const childId = resolved.id;
+    requiredIds[childId] = true;
+    if (!(isConditional || knownCjsModuleTypes[parentId] === IS_WRAPPED_COMMONJS)) {
+      unconditionallyRequiredIds[childId] = true;
+    }
+
+    getDependencies(parentId).add(childId);
+    if (!isCyclic(childId)) {
+      // This makes sure the current transform handler waits for all direct dependencies to be
+      // loaded and transformed and therefore for all transitive CommonJS dependencies to be
+      // loaded as well so that all cycles have been found and knownCjsModuleTypes is reliable.
+      await loadModule(resolved);
     }
+  };
 
-    return this.resolve(importee, importer, {
-      skipSelf: true,
-      custom: { 'node-resolve': { isRequire: isProxyModule || isRequiredModule } }
-    }).then((resolved) => {
-      if (!resolved) {
-        resolved = resolveExtensions(importee, importer);
+  return {
+    getWrappedIds: () =>
+      Object.keys(knownCjsModuleTypes).filter(
+        (id) => knownCjsModuleTypes[id] === IS_WRAPPED_COMMONJS
+      ),
+    isRequiredId: (id) => requiredIds[id],
+    async shouldTransformCachedModule({ id: parentId, meta: { commonjs: parentMeta } }) {
+      // Ignore modules that did not pass through the original transformer in a previous build
+      if (!(parentMeta && parentMeta.requires)) {
+        return false;
       }
-      if (resolved && isProxyModule) {
-        resolved.id = wrapId(resolved.id, resolved.external ? EXTERNAL_SUFFIX : PROXY_SUFFIX);
-        resolved.external = false;
-      } else if (resolved && isModuleRegistration) {
-        resolved.id = wrapId(resolved.id, DYNAMIC_REGISTER_SUFFIX);
-      } else if (!resolved && (isProxyModule || isRequiredModule)) {
-        return { id: wrapId(importee, EXTERNAL_SUFFIX), external: false };
+      setInitialParentType(parentId, parentMeta.initialCommonJSType);
+      await Promise.all(
+        parentMeta.requires.map(({ resolved, isConditional }) =>
+          setTypesForRequiredModules(parentId, resolved, isConditional, this.load)
+        )
+      );
+      if (getTypeForFullyAnalyzedModule(parentId) !== parentMeta.isCommonJS) {
+        return true;
       }
-      return resolved;
-    });
+      for (const {
+        resolved: { id }
+      } of parentMeta.requires) {
+        if (getTypeForFullyAnalyzedModule(id) !== parentMeta.isRequiredCommonJS[id]) {
+          return true;
+        }
+      }
+      return false;
+    },
+    /* eslint-disable no-param-reassign */
+    resolveRequireSourcesAndUpdateMeta: (rollupContext) => async (
+      parentId,
+      isParentCommonJS,
+      parentMeta,
+      sources
+    ) => {
+      parentMeta.initialCommonJSType = isParentCommonJS;
+      parentMeta.requires = [];
+      parentMeta.isRequiredCommonJS = Object.create(null);
+      setInitialParentType(parentId, isParentCommonJS);
+      const requireTargets = await Promise.all(
+        sources.map(async ({ source, isConditional }) => {
+          // Never analyze or proxy internal modules
+          if (source.startsWith('\0')) {
+            return { id: source, allowProxy: false };
+          }
+          const resolved =
+            (await rollupContext.resolve(source, parentId, {
+              custom: { 'node-resolve': { isRequire: true } }
+            })) || resolveExtensions(source, parentId, extensions);
+          if (!resolved) {
+            return { id: wrapId(source, EXTERNAL_SUFFIX), allowProxy: false };
+          }
+          const childId = resolved.id;
+          if (resolved.external) {
+            return { id: wrapId(childId, EXTERNAL_SUFFIX), allowProxy: false };
+          }
+          parentMeta.requires.push({ resolved, isConditional });
+          await setTypesForRequiredModules(parentId, resolved, isConditional, rollupContext.load);
+          return { id: childId, allowProxy: true };
+        })
+      );
+      parentMeta.isCommonJS = getTypeForFullyAnalyzedModule(parentId);
+      return requireTargets.map(({ id: dependencyId, allowProxy }, index) => {
+        // eslint-disable-next-line no-multi-assign
+        const isCommonJS = (parentMeta.isRequiredCommonJS[
+          dependencyId
+        ] = getTypeForFullyAnalyzedModule(dependencyId));
+        return {
+          source: sources[index].source,
+          id: allowProxy
+            ? isCommonJS === IS_WRAPPED_COMMONJS
+              ? wrapId(dependencyId, WRAPPED_SUFFIX)
+              : wrapId(dependencyId, PROXY_SUFFIX)
+            : dependencyId,
+          isCommonJS
+        };
+      });
+    }
   };
 }
 
-function validateRollupVersion(rollupVersion, peerDependencyVersion) {
-  const [major, minor] = rollupVersion.split('.').map(Number);
-  const versionRegexp = /\^(\d+\.\d+)\.\d+/g;
+function validateVersion(actualVersion, peerDependencyVersion, name) {
+  const versionRegexp = /\^(\d+\.\d+\.\d+)/g;
   let minMajor = Infinity;
   let minMinor = Infinity;
+  let minPatch = Infinity;
   let foundVersion;
   // eslint-disable-next-line no-cond-assign
   while ((foundVersion = versionRegexp.exec(peerDependencyVersion))) {
-    const [foundMajor, foundMinor] = foundVersion[1].split('.').map(Number);
+    const [foundMajor, foundMinor, foundPatch] = foundVersion[1].split('.').map(Number);
     if (foundMajor < minMajor) {
       minMajor = foundMajor;
       minMinor = foundMinor;
+      minPatch = foundPatch;
     }
   }
-  if (major < minMajor || (major === minMajor && minor < minMinor)) {
+  if (!actualVersion) {
     throw new Error(
-      `Insufficient Rollup version: "@rollup/plugin-commonjs" requires at least rollup@${minMajor}.${minMinor} but found rollup@${rollupVersion}.`
+      `Insufficient ${name} version: "@rollup/plugin-commonjs" requires at least ${name}@${minMajor}.${minMinor}.${minPatch}.`
+    );
+  }
+  const [major, minor, patch] = actualVersion.split('.').map(Number);
+  if (
+    major < minMajor ||
+    (major === minMajor && (minor < minMinor || (minor === minMinor && patch < minPatch)))
+  ) {
+    throw new Error(
+      `Insufficient ${name} version: "@rollup/plugin-commonjs" requires at least ${name}@${minMajor}.${minMinor}.${minPatch} but found ${name}@${actualVersion}.`
     );
   }
 }
@@ -814,8 +893,9 @@ function wrapCode(magicString, uses, moduleName, exportsName) {
   }
   magicString
     .trim()
+    .indent('\t')
     .prepend(`(function (${args.join(', ')}) {\n`)
-    .append(`\n}(${passedArgs.join(', ')}));`);
+    .append(`\n} (${passedArgs.join(', ')}));`);
 }
 
 function rewriteExportsAndGetExportsBlock(
@@ -833,12 +913,27 @@ function rewriteExportsAndGetExportsBlock(
   HELPERS_NAME,
   exportMode,
   detectWrappedDefault,
-  defaultIsModuleExports
+  defaultIsModuleExports,
+  usesRequireWrapper,
+  requireName
 ) {
   const exports = [];
   const exportDeclarations = [];
 
-  if (exportMode === 'replace') {
+  if (usesRequireWrapper) {
+    getExportsWhenUsingRequireWrapper(
+      magicString,
+      wrapped,
+      exportMode,
+      exports,
+      moduleExportsAssignments,
+      exportsAssignmentsByName,
+      moduleName,
+      exportsName,
+      requireName,
+      defineCompiledEsmExpressions
+    );
+  } else if (exportMode === 'replace') {
     getExportsForReplacedModuleExports(
       magicString,
       exports,
@@ -881,6 +976,49 @@ function rewriteExportsAndGetExportsBlock(
   return `\n\n${exportDeclarations.join('\n')}`;
 }
 
+function getExportsWhenUsingRequireWrapper(
+  magicString,
+  wrapped,
+  exportMode,
+  exports,
+  moduleExportsAssignments,
+  exportsAssignmentsByName,
+  moduleName,
+  exportsName,
+  requireName,
+  defineCompiledEsmExpressions
+) {
+  if (!wrapped) {
+    if (exportMode === 'replace') {
+      for (const { left } of moduleExportsAssignments) {
+        magicString.overwrite(left.start, left.end, exportsName);
+      }
+    } else {
+      // Collect and rewrite module.exports assignments
+      for (const { left } of moduleExportsAssignments) {
+        magicString.overwrite(left.start, left.end, `${moduleName}.exports`);
+      }
+      // Collect and rewrite named exports
+      for (const [exportName, { nodes }] of exportsAssignmentsByName) {
+        for (const node of nodes) {
+          magicString.overwrite(node.start, node.left.end, `${exportsName}.${exportName}`);
+        }
+      }
+      // Collect and rewrite exports.__esModule assignments
+      for (const expression of defineCompiledEsmExpressions) {
+        const moduleExportsExpression =
+          expression.type === 'CallExpression' ? expression.arguments[0] : expression.left.object;
+        magicString.overwrite(
+          moduleExportsExpression.start,
+          moduleExportsExpression.end,
+          exportsName
+        );
+      }
+    }
+  }
+  exports.push(`${requireName} as __require`);
+}
+
 function getExportsForReplacedModuleExports(
   magicString,
   exports,
@@ -968,7 +1106,7 @@ function getExports(
   }
 
   if (!isRestorableCompiledEsm || defaultIsModuleExports === true) {
-    exportDeclarations.push(`export default ${exportsName};`);
+    exports.push(`${exportsName} as default`);
   } else if (moduleExportsAssignments.length === 0 || defaultIsModuleExports === false) {
     exports.push(`${deconflictedDefaultExportName || exportsName} as default`);
   } else {
@@ -978,7 +1116,7 @@ function getExports(
   }
 }
 
-function isRequireStatement(node, scope) {
+function isRequireExpression(node, scope) {
   if (!node) return false;
   if (node.type !== 'CallExpression') return false;
 
@@ -1005,11 +1143,6 @@ function isModuleRequire({ object, property }, scope) {
   );
 }
 
-function isStaticRequireStatement(node, scope) {
-  if (!isRequireStatement(node, scope)) return false;
-  return !hasDynamicArguments(node);
-}
-
 function hasDynamicArguments(node) {
   return (
     node.arguments.length > 1 ||
@@ -1024,89 +1157,61 @@ function isNodeRequirePropertyAccess(parent) {
   return parent && parent.property && reservedMethod[parent.property.name];
 }
 
-function isIgnoredRequireStatement(requiredNode, ignoreRequire) {
-  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;
 }
 
-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;
-    }
-
-    return false;
-  }
-
-  for (const attemptExt of ['', '.js', '.json']) {
-    const resolvedPath = normalizePathSlashes(path.resolve(path.dirname(id), source + attemptExt));
-    if (dynamicRequireModuleSet.has(resolvedPath)) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
 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);
-    }
-  }
-
-  function getRequired(sourceId) {
-    if (!requiredBySource[sourceId]) {
-      requiredSources.push(sourceId);
-
-      requiredBySource[sourceId] = {
-        source: sourceId,
-        name: null,
-        nodesUsingRequired: []
-      };
-    }
-
-    return requiredBySource[sourceId];
+  const requireExpressions = [];
+
+  function addRequireStatement(
+    sourceId,
+    node,
+    scope,
+    usesReturnValue,
+    isInsideTryBlock,
+    isInsideConditional,
+    toBeRemoved
+  ) {
+    requireExpressions.push({
+      sourceId,
+      node,
+      scope,
+      usesReturnValue,
+      isInsideTryBlock,
+      isInsideConditional,
+      toBeRemoved
+    });
   }
 
-  function rewriteRequireExpressionsAndGetImportBlock(
+  async function rewriteRequireExpressionsAndGetImportBlock(
     magicString,
     topLevelDeclarations,
-    topLevelRequireDeclarators,
     reassignedNames,
     helpersName,
-    dynamicRegisterSources,
+    dynamicRequireName,
     moduleName,
     exportsName,
     id,
-    exportMode
+    exportMode,
+    resolveRequireSourcesAndUpdateMeta,
+    needsRequireWrapper,
+    isEsModule,
+    isDynamicRequireModulesEnabled,
+    getIgnoreTryCatchRequireStatementMode,
+    commonjsMeta
   ) {
-    setRemainingImportNamesAndRewriteRequires(
-      requireExpressionsWithUsedReturnValue,
-      requiredByNode,
-      magicString
-    );
     const imports = [];
     imports.push(`import * as ${helpersName} from "${HELPERS_ID}";`);
+    if (dynamicRequireName) {
+      imports.push(
+        `import { ${
+          isDynamicRequireModulesEnabled ? CREATE_COMMONJS_REQUIRE_EXPORT : COMMONJS_REQUIRE_EXPORT
+        } as ${dynamicRequireName} } from "${DYNAMIC_MODULES_ID}";`
+      );
+    }
     if (exportMode === 'module') {
       imports.push(
         `import { __module as ${moduleName}, exports as ${exportsName} } from ${JSON.stringify(
@@ -1118,58 +1223,113 @@ function getRequireHandlers() {
         `import { __exports as ${exportsName} } from ${JSON.stringify(wrapId(id, EXPORTS_SUFFIX))}`
       );
     }
-    for (const source of dynamicRegisterSources) {
-      imports.push(`import ${JSON.stringify(wrapId(source, REQUIRE_SUFFIX))};`);
-    }
-    for (const source of requiredSources) {
-      if (!source.startsWith('\0')) {
-        imports.push(`import ${JSON.stringify(wrapId(source, REQUIRE_SUFFIX))};`);
-      }
-      const { name, nodesUsingRequired } = requiredBySource[source];
-      imports.push(
-        `import ${nodesUsingRequired.length ? `${name} from ` : ''}${JSON.stringify(
-          source.startsWith('\0') ? source : wrapId(source, PROXY_SUFFIX)
-        )};`
-      );
-    }
+    const requiresBySource = collectSources(requireExpressions);
+    const requireTargets = await resolveRequireSourcesAndUpdateMeta(
+      id,
+      needsRequireWrapper ? IS_WRAPPED_COMMONJS : !isEsModule,
+      commonjsMeta,
+      Object.keys(requiresBySource).map((source) => {
+        return {
+          source,
+          isConditional: requiresBySource[source].every((require) => require.isInsideConditional)
+        };
+      })
+    );
+    processRequireExpressions(
+      imports,
+      requireTargets,
+      requiresBySource,
+      getIgnoreTryCatchRequireStatementMode,
+      magicString
+    );
     return imports.length ? `${imports.join('\n')}\n\n` : '';
   }
 
   return {
     addRequireStatement,
-    requiredSources,
     rewriteRequireExpressionsAndGetImportBlock
   };
 }
 
-function setRemainingImportNamesAndRewriteRequires(
-  requireExpressionsWithUsedReturnValue,
-  requiredByNode,
+function collectSources(requireExpressions) {
+  const requiresBySource = Object.create(null);
+  for (const requireExpression of requireExpressions) {
+    const { sourceId } = requireExpression;
+    if (!requiresBySource[sourceId]) {
+      requiresBySource[sourceId] = [];
+    }
+    const requires = requiresBySource[sourceId];
+    requires.push(requireExpression);
+  }
+  return requiresBySource;
+}
+
+function processRequireExpressions(
+  imports,
+  requireTargets,
+  requiresBySource,
+  getIgnoreTryCatchRequireStatementMode,
   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;
+  const generateRequireName = getGenerateRequireName();
+  for (const { source, id: resolvedId, isCommonJS } of requireTargets) {
+    const requires = requiresBySource[source];
+    const name = generateRequireName(requires);
+    let usesRequired = false;
+    let needsImport = false;
+    for (const { node, usesReturnValue, toBeRemoved, isInsideTryBlock } of requires) {
+      const { canConvertRequire, shouldRemoveRequire } =
+        isInsideTryBlock && isWrappedId(resolvedId, EXTERNAL_SUFFIX)
+          ? getIgnoreTryCatchRequireStatementMode(source)
+          : { canConvertRequire: true, shouldRemoveRequire: false };
+      if (shouldRemoveRequire) {
+        if (usesReturnValue) {
+          magicString.overwrite(node.start, node.end, 'undefined');
+        } else {
+          magicString.remove(toBeRemoved.start, toBeRemoved.end);
+        }
+      } else if (canConvertRequire) {
+        needsImport = true;
+        if (isCommonJS === IS_WRAPPED_COMMONJS) {
+          magicString.overwrite(node.start, node.end, `${name}()`);
+        } else if (usesReturnValue) {
+          usesRequired = true;
+          magicString.overwrite(node.start, node.end, name);
+        } else {
+          magicString.remove(toBeRemoved.start, toBeRemoved.end);
+        }
+      }
+    }
+    if (needsImport) {
+      if (isCommonJS === IS_WRAPPED_COMMONJS) {
+        imports.push(`import { __require as ${name} } from ${JSON.stringify(resolvedId)};`);
+      } else {
+        imports.push(`import ${usesRequired ? `${name} from ` : ''}${JSON.stringify(resolvedId)};`);
+      }
     }
-    magicString.overwrite(requireExpression.start, requireExpression.end, required.name);
   }
 }
 
+function getGenerateRequireName() {
+  let uid = 0;
+  return (requires) => {
+    let name;
+    const hasNameConflict = ({ scope }) => scope.contains(name);
+    do {
+      name = `require$$${uid}`;
+      uid += 1;
+    } while (requires.some(hasNameConflict));
+    return name;
+  };
+}
+
 /* eslint-disable no-param-reassign, no-shadow, no-underscore-dangle, no-continue */
 
 const exportsPattern = /^(?:module\.)?exports(?:\.([a-zA-Z_$][a-zA-Z_$0-9]*))?$/;
 
 const functionType = /^(?:FunctionDeclaration|FunctionExpression|ArrowFunctionExpression)$/;
 
-function transformCommonjs(
+async function transformCommonjs(
   parse,
   code,
   id,
@@ -1180,21 +1340,24 @@ function transformCommonjs(
   getIgnoreTryCatchRequireStatementMode,
   sourceMap,
   isDynamicRequireModulesEnabled,
-  dynamicRequireModuleSet,
-  disableWrap,
+  dynamicRequireModules,
   commonDir,
   astCache,
-  defaultIsModuleExports
+  defaultIsModuleExports,
+  needsRequireWrapper,
+  resolveRequireSourcesAndUpdateMeta,
+  isRequired,
+  checkDynamicRequire,
+  commonjsMeta
 ) {
   const ast = astCache || tryParse(parse, code, id);
-  const magicString = new MagicString__default['default'](code);
+  const magicString = new MagicString__default["default"](code);
   const uses = {
     module: false,
     exports: false,
     global: false,
     require: false
   };
-  let usesDynamicRequire = false;
   const virtualDynamicRequirePath =
     isDynamicRequireModulesEnabled && getVirtualPathForDynamicRequirePath(path.dirname(id), commonDir);
   let scope = pluginutils.attachScopes(ast, 'scope');
@@ -1204,24 +1367,18 @@ function transformCommonjs(
   let shouldWrap = false;
 
   const globals = new Set();
-
-  // TODO technically wrong since globals isn't populated yet, but ¯\_(ツ)_/¯
-  const HELPERS_NAME = deconflict([scope], globals, 'commonjsHelpers');
-  const dynamicRegisterSources = new Set();
-  let hasRemovedRequire = false;
-
-  const {
-    addRequireStatement,
-    requiredSources,
-    rewriteRequireExpressionsAndGetImportBlock
-  } = getRequireHandlers();
+  // A conditionalNode is a node for which execution is not guaranteed. If such a node is a require
+  // or contains nested requires, those should be handled as function calls unless there is an
+  // unconditional require elsewhere.
+  let currentConditionalNodeEnd = null;
+  const conditionalNodes = new Set();
+  const { addRequireStatement, rewriteRequireExpressionsAndGetImportBlock } = getRequireHandlers();
 
   // 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 moduleAccessScopes = new Set([scope]);
   const exportsAccessScopes = new Set([scope]);
@@ -1230,6 +1387,9 @@ function transformCommonjs(
   const exportsAssignmentsByName = new Map();
   const topLevelAssignments = new Set();
   const topLevelDefineCompiledEsmExpressions = [];
+  const replacedGlobal = [];
+  const replacedDynamicRequires = [];
+  const importedVariables = new Set();
 
   estreeWalker.walk(ast, {
     enter(node, parent) {
@@ -1241,6 +1401,12 @@ function transformCommonjs(
       if (currentTryBlockEnd !== null && node.start > currentTryBlockEnd) {
         currentTryBlockEnd = null;
       }
+      if (currentConditionalNodeEnd !== null && node.start > currentConditionalNodeEnd) {
+        currentConditionalNodeEnd = null;
+      }
+      if (currentConditionalNodeEnd === null && conditionalNodes.has(node)) {
+        currentConditionalNodeEnd = node.end;
+      }
 
       programDepth += 1;
       if (node.scope) ({ scope } = node);
@@ -1252,11 +1418,6 @@ function transformCommonjs(
 
       // 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);
@@ -1327,110 +1488,58 @@ function transformCommonjs(
             return;
           }
 
+          // Transform require.resolve
           if (
+            isDynamicRequireModulesEnabled &&
             node.callee.object &&
-            node.callee.object.name === 'require' &&
-            node.callee.property.name === 'resolve' &&
-            hasDynamicModuleForPath(id, '/', dynamicRequireModuleSet)
+            isRequire(node.callee.object, scope) &&
+            node.callee.property.name === 'resolve'
           ) {
+            checkDynamicRequire(node.start);
+            uses.require = true;
             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
-              }
-            );
+            replacedDynamicRequires.push(requireNode);
             return;
           }
 
-          if (!isStaticRequireStatement(node, scope)) return;
-          if (!isDynamicRequireModulesEnabled) {
-            skippedNodes.add(node.callee);
+          if (!isRequireExpression(node, scope)) {
+            const keypath = getKeypath(node.callee);
+            if (keypath && importedVariables.has(keypath.name)) {
+              // Heuristic to deoptimize requires after a required function has been called
+              currentConditionalNodeEnd = Infinity;
+            }
+            return;
           }
-          if (!isIgnoredRequireStatement(node, ignoreRequire)) {
-            skippedNodes.add(node.callee);
-            const usesReturnValue = parent.type !== 'ExpressionStatement';
-
-            let canConvertRequire = true;
-            let shouldRemoveRequireStatement = false;
 
-            if (currentTryBlockEnd !== null) {
-              ({
-                canConvertRequire,
-                shouldRemoveRequireStatement
-              } = getIgnoreTryCatchRequireStatementMode(node.arguments[0].value));
+          skippedNodes.add(node.callee);
+          uses.require = true;
 
-              if (shouldRemoveRequireStatement) {
-                hasRemovedRequire = true;
-              }
+          if (hasDynamicArguments(node)) {
+            if (isDynamicRequireModulesEnabled) {
+              checkDynamicRequire(node.start);
             }
-
-            let sourceId = getRequireStringArg(node);
-            const isDynamicRegister = isWrappedId(sourceId, DYNAMIC_REGISTER_SUFFIX);
-            if (isDynamicRegister) {
-              sourceId = unwrapId(sourceId, DYNAMIC_REGISTER_SUFFIX);
-              if (sourceId.endsWith('.json')) {
-                sourceId = DYNAMIC_JSON_PREFIX + sourceId;
-              }
-              dynamicRegisterSources.add(wrapId(sourceId, DYNAMIC_REGISTER_SUFFIX));
-            } 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
-                    )})`
-                  );
-                  usesDynamicRequire = true;
-                }
-                return;
-              }
-
-              if (canConvertRequire) {
-                addRequireStatement(sourceId, node, scope, usesReturnValue);
-              }
+            if (!ignoreDynamicRequires) {
+              replacedDynamicRequires.push(node.callee);
             }
+            return;
+          }
 
-            if (usesReturnValue) {
-              if (shouldRemoveRequireStatement) {
-                magicString.overwrite(node.start, node.end, `undefined`);
-                return;
-              }
-
-              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');`
-
-              if (!canConvertRequire && !shouldRemoveRequireStatement) {
-                return;
+          const requireStringArg = getRequireStringArg(node);
+          if (!ignoreRequire(requireStringArg)) {
+            const usesReturnValue = parent.type !== 'ExpressionStatement';
+            addRequireStatement(
+              requireStringArg,
+              node,
+              scope,
+              usesReturnValue,
+              currentTryBlockEnd !== null,
+              currentConditionalNodeEnd !== null,
+              parent.type === 'ExpressionStatement' ? parent : node
+            );
+            if (parent.type === 'VariableDeclarator' && parent.id.type === 'Identifier') {
+              for (const name of pluginutils.extractAssignedNames(parent.id)) {
+                importedVariables.add(name);
               }
-
-              magicString.remove(parent.start, parent.end);
             }
           }
           return;
@@ -1440,45 +1549,43 @@ function transformCommonjs(
           // skip dead branches
           if (isFalsy(node.test)) {
             skippedNodes.add(node.consequent);
-          } else if (node.alternate && isTruthy(node.test)) {
-            skippedNodes.add(node.alternate);
+          } else if (isTruthy(node.test)) {
+            if (node.alternate) {
+              skippedNodes.add(node.alternate);
+            }
+          } else {
+            conditionalNodes.add(node.consequent);
+            if (node.alternate) {
+              conditionalNodes.add(node.alternate);
+            }
+          }
+          return;
+        case 'ArrowFunctionExpression':
+        case 'FunctionDeclaration':
+        case 'FunctionExpression':
+          // requires in functions should be conditional unless it is an IIFE
+          if (
+            currentConditionalNodeEnd === null &&
+            !(parent.type === 'CallExpression' && parent.callee === node)
+          ) {
+            currentConditionalNodeEnd = node.end;
           }
           return;
         case 'Identifier': {
           const { name } = node;
-          if (!(isReference__default['default'](node, parent) && !scope.contains(name))) return;
+          if (!isReference__default["default"](node, parent) || scope.contains(name)) return;
           switch (name) {
             case 'require':
+              uses.require = true;
               if (isNodeRequirePropertyAccess(parent)) {
-                if (hasDynamicModuleForPath(id, '/', dynamicRequireModuleSet)) {
-                  if (parent.property.name === 'cache') {
-                    magicString.overwrite(node.start, node.end, `${HELPERS_NAME}.commonjsRequire`, {
-                      storeName: true
-                    });
-                  }
-                }
-
                 return;
               }
-
-              if (isDynamicRequireModulesEnabled && isRequireStatement(parent, scope)) {
-                magicString.appendLeft(
-                  parent.end - 1,
-                  `,${JSON.stringify(
-                    path.dirname(id) === '.' ? null /* default behavior */ : virtualDynamicRequirePath
-                  )}`
-                );
-              }
               if (!ignoreDynamicRequires) {
                 if (isShorthandProperty(parent)) {
-                  magicString.appendRight(node.end, `: ${HELPERS_NAME}.commonjsRequire`);
-                } else {
-                  magicString.overwrite(node.start, node.end, `${HELPERS_NAME}.commonjsRequire`, {
-                    storeName: true
-                  });
+                  magicString.prependRight(node.start, 'require: ');
                 }
+                replacedDynamicRequires.push(node);
               }
-              usesDynamicRequire = true;
               return;
             case 'module':
             case 'exports':
@@ -1488,9 +1595,7 @@ function transformCommonjs(
             case 'global':
               uses.global = true;
               if (!ignoreGlobal) {
-                magicString.overwrite(node.start, node.end, `${HELPERS_NAME}.commonjsGlobal`, {
-                  storeName: true
-                });
+                replacedGlobal.push(node);
               }
               return;
             case 'define':
@@ -1503,11 +1608,26 @@ function transformCommonjs(
               return;
           }
         }
+        case 'LogicalExpression':
+          // skip dead branches
+          if (node.operator === '&&') {
+            if (isFalsy(node.left)) {
+              skippedNodes.add(node.right);
+            } else if (!isTruthy(node.left)) {
+              conditionalNodes.add(node.right);
+            }
+          } else if (node.operator === '||') {
+            if (isTruthy(node.left)) {
+              skippedNodes.add(node.right);
+            } else if (!isFalsy(node.left)) {
+              conditionalNodes.add(node.right);
+            }
+          }
+          return;
         case 'MemberExpression':
           if (!isDynamicRequireModulesEnabled && isModuleRequire(node, scope)) {
-            magicString.overwrite(node.start, node.end, `${HELPERS_NAME}.commonjsRequire`, {
-              storeName: true
-            });
+            uses.require = true;
+            replacedDynamicRequires.push(node);
             skippedNodes.add(node.object);
             skippedNodes.add(node.property);
           }
@@ -1523,12 +1643,18 @@ function transformCommonjs(
           if (lexicalDepth === 0) {
             uses.global = true;
             if (!ignoreGlobal) {
-              magicString.overwrite(node.start, node.end, `${HELPERS_NAME}.commonjsGlobal`, {
-                storeName: true
-              });
+              replacedGlobal.push(node);
             }
           }
           return;
+        case 'TryStatement':
+          if (currentTryBlockEnd === null) {
+            currentTryBlockEnd = node.block.end;
+          }
+          if (currentConditionalNodeEnd === null) {
+            currentConditionalNodeEnd = node.end;
+          }
+          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') {
@@ -1538,9 +1664,10 @@ function transformCommonjs(
             if (scope.contains(flattened.name)) return;
 
             if (
-              flattened.keypath === 'module.exports' ||
-              flattened.keypath === 'module' ||
-              flattened.keypath === 'exports'
+              !isEsModule &&
+              (flattened.keypath === 'module.exports' ||
+                flattened.keypath === 'module' ||
+                flattened.keypath === 'exports')
             ) {
               magicString.overwrite(node.start, node.end, `'object'`, {
                 storeName: false
@@ -1565,29 +1692,53 @@ function transformCommonjs(
   const nameBase = getName(id);
   const exportsName = deconflict([...exportsAccessScopes], globals, nameBase);
   const moduleName = deconflict([...moduleAccessScopes], globals, `${nameBase}Module`);
+  const requireName = deconflict([scope], globals, `require${capitalize(nameBase)}`);
+  const isRequiredName = deconflict([scope], globals, `hasRequired${capitalize(nameBase)}`);
+  const helpersName = deconflict([scope], globals, 'commonjsHelpers');
+  const dynamicRequireName =
+    replacedDynamicRequires.length > 0 &&
+    deconflict(
+      [scope],
+      globals,
+      isDynamicRequireModulesEnabled ? CREATE_COMMONJS_REQUIRE_EXPORT : COMMONJS_REQUIRE_EXPORT
+    );
   const deconflictedExportNames = Object.create(null);
   for (const [exportName, { scopes }] of exportsAssignmentsByName) {
     deconflictedExportNames[exportName] = deconflict([...scopes], globals, exportName);
   }
 
+  for (const node of replacedGlobal) {
+    magicString.overwrite(node.start, node.end, `${helpersName}.commonjsGlobal`, {
+      storeName: true
+    });
+  }
+  for (const node of replacedDynamicRequires) {
+    magicString.overwrite(
+      node.start,
+      node.end,
+      isDynamicRequireModulesEnabled
+        ? `${dynamicRequireName}(${JSON.stringify(virtualDynamicRequirePath)})`
+        : dynamicRequireName,
+      {
+        contentOnly: true,
+        storeName: true
+      }
+    );
+  }
+
   // We cannot wrap ES/mixed modules
-  shouldWrap =
-    !isEsModule &&
-    !disableWrap &&
-    (shouldWrap || (uses.exports && moduleExportsAssignments.length > 0));
+  shouldWrap = !isEsModule && (shouldWrap || (uses.exports && moduleExportsAssignments.length > 0));
   const detectWrappedDefault =
     shouldWrap &&
     (topLevelDefineCompiledEsmExpressions.length > 0 || code.indexOf('__esModule') >= 0);
 
   if (
     !(
-      requiredSources.length ||
-      dynamicRegisterSources.size ||
+      shouldWrap ||
+      isRequired ||
       uses.module ||
       uses.exports ||
       uses.require ||
-      usesDynamicRequire ||
-      hasRemovedRequire ||
       topLevelDefineCompiledEsmExpressions.length > 0
     ) &&
     (ignoreGlobal || !uses.global)
@@ -1614,19 +1765,24 @@ function transformCommonjs(
     ? 'exports'
     : 'module';
 
-  const importBlock = rewriteRequireExpressionsAndGetImportBlock(
+  const importBlock = await rewriteRequireExpressionsAndGetImportBlock(
     magicString,
     topLevelDeclarations,
-    topLevelRequireDeclarators,
     reassignedNames,
-    HELPERS_NAME,
-    dynamicRegisterSources,
+    helpersName,
+    dynamicRequireName,
     moduleName,
     exportsName,
     id,
-    exportMode
+    exportMode,
+    resolveRequireSourcesAndUpdateMeta,
+    needsRequireWrapper,
+    isEsModule,
+    isDynamicRequireModulesEnabled,
+    getIgnoreTryCatchRequireStatementMode,
+    commonjsMeta
   );
-
+  const usesRequireWrapper = commonjsMeta.isCommonJS === IS_WRAPPED_COMMONJS;
   const exportBlock = isEsModule
     ? ''
     : rewriteExportsAndGetExportsBlock(
@@ -1641,16 +1797,35 @@ function transformCommonjs(
         topLevelDefineCompiledEsmExpressions,
         deconflictedExportNames,
         code,
-        HELPERS_NAME,
+        helpersName,
         exportMode,
         detectWrappedDefault,
-        defaultIsModuleExports
+        defaultIsModuleExports,
+        usesRequireWrapper,
+        requireName
       );
 
   if (shouldWrap) {
     wrapCode(magicString, uses, moduleName, exportsName);
   }
 
+  if (usesRequireWrapper) {
+    magicString.trim().indent('\t');
+    magicString.prepend(
+      `var ${isRequiredName};
+
+function ${requireName} () {
+\tif (${isRequiredName}) return ${exportsName};
+\t${isRequiredName} = 1;
+`
+    ).append(`
+\treturn ${exportsName};
+}`);
+    if (exportMode === 'replace') {
+      magicString.prepend(`var ${exportsName};\n`);
+    }
+  }
+
   magicString
     .trim()
     .prepend(leadingComment + importBlock)
@@ -1659,24 +1834,29 @@ function transformCommonjs(
   return {
     code: magicString.toString(),
     map: sourceMap ? magicString.generateMap() : null,
-    syntheticNamedExports: isEsModule ? false : '__moduleExports',
-    meta: { commonjs: { isCommonJS: !isEsModule } }
+    syntheticNamedExports: isEsModule || usesRequireWrapper ? false : '__moduleExports',
+    meta: { commonjs: commonjsMeta }
   };
 }
 
+const PLUGIN_NAME = 'commonjs';
+
 function commonjs(options = {}) {
-  const extensions = options.extensions || ['.js'];
-  const filter = pluginutils.createFilter(options.include, options.exclude);
   const {
     ignoreGlobal,
     ignoreDynamicRequires,
     requireReturnsDefault: requireReturnsDefaultOption,
     esmExternals
   } = options;
+  const extensions = options.extensions || ['.js'];
+  const filter = pluginutils.createFilter(options.include, options.exclude);
+  const { strictRequiresFilter, detectCyclesAndConditional } = getStrictRequiresFilter(options);
+
   const getRequireReturnsDefault =
     typeof requireReturnsDefaultOption === 'function'
       ? requireReturnsDefaultOption
       : () => requireReturnsDefaultOption;
+
   let esmExternalIds;
   const isEsmExternal =
     typeof esmExternals === 'function'
@@ -1684,20 +1864,19 @@ function commonjs(options = {}) {
       : Array.isArray(esmExternals)
       ? ((esmExternalIds = new Set(esmExternals)), (id) => esmExternalIds.has(id))
       : () => esmExternals;
+
   const defaultIsModuleExports =
     typeof options.defaultIsModuleExports === 'boolean' ? options.defaultIsModuleExports : 'auto';
 
-  const { dynamicRequireModuleSet, dynamicRequireModuleDirPaths } = getDynamicRequirePaths(
-    options.dynamicRequireTargets
+  const dynamicRequireRoot =
+    typeof options.dynamicRequireRoot === 'string'
+      ? path.resolve(options.dynamicRequireRoot)
+      : process.cwd();
+  const { commonDir, dynamicRequireModules } = getDynamicRequireModules(
+    options.dynamicRequireTargets,
+    dynamicRequireRoot
   );
-  const isDynamicRequireModulesEnabled = dynamicRequireModuleSet.size > 0;
-  const commonDir = isDynamicRequireModulesEnabled
-    ? getCommonDir__default['default'](null, Array.from(dynamicRequireModuleSet).concat(process.cwd()))
-    : null;
-
-  const esModulesWithDefaultExport = new Set();
-  const esModulesWithNamedExports = new Set();
-  const commonJsMetaPromises = new Map();
+  const isDynamicRequireModulesEnabled = dynamicRequireModules.size > 0;
 
   const ignoreRequire =
     typeof options.ignore === 'function'
@@ -1718,7 +1897,7 @@ function commonjs(options = {}) {
 
     return {
       canConvertRequire: mode !== 'remove' && mode !== true,
-      shouldRemoveRequireStatement: mode === 'remove'
+      shouldRemoveRequire: mode === 'remove'
     };
   };
 
@@ -1726,38 +1905,52 @@ function commonjs(options = {}) {
 
   const sourceMap = options.sourceMap !== false;
 
-  function transformAndCheckExports(code, id) {
-    if (isDynamicRequireModulesEnabled && this.getModuleInfo(id).isEntry) {
-      // eslint-disable-next-line no-param-reassign
-      code =
-        getDynamicPackagesEntryIntro(dynamicRequireModuleDirPaths, dynamicRequireModuleSet) + code;
-    }
+  // Initialized in buildStart
+  let requireResolver;
 
+  function transformAndCheckExports(code, id) {
     const { isEsModule, hasDefaultExport, hasNamedExports, ast } = analyzeTopLevelStatements(
       this.parse,
       code,
       id
     );
+
+    const commonjsMeta = this.getModuleInfo(id).meta.commonjs || {};
     if (hasDefaultExport) {
-      esModulesWithDefaultExport.add(id);
+      commonjsMeta.hasDefaultExport = true;
     }
     if (hasNamedExports) {
-      esModulesWithNamedExports.add(id);
+      commonjsMeta.hasNamedExports = true;
     }
 
     if (
-      !dynamicRequireModuleSet.has(normalizePathSlashes(id)) &&
-      (!hasCjsKeywords(code, ignoreGlobal) || (isEsModule && !options.transformMixedEsModules))
+      !dynamicRequireModules.has(normalizePathSlashes(id)) &&
+      (!(hasCjsKeywords(code, ignoreGlobal) || requireResolver.isRequiredId(id)) ||
+        (isEsModule && !options.transformMixedEsModules))
     ) {
-      return { meta: { commonjs: { isCommonJS: false } } };
+      commonjsMeta.isCommonJS = false;
+      return { meta: { commonjs: commonjsMeta } };
     }
 
-    // avoid wrapping as this is a commonjsRegister call
-    const disableWrap = isWrappedId(id, DYNAMIC_REGISTER_SUFFIX);
-    if (disableWrap) {
-      // eslint-disable-next-line no-param-reassign
-      id = unwrapId(id, DYNAMIC_REGISTER_SUFFIX);
-    }
+    const needsRequireWrapper =
+      !isEsModule &&
+      (dynamicRequireModules.has(normalizePathSlashes(id)) || strictRequiresFilter(id));
+
+    const checkDynamicRequire = (position) => {
+      if (id.indexOf(dynamicRequireRoot) !== 0) {
+        this.error(
+          {
+            code: 'DYNAMIC_REQUIRE_OUTSIDE_ROOT',
+            id,
+            dynamicRequireRoot,
+            message: `"${id}" contains dynamic require statements but it is not within the current dynamicRequireRoot "${dynamicRequireRoot}". You should set dynamicRequireRoot to "${path.dirname(
+              id
+            )}" or one of its parent directories.`
+          },
+          position
+        );
+      }
+    };
 
     return transformCommonjs(
       this.parse,
@@ -1770,64 +1963,89 @@ function commonjs(options = {}) {
       getIgnoreTryCatchRequireStatementMode,
       sourceMap,
       isDynamicRequireModulesEnabled,
-      dynamicRequireModuleSet,
-      disableWrap,
+      dynamicRequireModules,
       commonDir,
       ast,
-      defaultIsModuleExports
+      defaultIsModuleExports,
+      needsRequireWrapper,
+      requireResolver.resolveRequireSourcesAndUpdateMeta(this),
+      requireResolver.isRequiredId(id),
+      checkDynamicRequire,
+      commonjsMeta
     );
   }
 
   return {
-    name: 'commonjs',
+    name: PLUGIN_NAME,
+
+    version,
+
+    options(rawOptions) {
+      // We inject the resolver in the beginning so that "catch-all-resolver" like node-resolver
+      // do not prevent our plugin from resolving entry points ot proxies.
+      const plugins = Array.isArray(rawOptions.plugins)
+        ? [...rawOptions.plugins]
+        : rawOptions.plugins
+        ? [rawOptions.plugins]
+        : [];
+      plugins.unshift({
+        name: 'commonjs--resolver',
+        resolveId
+      });
+      return { ...rawOptions, plugins };
+    },
 
-    buildStart() {
-      validateRollupVersion(this.meta.rollupVersion, peerDependencies.rollup);
+    buildStart({ plugins }) {
+      validateVersion(this.meta.rollupVersion, peerDependencies.rollup, 'rollup');
+      const nodeResolve = plugins.find(({ name }) => name === 'node-resolve');
+      if (nodeResolve) {
+        validateVersion(nodeResolve.version, '^13.0.6', '@rollup/plugin-node-resolve');
+      }
       if (options.namedExports != null) {
         this.warn(
           'The namedExports option from "@rollup/plugin-commonjs" is deprecated. Named exports are now handled automatically.'
         );
       }
+      requireResolver = getRequireResolver(extensions, detectCyclesAndConditional);
     },
 
-    resolveId,
+    buildEnd() {
+      if (options.strictRequires === 'debug') {
+        const wrappedIds = requireResolver.getWrappedIds();
+        if (wrappedIds.length) {
+          this.warn({
+            code: 'WRAPPED_IDS',
+            ids: wrappedIds,
+            message: `The commonjs plugin automatically wrapped the following files:\n[\n${wrappedIds
+              .map((id) => `\t${JSON.stringify(path.relative(process.cwd(), id))}`)
+              .join(',\n')}\n]`
+          });
+        } else {
+          this.warn({
+            code: 'WRAPPED_IDS',
+            ids: wrappedIds,
+            message: 'The commonjs plugin did not wrap any files.'
+          });
+        }
+      }
+    },
 
     load(id) {
       if (id === HELPERS_ID) {
-        return getHelpersModule(isDynamicRequireModulesEnabled, ignoreDynamicRequires);
-      }
-
-      if (id.startsWith(HELPERS_ID)) {
-        return getSpecificHelperProxy(id);
+        return getHelpersModule();
       }
 
       if (isWrappedId(id, MODULE_SUFFIX)) {
-        const actualId = unwrapId(id, MODULE_SUFFIX);
-        let name = getName(actualId);
-        let code;
-        if (isDynamicRequireModulesEnabled) {
-          if (['modulePath', 'commonjsRequire', 'createModule'].includes(name)) {
-            name = `${name}_`;
-          }
-          code =
-            `import {commonjsRequire, createModule} from "${HELPERS_ID}";\n` +
-            `var ${name} = createModule(${JSON.stringify(
-              getVirtualPathForDynamicRequirePath(path.dirname(actualId), commonDir)
-            )});\n` +
-            `export {${name} as __module}`;
-        } else {
-          code = `var ${name} = {exports: {}}; export {${name} as __module}`;
-        }
+        const name = getName(unwrapId(id, MODULE_SUFFIX));
         return {
-          code,
+          code: `var ${name} = {exports: {}}; export {${name} as __module}`,
           syntheticNamedExports: '__module',
           meta: { commonjs: { isCommonJS: false } }
         };
       }
 
       if (isWrappedId(id, EXPORTS_SUFFIX)) {
-        const actualId = unwrapId(id, EXPORTS_SUFFIX);
-        const name = getName(actualId);
+        const name = getName(unwrapId(id, EXPORTS_SUFFIX));
         return {
           code: `var ${name} = {}; export {${name} as __exports}`,
           meta: { commonjs: { isCommonJS: false } }
@@ -1842,69 +2060,51 @@ function commonjs(options = {}) {
         );
       }
 
-      if (id === DYNAMIC_PACKAGES_ID) {
-        return getDynamicPackagesModule(dynamicRequireModuleDirPaths, commonDir);
-      }
-
-      if (id.startsWith(DYNAMIC_JSON_PREFIX)) {
-        return getDynamicJsonProxy(id, commonDir);
+      // entry suffix is just appended to not mess up relative external resolution
+      if (id.endsWith(ENTRY_SUFFIX)) {
+        return getEntryProxy(
+          id.slice(0, -ENTRY_SUFFIX.length),
+          defaultIsModuleExports,
+          this.getModuleInfo
+        );
       }
 
-      if (isDynamicModuleImport(id, dynamicRequireModuleSet)) {
-        return `export default require(${JSON.stringify(normalizePathSlashes(id))});`;
+      if (isWrappedId(id, ES_IMPORT_SUFFIX)) {
+        return getEsImportProxy(unwrapId(id, ES_IMPORT_SUFFIX), defaultIsModuleExports);
       }
 
-      if (isWrappedId(id, DYNAMIC_REGISTER_SUFFIX)) {
-        return getDynamicRequireProxy(
-          normalizePathSlashes(unwrapId(id, DYNAMIC_REGISTER_SUFFIX)),
-          commonDir
+      if (id === DYNAMIC_MODULES_ID) {
+        return getDynamicModuleRegistry(
+          isDynamicRequireModulesEnabled,
+          dynamicRequireModules,
+          commonDir,
+          ignoreDynamicRequires
         );
       }
 
       if (isWrappedId(id, PROXY_SUFFIX)) {
         const actualId = unwrapId(id, PROXY_SUFFIX);
-        return getStaticRequireProxy(
-          actualId,
-          getRequireReturnsDefault(actualId),
-          esModulesWithDefaultExport,
-          esModulesWithNamedExports,
-          commonJsMetaPromises
-        );
+        return getStaticRequireProxy(actualId, getRequireReturnsDefault(actualId), this.load);
       }
 
       return null;
     },
 
-    transform(code, rawId) {
-      let id = rawId;
-
-      if (isWrappedId(id, DYNAMIC_REGISTER_SUFFIX)) {
-        id = unwrapId(id, DYNAMIC_REGISTER_SUFFIX);
-      }
+    shouldTransformCachedModule(...args) {
+      return requireResolver.shouldTransformCachedModule.call(this, ...args);
+    },
 
+    transform(code, id) {
       const extName = path.extname(id);
-      if (
-        extName !== '.cjs' &&
-        id !== DYNAMIC_PACKAGES_ID &&
-        !id.startsWith(DYNAMIC_JSON_PREFIX) &&
-        (!filter(id) || !extensions.includes(extName))
-      ) {
+      if (extName !== '.cjs' && (!filter(id) || !extensions.includes(extName))) {
         return null;
       }
 
       try {
-        return transformAndCheckExports.call(this, code, rawId);
+        return transformAndCheckExports.call(this, code, id);
       } catch (err) {
         return this.error(err, err.loc);
       }
-    },
-
-    moduleParsed({ id, meta: { commonjs: commonjsMeta } }) {
-      if (commonjsMeta && commonjsMeta.isCommonJS != null) {
-        setCommonJSMetaPromise(commonJsMetaPromises, id, commonjsMeta);
-        return;
-      }
-      setCommonJSMetaPromise(commonJsMetaPromises, id, null);
     }
   };
 }