loader: fix package resolution for edge case

lib/internal/modules/cjs/loader.js

@@ -457,7 +457,7 @@ function trySelf(parentPath, request) {
   try {
     return finalizeEsmResolution(packageExportsResolve(
       pathToFileURL(pkgPath + '/package.json'), expansion, pkg,
-      pathToFileURL(parentPath), cjsConditions).resolved, parentPath, pkgPath);
+      pathToFileURL(parentPath), cjsConditions), parentPath, pkgPath);
   } catch (e) {
     if (e.code === 'ERR_MODULE_NOT_FOUND')
       throw createEsmNotFoundErr(request, pkgPath + '/package.json');
@@ -481,7 +481,7 @@ function resolveExports(nmPath, request) {
     try {
       return finalizeEsmResolution(packageExportsResolve(
         pathToFileURL(pkgPath + '/package.json'), '.' + expansion, pkg, null,
-        cjsConditions).resolved, null, pkgPath);
+        cjsConditions), null, pkgPath);
     } catch (e) {
       if (e.code === 'ERR_MODULE_NOT_FOUND')
         throw createEsmNotFoundErr(request, pkgPath + '/package.json');

lib/internal/modules/esm/get_format.js

@@ -32,6 +32,8 @@ const legacyExtensionFormatMap = {
   '.node': 'commonjs'
 };
 
+let experimentalSpecifierResolutionWarned = false;
+
 if (experimentalWasmModules)
   extensionFormatMap['.wasm'] = legacyExtensionFormatMap['.wasm'] = 'wasm';
 
@@ -54,30 +56,48 @@ const protocolHandlers = ObjectAssign(ObjectCreate(null), {
     return format;
   },
   'file:'(parsed, url) {
-    const ext = extname(parsed.pathname);
-    let format;
-
-    if (ext === '.js') {
-      format = getPackageType(parsed.href) === 'module' ? 'module' : 'commonjs';
-    } else {
-      format = extensionFormatMap[ext];
-    }
-    if (!format) {
-      if (experimentalSpecifierResolution === 'node') {
-        process.emitWarning(
-          'The Node.js specifier resolution in ESM is experimental.',
-          'ExperimentalWarning');
-        format = legacyExtensionFormatMap[ext];
-      } else {
-        throw new ERR_UNKNOWN_FILE_EXTENSION(ext, fileURLToPath(url));
-      }
-    }
-
-    return format || null;
+    return getModuleFileFormat(parsed, true, url) || null;
   },
   'node:'() { return 'builtin'; },
 });
 
