@rollup/plugin-commonjs 18.1.0 → 19.0.0

package/dist/index.js

@@ -18,7 +18,7 @@ var MagicString__default = /*#__PURE__*/_interopDefaultLegacy(MagicString);
 var isReference__default = /*#__PURE__*/_interopDefaultLegacy(isReference);
 
 var peerDependencies = {
-	rollup: "^2.30.0"
+	rollup: "^2.38.3"
 };
 
 function tryParse(parse, code, id) {
@@ -92,6 +92,8 @@ 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:';
@@ -138,25 +140,20 @@ export function getAugmentedNamespace(n) {
 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 createCommonjsModule(fn) {
-  var module = { exports: {} }
-	return fn(module, module.exports), module.exports;
-}
-
 export function commonjsRequire (path) {
 	${FAILED_REQUIRE_ERROR}
 }
 `;
 
 const getDynamicHelpers = (ignoreDynamicRequires) => `
-export function createCommonjsModule(fn, basedir, module) {
-	return module = {
-		path: basedir,
+export function createModule(modulePath) {
+	return {
+		path: modulePath,
 		exports: {},
 		require: function (path, base) {
-			return commonjsRequire(path, (base === undefined || base === null) ? module.path : base);
+			return commonjsRequire(path, base == null ? modulePath : base);
 		}
-	}, fn(module, module.exports), module.exports;
+	};
 }
 
 export function commonjsRegister (path, loader) {
@@ -335,16 +332,20 @@ function getHelpersModule(isDynamicRequireModulesEnabled, ignoreDynamicRequires)
 
 /* eslint-disable import/prefer-default-export */
 
-function deconflict(scope, globals, identifier) {
+function deconflict(scopes, globals, identifier) {
   let i = 1;
   let deconflicted = pluginutils.makeLegalIdentifier(identifier);
+  const hasConflicts = () =>
+    scopes.some((scope) => scope.contains(deconflicted)) || globals.has(deconflicted);
 
-  while (scope.contains(deconflicted) || globals.has(deconflicted)) {
+  while (hasConflicts()) {
     deconflicted = pluginutils.makeLegalIdentifier(`${identifier}_${i}`);
     i += 1;
   }
-  // eslint-disable-next-line no-param-reassign
-  scope.declarations[deconflicted] = true;
+
+  for (const scope of scopes) {
+    scope.declarations[deconflicted] = true;
+  }
 
   return deconflicted;
 }
@@ -406,28 +407,18 @@ function getDynamicPackagesEntryIntro(
 ) {
   let dynamicImports = Array.from(
     dynamicRequireModuleSet,
-    (dynamicId) => `require(${JSON.stringify(wrapModuleRegisterProxy(dynamicId))});`
+    (dynamicId) => `require(${JSON.stringify(wrapId(dynamicId, DYNAMIC_REGISTER_SUFFIX))});`
   ).join('\n');
 
   if (dynamicRequireModuleDirPaths.length) {
-    dynamicImports += `require(${JSON.stringify(wrapModuleRegisterProxy(DYNAMIC_PACKAGES_ID))});`;
+    dynamicImports += `require(${JSON.stringify(
+      wrapId(DYNAMIC_PACKAGES_ID, DYNAMIC_REGISTER_SUFFIX)
+    )});`;
   }
 
   return dynamicImports;
 }
 
-function wrapModuleRegisterProxy(id) {
-  return wrapId(id, DYNAMIC_REGISTER_SUFFIX);
-}
-
-function unwrapModuleRegisterProxy(id) {
-  return unwrapId(id, DYNAMIC_REGISTER_SUFFIX);
-}
-
-function isModuleRegisterProxy(id) {
-  return isWrappedId(id, DYNAMIC_REGISTER_SUFFIX);
-}
-
 function isDynamicModuleImport(id, dynamicRequireModuleSet) {
   const normalizedPath = normalizePathSlashes(id);
   return dynamicRequireModuleSet.has(normalizedPath) && !normalizedPath.endsWith('.json');
@@ -460,37 +451,37 @@ function getDynamicRequirePaths(patterns) {
   return { dynamicRequireModuleSet, dynamicRequireModuleDirPaths };
 }
 
-function getIsCjsPromise(isCjsPromises, id) {
-  let isCjsPromise = isCjsPromises.get(id);
-  if (isCjsPromise) return isCjsPromise.promise;
+function getCommonJSMetaPromise(commonJSMetaPromises, id) {
+  let commonJSMetaPromise = commonJSMetaPromises.get(id);
+  if (commonJSMetaPromise) return commonJSMetaPromise.promise;
 
   const promise = new Promise((resolve) => {
-    isCjsPromise = {
+    commonJSMetaPromise = {
       resolve,
       promise: null
     };
-    isCjsPromises.set(id, isCjsPromise);
+    commonJSMetaPromises.set(id, commonJSMetaPromise);
   });
-  isCjsPromise.promise = promise;
+  commonJSMetaPromise.promise = promise;
 
   return promise;
 }
 
-function setIsCjsPromise(isCjsPromises, id, resolution) {
-  const isCjsPromise = isCjsPromises.get(id);
-  if (isCjsPromise) {
-    if (isCjsPromise.resolve) {
-      isCjsPromise.resolve(resolution);
-      isCjsPromise.resolve = null;
+function setCommonJSMetaPromise(commonJSMetaPromises, id, commonjsMeta) {
+  const commonJSMetaPromise = commonJSMetaPromises.get(id);
+  if (commonJSMetaPromise) {
+    if (commonJSMetaPromise.resolve) {
+      commonJSMetaPromise.resolve(commonjsMeta);
+      commonJSMetaPromise.resolve = null;
     }
   } else {
-    isCjsPromises.set(id, { promise: Promise.resolve(resolution), resolve: null });
+    commonJSMetaPromises.set(id, { promise: Promise.resolve(commonjsMeta), resolve: null });
   }
 }
 
 // e.g. id === "commonjsHelpers?commonjsRegister"
 function getSpecificHelperProxy(id) {
-  return `export {${id.split('?')[1]} as default} from '${HELPERS_ID}';`;
+  return `export {${id.split('?')[1]} as default} from "${HELPERS_ID}";`;
 }
 
 function getUnknownRequireProxy(id, requireReturnsDefault) {
@@ -531,16 +522,16 @@ async function getStaticRequireProxy(
   requireReturnsDefault,
   esModulesWithDefaultExport,
   esModulesWithNamedExports,
-  isCjsPromises
+  commonJsMetaPromises
 ) {
   const name = getName(id);
-  const isCjs = await getIsCjsPromise(isCjsPromises, id);
-  if (isCjs) {
-    return `import { __moduleExports } from ${JSON.stringify(id)}; export default __moduleExports;`;
-  } else if (isCjs === null) {
+  const commonjsMeta = await getCommonJSMetaPromise(commonJsMetaPromises, id);
+  if (commonjsMeta && commonjsMeta.isCommonJS) {
+    return `export { __moduleExports as default } from ${JSON.stringify(id)};`;
+  } else if (commonjsMeta === null) {
     return getUnknownRequireProxy(id, requireReturnsDefault);
   } else if (!requireReturnsDefault) {
-    return `import {getAugmentedNamespace} from "${HELPERS_ID}"; import * as ${name} from ${JSON.stringify(
+    return `import { getAugmentedNamespace } from "${HELPERS_ID}"; import * as ${name} from ${JSON.stringify(
       id
     )}; export default /*@__PURE__*/getAugmentedNamespace(${name});`;
   } else if (
@@ -551,7 +542,7 @@ async function getStaticRequireProxy(
   ) {
     return `import * as ${name} from ${JSON.stringify(id)}; export default ${name};`;
   }
-  return `export {default} from ${JSON.stringify(id)};`;
+  return `export { default } from ${JSON.stringify(id)};`;
 }
 
 /* eslint-disable no-param-reassign, no-undefined */
@@ -588,12 +579,17 @@ function getResolveId(extensions) {
   }
 
   return function resolveId(importee, rawImporter) {
+    if (isWrappedId(importee, MODULE_SUFFIX) || isWrappedId(importee, EXPORTS_SUFFIX)) {
+      return importee;
+    }
+
     const importer =
-      rawImporter && isModuleRegisterProxy(rawImporter)
-        ? unwrapModuleRegisterProxy(rawImporter)
+      rawImporter && isWrappedId(rawImporter, DYNAMIC_REGISTER_SUFFIX)
+        ? unwrapId(rawImporter, DYNAMIC_REGISTER_SUFFIX)
         : rawImporter;
 
-    // Proxies are only importing resolved ids, no need to resolve again
+    // Except for exports, proxies are only importing resolved ids,
+    // no need to resolve again
     if (importer && isWrappedId(importer, PROXY_SUFFIX)) {
       return importee;
     }
@@ -607,9 +603,9 @@ function getResolveId(extensions) {
     } else if (isRequiredModule) {
       importee = unwrapId(importee, REQUIRE_SUFFIX);
 
-      isModuleRegistration = isModuleRegisterProxy(importee);
+      isModuleRegistration = isWrappedId(importee, DYNAMIC_REGISTER_SUFFIX);
       if (isModuleRegistration) {
-        importee = unwrapModuleRegisterProxy(importee);
+        importee = unwrapId(importee, DYNAMIC_REGISTER_SUFFIX);
       }
     }
 
@@ -636,7 +632,7 @@ function getResolveId(extensions) {
         resolved.id = wrapId(resolved.id, resolved.external ? EXTERNAL_SUFFIX : PROXY_SUFFIX);
         resolved.external = false;
       } else if (resolved && isModuleRegistration) {
-        resolved.id = wrapModuleRegisterProxy(resolved.id);
+        resolved.id = wrapId(resolved.id, DYNAMIC_REGISTER_SUFFIX);
       } else if (!resolved && (isProxyModule || isRequiredModule)) {
         return { id: wrapId(importee, EXTERNAL_SUFFIX), external: false };
       }
@@ -736,8 +732,6 @@ function isDefineCompiledEsm(node) {
 }
 
 function getDefinePropertyCallName(node, targetName) {
-  const targetNames = targetName.split('.');
-
   const {
     callee: { object, property }
   } = node;
@@ -745,6 +739,7 @@ function getDefinePropertyCallName(node, targetName) {
   if (!property || property.type !== 'Identifier' || property.name !== 'defineProperty') return;
   if (node.arguments.length !== 3) return;
 
+  const targetNames = targetName.split('.');
   const [target, key, value] = node.arguments;
   if (targetNames.length === 1) {
     if (target.type !== 'Identifier' || target.name !== targetNames[0]) {
@@ -771,128 +766,185 @@ function getDefinePropertyCallName(node, targetName) {
   return { key: key.value, value: valueProperty.value };
 }
 
-function isLocallyShadowed(name, scope) {
-  while (scope.parent) {
-    if (scope.declarations[name]) {
-      return true;
-    }
-    // eslint-disable-next-line no-param-reassign
-    scope = scope.parent;
-  }
-  return false;
-}
-
 function isShorthandProperty(parent) {
   return parent && parent.type === 'Property' && parent.shorthand;
 }
 
-function wrapCode(magicString, uses, moduleName, HELPERS_NAME, virtualDynamicRequirePath) {
-  const args = `module${uses.exports ? ', exports' : ''}`;
-
+function wrapCode(magicString, uses, moduleName, exportsName) {
+  const args = [];
+  const passedArgs = [];
+  if (uses.module) {
+    args.push('module');
+    passedArgs.push(moduleName);
+  }
+  if (uses.exports) {
+    args.push('exports');
+    passedArgs.push(exportsName);
+  }
   magicString
     .trim()
-    .prepend(`var ${moduleName} = ${HELPERS_NAME}.createCommonjsModule(function (${args}) {\n`)
-    .append(
-      `\n}${virtualDynamicRequirePath ? `, ${JSON.stringify(virtualDynamicRequirePath)}` : ''});`
-    );
+    .prepend(`(function (${args.join(', ')}) {\n`)
+    .append(`\n}(${passedArgs.join(', ')}));`);
 }
 
 function rewriteExportsAndGetExportsBlock(
   magicString,
   moduleName,
+  exportsName,
   wrapped,
-  topLevelModuleExportsAssignments,
-  topLevelExportsAssignmentsByName,
+  moduleExportsAssignments,
+  firstTopLevelModuleExportsAssignment,
+  exportsAssignmentsByName,
+  topLevelAssignments,
   defineCompiledEsmExpressions,
-  deconflict,
-  isRestorableCompiledEsm,
+  deconflictedExportNames,
   code,
-  uses,
   HELPERS_NAME,
+  exportMode,
+  detectWrappedDefault,
   defaultIsModuleExports
 ) {
-  const namedExportDeclarations = [`export { ${moduleName} as __moduleExports };`];
-  const moduleExportsPropertyAssignments = [];
-  let deconflictedDefaultExportName;
+  const exports = [];
+  const exportDeclarations = [];
+
+  if (exportMode === 'replace') {
+    getExportsForReplacedModuleExports(
+      magicString,
+      exports,
+      exportDeclarations,
+      moduleExportsAssignments,
+      firstTopLevelModuleExportsAssignment,
+      exportsName
+    );
+  } else {
+    exports.push(`${exportsName} as __moduleExports`);
+    if (wrapped) {
+      getExportsWhenWrapping(
+        exportDeclarations,
+        exportsName,
+        detectWrappedDefault,
+        HELPERS_NAME,
+        defaultIsModuleExports
+      );
+    } else {
+      getExports(
+        magicString,
+        exports,
+        exportDeclarations,
+        moduleExportsAssignments,
+        exportsAssignmentsByName,
+        deconflictedExportNames,
+        topLevelAssignments,
+        moduleName,
+        exportsName,
+        defineCompiledEsmExpressions,
+        HELPERS_NAME,
+        defaultIsModuleExports
+      );
+    }
+  }
+  if (exports.length) {
+    exportDeclarations.push(`export { ${exports.join(', ')} };`);
+  }
 
-  if (!wrapped) {
-    let hasModuleExportsAssignment = false;
-    const namedExportProperties = [];
+  return `\n\n${exportDeclarations.join('\n')}`;
+}
 
-    // Collect and rewrite module.exports assignments
-    for (const { left } of topLevelModuleExportsAssignments) {
-      hasModuleExportsAssignment = true;
-      magicString.overwrite(left.start, left.end, `var ${moduleName}`);
-    }
+function getExportsForReplacedModuleExports(
+  magicString,
+  exports,
+  exportDeclarations,
+  moduleExportsAssignments,
+  firstTopLevelModuleExportsAssignment,
+  exportsName
+) {
+  for (const { left } of moduleExportsAssignments) {
+    magicString.overwrite(left.start, left.end, exportsName);
+  }
+  magicString.prependRight(firstTopLevelModuleExportsAssignment.left.start, 'var ');
+  exports.push(`${exportsName} as __moduleExports`);
+  exportDeclarations.push(`export default ${exportsName};`);
+}
 
-    // Collect and rewrite named exports
-    for (const [exportName, node] of topLevelExportsAssignmentsByName) {
-      const deconflicted = deconflict(exportName);
-      magicString.overwrite(node.start, node.left.end, `var ${deconflicted}`);
-
-      if (exportName === 'default') {
-        deconflictedDefaultExportName = deconflicted;
-      } else {
-        namedExportDeclarations.push(
-          exportName === deconflicted
-            ? `export { ${exportName} };`
-            : `export { ${deconflicted} as ${exportName} };`
-        );
-      }
+function getExportsWhenWrapping(
+  exportDeclarations,
+  exportsName,
+  detectWrappedDefault,
+  HELPERS_NAME,
+  defaultIsModuleExports
+) {
+  exportDeclarations.push(
+    `export default ${
+      detectWrappedDefault && defaultIsModuleExports === 'auto'
+        ? `/*@__PURE__*/${HELPERS_NAME}.getDefaultExportFromCjs(${exportsName})`
+        : defaultIsModuleExports === false
+        ? `${exportsName}.default`
+        : exportsName
+    };`
+  );
+}
+
+function getExports(
+  magicString,
+  exports,
+  exportDeclarations,
+  moduleExportsAssignments,
+  exportsAssignmentsByName,
+  deconflictedExportNames,
+  topLevelAssignments,
+  moduleName,
+  exportsName,
+  defineCompiledEsmExpressions,
+  HELPERS_NAME,
+  defaultIsModuleExports
+) {
+  let deconflictedDefaultExportName;
+  // Collect and rewrite module.exports assignments
+  for (const { left } of moduleExportsAssignments) {
+    magicString.overwrite(left.start, left.end, `${moduleName}.exports`);
+  }
 
-      if (hasModuleExportsAssignment) {
-        moduleExportsPropertyAssignments.push(`${moduleName}.${exportName} = ${deconflicted};`);
-      } else {
-        namedExportProperties.push(`\t${exportName}: ${deconflicted}`);
+  // Collect and rewrite named exports
+  for (const [exportName, { nodes }] of exportsAssignmentsByName) {
+    const deconflicted = deconflictedExportNames[exportName];
+    let needsDeclaration = true;
+    for (const node of nodes) {
+      let replacement = `${deconflicted} = ${exportsName}.${exportName}`;
+      if (needsDeclaration && topLevelAssignments.has(node)) {
+        replacement = `var ${replacement}`;
+        needsDeclaration = false;
       }
+      magicString.overwrite(node.start, node.left.end, replacement);
     }
-
-    // Regenerate CommonJS namespace
-    if (!hasModuleExportsAssignment) {
-      const moduleExports = `{\n${namedExportProperties.join(',\n')}\n}`;
-      magicString
-        .trim()
-        .append(
-          `\n\nvar ${moduleName} = ${
-            isRestorableCompiledEsm
-              ? `/*#__PURE__*/Object.defineProperty(${moduleExports}, '__esModule', {value: true})`
-              : moduleExports
-          };`
-        );
+    if (needsDeclaration) {
+      magicString.prepend(`var ${deconflicted};\n`);
     }
-  }
 
-  // Generate default export
-  const defaultExport = [];
-  if (defaultIsModuleExports === 'auto') {
-    if (isRestorableCompiledEsm) {
-      defaultExport.push(`export default ${deconflictedDefaultExportName || moduleName};`);
-    } else if (
-      (wrapped || deconflictedDefaultExportName) &&
-      (defineCompiledEsmExpressions.length > 0 || code.includes('__esModule'))
-    ) {
-      // eslint-disable-next-line no-param-reassign
-      uses.commonjsHelpers = true;
-      defaultExport.push(
-        `export default /*@__PURE__*/${HELPERS_NAME}.getDefaultExportFromCjs(${moduleName});`
-      );
+    if (exportName === 'default') {
+      deconflictedDefaultExportName = deconflicted;
     } else {
-      defaultExport.push(`export default ${moduleName};`);
-    }
-  } else if (defaultIsModuleExports === true) {
-    defaultExport.push(`export default ${moduleName};`);
-  } else if (defaultIsModuleExports === false) {
-    if (deconflictedDefaultExportName) {
-      defaultExport.push(`export default ${deconflictedDefaultExportName};`);
-    } else {
-      defaultExport.push(`export default ${moduleName}.default;`);
+      exports.push(exportName === deconflicted ? exportName : `${deconflicted} as ${exportName}`);
     }
   }
 
-  return `\n\n${defaultExport
-    .concat(namedExportDeclarations)
-    .concat(moduleExportsPropertyAssignments)
-    .join('\n')}`;
+  // Collect and rewrite exports.__esModule assignments
+  let isRestorableCompiledEsm = false;
+  for (const expression of defineCompiledEsmExpressions) {
+    isRestorableCompiledEsm = true;
+    const moduleExportsExpression =
+      expression.type === 'CallExpression' ? expression.arguments[0] : expression.left.object;
+    magicString.overwrite(moduleExportsExpression.start, moduleExportsExpression.end, exportsName);
+  }
+
+  if (!isRestorableCompiledEsm || defaultIsModuleExports === true) {
+    exportDeclarations.push(`export default ${exportsName};`);
+  } else if (moduleExportsAssignments.length === 0 || defaultIsModuleExports === false) {
+    exports.push(`${deconflictedDefaultExportName || exportsName} as default`);
+  } else {
+    exportDeclarations.push(
+      `export default /*@__PURE__*/${HELPERS_NAME}.getDefaultExportFromCjs(${exportsName});`
+    );
+  }
 }
 
 function isRequireStatement(node, scope) {
@@ -1010,44 +1062,46 @@ function getRequireHandlers() {
     topLevelDeclarations,
     topLevelRequireDeclarators,
     reassignedNames,
-    helpersNameIfUsed,
-    dynamicRegisterSources
+    helpersName,
+    dynamicRegisterSources,
+    moduleName,
+    exportsName,
+    id,
+    exportMode
   ) {
-    const removedDeclarators = getDeclaratorsReplacedByImportsAndSetImportNames(
-      topLevelRequireDeclarators,
-      requiredByNode,
-      reassignedNames
-    );
     setRemainingImportNamesAndRewriteRequires(
       requireExpressionsWithUsedReturnValue,
       requiredByNode,
       magicString
     );
-    removeDeclaratorsFromDeclarations(topLevelDeclarations, removedDeclarators, magicString);
-    const importBlock = `${(helpersNameIfUsed
-      ? [`import * as ${helpersNameIfUsed} from '${HELPERS_ID}';`]
-      : []
-    )
-      .concat(
-        // dynamic registers first, as the may be required in the other modules
-        [...dynamicRegisterSources].map((source) => `import '${wrapId(source, REQUIRE_SUFFIX)}';`),
-
-        // now the actual modules so that they are analyzed before creating the proxies;
-        // no need to do this for virtual modules as we never proxy them
-        requiredSources
-          .filter((source) => !source.startsWith('\0'))
-          .map((source) => `import '${wrapId(source, REQUIRE_SUFFIX)}';`),
-
-        // now the proxy modules
-        requiredSources.map((source) => {
-          const { name, nodesUsingRequired } = requiredBySource[source];
-          return `import ${nodesUsingRequired.length ? `${name} from ` : ``}'${
-            source.startsWith('\0') ? source : wrapId(source, PROXY_SUFFIX)
-          }';`;
-        })
-      )
-      .join('\n')}`;
-    return importBlock ? `${importBlock}\n\n` : '';
+    const imports = [];
+    imports.push(`import * as ${helpersName} from "${HELPERS_ID}";`);
+    if (exportMode === 'module') {
+      imports.push(
+        `import { __module as ${moduleName}, exports as ${exportsName} } from ${JSON.stringify(
+          wrapId(id, MODULE_SUFFIX)
+        )}`
+      );
+    } else if (exportMode === 'exports') {
+      imports.push(
+        `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)
+        )};`
+      );
+    }
+    return imports.length ? `${imports.join('\n')}\n\n` : '';
   }
 
   return {
@@ -1057,30 +1111,6 @@ function getRequireHandlers() {
   };
 }
 
-function getDeclaratorsReplacedByImportsAndSetImportNames(
-  topLevelRequireDeclarators,
-  requiredByNode,
-  reassignedNames
-) {
-  const removedDeclarators = new Set();
-  for (const declarator of topLevelRequireDeclarators) {
-    const { required } = requiredByNode.get(declarator.init);
-    if (!required.name) {
-      const potentialName = declarator.id.name;
-      if (
-        !reassignedNames.has(potentialName) &&
-        !required.nodesUsingRequired.some((node) =>
-          isLocallyShadowed(potentialName, requiredByNode.get(node).scope)
-        )
-      ) {
-        required.name = potentialName;
-        removedDeclarators.add(declarator);
-      }
-    }
-  }
-  return removedDeclarators;
-}
-
 function setRemainingImportNamesAndRewriteRequires(
   requireExpressionsWithUsedReturnValue,
   requiredByNode,
@@ -1102,25 +1132,6 @@ function setRemainingImportNamesAndRewriteRequires(
   }
 }
 
-function removeDeclaratorsFromDeclarations(topLevelDeclarations, removedDeclarators, magicString) {
-  for (const declaration of topLevelDeclarations) {
-    let keepDeclaration = false;
-    let [{ start }] = declaration.declarations;
-    for (const declarator of declaration.declarations) {
-      if (removedDeclarators.has(declarator)) {
-        magicString.remove(start, declarator.end);
-      } else if (!keepDeclaration) {
-        magicString.remove(start, declarator.start);
-        keepDeclaration = true;
-      }
-      start = declarator.end;
-    }
-    if (!keepDeclaration) {
-      magicString.remove(declaration.start, declaration.end);
-    }
-  }
-}
-
 /* eslint-disable no-param-reassign, no-shadow, no-underscore-dangle, no-continue */
 
 const exportsPattern = /^(?:module\.)?exports(?:\.([a-zA-Z_$][a-zA-Z_$0-9]*))?$/;
@@ -1150,9 +1161,9 @@ function transformCommonjs(
     module: false,
     exports: false,
     global: false,
-    require: false,
-    commonjsHelpers: false
+    require: false
   };
+  let usesDynamicRequire = false;
   const virtualDynamicRequirePath =
     isDynamicRequireModulesEnabled && getVirtualPathForDynamicRequirePath(path.dirname(id), commonDir);
   let scope = pluginutils.attachScopes(ast, 'scope');
@@ -1160,13 +1171,11 @@ function transformCommonjs(
   let programDepth = 0;
   let currentTryBlockEnd = null;
   let shouldWrap = false;
-  const defineCompiledEsmExpressions = [];
 
   const globals = new Set();
 
   // TODO technically wrong since globals isn't populated yet, but ¯\_(ツ)_/¯
-  const HELPERS_NAME = deconflict(scope, globals, 'commonjsHelpers');
-  const namedExports = {};
+  const HELPERS_NAME = deconflict([scope], globals, 'commonjsHelpers');
   const dynamicRegisterSources = new Set();
   let hasRemovedRequire = false;
 
@@ -1183,8 +1192,13 @@ function transformCommonjs(
   const topLevelDeclarations = [];
   const topLevelRequireDeclarators = new Set();
   const skippedNodes = new Set();
-  const topLevelModuleExportsAssignments = [];
-  const topLevelExportsAssignmentsByName = new Map();
+  const moduleAccessScopes = new Set([scope]);
+  const exportsAccessScopes = new Set([scope]);
+  const moduleExportsAssignments = [];
+  let firstTopLevelModuleExportsAssignment = null;
+  const exportsAssignmentsByName = new Map();
+  const topLevelAssignments = new Set();
+  const topLevelDefineCompiledEsmExpressions = [];
 
   estreeWalker.walk(ast, {
     enter(node, parent) {
@@ -1224,30 +1238,34 @@ function transformCommonjs(
             uses[flattened.name] = true;
 
             // we're dealing with `module.exports = ...` or `[module.]exports.foo = ...` –
-            if (programDepth > 3) {
-              shouldWrap = true;
+            if (flattened.keypath === 'module.exports') {
+              moduleExportsAssignments.push(node);
+              if (programDepth > 3) {
+                moduleAccessScopes.add(scope);
+              } else if (!firstTopLevelModuleExportsAssignment) {
+                firstTopLevelModuleExportsAssignment = node;
+              }
             } else if (exportName === KEY_COMPILED_ESM) {
-              defineCompiledEsmExpressions.push(parent);
-            } else if (flattened.keypath === 'module.exports') {
-              topLevelModuleExportsAssignments.push(node);
-            } else if (!topLevelExportsAssignmentsByName.has(exportName)) {
-              topLevelExportsAssignmentsByName.set(exportName, node);
+              if (programDepth > 3) {
+                shouldWrap = true;
+              } else {
+                topLevelDefineCompiledEsmExpressions.push(node);
+              }
             } else {
-              shouldWrap = true;
+              const exportsAssignments = exportsAssignmentsByName.get(exportName) || {
+                nodes: [],
+                scopes: new Set()
+              };
+              exportsAssignments.nodes.push(node);
+              exportsAssignments.scopes.add(scope);
+              exportsAccessScopes.add(scope);
+              exportsAssignmentsByName.set(exportName, exportsAssignments);
+              if (programDepth <= 3) {
+                topLevelAssignments.add(node);
+              }
             }
 
             skippedNodes.add(node.left);
-
-            if (flattened.keypath === 'module.exports' && node.right.type === 'ObjectExpression') {
-              node.right.properties.forEach((prop) => {
-                if (prop.computed || !('key' in prop) || prop.key.type !== 'Identifier') return;
-                const { name } = prop.key;
-                if (name === pluginutils.makeLegalIdentifier(name)) namedExports[name] = true;
-              });
-              return;
-            }
-
-            if (exportsPatternMatch[1]) namedExports[exportsPatternMatch[1]] = true;
           } else {
             for (const name of pluginutils.extractAssignedNames(node.left)) {
               reassignedNames.add(name);
@@ -1259,7 +1277,7 @@ function transformCommonjs(
             if (programDepth === 3 && parent.type === 'ExpressionStatement') {
               // skip special handling for [module.]exports until we know we render this
               skippedNodes.add(node.arguments[0]);
-              defineCompiledEsmExpressions.push(parent);
+              topLevelDefineCompiledEsmExpressions.push(node);
             } else {
               shouldWrap = true;
             }
@@ -1287,7 +1305,6 @@ function transformCommonjs(
                 storeName: true
               }
             );
-            uses.commonjsHelpers = true;
             return;
           }
 
@@ -1314,13 +1331,13 @@ function transformCommonjs(
             }
 
             let sourceId = getRequireStringArg(node);
-            const isDynamicRegister = isModuleRegisterProxy(sourceId);
+            const isDynamicRegister = isWrappedId(sourceId, DYNAMIC_REGISTER_SUFFIX);
             if (isDynamicRegister) {
-              sourceId = unwrapModuleRegisterProxy(sourceId);
+              sourceId = unwrapId(sourceId, DYNAMIC_REGISTER_SUFFIX);
               if (sourceId.endsWith('.json')) {
                 sourceId = DYNAMIC_JSON_PREFIX + sourceId;
               }
-              dynamicRegisterSources.add(wrapModuleRegisterProxy(sourceId));
+              dynamicRegisterSources.add(wrapId(sourceId, DYNAMIC_REGISTER_SUFFIX));
             } else {
               if (
                 !sourceId.endsWith('.json') &&
@@ -1338,7 +1355,7 @@ function transformCommonjs(
                       path.dirname(id) === '.' ? null /* default behavior */ : virtualDynamicRequirePath
                     )})`
                   );
-                  uses.commonjsHelpers = true;
+                  usesDynamicRequire = true;
                 }
                 return;
               }
@@ -1395,7 +1412,6 @@ function transformCommonjs(
                     magicString.overwrite(node.start, node.end, `${HELPERS_NAME}.commonjsRequire`, {
                       storeName: true
                     });
-                    uses.commonjsHelpers = true;
                   }
                 }
 
@@ -1419,8 +1435,7 @@ function transformCommonjs(
                   });
                 }
               }
-
-              uses.commonjsHelpers = true;
+              usesDynamicRequire = true;
               return;
             case 'module':
             case 'exports':
@@ -1433,11 +1448,12 @@ function transformCommonjs(
                 magicString.overwrite(node.start, node.end, `${HELPERS_NAME}.commonjsGlobal`, {
                   storeName: true
                 });
-                uses.commonjsHelpers = true;
               }
               return;
             case 'define':
-              magicString.overwrite(node.start, node.end, 'undefined', { storeName: true });
+              magicString.overwrite(node.start, node.end, 'undefined', {
+                storeName: true
+              });
               return;
             default:
               globals.add(name);
@@ -1449,7 +1465,6 @@ function transformCommonjs(
             magicString.overwrite(node.start, node.end, `${HELPERS_NAME}.commonjsRequire`, {
               storeName: true
             });
-            uses.commonjsHelpers = true;
             skippedNodes.add(node.object);
             skippedNodes.add(node.property);
           }
@@ -1468,7 +1483,6 @@ function transformCommonjs(
               magicString.overwrite(node.start, node.end, `${HELPERS_NAME}.commonjsGlobal`, {
                 storeName: true
               });
-              uses.commonjsHelpers = true;
             }
           }
           return;
@@ -1485,7 +1499,9 @@ function transformCommonjs(
               flattened.keypath === 'module' ||
               flattened.keypath === 'exports'
             ) {
-              magicString.overwrite(node.start, node.end, `'object'`, { storeName: false });
+              magicString.overwrite(node.start, node.end, `'object'`, {
+                storeName: false
+              });
             }
           }
           return;
@@ -1503,23 +1519,22 @@ function transformCommonjs(
     }
   });
 
-  let isRestorableCompiledEsm = false;
-  if (defineCompiledEsmExpressions.length > 0) {
-    if (!shouldWrap && defineCompiledEsmExpressions.length === 1) {
-      isRestorableCompiledEsm = true;
-      magicString.remove(
-        defineCompiledEsmExpressions[0].start,
-        defineCompiledEsmExpressions[0].end
-      );
-    } else {
-      shouldWrap = true;
-      uses.exports = true;
-    }
+  const nameBase = getName(id);
+  const exportsName = deconflict([...exportsAccessScopes], globals, nameBase);
+  const moduleName = deconflict([...moduleAccessScopes], globals, `${nameBase}Module`);
+  const deconflictedExportNames = Object.create(null);
+  for (const [exportName, { scopes }] of exportsAssignmentsByName) {
+    deconflictedExportNames[exportName] = deconflict([...scopes], globals, exportName);
   }
 
   // We cannot wrap ES/mixed modules
-  shouldWrap = shouldWrap && !disableWrap && !isEsModule;
-  uses.commonjsHelpers = uses.commonjsHelpers || shouldWrap;
+  shouldWrap =
+    !isEsModule &&
+    !disableWrap &&
+    (shouldWrap || (uses.exports && moduleExportsAssignments.length > 0));
+  const detectWrappedDefault =
+    shouldWrap &&
+    (topLevelDefineCompiledEsmExpressions.length > 0 || code.indexOf('__esModule') >= 0);
 
   if (
     !(
@@ -1528,17 +1543,15 @@ function transformCommonjs(
       uses.module ||
       uses.exports ||
       uses.require ||
-      uses.commonjsHelpers ||
+      usesDynamicRequire ||
       hasRemovedRequire ||
-      isRestorableCompiledEsm
+      topLevelDefineCompiledEsmExpressions.length > 0
     ) &&
     (ignoreGlobal || !uses.global)
   ) {
     return { meta: { commonjs: { isCommonJS: false } } };
   }
 
-  const moduleName = deconflict(scope, globals, getName(id));
-
   let leadingComment = '';
   if (code.startsWith('/*')) {
     const commentEnd = code.indexOf('*/', 2) + 2;
@@ -1546,34 +1559,53 @@ function transformCommonjs(
     magicString.remove(0, commentEnd).trim();
   }
 
+  const exportMode = shouldWrap
+    ? uses.module
+      ? 'module'
+      : 'exports'
+    : firstTopLevelModuleExportsAssignment
+    ? exportsAssignmentsByName.size === 0 && topLevelDefineCompiledEsmExpressions.length === 0
+      ? 'replace'
+      : 'module'
+    : moduleExportsAssignments.length === 0
+    ? 'exports'
+    : 'module';
+
+  const importBlock = rewriteRequireExpressionsAndGetImportBlock(
+    magicString,
+    topLevelDeclarations,
+    topLevelRequireDeclarators,
+    reassignedNames,
+    HELPERS_NAME,
+    dynamicRegisterSources,
+    moduleName,
+    exportsName,
+    id,
+    exportMode
+  );
+
   const exportBlock = isEsModule
     ? ''
     : rewriteExportsAndGetExportsBlock(
         magicString,
         moduleName,
+        exportsName,
         shouldWrap,
-        topLevelModuleExportsAssignments,
-        topLevelExportsAssignmentsByName,
-        defineCompiledEsmExpressions,
-        (name) => deconflict(scope, globals, name),
-        isRestorableCompiledEsm,
+        moduleExportsAssignments,
+        firstTopLevelModuleExportsAssignment,
+        exportsAssignmentsByName,
+        topLevelAssignments,
+        topLevelDefineCompiledEsmExpressions,
+        deconflictedExportNames,
         code,
-        uses,
         HELPERS_NAME,
+        exportMode,
+        detectWrappedDefault,
         defaultIsModuleExports
       );
 
-  const importBlock = rewriteRequireExpressionsAndGetImportBlock(
-    magicString,
-    topLevelDeclarations,
-    topLevelRequireDeclarators,
-    reassignedNames,
-    uses.commonjsHelpers && HELPERS_NAME,
-    dynamicRegisterSources
-  );
-
   if (shouldWrap) {
-    wrapCode(magicString, uses, moduleName, HELPERS_NAME, virtualDynamicRequirePath);
+    wrapCode(magicString, uses, moduleName, exportsName);
   }
 
   magicString
@@ -1622,7 +1654,7 @@ function commonjs(options = {}) {
 
   const esModulesWithDefaultExport = new Set();
   const esModulesWithNamedExports = new Set();
-  const isCjsPromises = new Map();
+  const commonJsMetaPromises = new Map();
 
   const ignoreRequire =
     typeof options.ignore === 'function'
@@ -1675,13 +1707,11 @@ function commonjs(options = {}) {
       return { meta: { commonjs: { isCommonJS: false } } };
     }
 
-    let disableWrap = false;
-
-    // avoid wrapping in createCommonjsModule, as this is a commonjsRegister call
-    if (isModuleRegisterProxy(id)) {
-      disableWrap = true;
+    // 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 = unwrapModuleRegisterProxy(id);
+      id = unwrapId(id, DYNAMIC_REGISTER_SUFFIX);
     }
 
     return transformCommonjs(
@@ -1726,6 +1756,39 @@ function commonjs(options = {}) {
         return getSpecificHelperProxy(id);
       }
 
+      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}`;
+        }
+        return {
+          code,
+          syntheticNamedExports: '__module',
+          meta: { commonjs: { isCommonJS: false } }
+        };
+      }
+
+      if (isWrappedId(id, EXPORTS_SUFFIX)) {
+        const actualId = unwrapId(id, EXPORTS_SUFFIX);
+        const name = getName(actualId);
+        return {
+          code: `var ${name} = {}; export {${name} as __exports}`,
+          meta: { commonjs: { isCommonJS: false } }
+        };
+      }
+
       if (isWrappedId(id, EXTERNAL_SUFFIX)) {
         const actualId = unwrapId(id, EXTERNAL_SUFFIX);
         return getUnknownRequireProxy(
@@ -1746,9 +1809,9 @@ function commonjs(options = {}) {
         return `export default require(${JSON.stringify(normalizePathSlashes(id))});`;
       }
 
-      if (isModuleRegisterProxy(id)) {
+      if (isWrappedId(id, DYNAMIC_REGISTER_SUFFIX)) {
         return getDynamicRequireProxy(
-          normalizePathSlashes(unwrapModuleRegisterProxy(id)),
+          normalizePathSlashes(unwrapId(id, DYNAMIC_REGISTER_SUFFIX)),
           commonDir
         );
       }
@@ -1760,7 +1823,7 @@ function commonjs(options = {}) {
           getRequireReturnsDefault(actualId),
           esModulesWithDefaultExport,
           esModulesWithNamedExports,
-          isCjsPromises
+          commonJsMetaPromises
         );
       }
 
@@ -1770,8 +1833,8 @@ function commonjs(options = {}) {
     transform(code, rawId) {
       let id = rawId;
 
-      if (isModuleRegisterProxy(id)) {
-        id = unwrapModuleRegisterProxy(id);
+      if (isWrappedId(id, DYNAMIC_REGISTER_SUFFIX)) {
+        id = unwrapId(id, DYNAMIC_REGISTER_SUFFIX);
       }
 
       const extName = path.extname(id);
@@ -1791,16 +1854,12 @@ function commonjs(options = {}) {
       }
     },
 
-    // eslint-disable-next-line no-shadow
-    moduleParsed({ id, meta: { commonjs } }) {
-      if (commonjs) {
-        const isCjs = commonjs.isCommonJS;
-        if (isCjs != null) {
-          setIsCjsPromise(isCjsPromises, id, isCjs);
-          return;
-        }
+    moduleParsed({ id, meta: { commonjs: commonjsMeta } }) {
+      if (commonjsMeta && commonjsMeta.isCommonJS != null) {
+        setCommonJSMetaPromise(commonJsMetaPromises, id, commonjsMeta);
+        return;
       }
-      setIsCjsPromise(isCjsPromises, id, null);
+      setCommonJSMetaPromise(commonJsMetaPromises, id, null);
     }
   };
 }