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

package/esm/pipeline/loaderUtils/processRelativeImports.js

@@ -1,6 +1,3 @@
-import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import { rewriteImports } from "./rewriteImports.js";
 import { isJavaScriptModule } from "./resolveModulePath.js";
 import { getFileNameFromUrl } from "./getFileNameFromUrl.js";
@@ -9,22 +6,19 @@ import { fileUrlToPortablePath, portablePathToFileUrl } from "./fileUrlToPortabl
  * Processes flat mode with intelligent conflict resolution
  */
 function processFlatMode(importResult, resolvedPathsMap) {
-  var extraFiles = {};
-  var fileMapping = [];
+  const extraFiles = {};
+  const fileMapping = [];
 
   // First pass: collect all files and their path segments
-  Object.entries(importResult).forEach(function (_ref) {
-    var _ref2 = _slicedToArray(_ref, 2),
-      relativePath = _ref2[0],
-      importInfo = _ref2[1];
-    var resolvedUrl = resolvedPathsMap.get(importInfo.url);
+  Object.entries(importResult).forEach(([relativePath, importInfo]) => {
+    const resolvedUrl = resolvedPathsMap.get(importInfo.url);
     if (resolvedUrl) {
       // Convert file URL to portable path for path manipulation
-      var resolvedPath = resolvedUrl.startsWith('file://') ? fileUrlToPortablePath(resolvedUrl) : resolvedUrl;
-      var fileExtension = getFileNameFromUrl(resolvedUrl).extension;
-      var pathSegments = resolvedPath.split('/').filter(Boolean);
+      const resolvedPath = resolvedUrl.startsWith('file://') ? fileUrlToPortablePath(resolvedUrl) : resolvedUrl;
+      const fileExtension = getFileNameFromUrl(resolvedUrl).extension;
+      const pathSegments = resolvedPath.split('/').filter(Boolean);
       fileMapping.push({
-        resolvedPath: resolvedPath,
+        resolvedPath,
         extension: fileExtension,
         segments: pathSegments,
         originalImportPath: relativePath
@@ -33,29 +27,28 @@ function processFlatMode(importResult, resolvedPathsMap) {
   });
 
   // Second pass: determine candidate names and group by conflicts
-  var candidateNames = new Map();
-  var nameGroups = new Map();
-  for (var _i = 0, _fileMapping = fileMapping; _i < _fileMapping.length; _i++) {
-    var file = _fileMapping[_i];
-    var fileName = file.segments[file.segments.length - 1];
-    var isIndexFile = fileName.startsWith('index.');
-    var isUnderscoreIndexFile = fileName.startsWith('_index.');
-    var candidateName = void 0;
+  const candidateNames = new Map();
+  const nameGroups = new Map();
+  for (const file of fileMapping) {
+    const fileName = file.segments[file.segments.length - 1];
+    const isIndexFile = fileName.startsWith('index.');
+    const isUnderscoreIndexFile = fileName.startsWith('_index.');
+    let candidateName;
     if (isUnderscoreIndexFile) {
       // Files starting with "_index." should be treated as direct index imports
       // e.g., "../../dir/_index.module.css" -> "index.module.css"
-      candidateName = "index".concat(file.extension);
+      candidateName = `index${file.extension}`;
     } else if (isIndexFile) {
       // Check if the original import was a direct index file (e.g., "./index.ext")
-      var originalImportParts = file.originalImportPath.split('/');
-      var isDirectIndexImport = originalImportParts.length === 2 && originalImportParts[0] === '.' && originalImportParts[1].startsWith('index.');
+      const originalImportParts = file.originalImportPath.split('/');
+      const isDirectIndexImport = originalImportParts.length === 2 && originalImportParts[0] === '.' && originalImportParts[1].startsWith('index.');
       if (isDirectIndexImport) {
         // For direct index imports like "./index.ext", keep the original name
-        candidateName = "index".concat(file.extension);
+        candidateName = `index${file.extension}`;
       } else {
         // For nested index files like "./test/index.ext", use parent directory + extension
-        var parentDir = file.segments[file.segments.length - 2];
-        candidateName = "".concat(parentDir).concat(file.extension);
+        const parentDir = file.segments[file.segments.length - 2];
+        candidateName = `${parentDir}${file.extension}`;
       }
     } else {
       candidateName = fileName;
@@ -68,116 +61,79 @@ function processFlatMode(importResult, resolvedPathsMap) {
   }
 
   // Third pass: resolve conflicts for all files in conflicting groups
-  var finalNames = new Map();
-  nameGroups.forEach(function (paths, candidateName) {
+  const finalNames = new Map();
+  nameGroups.forEach((paths, candidateName) => {
     if (paths.length === 1) {
       // No conflict, use the candidate name
       finalNames.set(paths[0], candidateName);
     } else {
       // Conflict detected, find optimal minimal distinguishing paths for all files
-      var conflictingFiles = paths.map(function (resolvedPath) {
-        return fileMapping.find(function (f) {
-          return f.resolvedPath === resolvedPath;
-        });
-      });
+      const conflictingFiles = paths.map(resolvedPath => fileMapping.find(f => f.resolvedPath === resolvedPath));
 
       // Check if we can resolve conflicts by treating some files differently
       // This specifically handles cases like:
       // - /path/to/a/Component.js and /path/to/Component.js (parent-child relationship)
 
       // Find files that are "shorter" (parent level) compared to others
-      var minLength = Math.min.apply(Math, _toConsumableArray(conflictingFiles.map(function (f) {
-        return f.segments.length;
-      })));
-      var maxLengthForSmart = Math.max.apply(Math, _toConsumableArray(conflictingFiles.map(function (f) {
-        return f.segments.length;
-      })));
+      const minLength = Math.min(...conflictingFiles.map(f => f.segments.length));
+      const maxLengthForSmart = Math.max(...conflictingFiles.map(f => f.segments.length));
       if (maxLengthForSmart > minLength) {
         // We have files at different depths, check if it's a parent-child scenario
-        var shorterFiles = conflictingFiles.filter(function (file) {
-          return file.segments.length === minLength;
-        });
-        var longerFiles = conflictingFiles.filter(function (file) {
-          return file.segments.length > minLength;
-        });
+        const shorterFiles = conflictingFiles.filter(file => file.segments.length === minLength);
+        const longerFiles = conflictingFiles.filter(file => file.segments.length > minLength);
         if (shorterFiles.length === 1 && longerFiles.length >= 1) {
           // Check if the shorter file is truly a "parent" of the longer files
-          var shorterFile = shorterFiles[0];
-          var shorterPath = shorterFile.segments.slice(0, -1).join('/'); // Remove filename
+          const shorterFile = shorterFiles[0];
+          const shorterPath = shorterFile.segments.slice(0, -1).join('/'); // Remove filename
 
           // Check if all longer files share the same prefix as the shorter file
-          var allLongerFilesAreChildren = longerFiles.every(function (longerFile) {
-            var longerPath = longerFile.segments.slice(0, shorterFile.segments.length - 1).join('/');
+          const allLongerFilesAreChildren = longerFiles.every(longerFile => {
+            const longerPath = longerFile.segments.slice(0, shorterFile.segments.length - 1).join('/');
             return longerPath === shorterPath;
           });
           if (allLongerFilesAreChildren) {
             // This is a true parent-child scenario, apply smart resolution
 
             // For longer files, find distinguishing index
-            var _distinguishingIndex = -1;
-            var maxLongerLength = Math.max.apply(Math, _toConsumableArray(longerFiles.map(function (f) {
-              return f.segments.length;
-            })));
-            var _loop = function _loop(i) {
-              var segmentsAtIndex = new Set(longerFiles.map(function (f) {
-                return f.segments[i];
-              }).filter(Boolean));
+            let distinguishingIndex = -1;
+            const maxLongerLength = Math.max(...longerFiles.map(f => f.segments.length));
+            for (let i = 0; i < maxLongerLength; i += 1) {
+              const segmentsAtIndex = new Set(longerFiles.map(f => f.segments[i]).filter(Boolean));
               if (segmentsAtIndex.size === longerFiles.length) {
-                _distinguishingIndex = i;
-                return 1; // break
+                distinguishingIndex = i;
+                break;
               }
-            };
-            for (var i = 0; i < maxLongerLength; i += 1) {
-              if (_loop(i)) break;
             }
-            if (_distinguishingIndex !== -1) {
+            if (distinguishingIndex !== -1) {
               // Generate names for longer files using distinguishing segment
-              var _iterator = _createForOfIteratorHelper(longerFiles),
-                _step;
-              try {
-                for (_iterator.s(); !(_step = _iterator.n()).done;) {
-                  var _file = _step.value;
-                  var _fileName = _file.segments[_file.segments.length - 1];
-                  var _isIndexFile = _fileName.startsWith('index.');
-                  var _isUnderscoreIndexFile = _fileName.startsWith('_index.');
-                  var distinguishingSegment = _file.segments[_distinguishingIndex];
-                  var finalName = void 0;
-                  if (_isUnderscoreIndexFile) {
-                    // Files starting with "_index." should always use "index" as the base name
-                    finalName = "".concat(distinguishingSegment, "/index").concat(_file.extension);
-                  } else if (_isIndexFile) {
-                    // Check if this was a direct index import
-                    var _originalImportParts = _file.originalImportPath.split('/');
-                    var _isDirectIndexImport = _originalImportParts.length === 2 && _originalImportParts[0] === '.' && _originalImportParts[1].startsWith('index.');
-                    if (_isDirectIndexImport) {
-                      finalName = "".concat(distinguishingSegment, "/index").concat(_file.extension);
-                    } else {
-                      var _parentDir = _file.segments[_file.segments.length - 2];
-                      finalName = "".concat(distinguishingSegment, "/").concat(_parentDir).concat(_file.extension);
-                    }
+              for (const file of longerFiles) {
+                const fileName = file.segments[file.segments.length - 1];
+                const isIndexFile = fileName.startsWith('index.');
+                const isUnderscoreIndexFile = fileName.startsWith('_index.');
+                const distinguishingSegment = file.segments[distinguishingIndex];
+                let finalName;
+                if (isUnderscoreIndexFile) {
+                  // Files starting with "_index." should always use "index" as the base name
+                  finalName = `${distinguishingSegment}/index${file.extension}`;
+                } else if (isIndexFile) {
+                  // Check if this was a direct index import
+                  const originalImportParts = file.originalImportPath.split('/');
+                  const isDirectIndexImport = originalImportParts.length === 2 && originalImportParts[0] === '.' && originalImportParts[1].startsWith('index.');
+                  if (isDirectIndexImport) {
+                    finalName = `${distinguishingSegment}/index${file.extension}`;
                   } else {
-                    finalName = "".concat(distinguishingSegment, "/").concat(_fileName);
+                    const parentDir = file.segments[file.segments.length - 2];
+                    finalName = `${distinguishingSegment}/${parentDir}${file.extension}`;
                   }
-                  finalNames.set(_file.resolvedPath, finalName);
+                } else {
+                  finalName = `${distinguishingSegment}/${fileName}`;
                 }
-
-                // For shorter files, use the candidate name as-is (no conflicts after disambiguation)
-              } catch (err) {
-                _iterator.e(err);
-              } finally {
-                _iterator.f();
+                finalNames.set(file.resolvedPath, finalName);
               }
-              var _iterator2 = _createForOfIteratorHelper(shorterFiles),
-                _step2;
-              try {
-                for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-                  var shortFile = _step2.value;
-                  finalNames.set(shortFile.resolvedPath, candidateName);
-                }
-              } catch (err) {
-                _iterator2.e(err);
-              } finally {
-                _iterator2.f();
+
+              // For shorter files, use the candidate name as-is (no conflicts after disambiguation)
+              for (const shortFile of shorterFiles) {
+                finalNames.set(shortFile.resolvedPath, candidateName);
               }
               return; // Successfully resolved
             }
@@ -186,71 +142,55 @@ function processFlatMode(importResult, resolvedPathsMap) {
       }
 
       // Fallback to original algorithm if smart resolution fails
-      var distinguishingIndex = -1;
-      var maxLength = Math.max.apply(Math, _toConsumableArray(conflictingFiles.map(function (f) {
-        return f.segments.length;
-      })));
-      var _loop2 = function _loop2(_i2) {
-        var segmentsAtIndex = new Set(conflictingFiles.map(function (f) {
-          return f.segments[_i2];
-        }).filter(Boolean));
+      let distinguishingIndex = -1;
+      const maxLength = Math.max(...conflictingFiles.map(f => f.segments.length));
+      for (let i = 0; i < maxLength; i += 1) {
+        const segmentsAtIndex = new Set(conflictingFiles.map(f => f.segments[i]).filter(Boolean));
         if (segmentsAtIndex.size === conflictingFiles.length) {
-          distinguishingIndex = _i2;
-          return 1; // break
+          distinguishingIndex = i;
+          break;
         }
-      };
-      for (var _i2 = 0; _i2 < maxLength; _i2 += 1) {
-        if (_loop2(_i2)) break;
       }
       if (distinguishingIndex === -1) {
-        throw new Error("Cannot find distinguishing segment for files: ".concat(paths.join(', ')));
+        throw new Error(`Cannot find distinguishing segment for files: ${paths.join(', ')}`);
       }
 
       // Generate names using the distinguishing segment
-      var _iterator3 = _createForOfIteratorHelper(conflictingFiles),
-        _step3;
-      try {
-        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-          var _file2 = _step3.value;
-          var _fileName2 = _file2.segments[_file2.segments.length - 1];
-          var _isIndexFile2 = _fileName2.startsWith('index.');
-          var _isUnderscoreIndexFile2 = _fileName2.startsWith('_index.');
-          var _distinguishingSegment = _file2.segments[distinguishingIndex];
-          var _finalName = void 0;
-          if (_isUnderscoreIndexFile2) {
-            // Files starting with "_index." should always use "index" as the base name
-            _finalName = "".concat(_distinguishingSegment, "/index").concat(_file2.extension);
-          } else if (_isIndexFile2) {
-            // Check if this was a direct index import
-            var _originalImportParts2 = _file2.originalImportPath.split('/');
-            var _isDirectIndexImport2 = _originalImportParts2.length === 2 && _originalImportParts2[0] === '.' && _originalImportParts2[1].startsWith('index.');
-            if (_isDirectIndexImport2) {
-              _finalName = "".concat(_distinguishingSegment, "/index").concat(_file2.extension);
-            } else {
-              var _parentDir2 = _file2.segments[_file2.segments.length - 2];
-              _finalName = "".concat(_distinguishingSegment, "/").concat(_parentDir2).concat(_file2.extension);
-            }
+      for (const file of conflictingFiles) {
+        const fileName = file.segments[file.segments.length - 1];
+        const isIndexFile = fileName.startsWith('index.');
+        const isUnderscoreIndexFile = fileName.startsWith('_index.');
+        const distinguishingSegment = file.segments[distinguishingIndex];
+        let finalName;
+        if (isUnderscoreIndexFile) {
+          // Files starting with "_index." should always use "index" as the base name
+          finalName = `${distinguishingSegment}/index${file.extension}`;
+        } else if (isIndexFile) {
+          // Check if this was a direct index import
+          const originalImportParts = file.originalImportPath.split('/');
+          const isDirectIndexImport = originalImportParts.length === 2 && originalImportParts[0] === '.' && originalImportParts[1].startsWith('index.');
+          if (isDirectIndexImport) {
+            finalName = `${distinguishingSegment}/index${file.extension}`;
           } else {
-            _finalName = "".concat(_distinguishingSegment, "/").concat(_fileName2);
+            const parentDir = file.segments[file.segments.length - 2];
+            finalName = `${distinguishingSegment}/${parentDir}${file.extension}`;
           }
-          finalNames.set(_file2.resolvedPath, _finalName);
+        } else {
+          finalName = `${distinguishingSegment}/${fileName}`;
         }
-      } catch (err) {
-        _iterator3.e(err);
-      } finally {
-        _iterator3.f();
+        finalNames.set(file.resolvedPath, finalName);
       }
     }
   });
 
   // Fourth pass: build the extraFiles mapping
-  finalNames.forEach(function (finalName, resolvedPath) {
-    extraFiles["./".concat(finalName)] = portablePathToFileUrl(resolvedPath);
+  finalNames.forEach((finalName, resolvedPath) => {
+    extraFiles[`./${finalName}`] = portablePathToFileUrl(resolvedPath);
   });
   return {
     processedSource: '',
     // Will be set by caller after rewriting
-    extraFiles: extraFiles
+    extraFiles
   };
 }
 
@@ -259,28 +199,26 @@ function processFlatMode(importResult, resolvedPathsMap) {
  * Used for CSS, JSON, and other simple file types that don't require complex module resolution.
  */
 function processBasicImports(source, importResult, storeAt) {
-  var extraFiles = {};
+  const extraFiles = {};
   if (storeAt === 'flat') {
-    var finalNames = new Map();
-    var usedNames = new Set();
+    const finalNames = new Map();
+    const usedNames = new Set();
 
     // Process each import to determine final names with simple conflict resolution
-    Object.entries(importResult).forEach(function (_ref3) {
-      var _ref4 = _slicedToArray(_ref3, 2),
-        _relativePath = _ref4[0],
-        importInfo = _ref4[1];
-      var resolvedPath = importInfo.url; // For CSS, this is already resolved by parseImports
-      var fileUrl = portablePathToFileUrl(resolvedPath);
-      var _getFileNameFromUrl = getFileNameFromUrl(fileUrl),
-        fileName = _getFileNameFromUrl.fileName,
-        extension = _getFileNameFromUrl.extension;
-      var finalName = fileName;
-      var counter = 1;
+    Object.entries(importResult).forEach(([_relativePath, importInfo]) => {
+      const resolvedPath = importInfo.url; // For CSS, this is already resolved by parseImports
+      const fileUrl = portablePathToFileUrl(resolvedPath);
+      const {
+        fileName,
+        extension
+      } = getFileNameFromUrl(fileUrl);
+      let finalName = fileName;
+      let counter = 1;
 
       // Handle naming conflicts by appending numbers
       while (usedNames.has(finalName)) {
-        var baseName = fileName.replace(extension, '');
-        finalName = "".concat(baseName, "-").concat(counter).concat(extension);
+        const baseName = fileName.replace(extension, '');
+        finalName = `${baseName}-${counter}${extension}`;
         counter += 1;
       }
       usedNames.add(finalName);
@@ -288,38 +226,33 @@ function processBasicImports(source, importResult, storeAt) {
     });
 
     // Create the import path mapping for rewriting
-    var importPathMapping = new Map();
-    Object.entries(importResult).forEach(function (_ref5) {
-      var _ref6 = _slicedToArray(_ref5, 2),
-        relativePath = _ref6[0],
-        importInfo = _ref6[1];
-      var resolvedPath = importInfo.url;
-      var finalName = finalNames.get(resolvedPath);
+    const importPathMapping = new Map();
+    Object.entries(importResult).forEach(([relativePath, importInfo]) => {
+      const resolvedPath = importInfo.url;
+      const finalName = finalNames.get(resolvedPath);
       if (finalName) {
         importPathMapping.set(relativePath, finalName);
       }
     });
 
     // Create extraFiles entries
-    finalNames.forEach(function (finalName, resolvedPath) {
-      extraFiles["./".concat(finalName)] = portablePathToFileUrl(resolvedPath);
+    finalNames.forEach((finalName, resolvedPath) => {
+      extraFiles[`./${finalName}`] = portablePathToFileUrl(resolvedPath);
     });
 
     // Apply import path replacements using position-based rewriting
     // Only rewrite if positions are available
-    var hasPositions = Object.values(importResult).some(function (imp) {
-      return imp.positions && imp.positions.length > 0;
-    });
-    var processedSource = hasPositions ? rewriteImports(source, importPathMapping, importResult) : source;
+    const hasPositions = Object.values(importResult).some(imp => imp.positions && imp.positions.length > 0);
+    const processedSource = hasPositions ? rewriteImports(source, importPathMapping, importResult) : source;
     return {
-      processedSource: processedSource,
-      extraFiles: extraFiles
+      processedSource,
+      extraFiles
     };
   }
   if (storeAt === 'import') {
     // Create a mapping for import mode: remove ./ prefix from relative paths
-    var importModeMapping = new Map();
-    Object.keys(importResult).forEach(function (relativePath) {
+    const importModeMapping = new Map();
+    Object.keys(importResult).forEach(relativePath => {
       if (relativePath.startsWith('./')) {
         importModeMapping.set(relativePath, relativePath.slice(2));
       }
@@ -327,38 +260,30 @@ function processBasicImports(source, importResult, storeAt) {
     });
 
     // Process each import for extraFiles
-    Object.entries(importResult).forEach(function (_ref7) {
-      var _ref8 = _slicedToArray(_ref7, 2),
-        relativePath = _ref8[0],
-        importInfo = _ref8[1];
-      var resolvedPath = importInfo.url;
+    Object.entries(importResult).forEach(([relativePath, importInfo]) => {
+      const resolvedPath = importInfo.url;
       extraFiles[relativePath] = portablePathToFileUrl(resolvedPath); // Always use original path for extraFiles
     });
 
     // Apply import path replacements using position-based rewriting
     // Only rewrite if positions are available
-    var _hasPositions = Object.values(importResult).some(function (imp) {
-      return imp.positions && imp.positions.length > 0;
-    });
-    var _processedSource = _hasPositions ? rewriteImports(source, importModeMapping, importResult) : source;
+    const hasPositions = Object.values(importResult).some(imp => imp.positions && imp.positions.length > 0);
+    const processedSource = hasPositions ? rewriteImports(source, importModeMapping, importResult) : source;
     return {
-      processedSource: _processedSource,
-      extraFiles: extraFiles
+      processedSource,
+      extraFiles
     };
   }
 
   // Canonical mode - no rewriting needed
-  Object.entries(importResult).forEach(function (_ref9) {
-    var _ref0 = _slicedToArray(_ref9, 2),
-      relativePath = _ref0[0],
-      importInfo = _ref0[1];
-    var resolvedPath = importInfo.url;
+  Object.entries(importResult).forEach(([relativePath, importInfo]) => {
+    const resolvedPath = importInfo.url;
     extraFiles[relativePath] = portablePathToFileUrl(resolvedPath); // Use original import path
   });
   return {
     processedSource: source,
     // No rewriting needed for canonical mode
-    extraFiles: extraFiles
+    extraFiles
   };
 }
 
@@ -366,36 +291,30 @@ function processBasicImports(source, importResult, storeAt) {
  * Processes JavaScript imports with complex conflict resolution and module handling
  */
 function processJsImports(source, importResult, storeAt, resolvedPathsMap) {
-  var extraFiles = {};
+  const extraFiles = {};
   if (storeAt === 'flat') {
-    var result = processFlatMode(importResult, resolvedPathsMap);
+    const result = processFlatMode(importResult, resolvedPathsMap);
 
     // Build a reverse mapping from resolved paths to extraFiles keys
-    var resolvedToExtraFile = new Map();
-    Object.entries(result.extraFiles).forEach(function (_ref1) {
-      var _ref10 = _slicedToArray(_ref1, 2),
-        extraFileKey = _ref10[0],
-        fileUrl = _ref10[1];
+    const resolvedToExtraFile = new Map();
+    Object.entries(result.extraFiles).forEach(([extraFileKey, fileUrl]) => {
       // Convert file URL to portable path for lookup
-      var resolvedPath = fileUrl.startsWith('file://') ? fileUrlToPortablePath(fileUrl) : fileUrl;
+      const resolvedPath = fileUrl.startsWith('file://') ? fileUrlToPortablePath(fileUrl) : fileUrl;
       resolvedToExtraFile.set(resolvedPath, extraFileKey);
     });
 
     // For each import, find its resolved path and map to the corresponding extraFile key
-    var importPathMapping = new Map();
-    Object.entries(importResult).forEach(function (_ref11) {
-      var _ref12 = _slicedToArray(_ref11, 2),
-        relativePath = _ref12[0],
-        importInfo = _ref12[1];
-      var resolvedUrl = resolvedPathsMap.get(importInfo.url);
+    const importPathMapping = new Map();
+    Object.entries(importResult).forEach(([relativePath, importInfo]) => {
+      const resolvedUrl = resolvedPathsMap.get(importInfo.url);
       if (resolvedUrl) {
         // Convert file URL to portable path for lookup
-        var resolvedPath = resolvedUrl.startsWith('file://') ? fileUrlToPortablePath(resolvedUrl) : resolvedUrl;
-        var extraFileKey = resolvedToExtraFile.get(resolvedPath);
+        const resolvedPath = resolvedUrl.startsWith('file://') ? fileUrlToPortablePath(resolvedUrl) : resolvedUrl;
+        const extraFileKey = resolvedToExtraFile.get(resolvedPath);
         if (extraFileKey) {
           // For JavaScript modules, remove the extension; for other files (CSS, JSON, etc.), keep it
-          var isJavascriptModule = isJavaScriptModule(relativePath);
-          var newPath = extraFileKey;
+          const isJavascriptModule = isJavaScriptModule(relativePath);
+          let newPath = extraFileKey;
           if (isJavascriptModule) {
             // Handle TypeScript declaration files (.d.ts) properly
             if (newPath.endsWith('.d.ts')) {
@@ -412,28 +331,25 @@ function processJsImports(source, importResult, storeAt, resolvedPathsMap) {
     });
 
     // Apply import path replacements using position-based rewriting
-    var processedSource = rewriteImports(source, importPathMapping, importResult);
+    const processedSource = rewriteImports(source, importPathMapping, importResult);
     return {
-      processedSource: processedSource,
+      processedSource,
       extraFiles: result.extraFiles
     };
   }
 
   // Non-flat modes (canonical and import)
-  Object.entries(importResult).forEach(function (_ref13) {
-    var _ref14 = _slicedToArray(_ref13, 2),
-      relativePath = _ref14[0],
-      importInfo = _ref14[1];
-    var resolvedUrl = resolvedPathsMap.get(importInfo.url);
+  Object.entries(importResult).forEach(([relativePath, importInfo]) => {
+    const resolvedUrl = resolvedPathsMap.get(importInfo.url);
     if (!resolvedUrl) {
       return;
     }
 
     // Convert file URL to portable path for path manipulation
-    var resolvedPath = resolvedUrl.startsWith('file://') ? fileUrlToPortablePath(resolvedUrl) : resolvedUrl;
-    var fileExtension = getFileNameFromUrl(resolvedUrl).extension;
-    var isJavascriptModule = isJavaScriptModule(relativePath);
-    var keyPath;
+    const resolvedPath = resolvedUrl.startsWith('file://') ? fileUrlToPortablePath(resolvedUrl) : resolvedUrl;
+    const fileExtension = getFileNameFromUrl(resolvedUrl).extension;
+    const isJavascriptModule = isJavaScriptModule(relativePath);
+    let keyPath;
     if (!isJavascriptModule) {
       // For static assets (CSS, JSON, etc.), use the original import path as-is
       keyPath = relativePath;
@@ -442,14 +358,14 @@ function processJsImports(source, importResult, storeAt, resolvedPathsMap) {
       switch (storeAt) {
         case 'canonical':
           // Show the full resolved path including index files when they exist
-          keyPath = "".concat(relativePath).concat(resolvedPath.endsWith("/index".concat(fileExtension)) ? "/index".concat(fileExtension) : fileExtension);
+          keyPath = `${relativePath}${resolvedPath.endsWith(`/index${fileExtension}`) ? `/index${fileExtension}` : fileExtension}`;
           break;
         case 'import':
           // Use the original import path with the actual file extension
-          keyPath = "".concat(relativePath).concat(fileExtension);
+          keyPath = `${relativePath}${fileExtension}`;
           break;
         default:
-          keyPath = "".concat(relativePath).concat(fileExtension);
+          keyPath = `${relativePath}${fileExtension}`;
       }
     }
     extraFiles[keyPath] = portablePathToFileUrl(resolvedPath);
@@ -457,7 +373,7 @@ function processJsImports(source, importResult, storeAt, resolvedPathsMap) {
   return {
     processedSource: source,
     // No rewriting needed for non-flat modes
-    extraFiles: extraFiles
+    extraFiles
   };
 }
 
@@ -472,9 +388,7 @@ function processJsImports(source, importResult, storeAt, resolvedPathsMap) {
  * @param resolvedPathsMap - Map from import paths to resolved file paths (only needed for JavaScript files)
  * @returns Object with processed source and extraFiles mapping
  */
-export function processRelativeImports(source, importResult, storeAt) {
-  var isJsFile = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
-  var resolvedPathsMap = arguments.length > 4 ? arguments[4] : undefined;
+export function processRelativeImports(source, importResult, storeAt, isJsFile = false, resolvedPathsMap) {
   if (!isJsFile) {
     // Use basic processing mode for CSS, JSON, and other simple file types
     return processBasicImports(source, importResult, storeAt);