@rollup/plugin-commonjs 22.0.0-9 → 22.0.0

package/dist/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-9";
+var version = "22.0.0";
 var peerDependencies = {
-	rollup: "^2.67.0"
+	rollup: "^2.68.0"
 };
 
 function tryParse(parse, code, id) {
@@ -462,8 +462,7 @@ function getEsImportProxy(id, defaultIsModuleExports) {
   }
   return {
     code,
-    syntheticNamedExports: '__moduleExports',
-    meta: { commonjs: { isCommonJS: false } }
+    syntheticNamedExports: '__moduleExports'
   };
 }
 
@@ -500,84 +499,119 @@ function resolveExtensions(importee, importer, extensions) {
 }
 
 function getResolveId(extensions) {
-  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 currentlyResolving = new Map();
 
-    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;
-    }
+  return {
+    /**
+     * This is a Maps of importers to Sets of require sources being resolved at
+     * the moment by resolveRequireSourcesAndUpdateMeta
+     */
+    currentlyResolving,
+    async resolveId(importee, importer, resolveOptions) {
+      const customOptions = resolveOptions.custom;
+      // All logic below is specific to ES imports.
+      // Also, if we do not skip this logic for requires that are resolved while
+      // transforming a commonjs file, it can easily lead to deadlocks.
+      if (
+        customOptions &&
+        customOptions['node-resolve'] &&
+        customOptions['node-resolve'].isRequire
+      ) {
+        return null;
+      }
+      const currentlyResolvingForParent = currentlyResolving.get(importer);
+      if (currentlyResolvingForParent && currentlyResolvingForParent.has(importee)) {
+        this.warn({
+          code: 'THIS_RESOLVE_WITHOUT_OPTIONS',
+          message:
+            'It appears a plugin has implemented a "resolveId" hook that uses "this.resolve" without forwarding the third "options" parameter of "resolveId". This is problematic as it can lead to wrong module resolutions especially for the node-resolve plugin and in certain cases cause early exit errors for the commonjs plugin.\nIn rare cases, this warning can appear if the same file is both imported and required from the same mixed ES/CommonJS module, in which case it can be ignored.',
+          url: 'https://rollupjs.org/guide/en/#resolveid'
+        });
+        return null;
+      }
+
+      if (isWrappedId(importee, WRAPPED_SUFFIX)) {
+        return unwrapId(importee, WRAPPED_SUFFIX);
+      }
 
-    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)
+        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;
       }
-      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;
+
+      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,
+              Object.assign({ skipSelf: true }, resolveOptions)
+            ))
+          ) {
+            return null;
+          }
+          // For other external imports, we need to make sure they are handled as external
+          return { id: importee, external: true };
         }
-        // For other external imports, we need to make sure they are handled as external
-        return { id: importee, external: true };
       }
-    }
 
-    if (importee.startsWith('\0')) {
-      return null;
-    }
+      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)
-    ) {
+      // 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 { id: wrapId(resolved.id, ES_IMPORT_SUFFIX), meta: { commonjs: { resolved } } };
+      }
       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;
   };
 }
 
