@rollup/plugin-commonjs 22.0.0-1 → 22.0.0-10

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

@@ -16,9 +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-1";
+var version = " 22.0.0-10";
 var peerDependencies = {
-	rollup: "^2.60.0"
+	rollup: "^2.67.0"
 };
 
 function tryParse(parse, code, id) {
@@ -203,6 +203,9 @@ function getDynamicRequireModules(patterns, dynamicRequireRoot) {
 
 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 COMMONJS_REQUIRE_EXPORT = 'commonjsRequire';
+const CREATE_COMMONJS_REQUIRE_EXPORT = 'createCommonjsRequire';
+
 function getDynamicModuleRegistry(
   isDynamicRequireModulesEnabled,
   dynamicRequireModules,
@@ -210,7 +213,7 @@ function getDynamicModuleRegistry(
   ignoreDynamicRequires
 ) {
   if (!isDynamicRequireModulesEnabled) {
-    return `export function commonjsRequire(path) {
+    return `export function ${COMMONJS_REQUIRE_EXPORT}(path) {
 	${FAILED_REQUIRE_ERROR}
 }`;
   }
@@ -240,25 +243,25 @@ ${dynamicModuleProps}
 	});
 }
 
-export function commonjsRequire(path, originalModuleDir) {
-	var resolvedPath = commonjsResolveImpl(path, originalModuleDir);
-	if (resolvedPath !== null) {
-		return getDynamicModules()[resolvedPath]();
+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}
 	}
-	${ignoreDynamicRequires ? 'return require(path);' : FAILED_REQUIRE_ERROR}
-}
-
-function commonjsResolve (path, originalModuleDir) {
-	const resolvedPath = commonjsResolveImpl(path, originalModuleDir);
-	if (resolvedPath !== null) {
-		return resolvedPath;
+	handleRequire.resolve = function (path) {
+		var resolvedPath = commonjsResolve(path, originalModuleDir);
+		if (resolvedPath !== null) {
+			return resolvedPath;
+		}
+		return require.resolve(path);
 	}
-	return require.resolve(path);
+	return handleRequire;
 }
 
-commonjsRequire.resolve = commonjsResolve;
-
-function commonjsResolveImpl (path, originalModuleDir) {
+function commonjsResolve (path, originalModuleDir) {
 	var shouldTryNodeModules = isPossibleNodeModulesPath(path);
 	path = normalize(path);
 	var relPath;
@@ -334,7 +337,8 @@ const WRAPPED_SUFFIX = '?commonjs-wrapped';
 const EXTERNAL_SUFFIX = '?commonjs-external';
 const EXPORTS_SUFFIX = '?commonjs-exports';
 const MODULE_SUFFIX = '?commonjs-module';
-const ES_IMPORT_SUFFIX = '?es-import';
+const ENTRY_SUFFIX = '?commonjs-entry';
+const ES_IMPORT_SUFFIX = '?commonjs-es-import';
 
 const DYNAMIC_MODULES_ID = '\0commonjs-dynamic-modules';
 const HELPERS_ID = '\0commonjsHelpers.js';
@@ -402,21 +406,15 @@ function getUnknownRequireProxy(id, requireReturnsDefault) {
   return `import * as ${name} from ${JSON.stringify(id)}; ${exported}`;
 }
 
-async function getStaticRequireProxy(
-  id,
-  requireReturnsDefault,
-  esModulesWithDefaultExport,
-  esModulesWithNamedExports,
-  loadModule
-) {
+async function getStaticRequireProxy(id, requireReturnsDefault, loadModule) {
   const name = getName(id);
   const {
     meta: { commonjs: commonjsMeta }
   } = await loadModule({ id });
-  if (commonjsMeta && commonjsMeta.isCommonJS) {
-    return `export { __moduleExports as default } from ${JSON.stringify(id)};`;
-  } else if (!commonjsMeta) {
+  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
@@ -424,14 +422,30 @@ 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`;
@@ -487,11 +501,9 @@ function resolveExtensions(importee, importer, extensions) {
 
 function getResolveId(extensions) {
   return async function resolveId(importee, importer, resolveOptions) {
-    if (
-      resolveOptions.custom &&
-      resolveOptions.custom.commonjs &&
-      resolveOptions.custom.commonjs.skipResolver
-    ) {
+    // 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)) {
@@ -499,6 +511,7 @@ function getResolveId(extensions) {
     }
 
     if (
+      importee.endsWith(ENTRY_SUFFIX) ||
       isWrappedId(importee, MODULE_SUFFIX) ||
       isWrappedId(importee, EXPORTS_SUFFIX) ||
       isWrappedId(importee, PROXY_SUFFIX) ||
@@ -515,7 +528,8 @@ function getResolveId(extensions) {
         importer === DYNAMIC_MODULES_ID ||
         // Proxies are only importing resolved ids, no need to resolve again
         isWrappedId(importer, PROXY_SUFFIX) ||
-        isWrappedId(importer, ES_IMPORT_SUFFIX)
+        isWrappedId(importer, ES_IMPORT_SUFFIX) ||
+        importer.endsWith(ENTRY_SUFFIX)
       ) {
         return importee;
       }
@@ -535,22 +549,27 @@ function getResolveId(extensions) {
 
     // 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 customOptions = resolveOptions.custom;
-
-    // If this is a require, we do not need a proxy
-    if (customOptions && customOptions['node-resolve'] && customOptions['node-resolve'].isRequire) {
-      return null;
-    }
-
     const resolved =
       (await this.resolve(importee, importer, Object.assign({ skipSelf: true }, resolveOptions))) ||
       resolveExtensions(importee, importer, extensions);
-    if (!resolved || resolved.external) {
+    // 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 }
-    } = await this.load(resolved);
+    } = moduleInfo;
     if (commonjsMeta && commonjsMeta.isCommonJS === IS_WRAPPED_COMMONJS) {
       return wrapId(resolved.id, ES_IMPORT_SUFFIX);
     }
@@ -558,14 +577,73 @@ function getResolveId(extensions) {
   };
 }
 
-function getResolveRequireSourcesAndGetMeta(extensions, detectCyclesAndConditional) {
+function getRequireResolver(extensions, detectCyclesAndConditional) {
   const knownCjsModuleTypes = Object.create(null);
   const requiredIds = Object.create(null);
   const unconditionallyRequiredIds = Object.create(null);
-  const parentModules = Object.create(null);
-  const childModules = Object.create(null);
-  const getParentModules = (id) => parentModules[id] || (parentModules[id] = Object.create(null));
-  const getChildModules = (id) => childModules[id] || (childModules[id] = Object.create(null));
+  const dependencies = Object.create(null);
+  const getDependencies = (id) => dependencies[id] || (dependencies[id] = new Set());
+
+  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 fullyAnalyzedModules = Object.create(null);
+
+  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 (
+      detectCyclesAndConditional &&
+      knownCjsModuleTypes[id] === true &&
+      requiredIds[id] &&
+      !unconditionallyRequiredIds[id]
+    ) {
+      knownCjsModuleTypes[id] = IS_WRAPPED_COMMONJS;
+    }
+  };
+
+  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 {
     getWrappedIds: () =>
@@ -573,19 +651,40 @@ function getResolveRequireSourcesAndGetMeta(extensions, detectCyclesAndCondition
         (id) => knownCjsModuleTypes[id] === IS_WRAPPED_COMMONJS
       ),
     isRequiredId: (id) => requiredIds[id],
-    resolveRequireSourcesAndGetMeta: (rollupContext) => async (
+    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;
+      }
+      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;
+      }
+      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
     ) => {
-      knownCjsModuleTypes[parentId] = knownCjsModuleTypes[parentId] || isParentCommonJS;
-      if (
-        knownCjsModuleTypes[parentId] &&
-        requiredIds[parentId] &&
-        !unconditionallyRequiredIds[parentId]
-      ) {
-        knownCjsModuleTypes[parentId] = IS_WRAPPED_COMMONJS;
-      }
+      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
@@ -594,10 +693,7 @@ function getResolveRequireSourcesAndGetMeta(extensions, detectCyclesAndCondition
           }
           const resolved =
             (await rollupContext.resolve(source, parentId, {
-              custom: {
-                'node-resolve': { isRequire: true },
-                commonjs: { skipResolver: true }
-              }
+              custom: { 'node-resolve': { isRequire: true } }
             })) || resolveExtensions(source, parentId, extensions);
           if (!resolved) {
             return { id: wrapId(source, EXTERNAL_SUFFIX), allowProxy: false };
@@ -606,96 +702,58 @@ function getResolveRequireSourcesAndGetMeta(extensions, detectCyclesAndCondition
           if (resolved.external) {
             return { id: wrapId(childId, EXTERNAL_SUFFIX), allowProxy: false };
           }
-          requiredIds[childId] = true;
-          if (
-            !(
-              detectCyclesAndConditional &&
-              (isConditional || knownCjsModuleTypes[parentId] === IS_WRAPPED_COMMONJS)
-            )
-          ) {
-            unconditionallyRequiredIds[childId] = true;
-          }
-          const parentDependentModules = getParentModules(parentId);
-          const childDependentModules = getParentModules(childId);
-
-          // Copy the parents of the current parent to the child
-          for (const dependentId of Object.keys(parentDependentModules)) {
-            childDependentModules[dependentId] = true;
-          }
-
-          // Add the current parent to the child as well. If the child module already has known
-          // dependencies because it has already been loaded, add the current parent module to their
-          // parent modules
-          childDependentModules[parentId] = true;
-          const dependenciesToUpdate = new Set(Object.keys(getChildModules(childId)));
-          for (const dependencyId of dependenciesToUpdate) {
-            getParentModules(dependencyId)[parentId] = true;
-            for (const subDependencyId of Object.keys(getChildModules(dependencyId))) {
-              dependenciesToUpdate.add(subDependencyId);
-            }
-          }
-
-          // Add the child as a dependency to the parent
-          getChildModules(parentId)[childId] = true;
-
-          // If we depend on one of our dependencies, we have a cycle. Then all modules that
-          // we depend on that also depend on the same module are part of a cycle as well. Trying
-          // to wait for loading this module would lead to a deadlock.
-          if (parentDependentModules[childId]) {
-            if (detectCyclesAndConditional && isParentCommonJS) {
-              knownCjsModuleTypes[parentId] = IS_WRAPPED_COMMONJS;
-              knownCjsModuleTypes[childId] = IS_WRAPPED_COMMONJS;
-              for (const dependentId of Object.keys(parentDependentModules)) {
-                if (getParentModules(dependentId)[childId]) {
-                  knownCjsModuleTypes[dependentId] = IS_WRAPPED_COMMONJS;
-                }
-              }
-            }
-          } else {
-            // 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 rollupContext.load(resolved);
-          }
+          parentMeta.requires.push({ resolved, isConditional });
+          await setTypesForRequiredModules(parentId, resolved, isConditional, rollupContext.load);
           return { id: childId, allowProxy: true };
         })
       );
-      return {
-        requireTargets: requireTargets.map(({ id: dependencyId, allowProxy }, index) => {
-          const isCommonJS = knownCjsModuleTypes[dependencyId];
-          return {
-            source: sources[index].source,
-            id: allowProxy
-              ? isCommonJS === IS_WRAPPED_COMMONJS
-                ? wrapId(dependencyId, WRAPPED_SUFFIX)
-                : wrapId(dependencyId, PROXY_SUFFIX)
-              : dependencyId,
-            isCommonJS
-          };
-        }),
-        usesRequireWrapper: knownCjsModuleTypes[parentId] === IS_WRAPPED_COMMONJS
-      };
+      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}.`
     );
   }
 }
@@ -1138,17 +1196,20 @@ function getRequireHandlers() {
     exportsName,
     id,
     exportMode,
-    resolveRequireSourcesAndGetMeta,
+    resolveRequireSourcesAndUpdateMeta,
     needsRequireWrapper,
     isEsModule,
-    usesRequire,
-    getIgnoreTryCatchRequireStatementMode
+    isDynamicRequireModulesEnabled,
+    getIgnoreTryCatchRequireStatementMode,
+    commonjsMeta
   ) {
     const imports = [];
     imports.push(`import * as ${helpersName} from "${HELPERS_ID}";`);
-    if (usesRequire) {
+    if (dynamicRequireName) {
       imports.push(
-        `import { commonjsRequire as ${dynamicRequireName} } from "${DYNAMIC_MODULES_ID}";`
+        `import { ${
+          isDynamicRequireModulesEnabled ? CREATE_COMMONJS_REQUIRE_EXPORT : COMMONJS_REQUIRE_EXPORT
+        } as ${dynamicRequireName} } from "${DYNAMIC_MODULES_ID}";`
       );
     }
     if (exportMode === 'module') {
@@ -1163,9 +1224,10 @@ function getRequireHandlers() {
       );
     }
     const requiresBySource = collectSources(requireExpressions);
-    const { requireTargets, usesRequireWrapper } = await resolveRequireSourcesAndGetMeta(
+    const requireTargets = await resolveRequireSourcesAndUpdateMeta(
       id,
       needsRequireWrapper ? IS_WRAPPED_COMMONJS : !isEsModule,
+      commonjsMeta,
       Object.keys(requiresBySource).map((source) => {
         return {
           source,
@@ -1180,10 +1242,7 @@ function getRequireHandlers() {
       getIgnoreTryCatchRequireStatementMode,
       magicString
     );
-    return {
-      importBlock: imports.length ? `${imports.join('\n')}\n\n` : '',
-      usesRequireWrapper
-    };
+    return imports.length ? `${imports.join('\n')}\n\n` : '';
   }
 
   return {
@@ -1286,9 +1345,10 @@ async function transformCommonjs(
   astCache,
   defaultIsModuleExports,
   needsRequireWrapper,
-  resolveRequireSourcesAndGetMeta,
+  resolveRequireSourcesAndUpdateMeta,
   isRequired,
-  checkDynamicRequire
+  checkDynamicRequire,
+  commonjsMeta
 ) {
   const ast = astCache || tryParse(parse, code, id);
   const magicString = new MagicString__default["default"](code);
@@ -1329,6 +1389,7 @@ async function transformCommonjs(
   const topLevelDefineCompiledEsmExpressions = [];
   const replacedGlobal = [];
   const replacedDynamicRequires = [];
+  const importedVariables = new Set();
 
   estreeWalker.walk(ast, {
     enter(node, parent) {
@@ -1434,20 +1495,19 @@ async function transformCommonjs(
             isRequire(node.callee.object, scope) &&
             node.callee.property.name === 'resolve'
           ) {
-            checkDynamicRequire();
+            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
-              )}`
-            );
             replacedDynamicRequires.push(requireNode);
             return;
           }
 
           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;
           }
 
@@ -1456,15 +1516,9 @@ async function transformCommonjs(
 
           if (hasDynamicArguments(node)) {
             if (isDynamicRequireModulesEnabled) {
-              magicString.appendLeft(
-                node.end - 1,
-                `, ${JSON.stringify(
-                  path.dirname(id) === '.' ? null /* default behavior */ : virtualDynamicRequirePath
-                )}`
-              );
+              checkDynamicRequire(node.start);
             }
             if (!ignoreDynamicRequires) {
-              checkDynamicRequire();
               replacedDynamicRequires.push(node.callee);
             }
             return;
@@ -1482,6 +1536,11 @@ async function transformCommonjs(
               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);
+              }
+            }
           }
           return;
         }
@@ -1522,7 +1581,6 @@ async function transformCommonjs(
                 return;
               }
               if (!ignoreDynamicRequires) {
-                checkDynamicRequire();
                 if (isShorthandProperty(parent)) {
                   magicString.prependRight(node.start, 'require: ');
                 }
@@ -1606,9 +1664,10 @@ async 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
@@ -1636,7 +1695,13 @@ async function transformCommonjs(
   const requireName = deconflict([scope], globals, `require${capitalize(nameBase)}`);
   const isRequiredName = deconflict([scope], globals, `hasRequired${capitalize(nameBase)}`);
   const helpersName = deconflict([scope], globals, 'commonjsHelpers');
-  const dynamicRequireName = deconflict([scope], globals, 'commonjsRequire');
+  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);
@@ -1648,10 +1713,17 @@ async function transformCommonjs(
     });
   }
   for (const node of replacedDynamicRequires) {
-    magicString.overwrite(node.start, node.end, dynamicRequireName, {
-      contentOnly: true,
-      storeName: true
-    });
+    magicString.overwrite(
+      node.start,
+      node.end,
+      isDynamicRequireModulesEnabled
+        ? `${dynamicRequireName}(${JSON.stringify(virtualDynamicRequirePath)})`
+        : dynamicRequireName,
+      {
+        contentOnly: true,
+        storeName: true
+      }
+    );
   }
 
   // We cannot wrap ES/mixed modules
@@ -1671,7 +1743,7 @@ async function transformCommonjs(
     ) &&
     (ignoreGlobal || !uses.global)
   ) {
-    return { meta: { commonjs: { isCommonJS: false, isMixedModule: false } } };
+    return { meta: { commonjs: { isCommonJS: false } } };
   }
 
   let leadingComment = '';
@@ -1693,7 +1765,7 @@ async function transformCommonjs(
     ? 'exports'
     : 'module';
 
-  const { importBlock, usesRequireWrapper } = await rewriteRequireExpressionsAndGetImportBlock(
+  const importBlock = await rewriteRequireExpressionsAndGetImportBlock(
     magicString,
     topLevelDeclarations,
     reassignedNames,
@@ -1703,12 +1775,14 @@ async function transformCommonjs(
     exportsName,
     id,
     exportMode,
-    resolveRequireSourcesAndGetMeta,
+    resolveRequireSourcesAndUpdateMeta,
     needsRequireWrapper,
     isEsModule,
-    uses.require,
-    getIgnoreTryCatchRequireStatementMode
+    isDynamicRequireModulesEnabled,
+    getIgnoreTryCatchRequireStatementMode,
+    commonjsMeta
   );
+  const usesRequireWrapper = commonjsMeta.isCommonJS === IS_WRAPPED_COMMONJS;
   const exportBlock = isEsModule
     ? ''
     : rewriteExportsAndGetExportsBlock(
@@ -1761,15 +1835,12 @@ function ${requireName} () {
     code: magicString.toString(),
     map: sourceMap ? magicString.generateMap() : null,
     syntheticNamedExports: isEsModule || usesRequireWrapper ? false : '__moduleExports',
-    meta: {
-      commonjs: {
-        isCommonJS: !isEsModule && (usesRequireWrapper ? IS_WRAPPED_COMMONJS : true),
-        isMixedModule: isEsModule
-      }
-    }
+    meta: { commonjs: commonjsMeta }
   };
 }
 
+const PLUGIN_NAME = 'commonjs';
+
 function commonjs(options = {}) {
   const {
     ignoreGlobal,
@@ -1797,11 +1868,6 @@ function commonjs(options = {}) {
   const defaultIsModuleExports =
     typeof options.defaultIsModuleExports === 'boolean' ? options.defaultIsModuleExports : 'auto';
 
-  const {
-    resolveRequireSourcesAndGetMeta,
-    getWrappedIds,
-    isRequiredId
-  } = getResolveRequireSourcesAndGetMeta(extensions, detectCyclesAndConditional);
   const dynamicRequireRoot =
     typeof options.dynamicRequireRoot === 'string'
       ? path.resolve(options.dynamicRequireRoot)
@@ -1812,9 +1878,6 @@ function commonjs(options = {}) {
   );
   const isDynamicRequireModulesEnabled = dynamicRequireModules.size > 0;
 
-  const esModulesWithDefaultExport = new Set();
-  const esModulesWithNamedExports = new Set();
-
   const ignoreRequire =
     typeof options.ignore === 'function'
       ? options.ignore
@@ -1842,41 +1905,50 @@ function commonjs(options = {}) {
 
   const sourceMap = options.sourceMap !== false;
 
+  // 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 (
       !dynamicRequireModules.has(normalizePathSlashes(id)) &&
-      (!(hasCjsKeywords(code, ignoreGlobal) || isRequiredId(id)) ||
+      (!(hasCjsKeywords(code, ignoreGlobal) || requireResolver.isRequiredId(id)) ||
         (isEsModule && !options.transformMixedEsModules))
     ) {
-      return { meta: { commonjs: { isCommonJS: false } } };
+      commonjsMeta.isCommonJS = false;
+      return { meta: { commonjs: commonjsMeta } };
     }
 
     const needsRequireWrapper =
       !isEsModule &&
       (dynamicRequireModules.has(normalizePathSlashes(id)) || strictRequiresFilter(id));
 
-    const checkDynamicRequire = () => {
+    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.`
-        });
+        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
+        );
       }
     };
 
@@ -1896,14 +1968,15 @@ function commonjs(options = {}) {
       ast,
       defaultIsModuleExports,
       needsRequireWrapper,
-      resolveRequireSourcesAndGetMeta(this),
-      isRequiredId(id),
-      checkDynamicRequire
+      requireResolver.resolveRequireSourcesAndUpdateMeta(this),
+      requireResolver.isRequiredId(id),
+      checkDynamicRequire,
+      commonjsMeta
     );
   }
 
   return {
-    name: 'commonjs',
+    name: PLUGIN_NAME,
 
     version,
 
@@ -1911,7 +1984,7 @@ function commonjs(options = {}) {
       // 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
         ? [rawOptions.plugins]
         : [];
@@ -1922,18 +1995,23 @@ function commonjs(options = {}) {
       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);
     },
 
     buildEnd() {
       if (options.strictRequires === 'debug') {
-        const wrappedIds = getWrappedIds();
+        const wrappedIds = requireResolver.getWrappedIds();
         if (wrappedIds.length) {
           this.warn({
             code: 'WRAPPED_IDS',
@@ -1982,6 +2060,15 @@ function commonjs(options = {}) {
         );
       }
 
+      // 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 (isWrappedId(id, ES_IMPORT_SUFFIX)) {
         return getEsImportProxy(unwrapId(id, ES_IMPORT_SUFFIX), defaultIsModuleExports);
       }
@@ -1997,18 +2084,16 @@ function commonjs(options = {}) {
 
       if (isWrappedId(id, PROXY_SUFFIX)) {
         const actualId = unwrapId(id, PROXY_SUFFIX);
-        return getStaticRequireProxy(
-          actualId,
-          getRequireReturnsDefault(actualId),
-          esModulesWithDefaultExport,
-          esModulesWithNamedExports,
-          this.load
-        );
+        return getStaticRequireProxy(actualId, getRequireReturnsDefault(actualId), this.load);
       }
 
       return null;
     },
 
+    shouldTransformCachedModule(...args) {
+      return requireResolver.shouldTransformCachedModule.call(this, ...args);
+    },
+
     transform(code, id) {
       const extName = path.extname(id);
       if (extName !== '.cjs' && (!filter(id) || !extensions.includes(extName))) {