@mui/internal-docs-infra 0.3.1-canary.3 → 0.3.1-canary.5

package/esm/pipeline/loaderUtils/resolveModulePath.js

@@ -1,9 +1,3 @@
-import _regeneratorValues from "@babel/runtime/helpers/esm/regeneratorValues";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import _extends from "@babel/runtime/helpers/esm/extends";
-import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
-import _regenerator from "@babel/runtime/helpers/esm/regenerator";
-import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import { getFileNameFromUrl } from "./getFileNameFromUrl.js";
 import { fileUrlToPortablePath, portablePathToFileUrl } from "./fileUrlToPortablePath.js";
 
@@ -11,20 +5,20 @@ import { fileUrlToPortablePath, portablePathToFileUrl } from "./fileUrlToPortabl
  * Isomorphic path joining function that works in both Node.js and browser environments.
  * Uses string concatenation to handle path joining consistently across platforms.
  */
-function joinPath(basePath) {
+function joinPath(basePath, ...segments) {
   // Start with the base path, ensuring it has a trailing slash for URL construction
-  var result = basePath.endsWith('/') ? basePath : "".concat(basePath, "/");
+  let result = basePath.endsWith('/') ? basePath : `${basePath}/`;
 
   // Handle each segment
-  for (var i = 0; i < (arguments.length <= 1 ? 0 : arguments.length - 1); i += 1) {
-    var segment = i + 1 < 1 || arguments.length <= i + 1 ? undefined : arguments[i + 1];
+  for (let i = 0; i < segments.length; i += 1) {
+    const segment = segments[i];
     if (segment) {
       // Remove leading slash from segment to avoid double slashes
-      var cleanSegment = segment.startsWith('/') ? segment.slice(1) : segment;
+      const cleanSegment = segment.startsWith('/') ? segment.slice(1) : segment;
       // Append segment
       result += cleanSegment;
       // Add trailing slash for intermediate segments
-      if (i < (arguments.length <= 1 ? 0 : arguments.length - 1) - 1) {
+      if (i < segments.length - 1) {
         result += '/';
       }
     }
@@ -35,17 +29,17 @@ function joinPath(basePath) {
 /**
  * Default file extensions for JavaScript/TypeScript modules that can be resolved
  */
-export var JAVASCRIPT_MODULE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mdx', '.d.ts'];
+export const JAVASCRIPT_MODULE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mdx', '.d.ts'];
 
 /**
  * Extension priority for type-only imports - prioritize .d.ts first
  */
-export var TYPE_IMPORT_EXTENSIONS = ['.d.ts', '.ts', '.tsx', '.js', '.jsx', '.mdx'];
+export const TYPE_IMPORT_EXTENSIONS = ['.d.ts', '.ts', '.tsx', '.js', '.jsx', '.mdx'];
 
 /**
  * Extension priority for value imports - standard priority with .d.ts last
  */
-export var VALUE_IMPORT_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mdx', '.d.ts'];
+export const VALUE_IMPORT_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mdx', '.d.ts'];
 
 /**
  * Checks if a file path or import path represents a JavaScript/TypeScript module
@@ -55,9 +49,7 @@ export var VALUE_IMPORT_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mdx', '.d.
 export function isJavaScriptModule(path) {
   // If the path has an extension, check if it's one of the JS/TS extensions
   if (/\.[^/]+$/.test(path)) {
-    return JAVASCRIPT_MODULE_EXTENSIONS.some(function (ext) {
-      return path.endsWith(ext);
-    });
+    return JAVASCRIPT_MODULE_EXTENSIONS.some(ext => path.endsWith(ext));
   }
   // If no extension, assume it's a JS/TS module (will be resolved to one)
   return true;
@@ -77,543 +69,326 @@ export function isJavaScriptModule(path) {
  * @param includeTypeDefs - If true, returns both import and typeImport paths with different extension priorities
  * @returns Promise<string | TypeAwareResolveResult> - The resolved file:// URL(s)
  */
-export function resolveModulePath(_x, _x2) {
-  return _resolveModulePath.apply(this, arguments);
+export async function resolveModulePath(moduleUrl, readDirectory, options = {}, includeTypeDefs) {
+  const {
+    extensions = JAVASCRIPT_MODULE_EXTENSIONS
+  } = options;
+
+  // Convert file URL to portable path for internal processing
+  const modulePath = moduleUrl.startsWith('file://') ? fileUrlToPortablePath(moduleUrl) : moduleUrl;
+
+  // If includeTypeDefs is true, we need to resolve with both type and value extension priorities
+  if (includeTypeDefs) {
+    return resolveWithTypeAwareness(modulePath, readDirectory, options);
+  }
+
+  // Extract the parent directory and the module name
+  const lastSlashIndex = modulePath.lastIndexOf('/');
+  const parentDir = modulePath.substring(0, lastSlashIndex);
+  const moduleName = modulePath.substring(lastSlashIndex + 1);
+  const resolvedPath = await resolveSinglePath(modulePath, parentDir, moduleName, readDirectory, extensions);
+  return resolvedPath;
 }
 
 /**
  * Resolves a module path with type-aware resolution, returning both import and typeImport paths
  * This function is optimized to do only a single directory read instead of two separate reads.
  */
-function _resolveModulePath() {
-  _resolveModulePath = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(moduleUrl, readDirectory) {
-    var options,
-      includeTypeDefs,
-      _options$extensions,
-      extensions,
-      modulePath,
-      lastSlashIndex,
-      parentDir,
-      moduleName,
-      resolvedPath,
-      _args = arguments;
-    return _regenerator().w(function (_context) {
-      while (1) switch (_context.n) {
-        case 0:
-          options = _args.length > 2 && _args[2] !== undefined ? _args[2] : {};
-          includeTypeDefs = _args.length > 3 ? _args[3] : undefined;
-          _options$extensions = options.extensions, extensions = _options$extensions === void 0 ? JAVASCRIPT_MODULE_EXTENSIONS : _options$extensions; // Convert file URL to portable path for internal processing
-          modulePath = moduleUrl.startsWith('file://') ? fileUrlToPortablePath(moduleUrl) : moduleUrl; // If includeTypeDefs is true, we need to resolve with both type and value extension priorities
-          if (!includeTypeDefs) {
-            _context.n = 1;
-            break;
-          }
-          return _context.a(2, resolveWithTypeAwareness(modulePath, readDirectory, options));
-        case 1:
-          // Extract the parent directory and the module name
-          lastSlashIndex = modulePath.lastIndexOf('/');
-          parentDir = modulePath.substring(0, lastSlashIndex);
-          moduleName = modulePath.substring(lastSlashIndex + 1);
-          _context.n = 2;
-          return resolveSinglePath(modulePath, parentDir, moduleName, readDirectory, extensions);
-        case 2:
-          resolvedPath = _context.v;
-          return _context.a(2, resolvedPath);
+async function resolveWithTypeAwareness(modulePath, readDirectory, _options = {}) {
+  const lastSlashIndex = modulePath.lastIndexOf('/');
+  const parentDir = modulePath.substring(0, lastSlashIndex);
+  const moduleName = modulePath.substring(lastSlashIndex + 1);
+
+  // Single filesystem read to get directory contents
+  const dirContents = await readDirectory(portablePathToFileUrl(parentDir));
+
+  // Build a map of available files by basename
+  const filesByBaseName = new Map();
+  for (const entry of dirContents) {
+    if (entry.isFile) {
+      const fileName = entry.name;
+      let fileBaseName;
+      let actualExtension;
+
+      // Handle .d.ts files specially since getFileNameFromUrl returns .ts for types.d.ts
+      if (fileName.endsWith('.d.ts')) {
+        actualExtension = '.d.ts';
+        fileBaseName = fileName.substring(0, fileName.length - 5); // Remove .d.ts
+      } else {
+        const {
+          extension: fileExt
+        } = getFileNameFromUrl(fileName);
+        actualExtension = fileExt;
+        fileBaseName = fileName.substring(0, fileName.length - fileExt.length);
       }
-    }, _callee);
-  }));
-  return _resolveModulePath.apply(this, arguments);
-}
-function resolveWithTypeAwareness(_x3, _x4) {
-  return _resolveWithTypeAwareness.apply(this, arguments);
-}
-/**
- * Internal function to resolve a single path with given extensions
- */
-function _resolveWithTypeAwareness() {
-  _resolveWithTypeAwareness = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(modulePath, readDirectory) {
-    var _options,
-      lastSlashIndex,
-      parentDir,
-      moduleName,
-      dirContents,
-      filesByBaseName,
-      _iterator,
-      _step,
-      _entry4,
-      _fileName,
-      _fileBaseName,
-      _actualExtension,
-      _getFileNameFromUrl2,
-      _fileExt,
-      matchingFiles,
-      entryMap,
-      importPath,
-      _iterator2,
-      _step2,
-      ext,
-      _iterator4,
-      _step4,
-      entry,
-      typeImportPath,
-      _iterator3,
-      _step3,
-      _ext,
-      _iterator5,
-      _step5,
-      _entry,
-      directoryMatches,
-      moduleDir,
-      moduleDirContents,
-      indexFilesByBaseName,
-      _iterator6,
-      _step6,
-      moduleFile,
-      fileName,
-      fileBaseName,
-      actualExtension,
-      _getFileNameFromUrl,
-      fileExt,
-      indexFiles,
-      indexEntryMap,
-      _importPath,
-      _iterator7,
-      _step7,
-      _ext2,
-      _iterator9,
-      _step9,
-      _entry2,
-      _typeImportPath,
-      _iterator8,
-      _step8,
-      _ext3,
-      _iterator0,
-      _step0,
-      _entry3,
-      _args2 = arguments,
-      _t,
-      _t2,
-      _t3,
-      _t4,
-      _t5,
-      _t6,
-      _t7,
-      _t8,
-      _t9;
-    return _regenerator().w(function (_context2) {
-      while (1) switch (_context2.p = _context2.n) {
-        case 0:
-          _options = _args2.length > 2 && _args2[2] !== undefined ? _args2[2] : {};
-          lastSlashIndex = modulePath.lastIndexOf('/');
-          parentDir = modulePath.substring(0, lastSlashIndex);
-          moduleName = modulePath.substring(lastSlashIndex + 1); // Single filesystem read to get directory contents
-          _context2.n = 1;
-          return readDirectory(portablePathToFileUrl(parentDir));
-        case 1:
-          dirContents = _context2.v;
-          // Build a map of available files by basename
-          filesByBaseName = new Map();
-          _iterator = _createForOfIteratorHelper(dirContents);
-          try {
-            for (_iterator.s(); !(_step = _iterator.n()).done;) {
-              _entry4 = _step.value;
-              if (_entry4.isFile) {
-                _fileName = _entry4.name;
-                _fileBaseName = void 0;
-                _actualExtension = void 0; // Handle .d.ts files specially since getFileNameFromUrl returns .ts for types.d.ts
-                if (_fileName.endsWith('.d.ts')) {
-                  _actualExtension = '.d.ts';
-                  _fileBaseName = _fileName.substring(0, _fileName.length - 5); // Remove .d.ts
-                } else {
-                  _getFileNameFromUrl2 = getFileNameFromUrl(_fileName), _fileExt = _getFileNameFromUrl2.extension;
-                  _actualExtension = _fileExt;
-                  _fileBaseName = _fileName.substring(0, _fileName.length - _fileExt.length);
-                }
-                if (!filesByBaseName.has(_fileBaseName)) {
-                  filesByBaseName.set(_fileBaseName, []);
-                }
-                // Store the entry with its actual extension for later matching
-                filesByBaseName.get(_fileBaseName).push(_extends(_extends({}, _entry4), {}, {
-                  actualExtension: _actualExtension
-                }));
-              }
-            }
+      if (!filesByBaseName.has(fileBaseName)) {
+        filesByBaseName.set(fileBaseName, []);
+      }
+      // Store the entry with its actual extension for later matching
+      filesByBaseName.get(fileBaseName).push({
+        ...entry,
+        actualExtension
+      });
+    }
+  }
 
-            // Check for the module in both priority orders
-          } catch (err) {
-            _iterator.e(err);
-          } finally {
-            _iterator.f();
-          }
-          matchingFiles = filesByBaseName.get(moduleName);
-          if (!matchingFiles) {
-            _context2.n = 32;
-            break;
-          }
-          entryMap = matchingFiles; // Find best match for value imports (VALUE_IMPORT_EXTENSIONS priority)
-          importPath = null;
-          _iterator2 = _createForOfIteratorHelper(VALUE_IMPORT_EXTENSIONS);
-          _context2.p = 2;
-          _iterator2.s();
-        case 3:
-          if ((_step2 = _iterator2.n()).done) {
-            _context2.n = 12;
-            break;
-          }
-          ext = _step2.value;
-          _iterator4 = _createForOfIteratorHelper(entryMap);
-          _context2.p = 4;
-          _iterator4.s();
-        case 5:
-          if ((_step4 = _iterator4.n()).done) {
-            _context2.n = 7;
-            break;
-          }
-          entry = _step4.value;
-          if (!(entry.actualExtension === ext)) {
-            _context2.n = 6;
-            break;
-          }
+  // Check for the module in both priority orders
+  const matchingFiles = filesByBaseName.get(moduleName);
+  if (matchingFiles) {
+    const entryMap = matchingFiles;
+
+    // Find best match for value imports (VALUE_IMPORT_EXTENSIONS priority)
+    let importPath = null;
+    for (const ext of VALUE_IMPORT_EXTENSIONS) {
+      for (const entry of entryMap) {
+        if (entry.actualExtension === ext) {
           importPath = portablePathToFileUrl(joinPath(parentDir, entry.name));
-          return _context2.a(3, 7);
-        case 6:
-          _context2.n = 5;
-          break;
-        case 7:
-          _context2.n = 9;
-          break;
-        case 8:
-          _context2.p = 8;
-          _t = _context2.v;
-          _iterator4.e(_t);
-        case 9:
-          _context2.p = 9;
-          _iterator4.f();
-          return _context2.f(9);
-        case 10:
-          if (!importPath) {
-            _context2.n = 11;
-            break;
-          }
-          return _context2.a(3, 12);
-        case 11:
-          _context2.n = 3;
           break;
-        case 12:
-          _context2.n = 14;
+        }
+      }
+      if (importPath) {
+        break;
+      }
+    }
+
+    // Find best match for type imports (TYPE_IMPORT_EXTENSIONS priority)
+    let typeImportPath = null;
+    for (const ext of TYPE_IMPORT_EXTENSIONS) {
+      for (const entry of entryMap) {
+        if (entry.actualExtension === ext) {
+          typeImportPath = portablePathToFileUrl(joinPath(parentDir, entry.name));
           break;
-        case 13:
-          _context2.p = 13;
-          _t2 = _context2.v;
-          _iterator2.e(_t2);
-        case 14:
-          _context2.p = 14;
-          _iterator2.f();
-          return _context2.f(14);
-        case 15:
-          // Find best match for type imports (TYPE_IMPORT_EXTENSIONS priority)
-          typeImportPath = null;
-          _iterator3 = _createForOfIteratorHelper(TYPE_IMPORT_EXTENSIONS);
-          _context2.p = 16;
-          _iterator3.s();
-        case 17:
-          if ((_step3 = _iterator3.n()).done) {
-            _context2.n = 26;
-            break;
+        }
+      }
+      if (typeImportPath) {
+        break;
+      }
+    }
+    if (importPath && typeImportPath && importPath !== typeImportPath) {
+      return {
+        import: importPath,
+        typeImport: typeImportPath
+      };
+    }
+    if (importPath) {
+      return {
+        import: importPath
+      };
+    }
+    if (typeImportPath) {
+      return {
+        import: typeImportPath
+      };
+    }
+  }
+
+  // Try index files with the same single-pass approach
+  const directoryMatches = dirContents.filter(entry => entry.isDirectory && entry.name === moduleName);
+  if (directoryMatches.length > 0) {
+    const moduleDir = joinPath(parentDir, directoryMatches[0].name);
+    try {
+      const moduleDirContents = await readDirectory(portablePathToFileUrl(moduleDir));
+
+      // Build a map of available index files by basename
+      const indexFilesByBaseName = new Map();
+      for (const moduleFile of moduleDirContents) {
+        if (moduleFile.isFile) {
+          const fileName = moduleFile.name;
+          let fileBaseName;
+          let actualExtension;
+
+          // Handle .d.ts files specially since getFileNameFromUrl returns .ts for index.d.ts
+          if (fileName.endsWith('.d.ts')) {
+            actualExtension = '.d.ts';
+            fileBaseName = fileName.substring(0, fileName.length - 5); // Remove .d.ts
+          } else {
+            const {
+              extension: fileExt
+            } = getFileNameFromUrl(fileName);
+            actualExtension = fileExt;
+            fileBaseName = fileName.substring(0, fileName.length - fileExt.length);
+          }
+          if (!indexFilesByBaseName.has(fileBaseName)) {
+            indexFilesByBaseName.set(fileBaseName, []);
+          }
+          // Store the entry with its actual extension for later matching
+          indexFilesByBaseName.get(fileBaseName).push({
+            ...moduleFile,
+            actualExtension
+          });
+        }
+      }
+
+      // Check for index files in both priority orders
+      const indexFiles = indexFilesByBaseName.get('index');
+      if (indexFiles) {
+        const indexEntryMap = indexFiles;
+
+        // Find best match for value imports
+        let importPath = null;
+        for (const ext of VALUE_IMPORT_EXTENSIONS) {
+          for (const entry of indexEntryMap) {
+            if (entry.actualExtension === ext) {
+              importPath = portablePathToFileUrl(joinPath(moduleDir, entry.name));
+              break;
+            }
           }
-          _ext = _step3.value;
-          _iterator5 = _createForOfIteratorHelper(entryMap);
-          _context2.p = 18;
-          _iterator5.s();
-        case 19:
-          if ((_step5 = _iterator5.n()).done) {
-            _context2.n = 21;
+          if (importPath) {
             break;
           }
-          _entry = _step5.value;
-          if (!(_entry.actualExtension === _ext)) {
-            _context2.n = 20;
-            break;
+        }
+
+        // Find best match for type imports
+        let typeImportPath = null;
+        for (const ext of TYPE_IMPORT_EXTENSIONS) {
+          for (const entry of indexEntryMap) {
+            if (entry.actualExtension === ext) {
+              typeImportPath = portablePathToFileUrl(joinPath(moduleDir, entry.name));
+              break;
+            }
           }
-          typeImportPath = portablePathToFileUrl(joinPath(parentDir, _entry.name));
-          return _context2.a(3, 21);
-        case 20:
-          _context2.n = 19;
-          break;
-        case 21:
-          _context2.n = 23;
-          break;
-        case 22:
-          _context2.p = 22;
-          _t3 = _context2.v;
-          _iterator5.e(_t3);
-        case 23:
-          _context2.p = 23;
-          _iterator5.f();
-          return _context2.f(23);
-        case 24:
-          if (!typeImportPath) {
-            _context2.n = 25;
+          if (typeImportPath) {
             break;
           }
-          return _context2.a(3, 26);
-        case 25:
-          _context2.n = 17;
-          break;
-        case 26:
-          _context2.n = 28;
-          break;
-        case 27:
-          _context2.p = 27;
-          _t4 = _context2.v;
-          _iterator3.e(_t4);
-        case 28:
-          _context2.p = 28;
-          _iterator3.f();
-          return _context2.f(28);
-        case 29:
-          if (!(importPath && typeImportPath && importPath !== typeImportPath)) {
-            _context2.n = 30;
-            break;
-          }
-          return _context2.a(2, {
-            "import": importPath,
+        }
+        if (importPath && typeImportPath && importPath !== typeImportPath) {
+          return {
+            import: importPath,
             typeImport: typeImportPath
-          });
-        case 30:
-          if (!importPath) {
-            _context2.n = 31;
-            break;
-          }
-          return _context2.a(2, {
-            "import": importPath
-          });
-        case 31:
-          if (!typeImportPath) {
-            _context2.n = 32;
-            break;
-          }
-          return _context2.a(2, {
-            "import": typeImportPath
-          });
-        case 32:
-          // Try index files with the same single-pass approach
-          directoryMatches = dirContents.filter(function (entry) {
-            return entry.isDirectory && entry.name === moduleName;
-          });
-          if (!(directoryMatches.length > 0)) {
-            _context2.n = 67;
-            break;
+          };
+        }
+        if (importPath) {
+          return {
+            import: importPath
+          };
+        }
+        if (typeImportPath) {
+          return {
+            import: typeImportPath
+          };
+        }
+      }
+    } catch {
+      // Could not read module directory, continue
+    }
+  }
+  throw new Error(`Could not resolve module at path "${modulePath}". Tried extensions: ${VALUE_IMPORT_EXTENSIONS.join(', ')}, ${TYPE_IMPORT_EXTENSIONS.join(', ')}`);
+}
+
+/**
+ * Internal function to resolve a single path with given extensions
+ */
+async function resolveSinglePath(modulePath, parentDir, moduleName, readDirectory, extensions) {
+  try {
+    // Read the parent directory contents
+    const dirContents = await readDirectory(portablePathToFileUrl(parentDir));
+
+    // Look for direct file matches in extension priority order
+    // Create a map of baseName -> files with that basename for efficient lookup
+    const filesByBaseName = new Map();
+    for (const entry of dirContents) {
+      if (entry.isFile) {
+        const fileName = entry.name;
+        let fileBaseName;
+        let actualExtension;
+
+        // Handle .d.ts files specially since getFileNameFromUrl returns .ts for types.d.ts
+        if (fileName.endsWith('.d.ts')) {
+          actualExtension = '.d.ts';
+          fileBaseName = fileName.substring(0, fileName.length - 5); // Remove .d.ts
+        } else {
+          const {
+            extension: fileExt
+          } = getFileNameFromUrl(fileName);
+          actualExtension = fileExt;
+          fileBaseName = fileName.substring(0, fileName.length - fileExt.length);
+        }
+        if (!filesByBaseName.has(fileBaseName)) {
+          filesByBaseName.set(fileBaseName, []);
+        }
+        // Store the entry with its actual extension for later matching
+        filesByBaseName.get(fileBaseName).push({
+          ...entry,
+          // Add a custom property to track the actual extension
+          actualExtension
+        });
+      }
+    }
+
+    // Check for the module in extension priority order
+    const matchingFiles = filesByBaseName.get(moduleName);
+    if (matchingFiles) {
+      for (const ext of extensions) {
+        for (const entry of matchingFiles) {
+          const entryWithExt = entry;
+          if (entryWithExt.actualExtension === ext) {
+            const resolvedPath = joinPath(parentDir, entry.name);
+            return portablePathToFileUrl(resolvedPath);
+          }
+        }
+      }
+    }
+
+    // Look for directory with index files
+    const directoryMatches = dirContents.filter(entry => entry.isDirectory && entry.name === moduleName);
+    if (directoryMatches.length > 0) {
+      const moduleDir = joinPath(parentDir, directoryMatches[0].name);
+      try {
+        const moduleDirContents = await readDirectory(portablePathToFileUrl(moduleDir));
+
+        // Look for index files in extension priority order
+        // Create a map of baseName -> files for efficient lookup
+        const indexFilesByBaseName = new Map();
+        for (const moduleFile of moduleDirContents) {
+          if (moduleFile.isFile) {
+            const fileName = moduleFile.name;
+            let fileBaseName;
+            let actualExtension;
+
+            // Handle .d.ts files specially since getFileNameFromUrl returns .ts for index.d.ts
+            if (fileName.endsWith('.d.ts')) {
+              actualExtension = '.d.ts';
+              fileBaseName = fileName.substring(0, fileName.length - 5); // Remove .d.ts
+            } else {
+              const {
+                extension: fileExt
+              } = getFileNameFromUrl(fileName);
+              actualExtension = fileExt;
+              fileBaseName = fileName.substring(0, fileName.length - fileExt.length);
+            }
+            if (!indexFilesByBaseName.has(fileBaseName)) {
+              indexFilesByBaseName.set(fileBaseName, []);
+            }
+            // Store the entry with its actual extension for later matching
+            indexFilesByBaseName.get(fileBaseName).push({
+              ...moduleFile,
+              actualExtension
+            });
           }
-          moduleDir = joinPath(parentDir, directoryMatches[0].name);
-          _context2.p = 33;
-          _context2.n = 34;
-          return readDirectory(portablePathToFileUrl(moduleDir));
-        case 34:
-          moduleDirContents = _context2.v;
-          // Build a map of available index files by basename
-          indexFilesByBaseName = new Map();
-          _iterator6 = _createForOfIteratorHelper(moduleDirContents);
-          try {
-            for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
-              moduleFile = _step6.value;
-              if (moduleFile.isFile) {
-                fileName = moduleFile.name;
-                fileBaseName = void 0;
-                actualExtension = void 0; // Handle .d.ts files specially since getFileNameFromUrl returns .ts for index.d.ts
-                if (fileName.endsWith('.d.ts')) {
-                  actualExtension = '.d.ts';
-                  fileBaseName = fileName.substring(0, fileName.length - 5); // Remove .d.ts
-                } else {
-                  _getFileNameFromUrl = getFileNameFromUrl(fileName), fileExt = _getFileNameFromUrl.extension;
-                  actualExtension = fileExt;
-                  fileBaseName = fileName.substring(0, fileName.length - fileExt.length);
-                }
-                if (!indexFilesByBaseName.has(fileBaseName)) {
-                  indexFilesByBaseName.set(fileBaseName, []);
-                }
-                // Store the entry with its actual extension for later matching
-                indexFilesByBaseName.get(fileBaseName).push(_extends(_extends({}, moduleFile), {}, {
-                  actualExtension: actualExtension
-                }));
+        }
+
+        // Check for index files in extension priority order
+        const indexFiles = indexFilesByBaseName.get('index');
+        if (indexFiles) {
+          for (const ext of extensions) {
+            for (const entry of indexFiles) {
+              const entryWithExt = entry;
+              if (entryWithExt.actualExtension === ext) {
+                return portablePathToFileUrl(joinPath(moduleDir, entry.name));
               }
             }
-
-            // Check for index files in both priority orders
-          } catch (err) {
-            _iterator6.e(err);
-          } finally {
-            _iterator6.f();
-          }
-          indexFiles = indexFilesByBaseName.get('index');
-          if (!indexFiles) {
-            _context2.n = 65;
-            break;
-          }
-          indexEntryMap = indexFiles; // Find best match for value imports
-          _importPath = null;
-          _iterator7 = _createForOfIteratorHelper(VALUE_IMPORT_EXTENSIONS);
-          _context2.p = 35;
-          _iterator7.s();
-        case 36:
-          if ((_step7 = _iterator7.n()).done) {
-            _context2.n = 45;
-            break;
-          }
-          _ext2 = _step7.value;
-          _iterator9 = _createForOfIteratorHelper(indexEntryMap);
-          _context2.p = 37;
-          _iterator9.s();
-        case 38:
-          if ((_step9 = _iterator9.n()).done) {
-            _context2.n = 40;
-            break;
-          }
-          _entry2 = _step9.value;
-          if (!(_entry2.actualExtension === _ext2)) {
-            _context2.n = 39;
-            break;
-          }
-          _importPath = portablePathToFileUrl(joinPath(moduleDir, _entry2.name));
-          return _context2.a(3, 40);
-        case 39:
-          _context2.n = 38;
-          break;
-        case 40:
-          _context2.n = 42;
-          break;
-        case 41:
-          _context2.p = 41;
-          _t5 = _context2.v;
-          _iterator9.e(_t5);
-        case 42:
-          _context2.p = 42;
-          _iterator9.f();
-          return _context2.f(42);
-        case 43:
-          if (!_importPath) {
-            _context2.n = 44;
-            break;
-          }
-          return _context2.a(3, 45);
-        case 44:
-          _context2.n = 36;
-          break;
-        case 45:
-          _context2.n = 47;
-          break;
-        case 46:
-          _context2.p = 46;
-          _t6 = _context2.v;
-          _iterator7.e(_t6);
-        case 47:
-          _context2.p = 47;
-          _iterator7.f();
-          return _context2.f(47);
-        case 48:
-          // Find best match for type imports
-          _typeImportPath = null;
-          _iterator8 = _createForOfIteratorHelper(TYPE_IMPORT_EXTENSIONS);
-          _context2.p = 49;
-          _iterator8.s();
-        case 50:
-          if ((_step8 = _iterator8.n()).done) {
-            _context2.n = 59;
-            break;
-          }
-          _ext3 = _step8.value;
-          _iterator0 = _createForOfIteratorHelper(indexEntryMap);
-          _context2.p = 51;
-          _iterator0.s();
-        case 52:
-          if ((_step0 = _iterator0.n()).done) {
-            _context2.n = 54;
-            break;
-          }
-          _entry3 = _step0.value;
-          if (!(_entry3.actualExtension === _ext3)) {
-            _context2.n = 53;
-            break;
-          }
-          _typeImportPath = portablePathToFileUrl(joinPath(moduleDir, _entry3.name));
-          return _context2.a(3, 54);
-        case 53:
-          _context2.n = 52;
-          break;
-        case 54:
-          _context2.n = 56;
-          break;
-        case 55:
-          _context2.p = 55;
-          _t7 = _context2.v;
-          _iterator0.e(_t7);
-        case 56:
-          _context2.p = 56;
-          _iterator0.f();
-          return _context2.f(56);
-        case 57:
-          if (!_typeImportPath) {
-            _context2.n = 58;
-            break;
-          }
-          return _context2.a(3, 59);
-        case 58:
-          _context2.n = 50;
-          break;
-        case 59:
-          _context2.n = 61;
-          break;
-        case 60:
-          _context2.p = 60;
-          _t8 = _context2.v;
-          _iterator8.e(_t8);
-        case 61:
-          _context2.p = 61;
-          _iterator8.f();
-          return _context2.f(61);
-        case 62:
-          if (!(_importPath && _typeImportPath && _importPath !== _typeImportPath)) {
-            _context2.n = 63;
-            break;
           }
-          return _context2.a(2, {
-            "import": _importPath,
-            typeImport: _typeImportPath
-          });
-        case 63:
-          if (!_importPath) {
-            _context2.n = 64;
-            break;
-          }
-          return _context2.a(2, {
-            "import": _importPath
-          });
-        case 64:
-          if (!_typeImportPath) {
-            _context2.n = 65;
-            break;
-          }
-          return _context2.a(2, {
-            "import": _typeImportPath
-          });
-        case 65:
-          _context2.n = 67;
-          break;
-        case 66:
-          _context2.p = 66;
-          _t9 = _context2.v;
-        case 67:
-          throw new Error("Could not resolve module at path \"".concat(modulePath, "\". Tried extensions: ").concat(VALUE_IMPORT_EXTENSIONS.join(', '), ", ").concat(TYPE_IMPORT_EXTENSIONS.join(', ')));
-        case 68:
-          return _context2.a(2);
+        }
+      } catch {
+        // Could not read module directory, continue
       }
-    }, _callee2, null, [[51, 55, 56, 57], [49, 60, 61, 62], [37, 41, 42, 43], [35, 46, 47, 48], [33, 66], [18, 22, 23, 24], [16, 27, 28, 29], [4, 8, 9, 10], [2, 13, 14, 15]]);
-  }));
-  return _resolveWithTypeAwareness.apply(this, arguments);
-}
-function resolveSinglePath(_x5, _x6, _x7, _x8, _x9) {
-  return _resolveSinglePath.apply(this, arguments);
+    }
+  } catch {
+    // Could not read parent directory
+  }
+  throw new Error(`Could not resolve module at path "${modulePath}". Tried extensions: ${extensions.join(', ')}`);
 }
+
 /**
  * Resolves multiple module paths efficiently by grouping them by directory
  * and performing batch directory lookups.
@@ -623,241 +398,172 @@ function resolveSinglePath(_x5, _x6, _x7, _x8, _x9) {
  * @param options - Configuration options
  * @returns Promise<Map<string, string>> - Map from input path to resolved file path
  */
-function _resolveSinglePath() {
-  _resolveSinglePath = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(modulePath, parentDir, moduleName, readDirectory, extensions) {
-    var dirContents, filesByBaseName, _iterator1, _step1, _entry6, _fileName2, _fileBaseName2, _actualExtension2, _getFileNameFromUrl4, _fileExt2, matchingFiles, _iterator10, _step10, ext, _iterator11, _step11, entry, entryWithExt, resolvedPath, directoryMatches, moduleDir, moduleDirContents, indexFilesByBaseName, _iterator12, _step12, moduleFile, fileName, fileBaseName, actualExtension, _getFileNameFromUrl3, fileExt, indexFiles, _iterator13, _step13, _ext4, _iterator14, _step14, _entry5, _entryWithExt, _t0, _t1, _t10, _t11, _t12, _t13;
-    return _regenerator().w(function (_context3) {
-      while (1) switch (_context3.p = _context3.n) {
-        case 0:
-          _context3.p = 0;
-          _context3.n = 1;
-          return readDirectory(portablePathToFileUrl(parentDir));
-        case 1:
-          dirContents = _context3.v;
-          // Look for direct file matches in extension priority order
-          // Create a map of baseName -> files with that basename for efficient lookup
-          filesByBaseName = new Map();
-          _iterator1 = _createForOfIteratorHelper(dirContents);
-          try {
-            for (_iterator1.s(); !(_step1 = _iterator1.n()).done;) {
-              _entry6 = _step1.value;
-              if (_entry6.isFile) {
-                _fileName2 = _entry6.name;
-                _fileBaseName2 = void 0;
-                _actualExtension2 = void 0; // Handle .d.ts files specially since getFileNameFromUrl returns .ts for types.d.ts
-                if (_fileName2.endsWith('.d.ts')) {
-                  _actualExtension2 = '.d.ts';
-                  _fileBaseName2 = _fileName2.substring(0, _fileName2.length - 5); // Remove .d.ts
-                } else {
-                  _getFileNameFromUrl4 = getFileNameFromUrl(_fileName2), _fileExt2 = _getFileNameFromUrl4.extension;
-                  _actualExtension2 = _fileExt2;
-                  _fileBaseName2 = _fileName2.substring(0, _fileName2.length - _fileExt2.length);
-                }
-                if (!filesByBaseName.has(_fileBaseName2)) {
-                  filesByBaseName.set(_fileBaseName2, []);
-                }
-                // Store the entry with its actual extension for later matching
-                filesByBaseName.get(_fileBaseName2).push(_extends(_extends({}, _entry6), {}, {
-                  // Add a custom property to track the actual extension
-                  actualExtension: _actualExtension2
-                }));
+export async function resolveModulePaths(modulePaths, readDirectory, options = {}) {
+  const {
+    extensions = JAVASCRIPT_MODULE_EXTENSIONS
+  } = options;
+  const results = new Map();
+
+  // Group paths by their parent directory
+  const pathsByDirectory = new Map();
+  for (const modulePath of modulePaths) {
+    const lastSlashIndex = modulePath.lastIndexOf('/');
+    const parentDir = modulePath.substring(0, lastSlashIndex);
+    const moduleName = modulePath.substring(lastSlashIndex + 1);
+    if (!pathsByDirectory.has(parentDir)) {
+      pathsByDirectory.set(parentDir, []);
+    }
+    pathsByDirectory.get(parentDir).push({
+      fullPath: modulePath,
+      moduleName
+    });
+  }
+
+  // Process each directory group
+  const directoryEntries = Array.from(pathsByDirectory.entries());
+  const directoryResults = await Promise.all(directoryEntries.map(async ([parentDir, pathGroup]) => {
+    try {
+      // Read the directory contents once for all paths in this directory
+      const dirContents = await readDirectory(portablePathToFileUrl(parentDir));
+      const unresolved = [];
+      const resolved = [];
+
+      // Look for direct file matches in extension priority order
+      // Create a map of baseName -> files for efficient lookup
+      const filesByBaseName = new Map();
+      for (const entry of dirContents) {
+        if (entry.isFile) {
+          const fileName = entry.name;
+          const {
+            extension: fileExt
+          } = getFileNameFromUrl(fileName);
+          const fileBaseName = fileName.substring(0, fileName.length - fileExt.length);
+          if (!filesByBaseName.has(fileBaseName)) {
+            filesByBaseName.set(fileBaseName, []);
+          }
+          filesByBaseName.get(fileBaseName).push(entry);
+        }
+      }
+
+      // Check each module path against the file map
+      for (const {
+        fullPath,
+        moduleName
+      } of pathGroup) {
+        let foundMatch = false;
+        const matchingFiles = filesByBaseName.get(moduleName);
+        if (matchingFiles) {
+          for (const ext of extensions) {
+            for (const entry of matchingFiles) {
+              const {
+                extension: entryExt
+              } = getFileNameFromUrl(entry.name);
+              if (entryExt === ext) {
+                resolved.push({
+                  fullPath,
+                  resolvedPath: portablePathToFileUrl(joinPath(parentDir, entry.name))
+                });
+                foundMatch = true;
+                break;
               }
             }
-
-            // Check for the module in extension priority order
-          } catch (err) {
-            _iterator1.e(err);
-          } finally {
-            _iterator1.f();
-          }
-          matchingFiles = filesByBaseName.get(moduleName);
-          if (!matchingFiles) {
-            _context3.n = 14;
-            break;
-          }
-          _iterator10 = _createForOfIteratorHelper(extensions);
-          _context3.p = 2;
-          _iterator10.s();
-        case 3:
-          if ((_step10 = _iterator10.n()).done) {
-            _context3.n = 11;
-            break;
-          }
-          ext = _step10.value;
-          _iterator11 = _createForOfIteratorHelper(matchingFiles);
-          _context3.p = 4;
-          _iterator11.s();
-        case 5:
-          if ((_step11 = _iterator11.n()).done) {
-            _context3.n = 7;
-            break;
-          }
-          entry = _step11.value;
-          entryWithExt = entry;
-          if (!(entryWithExt.actualExtension === ext)) {
-            _context3.n = 6;
-            break;
+            if (foundMatch) {
+              break;
+            }
           }
-          resolvedPath = joinPath(parentDir, entry.name);
-          return _context3.a(2, portablePathToFileUrl(resolvedPath));
-        case 6:
-          _context3.n = 5;
-          break;
-        case 7:
-          _context3.n = 9;
-          break;
-        case 8:
-          _context3.p = 8;
-          _t0 = _context3.v;
-          _iterator11.e(_t0);
-        case 9:
-          _context3.p = 9;
-          _iterator11.f();
-          return _context3.f(9);
-        case 10:
-          _context3.n = 3;
-          break;
-        case 11:
-          _context3.n = 13;
-          break;
-        case 12:
-          _context3.p = 12;
-          _t1 = _context3.v;
-          _iterator10.e(_t1);
-        case 13:
-          _context3.p = 13;
-          _iterator10.f();
-          return _context3.f(13);
-        case 14:
-          // Look for directory with index files
-          directoryMatches = dirContents.filter(function (entry) {
-            return entry.isDirectory && entry.name === moduleName;
+        }
+        if (!foundMatch) {
+          unresolved.push({
+            fullPath,
+            moduleName
           });
-          if (!(directoryMatches.length > 0)) {
-            _context3.n = 31;
-            break;
-          }
-          moduleDir = joinPath(parentDir, directoryMatches[0].name);
-          _context3.p = 15;
-          _context3.n = 16;
-          return readDirectory(portablePathToFileUrl(moduleDir));
-        case 16:
-          moduleDirContents = _context3.v;
-          // Look for index files in extension priority order
-          // Create a map of baseName -> files for efficient lookup
-          indexFilesByBaseName = new Map();
-          _iterator12 = _createForOfIteratorHelper(moduleDirContents);
-          try {
-            for (_iterator12.s(); !(_step12 = _iterator12.n()).done;) {
-              moduleFile = _step12.value;
-              if (moduleFile.isFile) {
-                fileName = moduleFile.name;
-                fileBaseName = void 0;
-                actualExtension = void 0; // Handle .d.ts files specially since getFileNameFromUrl returns .ts for index.d.ts
-                if (fileName.endsWith('.d.ts')) {
-                  actualExtension = '.d.ts';
-                  fileBaseName = fileName.substring(0, fileName.length - 5); // Remove .d.ts
-                } else {
-                  _getFileNameFromUrl3 = getFileNameFromUrl(fileName), fileExt = _getFileNameFromUrl3.extension;
-                  actualExtension = fileExt;
-                  fileBaseName = fileName.substring(0, fileName.length - fileExt.length);
+        }
+      }
+
+      // For unresolved paths, check if they are directories with index files
+      if (unresolved.length > 0) {
+        const directories = new Set(dirContents.filter(entry => entry.isDirectory).map(entry => entry.name));
+        const indexResults = await Promise.all(unresolved.map(async ({
+          fullPath,
+          moduleName
+        }) => {
+          if (directories.has(moduleName)) {
+            const moduleDir = joinPath(parentDir, moduleName);
+            try {
+              const moduleDirContents = await readDirectory(portablePathToFileUrl(moduleDir));
+
+              // Look for index files in extension priority order
+              // Create a map of baseName -> files for efficient lookup
+              const indexFilesByBaseName = new Map();
+              for (const moduleFile of moduleDirContents) {
+                if (moduleFile.isFile) {
+                  const fileName = moduleFile.name;
+                  const {
+                    extension: fileExt
+                  } = getFileNameFromUrl(fileName);
+                  const fileBaseName = fileName.substring(0, fileName.length - fileExt.length);
+                  if (!indexFilesByBaseName.has(fileBaseName)) {
+                    indexFilesByBaseName.set(fileBaseName, []);
+                  }
+                  indexFilesByBaseName.get(fileBaseName).push(moduleFile);
                 }
-                if (!indexFilesByBaseName.has(fileBaseName)) {
-                  indexFilesByBaseName.set(fileBaseName, []);
+              }
+
+              // Check for index files in extension priority order
+              const indexFiles = indexFilesByBaseName.get('index');
+              if (indexFiles) {
+                for (const ext of extensions) {
+                  for (const entry of indexFiles) {
+                    const {
+                      extension: entryExt
+                    } = getFileNameFromUrl(entry.name);
+                    if (entryExt === ext) {
+                      return {
+                        fullPath,
+                        resolvedPath: portablePathToFileUrl(joinPath(moduleDir, entry.name))
+                      };
+                    }
+                  }
                 }
-                // Store the entry with its actual extension for later matching
-                indexFilesByBaseName.get(fileBaseName).push(_extends(_extends({}, moduleFile), {}, {
-                  actualExtension: actualExtension
-                }));
               }
+            } catch {
+              // Could not read module directory, leave unresolved
             }
-
-            // Check for index files in extension priority order
-          } catch (err) {
-            _iterator12.e(err);
-          } finally {
-            _iterator12.f();
-          }
-          indexFiles = indexFilesByBaseName.get('index');
-          if (!indexFiles) {
-            _context3.n = 29;
-            break;
-          }
-          _iterator13 = _createForOfIteratorHelper(extensions);
-          _context3.p = 17;
-          _iterator13.s();
-        case 18:
-          if ((_step13 = _iterator13.n()).done) {
-            _context3.n = 26;
-            break;
-          }
-          _ext4 = _step13.value;
-          _iterator14 = _createForOfIteratorHelper(indexFiles);
-          _context3.p = 19;
-          _iterator14.s();
-        case 20:
-          if ((_step14 = _iterator14.n()).done) {
-            _context3.n = 22;
-            break;
-          }
-          _entry5 = _step14.value;
-          _entryWithExt = _entry5;
-          if (!(_entryWithExt.actualExtension === _ext4)) {
-            _context3.n = 21;
-            break;
           }
-          return _context3.a(2, portablePathToFileUrl(joinPath(moduleDir, _entry5.name)));
-        case 21:
-          _context3.n = 20;
-          break;
-        case 22:
-          _context3.n = 24;
-          break;
-        case 23:
-          _context3.p = 23;
-          _t10 = _context3.v;
-          _iterator14.e(_t10);
-        case 24:
-          _context3.p = 24;
-          _iterator14.f();
-          return _context3.f(24);
-        case 25:
-          _context3.n = 18;
-          break;
-        case 26:
-          _context3.n = 28;
-          break;
-        case 27:
-          _context3.p = 27;
-          _t11 = _context3.v;
-          _iterator13.e(_t11);
-        case 28:
-          _context3.p = 28;
-          _iterator13.f();
-          return _context3.f(28);
-        case 29:
-          _context3.n = 31;
-          break;
-        case 30:
-          _context3.p = 30;
-          _t12 = _context3.v;
-        case 31:
-          _context3.n = 33;
-          break;
-        case 32:
-          _context3.p = 32;
-          _t13 = _context3.v;
-        case 33:
-          throw new Error("Could not resolve module at path \"".concat(modulePath, "\". Tried extensions: ").concat(extensions.join(', ')));
-        case 34:
-          return _context3.a(2);
+          return {
+            fullPath,
+            resolvedPath: null
+          };
+        }));
+        for (const {
+          fullPath,
+          resolvedPath
+        } of indexResults) {
+          if (resolvedPath) {
+            resolved.push({
+              fullPath,
+              resolvedPath
+            });
+          }
+        }
       }
-    }, _callee3, null, [[19, 23, 24, 25], [17, 27, 28, 29], [15, 30], [4, 8, 9, 10], [2, 12, 13, 14], [0, 32]]);
+      return resolved;
+    } catch {
+      // Could not read parent directory, return empty array
+      return [];
+    }
   }));
-  return _resolveSinglePath.apply(this, arguments);
-}
-export function resolveModulePaths(_x0, _x1) {
-  return _resolveModulePaths.apply(this, arguments);
+
+  // Collect all resolved paths
+  for (const directoryResult of directoryResults) {
+    for (const {
+      fullPath,
+      resolvedPath
+    } of directoryResult) {
+      results.set(fullPath, resolvedPath);
+    }
+  }
+  return results;
 }
 
 /**
@@ -870,390 +576,79 @@ export function resolveModulePaths(_x0, _x1) {
  * @param options - Configuration options for module resolution
  * @returns Promise<Map<string, string>> - Map from import path to resolved file path
  */
-function _resolveModulePaths() {
-  _resolveModulePaths = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee6(modulePaths, readDirectory) {
-    var options,
-      _options$extensions2,
-      extensions,
-      results,
-      pathsByDirectory,
-      _iterator15,
-      _step15,
-      modulePath,
-      lastSlashIndex,
-      parentDir,
-      moduleName,
-      directoryEntries,
-      directoryResults,
-      _iterator24,
-      _step24,
-      directoryResult,
-      _iterator25,
-      _step25,
-      _step25$value,
-      fullPath,
-      resolvedPath,
-      _args6 = arguments;
-    return _regenerator().w(function (_context6) {
-      while (1) switch (_context6.n) {
-        case 0:
-          options = _args6.length > 2 && _args6[2] !== undefined ? _args6[2] : {};
-          _options$extensions2 = options.extensions, extensions = _options$extensions2 === void 0 ? JAVASCRIPT_MODULE_EXTENSIONS : _options$extensions2;
-          results = new Map(); // Group paths by their parent directory
-          pathsByDirectory = new Map();
-          _iterator15 = _createForOfIteratorHelper(modulePaths);
-          try {
-            for (_iterator15.s(); !(_step15 = _iterator15.n()).done;) {
-              modulePath = _step15.value;
-              lastSlashIndex = modulePath.lastIndexOf('/');
-              parentDir = modulePath.substring(0, lastSlashIndex);
-              moduleName = modulePath.substring(lastSlashIndex + 1);
-              if (!pathsByDirectory.has(parentDir)) {
-                pathsByDirectory.set(parentDir, []);
-              }
-              pathsByDirectory.get(parentDir).push({
-                fullPath: modulePath,
-                moduleName: moduleName
-              });
-            }
+export async function resolveImportResult(importResult, readDirectory, options = {}) {
+  const resolvedPathsMap = new Map();
 
-            // Process each directory group
-          } catch (err) {
-            _iterator15.e(err);
-          } finally {
-            _iterator15.f();
-          }
-          directoryEntries = Array.from(pathsByDirectory.entries());
-          _context6.n = 1;
-          return Promise.all(directoryEntries.map(/*#__PURE__*/function () {
-            var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5(_ref) {
-              var _ref3, parentDir, pathGroup, dirContents, unresolved, resolved, filesByBaseName, _iterator16, _step16, entry, fileName, _getFileNameFromUrl7, fileExt, fileBaseName, _iterator17, _step17, _step17$value, _fullPath, moduleName, foundMatch, matchingFiles, _iterator22, _step22, ext, _iterator23, _step23, _entry7, _getFileNameFromUrl8, entryExt, directories, indexResults, _iterator21, _step21, _step21$value, fullPath, resolvedPath, _t17, _t18, _t19, _t20;
-              return _regenerator().w(function (_context5) {
-                while (1) switch (_context5.p = _context5.n) {
-                  case 0:
-                    _ref3 = _slicedToArray(_ref, 2), parentDir = _ref3[0], pathGroup = _ref3[1];
-                    _context5.p = 1;
-                    _context5.n = 2;
-                    return readDirectory(portablePathToFileUrl(parentDir));
-                  case 2:
-                    dirContents = _context5.v;
-                    unresolved = [];
-                    resolved = []; // Look for direct file matches in extension priority order
-                    // Create a map of baseName -> files for efficient lookup
-                    filesByBaseName = new Map();
-                    _iterator16 = _createForOfIteratorHelper(dirContents);
-                    try {
-                      for (_iterator16.s(); !(_step16 = _iterator16.n()).done;) {
-                        entry = _step16.value;
-                        if (entry.isFile) {
-                          fileName = entry.name;
-                          _getFileNameFromUrl7 = getFileNameFromUrl(fileName), fileExt = _getFileNameFromUrl7.extension;
-                          fileBaseName = fileName.substring(0, fileName.length - fileExt.length);
-                          if (!filesByBaseName.has(fileBaseName)) {
-                            filesByBaseName.set(fileBaseName, []);
-                          }
-                          filesByBaseName.get(fileBaseName).push(entry);
-                        }
-                      }
+  // Separate imports into categories for processing
+  const jsModulesToResolve = [];
+  const jsModulesWithExtensions = [];
+  const staticAssets = [];
+  for (const [importPath, {
+    url,
+    includeTypeDefs
+  }] of Object.entries(importResult)) {
+    if (isJavaScriptModule(importPath)) {
+      // If the import path already has a JS/TS extension, use it as-is
+      if (JAVASCRIPT_MODULE_EXTENSIONS.some(ext => importPath.endsWith(ext))) {
+        jsModulesWithExtensions.push(url);
+      } else {
+        jsModulesToResolve.push({
+          url,
+          includeTypeDefs
+        });
+      }
+    } else {
+      // Static asset - use url as-is
+      staticAssets.push(url);
+    }
+  }
 
-                      // Check each module path against the file map
-                    } catch (err) {
-                      _iterator16.e(err);
-                    } finally {
-                      _iterator16.f();
-                    }
-                    _iterator17 = _createForOfIteratorHelper(pathGroup);
-                    _context5.p = 3;
-                    _iterator17.s();
-                  case 4:
-                    if ((_step17 = _iterator17.n()).done) {
-                      _context5.n = 20;
-                      break;
-                    }
-                    _step17$value = _step17.value, _fullPath = _step17$value.fullPath, moduleName = _step17$value.moduleName;
-                    foundMatch = false;
-                    matchingFiles = filesByBaseName.get(moduleName);
-                    if (!matchingFiles) {
-                      _context5.n = 18;
-                      break;
-                    }
-                    _iterator22 = _createForOfIteratorHelper(extensions);
-                    _context5.p = 5;
-                    _iterator22.s();
-                  case 6:
-                    if ((_step22 = _iterator22.n()).done) {
-                      _context5.n = 15;
-                      break;
-                    }
-                    ext = _step22.value;
-                    _iterator23 = _createForOfIteratorHelper(matchingFiles);
-                    _context5.p = 7;
-                    _iterator23.s();
-                  case 8:
-                    if ((_step23 = _iterator23.n()).done) {
-                      _context5.n = 10;
-                      break;
-                    }
-                    _entry7 = _step23.value;
-                    _getFileNameFromUrl8 = getFileNameFromUrl(_entry7.name), entryExt = _getFileNameFromUrl8.extension;
-                    if (!(entryExt === ext)) {
-                      _context5.n = 9;
-                      break;
-                    }
-                    resolved.push({
-                      fullPath: _fullPath,
-                      resolvedPath: portablePathToFileUrl(joinPath(parentDir, _entry7.name))
-                    });
-                    foundMatch = true;
-                    return _context5.a(3, 10);
-                  case 9:
-                    _context5.n = 8;
-                    break;
-                  case 10:
-                    _context5.n = 12;
-                    break;
-                  case 11:
-                    _context5.p = 11;
-                    _t17 = _context5.v;
-                    _iterator23.e(_t17);
-                  case 12:
-                    _context5.p = 12;
-                    _iterator23.f();
-                    return _context5.f(12);
-                  case 13:
-                    if (!foundMatch) {
-                      _context5.n = 14;
-                      break;
-                    }
-                    return _context5.a(3, 15);
-                  case 14:
-                    _context5.n = 6;
-                    break;
-                  case 15:
-                    _context5.n = 17;
-                    break;
-                  case 16:
-                    _context5.p = 16;
-                    _t18 = _context5.v;
-                    _iterator22.e(_t18);
-                  case 17:
-                    _context5.p = 17;
-                    _iterator22.f();
-                    return _context5.f(17);
-                  case 18:
-                    if (!foundMatch) {
-                      unresolved.push({
-                        fullPath: _fullPath,
-                        moduleName: moduleName
-                      });
-                    }
-                  case 19:
-                    _context5.n = 4;
-                    break;
-                  case 20:
-                    _context5.n = 22;
-                    break;
-                  case 21:
-                    _context5.p = 21;
-                    _t19 = _context5.v;
-                    _iterator17.e(_t19);
-                  case 22:
-                    _context5.p = 22;
-                    _iterator17.f();
-                    return _context5.f(22);
-                  case 23:
-                    if (!(unresolved.length > 0)) {
-                      _context5.n = 25;
-                      break;
-                    }
-                    directories = new Set(dirContents.filter(function (entry) {
-                      return entry.isDirectory;
-                    }).map(function (entry) {
-                      return entry.name;
-                    }));
-                    _context5.n = 24;
-                    return Promise.all(unresolved.map(/*#__PURE__*/function () {
-                      var _ref5 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(_ref4) {
-                        var fullPath, moduleName, moduleDir, moduleDirContents, indexFilesByBaseName, _iterator18, _step18, moduleFile, fileName, _getFileNameFromUrl6, fileExt, fileBaseName, indexFiles, _iterator19, _step19, ext, _iterator20, _step20, entry, _getFileNameFromUrl5, entryExt, _t14, _t15, _t16;
-                        return _regenerator().w(function (_context4) {
-                          while (1) switch (_context4.p = _context4.n) {
-                            case 0:
-                              fullPath = _ref4.fullPath, moduleName = _ref4.moduleName;
-                              if (!directories.has(moduleName)) {
-                                _context4.n = 17;
-                                break;
-                              }
-                              moduleDir = joinPath(parentDir, moduleName);
-                              _context4.p = 1;
-                              _context4.n = 2;
-                              return readDirectory(portablePathToFileUrl(moduleDir));
-                            case 2:
-                              moduleDirContents = _context4.v;
-                              // Look for index files in extension priority order
-                              // Create a map of baseName -> files for efficient lookup
-                              indexFilesByBaseName = new Map();
-                              _iterator18 = _createForOfIteratorHelper(moduleDirContents);
-                              try {
-                                for (_iterator18.s(); !(_step18 = _iterator18.n()).done;) {
-                                  moduleFile = _step18.value;
-                                  if (moduleFile.isFile) {
-                                    fileName = moduleFile.name;
-                                    _getFileNameFromUrl6 = getFileNameFromUrl(fileName), fileExt = _getFileNameFromUrl6.extension;
-                                    fileBaseName = fileName.substring(0, fileName.length - fileExt.length);
-                                    if (!indexFilesByBaseName.has(fileBaseName)) {
-                                      indexFilesByBaseName.set(fileBaseName, []);
-                                    }
-                                    indexFilesByBaseName.get(fileBaseName).push(moduleFile);
-                                  }
-                                }
+  // Add modules with extensions as-is
+  jsModulesWithExtensions.forEach(url => {
+    resolvedPathsMap.set(url, url);
+  });
 
-                                // Check for index files in extension priority order
-                              } catch (err) {
-                                _iterator18.e(err);
-                              } finally {
-                                _iterator18.f();
-                              }
-                              indexFiles = indexFilesByBaseName.get('index');
-                              if (!indexFiles) {
-                                _context4.n = 15;
-                                break;
-                              }
-                              _iterator19 = _createForOfIteratorHelper(extensions);
-                              _context4.p = 3;
-                              _iterator19.s();
-                            case 4:
-                              if ((_step19 = _iterator19.n()).done) {
-                                _context4.n = 12;
-                                break;
-                              }
-                              ext = _step19.value;
-                              _iterator20 = _createForOfIteratorHelper(indexFiles);
-                              _context4.p = 5;
-                              _iterator20.s();
-                            case 6:
-                              if ((_step20 = _iterator20.n()).done) {
-                                _context4.n = 8;
-                                break;
-                              }
-                              entry = _step20.value;
-                              _getFileNameFromUrl5 = getFileNameFromUrl(entry.name), entryExt = _getFileNameFromUrl5.extension;
-                              if (!(entryExt === ext)) {
-                                _context4.n = 7;
-                                break;
-                              }
-                              return _context4.a(2, {
-                                fullPath: fullPath,
-                                resolvedPath: portablePathToFileUrl(joinPath(moduleDir, entry.name))
-                              });
-                            case 7:
-                              _context4.n = 6;
-                              break;
-                            case 8:
-                              _context4.n = 10;
-                              break;
-                            case 9:
-                              _context4.p = 9;
-                              _t14 = _context4.v;
-                              _iterator20.e(_t14);
-                            case 10:
-                              _context4.p = 10;
-                              _iterator20.f();
-                              return _context4.f(10);
-                            case 11:
-                              _context4.n = 4;
-                              break;
-                            case 12:
-                              _context4.n = 14;
-                              break;
-                            case 13:
-                              _context4.p = 13;
-                              _t15 = _context4.v;
-                              _iterator19.e(_t15);
-                            case 14:
-                              _context4.p = 14;
-                              _iterator19.f();
-                              return _context4.f(14);
-                            case 15:
-                              _context4.n = 17;
-                              break;
-                            case 16:
-                              _context4.p = 16;
-                              _t16 = _context4.v;
-                            case 17:
-                              return _context4.a(2, {
-                                fullPath: fullPath,
-                                resolvedPath: null
-                              });
-                          }
-                        }, _callee4, null, [[5, 9, 10, 11], [3, 13, 14, 15], [1, 16]]);
-                      }));
-                      return function (_x15) {
-                        return _ref5.apply(this, arguments);
-                      };
-                    }()));
-                  case 24:
-                    indexResults = _context5.v;
-                    _iterator21 = _createForOfIteratorHelper(indexResults);
-                    try {
-                      for (_iterator21.s(); !(_step21 = _iterator21.n()).done;) {
-                        _step21$value = _step21.value, fullPath = _step21$value.fullPath, resolvedPath = _step21$value.resolvedPath;
-                        if (resolvedPath) {
-                          resolved.push({
-                            fullPath: fullPath,
-                            resolvedPath: resolvedPath
-                          });
-                        }
-                      }
-                    } catch (err) {
-                      _iterator21.e(err);
-                    } finally {
-                      _iterator21.f();
-                    }
-                  case 25:
-                    return _context5.a(2, resolved);
-                  case 26:
-                    _context5.p = 26;
-                    _t20 = _context5.v;
-                    return _context5.a(2, []);
-                }
-              }, _callee5, null, [[7, 11, 12, 13], [5, 16, 17, 18], [3, 21, 22, 23], [1, 26]]);
-            }));
-            return function (_x14) {
-              return _ref2.apply(this, arguments);
-            };
-          }()));
-        case 1:
-          directoryResults = _context6.v;
-          // Collect all resolved paths
-          _iterator24 = _createForOfIteratorHelper(directoryResults);
-          try {
-            for (_iterator24.s(); !(_step24 = _iterator24.n()).done;) {
-              directoryResult = _step24.value;
-              _iterator25 = _createForOfIteratorHelper(directoryResult);
-              try {
-                for (_iterator25.s(); !(_step25 = _iterator25.n()).done;) {
-                  _step25$value = _step25.value, fullPath = _step25$value.fullPath, resolvedPath = _step25$value.resolvedPath;
-                  results.set(fullPath, resolvedPath);
-                }
-              } catch (err) {
-                _iterator25.e(err);
-              } finally {
-                _iterator25.f();
-              }
-            }
-          } catch (err) {
-            _iterator24.e(err);
-          } finally {
-            _iterator24.f();
-          }
-          return _context6.a(2, results);
+  // Add static assets as-is
+  staticAssets.forEach(url => {
+    resolvedPathsMap.set(url, url);
+  });
+
+  // Resolve JS modules without extensions
+  if (jsModulesToResolve.length > 0) {
+    const resolutionPromises = jsModulesToResolve.map(async ({
+      url,
+      includeTypeDefs
+    }) => {
+      try {
+        const resolved = await resolveModulePath(url, readDirectory, options, includeTypeDefs);
+        if (typeof resolved === 'string') {
+          // Simple string result
+          return {
+            url,
+            resolved
+          };
+        }
+
+        // Type-aware result - for now, just use the import path
+        // TODO: We might want to store both paths in the future
+        return {
+          url,
+          resolved: resolved.import
+        };
+      } catch (error) {
+        return null; // Mark as failed
       }
-    }, _callee6);
-  }));
-  return _resolveModulePaths.apply(this, arguments);
-}
-export function resolveImportResult(_x10, _x11) {
-  return _resolveImportResult.apply(this, arguments);
+    });
+    const resolutionResults = await Promise.all(resolutionPromises);
+
+    // Add successful resolutions to the map
+    resolutionResults.forEach(result => {
+      if (result) {
+        resolvedPathsMap.set(result.url, result.resolved);
+      }
+    });
+  }
+  return resolvedPathsMap;
 }
 
 /**
@@ -1266,173 +661,19 @@ export function resolveImportResult(_x10, _x11) {
  * @param options - Configuration options for module resolution
  * @returns Promise<Map<string, string>> - Map from variant name to resolved file URL
  */
-function _resolveImportResult() {
-  _resolveImportResult = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee8(importResult, readDirectory) {
-    var options,
-      resolvedPathsMap,
-      jsModulesToResolve,
-      jsModulesWithExtensions,
-      staticAssets,
-      _loop,
-      _i,
-      _Object$entries,
-      resolutionPromises,
-      resolutionResults,
-      _args9 = arguments;
-    return _regenerator().w(function (_context9) {
-      while (1) switch (_context9.n) {
-        case 0:
-          options = _args9.length > 2 && _args9[2] !== undefined ? _args9[2] : {};
-          resolvedPathsMap = new Map(); // Separate imports into categories for processing
-          jsModulesToResolve = [];
-          jsModulesWithExtensions = [];
-          staticAssets = [];
-          _loop = /*#__PURE__*/_regenerator().m(function _loop() {
-            var _Object$entries$_i, importPath, _Object$entries$_i$, url, includeTypeDefs;
-            return _regenerator().w(function (_context7) {
-              while (1) switch (_context7.n) {
-                case 0:
-                  _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2), importPath = _Object$entries$_i[0], _Object$entries$_i$ = _Object$entries$_i[1], url = _Object$entries$_i$.url, includeTypeDefs = _Object$entries$_i$.includeTypeDefs;
-                  if (isJavaScriptModule(importPath)) {
-                    // If the import path already has a JS/TS extension, use it as-is
-                    if (JAVASCRIPT_MODULE_EXTENSIONS.some(function (ext) {
-                      return importPath.endsWith(ext);
-                    })) {
-                      jsModulesWithExtensions.push(url);
-                    } else {
-                      jsModulesToResolve.push({
-                        url: url,
-                        includeTypeDefs: includeTypeDefs
-                      });
-                    }
-                  } else {
-                    // Static asset - use url as-is
-                    staticAssets.push(url);
-                  }
-                case 1:
-                  return _context7.a(2);
-              }
-            }, _loop);
-          });
-          _i = 0, _Object$entries = Object.entries(importResult);
-        case 1:
-          if (!(_i < _Object$entries.length)) {
-            _context9.n = 3;
-            break;
-          }
-          return _context9.d(_regeneratorValues(_loop()), 2);
-        case 2:
-          _i++;
-          _context9.n = 1;
-          break;
-        case 3:
-          // Add modules with extensions as-is
-          jsModulesWithExtensions.forEach(function (url) {
-            resolvedPathsMap.set(url, url);
-          });
-
-          // Add static assets as-is
-          staticAssets.forEach(function (url) {
-            resolvedPathsMap.set(url, url);
-          });
+export async function resolveVariantPaths(variants, readDirectory, options = {}) {
+  // Extract the variant paths and resolve them
+  const variantPaths = Object.values(variants);
+  const resolvedVariantPaths = await resolveModulePaths(variantPaths, readDirectory, options);
 
-          // Resolve JS modules without extensions
-          if (!(jsModulesToResolve.length > 0)) {
-            _context9.n = 5;
-            break;
-          }
-          resolutionPromises = jsModulesToResolve.map(/*#__PURE__*/function () {
-            var _ref7 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee7(_ref6) {
-              var url, includeTypeDefs, resolved, _t21;
-              return _regenerator().w(function (_context8) {
-                while (1) switch (_context8.p = _context8.n) {
-                  case 0:
-                    url = _ref6.url, includeTypeDefs = _ref6.includeTypeDefs;
-                    _context8.p = 1;
-                    _context8.n = 2;
-                    return resolveModulePath(url, readDirectory, options, includeTypeDefs);
-                  case 2:
-                    resolved = _context8.v;
-                    if (!(typeof resolved === 'string')) {
-                      _context8.n = 3;
-                      break;
-                    }
-                    return _context8.a(2, {
-                      url: url,
-                      resolved: resolved
-                    });
-                  case 3:
-                    return _context8.a(2, {
-                      url: url,
-                      resolved: resolved["import"]
-                    });
-                  case 4:
-                    _context8.p = 4;
-                    _t21 = _context8.v;
-                    return _context8.a(2, null);
-                }
-              }, _callee7, null, [[1, 4]]);
-            }));
-            return function (_x16) {
-              return _ref7.apply(this, arguments);
-            };
-          }());
-          _context9.n = 4;
-          return Promise.all(resolutionPromises);
-        case 4:
-          resolutionResults = _context9.v;
-          // Add successful resolutions to the map
-          resolutionResults.forEach(function (result) {
-            if (result) {
-              resolvedPathsMap.set(result.url, result.resolved);
-            }
-          });
-        case 5:
-          return _context9.a(2, resolvedPathsMap);
-      }
-    }, _callee8);
-  }));
-  return _resolveImportResult.apply(this, arguments);
-}
-export function resolveVariantPaths(_x12, _x13) {
-  return _resolveVariantPaths.apply(this, arguments);
-}
-function _resolveVariantPaths() {
-  _resolveVariantPaths = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee9(variants, readDirectory) {
-    var options,
-      variantPaths,
-      resolvedVariantPaths,
-      variantMap,
-      _i2,
-      _Object$entries2,
-      _Object$entries2$_i,
-      variantName,
-      variantPath,
-      resolvedVariantPath,
-      _args0 = arguments;
-    return _regenerator().w(function (_context0) {
-      while (1) switch (_context0.n) {
-        case 0:
-          options = _args0.length > 2 && _args0[2] !== undefined ? _args0[2] : {};
-          // Extract the variant paths and resolve them
-          variantPaths = Object.values(variants);
-          _context0.n = 1;
-          return resolveModulePaths(variantPaths, readDirectory, options);
-        case 1:
-          resolvedVariantPaths = _context0.v;
-          // Build a map from variant name to resolved file URL
-          variantMap = new Map();
-          for (_i2 = 0, _Object$entries2 = Object.entries(variants); _i2 < _Object$entries2.length; _i2++) {
-            _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2), variantName = _Object$entries2$_i[0], variantPath = _Object$entries2$_i[1];
-            resolvedVariantPath = resolvedVariantPaths.get(variantPath);
-            if (resolvedVariantPath) {
-              // Store as a file URL (portablePathToFileUrl handles portable paths correctly)
-              variantMap.set(variantName, portablePathToFileUrl(resolvedVariantPath));
-            }
-          }
-          return _context0.a(2, variantMap);
-      }
-    }, _callee9);
-  }));
-  return _resolveVariantPaths.apply(this, arguments);
+  // Build a map from variant name to resolved file URL
+  const variantMap = new Map();
+  for (const [variantName, variantPath] of Object.entries(variants)) {
+    const resolvedVariantPath = resolvedVariantPaths.get(variantPath);
+    if (resolvedVariantPath) {
+      // Store as a file URL (portablePathToFileUrl handles portable paths correctly)
+      variantMap.set(variantName, portablePathToFileUrl(resolvedVariantPath));
+    }
+  }
+  return variantMap;
 }