-function getRequireResolver(extensions, detectCyclesAndConditional) {
+function getRequireResolver(extensions, detectCyclesAndConditional, currentlyResolving) {
   const knownCjsModuleTypes = Object.create(null);
   const requiredIds = Object.create(null);
   const unconditionallyRequiredIds = Object.create(null);
@@ -597,6 +631,9 @@ function getRequireResolver(extensions, detectCyclesAndConditional) {
     return false;
   };
 
+  // Once a module is listed here, its type (wrapped or not) is fixed and may
+  // not change for the rest of the current build, to not break already
+  // transformed modules.
   const fullyAnalyzedModules = Object.create(null);
 
   const getTypeForFullyAnalyzedModule = (id) => {
@@ -604,7 +641,6 @@ function getRequireResolver(extensions, detectCyclesAndConditional) {
     if (knownType !== true || !detectCyclesAndConditional || fullyAnalyzedModules[id]) {
       return knownType;
     }
-    fullyAnalyzedModules[id] = true;
     if (isCyclic(id)) {
       return (knownCjsModuleTypes[id] = IS_WRAPPED_COMMONJS);
     }
@@ -612,13 +648,11 @@ function getRequireResolver(extensions, detectCyclesAndConditional) {
   };
 
   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;
+    // Fully analyzed modules may never change type
+    if (fullyAnalyzedModules[id]) {
+      return;
+    }
+    knownCjsModuleTypes[id] = initialCommonJSType;
     if (
       detectCyclesAndConditional &&
       knownCjsModuleTypes[id] === true &&
@@ -629,7 +663,7 @@ function getRequireResolver(extensions, detectCyclesAndConditional) {
     }
   };
 
-  const setTypesForRequiredModules = async (parentId, resolved, isConditional, loadModule) => {
+  const analyzeRequiredModule = async (parentId, resolved, isConditional, loadModule) => {
     const childId = resolved.id;
     requiredIds[childId] = true;
     if (!(isConditional || knownCjsModuleTypes[parentId] === IS_WRAPPED_COMMONJS)) {
@@ -638,41 +672,85 @@ function getRequireResolver(extensions, detectCyclesAndConditional) {
 
     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.
+      // 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);
     }
   };
 
+  const getTypeForImportedModule = async (resolved, loadModule) => {
+    if (resolved.id in knownCjsModuleTypes) {
+      // This handles cyclic ES dependencies
+      return knownCjsModuleTypes[resolved.id];
+    }
+    const {
+      meta: { commonjs }
+    } = await loadModule(resolved);
+    return (commonjs && commonjs.isCommonJS) || false;
+  };
+
   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;
-      }
-      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]) {
+    async shouldTransformCachedModule({
+      id: parentId,
+      resolvedSources,
+      meta: { commonjs: parentMeta }
+    }) {
+      // We explicitly track ES modules to handle circular imports
+      if (!(parentMeta && parentMeta.isCommonJS)) knownCjsModuleTypes[parentId] = false;
+      if (isWrappedId(parentId, ES_IMPORT_SUFFIX)) return false;
+      const parentRequires = parentMeta && parentMeta.requires;
+      if (parentRequires) {
+        setInitialParentType(parentId, parentMeta.initialCommonJSType);
+        await Promise.all(
+          parentRequires.map(({ resolved, isConditional }) =>
+            analyzeRequiredModule(parentId, resolved, isConditional, this.load)
+          )
+        );
+        if (getTypeForFullyAnalyzedModule(parentId) !== parentMeta.isCommonJS) {
           return true;
         }
+        for (const {
+          resolved: { id }
+        } of parentRequires) {
+          if (getTypeForFullyAnalyzedModule(id) !== parentMeta.isRequiredCommonJS[id]) {
+            return true;
+          }
+        }
+        // Now that we decided to go with the cached copy, neither the parent
+        // module nor any of its children may change types anymore
+        fullyAnalyzedModules[parentId] = true;
+        for (const {
+          resolved: { id }
+        } of parentRequires) {
+          fullyAnalyzedModules[id] = true;
+        }
       }
-      return false;
+      const parentRequireSet = new Set((parentRequires || []).map(({ resolved: { id } }) => id));
+      return (
+        await Promise.all(
+          Object.keys(resolvedSources)
+            .map((source) => resolvedSources[source])
+            .filter(({ id, external }) => !(external || parentRequireSet.has(id)))
+            .map(async (resolved) => {
+              if (isWrappedId(resolved.id, ES_IMPORT_SUFFIX)) {
+                return (
+                  (await getTypeForImportedModule(
+                    (await this.load({ id: resolved.id })).meta.commonjs.resolved,
+                    this.load
+                  )) !== IS_WRAPPED_COMMONJS
+                );
+              }
+              return (await getTypeForImportedModule(resolved, this.load)) === IS_WRAPPED_COMMONJS;
+            })
+        )
+      ).some((shouldTransform) => shouldTransform);
     },
     /* eslint-disable no-param-reassign */
     resolveRequireSourcesAndUpdateMeta: (rollupContext) => async (
@@ -685,16 +763,20 @@ function getRequireResolver(extensions, detectCyclesAndConditional) {
       parentMeta.requires = [];
       parentMeta.isRequiredCommonJS = Object.create(null);
       setInitialParentType(parentId, isParentCommonJS);
+      const currentlyResolvingForParent = currentlyResolving.get(parentId) || new Set();
+      currentlyResolving.set(parentId, currentlyResolvingForParent);
       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 };
           }
+          currentlyResolvingForParent.add(source);
           const resolved =
             (await rollupContext.resolve(source, parentId, {
               custom: { 'node-resolve': { isRequire: true } }
             })) || resolveExtensions(source, parentId, extensions);
+          currentlyResolvingForParent.delete(source);
           if (!resolved) {
             return { id: wrapId(source, EXTERNAL_SUFFIX), allowProxy: false };
           }
@@ -703,16 +785,18 @@ function getRequireResolver(extensions, detectCyclesAndConditional) {
             return { id: wrapId(childId, EXTERNAL_SUFFIX), allowProxy: false };
           }
           parentMeta.requires.push({ resolved, isConditional });
-          await setTypesForRequiredModules(parentId, resolved, isConditional, rollupContext.load);
+          await analyzeRequiredModule(parentId, resolved, isConditional, rollupContext.load);
           return { id: childId, allowProxy: true };
         })
       );
       parentMeta.isCommonJS = getTypeForFullyAnalyzedModule(parentId);
+      fullyAnalyzedModules[parentId] = true;
       return requireTargets.map(({ id: dependencyId, allowProxy }, index) => {
         // eslint-disable-next-line no-multi-assign
         const isCommonJS = (parentMeta.isRequiredCommonJS[
           dependencyId
         ] = getTypeForFullyAnalyzedModule(dependencyId));
+        fullyAnalyzedModules[dependencyId] = true;
         return {
           source: sources[index].source,
           id: allowProxy
@@ -723,6 +807,10 @@ function getRequireResolver(extensions, detectCyclesAndConditional) {
           isCommonJS
         };
       });
+    },
+    isCurrentlyResolving(source, parentId) {
+      const currentlyResolvingForParent = currentlyResolving.get(parentId);
+      return currentlyResolvingForParent && currentlyResolvingForParent.has(source);
     }
   };
 }