+function throwIfNotExperimentalSpecifierResolution(ext, url) {
+  if (experimentalSpecifierResolution !== 'node') {
+    throw new ERR_UNKNOWN_FILE_EXTENSION(ext, fileURLToPath(url));
+  }
+  return getLegacyExtensionFormat(ext);
+}
+
+function getLegacyExtensionFormat(ext) {
+  if (
+    experimentalSpecifierResolution === 'node' &&
+    !experimentalSpecifierResolutionWarned
+  ) {
+    process.emitWarning(
+      'The Node.js specifier resolution in ESM is experimental.',
+      'ExperimentalWarning');
+    experimentalSpecifierResolutionWarned = true;
+  }
+  return legacyExtensionFormatMap[ext];
+}
+
+function getModuleFileFormat(url, throwIfNotResolved, urlForThrow) {
+  let format;
+
+  const ext = extname(url.pathname);
+  if (ext === '.js') {
+    format = getPackageType(url) === 'module' ? 'module' : 'commonjs';
+  } else {
+    format = extensionFormatMap[ext] ??
+      (throwIfNotResolved ?
+        throwIfNotExperimentalSpecifierResolution(ext, urlForThrow) :
+        getLegacyExtensionFormat(ext)
+      );
+  }
+
+  return format;
+}
+
 function defaultGetFormat(url, context) {
   const parsed = new URL(url);
 
@@ -90,4 +110,5 @@ module.exports = {
   defaultGetFormat,
   extensionFormatMap,
   legacyExtensionFormatMap,
+  getModuleFileFormat
 };

lib/internal/modules/esm/resolve.js

@@ -464,22 +464,6 @@ const patternRegEx = /\*/g;
 function resolvePackageTargetString(
   target, subpath, match, packageJSONUrl, base, pattern, internal, conditions) {
 
-  const composeResult = (resolved) => {
-    let format;
-    try {
-      format = getPackageType(resolved);
-    } catch (err) {
-      if (err.code === 'ERR_INVALID_FILE_URL_PATH') {
-        const invalidModuleErr = new ERR_INVALID_MODULE_SPECIFIER(
-          resolved, 'must not include encoded "/" or "\\" characters', base);
-        invalidModuleErr.cause = err;
-        throw invalidModuleErr;
-      }
-      throw err;
-    }
-    return { resolved, ...(format !== 'none') && { format } };
-  };
-
   if (subpath !== '' && !pattern && target[target.length - 1] !== '/')
     throwInvalidPackageTarget(match, target, packageJSONUrl, internal, base);
 
@@ -512,7 +496,7 @@ function resolvePackageTargetString(
   if (!StringPrototypeStartsWith(resolvedPath, packagePath))
     throwInvalidPackageTarget(match, target, packageJSONUrl, internal, base);
 
-  if (subpath === '') return composeResult(resolved);
+  if (subpath === '') return resolved;
 
   if (RegExpPrototypeTest(invalidSegmentRegEx, subpath)) {
     const request = pattern ?
@@ -521,12 +505,16 @@ function resolvePackageTargetString(
   }
 
   if (pattern) {
-    return composeResult(new URL(RegExpPrototypeSymbolReplace(patternRegEx,
-                                                              resolved.href,
-                                                              () => subpath)));
+    return new URL(
+      RegExpPrototypeSymbolReplace(
+        patternRegEx,
+        resolved.href,
+        () => subpath
+      )
+    );
   }
 
-  return composeResult(new URL(subpath, resolved));
+  return new URL(subpath, resolved);
 }
 
 /**
@@ -543,7 +531,13 @@ function resolvePackageTarget(packageJSONUrl, target, subpath, packageSubpath,
                               base, pattern, internal, conditions) {
   if (typeof target === 'string') {
     return resolvePackageTargetString(
-      target, subpath, packageSubpath, packageJSONUrl, base, pattern, internal,
+      target,
+      subpath,
+      packageSubpath,
+      packageJSONUrl,
+      base,
+      pattern,
+      internal,
       conditions);
   } else if (ArrayIsArray(target)) {
     if (target.length === 0)
@@ -753,7 +747,7 @@ function packageImportsResolve(name, base, conditions) {
           packageJSONUrl, imports[name], '', name, base, false, true, conditions
         );
         if (resolveResult != null) {
-          return resolveResult.resolved;
+          return resolveResult;
         }
       } else {
         let bestMatch = '';
@@ -785,7 +779,7 @@ function packageImportsResolve(name, base, conditions) {
                                                      bestMatch, base, true,
                                                      true, conditions);
           if (resolveResult != null) {
-            return resolveResult.resolved;
+            return resolveResult;
           }
         }
       }
@@ -849,7 +843,7 @@ function parsePackageName(specifier, base) {
  */
 function packageResolve(specifier, base, conditions) {
   if (NativeModule.canBeRequiredByUsers(specifier))
-    return { resolved: new URL('node:' + specifier) };
+    return new URL('node:' + specifier);
 
   const { packageName, packageSubpath, isScoped } =
     parsePackageName(specifier, base);
@@ -888,19 +882,14 @@ function packageResolve(specifier, base, conditions) {
         packageJSONUrl, packageSubpath, packageConfig, base, conditions);
     }
     if (packageSubpath === '.') {
-      return {
-        resolved: legacyMainResolve(
-          packageJSONUrl,
-          packageConfig,
-          base),
-        ...(packageConfig.type !== 'none') && { format: packageConfig.type }
-      };
+      return legacyMainResolve(
+        packageJSONUrl,
+        packageConfig,
+        base
+      );
     }
 
-    return {
-      resolved: new URL(packageSubpath, packageJSONUrl),
-      ...(packageConfig.type !== 'none') && { format: packageConfig.type }
-    };
+    return new URL(packageSubpath, packageJSONUrl);
     // Cross-platform root check.
   } while (packageJSONPath.length !== lastPath.length);
 
@@ -933,6 +922,12 @@ function shouldBeTreatedAsRelativeOrAbsolutePath(specifier) {
   return isRelativeSpecifier(specifier);
 }
 
+function amendFormatToUrl(resolved) {
+  const format = getModuleFileFormat(resolved, false);
+
+  return { resolved, ...(format !== null) && { format } };
+}
+
 /**
  * @param {string} specifier
  * @param {string | URL | undefined} base
@@ -945,6 +940,7 @@ function moduleResolve(specifier, base, conditions, preserveSymlinks) {
   // Ok since relative URLs cannot parse as URLs.
   let resolved;
   let format;
+
   if (shouldBeTreatedAsRelativeOrAbsolutePath(specifier)) {
     resolved = new URL(specifier, base);
   } else if (specifier[0] === '#') {
@@ -953,7 +949,13 @@ function moduleResolve(specifier, base, conditions, preserveSymlinks) {
     try {
       resolved = new URL(specifier);
     } catch {
-      ({ resolved, format } = packageResolve(specifier, base, conditions));
+      ({ resolved, format } =
+        amendFormatToUrl(
+          packageResolve(
+            specifier,
+            base,
+            conditions
+          )));
     }
   }
   if (resolved.protocol !== 'file:') {
@@ -1107,4 +1109,7 @@ module.exports = {
 };
 
 // cycle
-const { defaultGetFormat } = require('internal/modules/esm/get_format');
+const {
+  defaultGetFormat,
+  getModuleFileFormat,
+} = require('internal/modules/esm/get_format');