@@ -1166,7 +1254,7 @@ function getRequireStringArg(node) {
 function getRequireHandlers() {
   const requireExpressions = [];
 
-  function addRequireStatement(
+  function addRequireExpression(
     sourceId,
     node,
     scope,
@@ -1246,7 +1334,7 @@ function getRequireHandlers() {
   }
 
   return {
-    addRequireStatement,
+    addRequireExpression,
     rewriteRequireExpressionsAndGetImportBlock
   };
 }
@@ -1365,6 +1453,7 @@ async function transformCommonjs(
   let programDepth = 0;
   let currentTryBlockEnd = null;
   let shouldWrap = false;
+  let reexports = false;
 
   const globals = new Set();
   // A conditionalNode is a node for which execution is not guaranteed. If such a node is a require
@@ -1372,7 +1461,7 @@ async function transformCommonjs(
   // unconditional require elsewhere.
   let currentConditionalNodeEnd = null;
   const conditionalNodes = new Set();
-  const { addRequireStatement, rewriteRequireExpressionsAndGetImportBlock } = getRequireHandlers();
+  const { addRequireExpression, rewriteRequireExpressionsAndGetImportBlock } = getRequireHandlers();
 
   // See which names are assigned to. This is necessary to prevent
   // illegally replacing `var foo = require('foo')` with `import foo from 'foo'`,
@@ -1389,6 +1478,7 @@ async function transformCommonjs(
   const topLevelDefineCompiledEsmExpressions = [];
   const replacedGlobal = [];
   const replacedDynamicRequires = [];
+  const importedVariables = new Set();
 
   estreeWalker.walk(ast, {
     enter(node, parent) {
@@ -1444,8 +1534,9 @@ async function transformCommonjs(
                   if (hasDefineEsmProperty(node.right)) {
                     shouldWrap = true;
                   }
-                } else if (defaultIsModuleExports === false) {
+                } else if (isRequireExpression(node.right, scope)) {
                   shouldWrap = true;
+                  reexports = true;
                 }
               }
             } else if (exportName === KEY_COMPILED_ESM) {
@@ -1502,6 +1593,11 @@ async function transformCommonjs(
           }
 
           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;
           }
 
@@ -1521,15 +1617,28 @@ async function transformCommonjs(
           const requireStringArg = getRequireStringArg(node);
           if (!ignoreRequire(requireStringArg)) {
             const usesReturnValue = parent.type !== 'ExpressionStatement';
-            addRequireStatement(
+            const toBeRemoved =
+              parent.type === 'ExpressionStatement' &&
+              (!currentConditionalNodeEnd ||
+                // We should completely remove requires directly in a try-catch
+                // so that Rollup can remove up the try-catch
+                (currentTryBlockEnd !== null && currentTryBlockEnd < currentConditionalNodeEnd))
+                ? parent
+                : node;
+            addRequireExpression(
               requireStringArg,
               node,
               scope,
               usesReturnValue,
               currentTryBlockEnd !== null,
               currentConditionalNodeEnd !== null,
-              parent.type === 'ExpressionStatement' ? parent : node
+              toBeRemoved
             );
+            if (parent.type === 'VariableDeclarator' && parent.id.type === 'Identifier') {
+              for (const name of pluginutils.extractAssignedNames(parent.id)) {
+                importedVariables.add(name);
+              }
+            }
           }
           return;
         }
@@ -1719,12 +1828,15 @@ async function transformCommonjs(
   shouldWrap = !isEsModule && (shouldWrap || (uses.exports && moduleExportsAssignments.length > 0));
   const detectWrappedDefault =
     shouldWrap &&
-    (topLevelDefineCompiledEsmExpressions.length > 0 || code.indexOf('__esModule') >= 0);
+    (reexports ||
+      topLevelDefineCompiledEsmExpressions.length > 0 ||
+      code.indexOf('__esModule') >= 0);
 
   if (
     !(
       shouldWrap ||
       isRequired ||
+      needsRequireWrapper ||
       uses.module ||
       uses.exports ||
       uses.require ||
@@ -1742,7 +1854,9 @@ async function transformCommonjs(
     magicString.remove(0, commentEnd).trim();
   }
 
-  const exportMode = shouldWrap
+  const exportMode = isEsModule
+    ? 'none'
+    : shouldWrap
     ? uses.module
       ? 'module'
       : 'exports'
@@ -1835,6 +1949,7 @@ function commonjs(options = {}) {
     ignoreGlobal,
     ignoreDynamicRequires,
     requireReturnsDefault: requireReturnsDefaultOption,
+    defaultIsModuleExports: defaultIsModuleExportsOption,
     esmExternals
   } = options;
   const extensions = options.extensions || ['.js'];
@@ -1854,8 +1969,11 @@ function commonjs(options = {}) {
       ? ((esmExternalIds = new Set(esmExternals)), (id) => esmExternalIds.has(id))
       : () => esmExternals;
 
-  const defaultIsModuleExports =
-    typeof options.defaultIsModuleExports === 'boolean' ? options.defaultIsModuleExports : 'auto';
+  const getDefaultIsModuleExports =
+    typeof defaultIsModuleExportsOption === 'function'
+      ? defaultIsModuleExportsOption
+      : () =>
+          typeof defaultIsModuleExportsOption === 'boolean' ? defaultIsModuleExportsOption : 'auto';
 
   const dynamicRequireRoot =
     typeof options.dynamicRequireRoot === 'string'
@@ -1890,7 +2008,7 @@ function commonjs(options = {}) {
     };
   };
 
-  const resolveId = getResolveId(extensions);
+  const { currentlyResolving, resolveId } = getResolveId(extensions);
 
   const sourceMap = options.sourceMap !== false;
 
@@ -1955,7 +2073,7 @@ function commonjs(options = {}) {
       dynamicRequireModules,
       commonDir,
       ast,
-      defaultIsModuleExports,
+      getDefaultIsModuleExports(id),
       needsRequireWrapper,
       requireResolver.resolveRequireSourcesAndUpdateMeta(this),
       requireResolver.isRequiredId(id),
@@ -1995,7 +2113,11 @@ function commonjs(options = {}) {
           'The namedExports option from "@rollup/plugin-commonjs" is deprecated. Named exports are now handled automatically.'
         );
       }
-      requireResolver = getRequireResolver(extensions, detectCyclesAndConditional);
+      requireResolver = getRequireResolver(
+        extensions,
+        detectCyclesAndConditional,
+        currentlyResolving
+      );
     },
 
     buildEnd() {
@@ -2051,15 +2173,13 @@ 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
-        );
+        const acutalId = id.slice(0, -ENTRY_SUFFIX.length);
+        return getEntryProxy(acutalId, getDefaultIsModuleExports(acutalId), this.getModuleInfo);
       }
 
       if (isWrappedId(id, ES_IMPORT_SUFFIX)) {
-        return getEsImportProxy(unwrapId(id, ES_IMPORT_SUFFIX), defaultIsModuleExports);
+        const actualId = unwrapId(id, ES_IMPORT_SUFFIX);
+        return getEsImportProxy(actualId, getDefaultIsModuleExports(actualId));
       }
 
       if (id === DYNAMIC_MODULES_ID) {