@mui/internal-docs-infra 0.1.1-alpha.0 → 0.1.1-alpha.10

package/pipeline/loaderUtils/parseImports.js

@@ -0,0 +1,307 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import path from 'path';
+export function parseImports(_x, _x2) {
+  return _parseImports.apply(this, arguments);
+}
+function _parseImports() {
+  _parseImports = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(code, _filePath) {
+    var result, externals, importRegex, sideEffectImportRegex, match, _loop, _ret, sideEffectMatch, _sideEffectMatch, _sideEffectMatch2, modulePathRaw, modulePath, isRelative, resolvedPath;
+    return _regeneratorRuntime().wrap(function _callee$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          result = {};
+          externals = {}; // Regex to extract regular import statements with 'from' clause
+          importRegex = /import(?:\s+type)?\s*([^'"]*)\s*from\s*['"]([^'"]+)['"][;]?/g; // Regex to extract side-effect imports (without 'from' clause)
+          sideEffectImportRegex = /import\s*['"]([^'"]+)['"][;]?/g;
+          // eslint-disable-next-line no-cond-assign
+          _loop = /*#__PURE__*/_regeneratorRuntime().mark(function _loop() {
+            var _match, _match2, fullMatch, importSpecifierRaw, modulePathRaw, includeTypeDefs, importSpecifier, modulePath, isRelative, _resolvedPath, _resolvedPath2, defaultImportMatch, namespaceImportMatch, namedImportsMatch, defaultImport, namespaceImport, namedImportsStr, existing, _existing, cleanedImportsStr, namedImports, _defaultImportMatch, _namespaceImportMatch, _namedImportsMatch, _defaultImport, _namespaceImport, _namedImportsStr, _existing3, _existing4, _cleanedImportsStr, _namedImports;
+            return _regeneratorRuntime().wrap(function _loop$(_context) {
+              while (1) switch (_context.prev = _context.next) {
+                case 0:
+                  _match = match, _match2 = _slicedToArray(_match, 3), fullMatch = _match2[0], importSpecifierRaw = _match2[1], modulePathRaw = _match2[2]; // Determine if this is a type import by checking if the full match contains "import type"
+                  includeTypeDefs = fullMatch.includes('import type');
+                  importSpecifier = importSpecifierRaw == null ? void 0 : importSpecifierRaw.trim();
+                  modulePath = modulePathRaw == null ? void 0 : modulePathRaw.trim();
+                  if (modulePath) {
+                    _context.next = 6;
+                    break;
+                  }
+                  return _context.abrupt("return", 0);
+                case 6:
+                  // Check if this is a relative import
+                  isRelative = modulePath.startsWith('./') || modulePath.startsWith('../'); // Handle side-effect imports (no import specifier)
+                  if (importSpecifier) {
+                    _context.next = 10;
+                    break;
+                  }
+                  if (isRelative) {
+                    // Resolve the relative import to an absolute path
+                    _resolvedPath = path.resolve(path.dirname(_filePath), modulePath);
+                    if (!result[modulePath]) {
+                      result[modulePath] = {
+                        path: _resolvedPath,
+                        names: [] // Empty names array for side-effect imports
+                      };
+                    }
+                  } else if (!externals[modulePath]) {
+                    // External side-effect import
+                    externals[modulePath] = {
+                      names: []
+                    };
+                  }
+                  return _context.abrupt("return", 0);
+                case 10:
+                  if (isRelative) {
+                    // Resolve the relative import to an absolute path
+                    _resolvedPath2 = path.resolve(path.dirname(_filePath), modulePath);
+                    if (!result[modulePath]) {
+                      result[modulePath] = _objectSpread({
+                        path: _resolvedPath2,
+                        names: []
+                      }, includeTypeDefs && {
+                        includeTypeDefs: true
+                      });
+                    } else if (includeTypeDefs && !result[modulePath].includeTypeDefs) {
+                      result[modulePath].includeTypeDefs = true;
+                    }
+
+                    // Parse the import specifier to determine the type of import
+                    defaultImportMatch = importSpecifier.match(/^([a-zA-Z_$][a-zA-Z0-9_$]*)\s*(?:,|$)/);
+                    namespaceImportMatch = importSpecifier.match(/\*\s+as\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/);
+                    namedImportsMatch = importSpecifier.match(/\{([^}]+)\}/);
+                    defaultImport = defaultImportMatch == null ? void 0 : defaultImportMatch[1];
+                    namespaceImport = namespaceImportMatch == null ? void 0 : namespaceImportMatch[1];
+                    namedImportsStr = namedImportsMatch == null ? void 0 : namedImportsMatch[1];
+                    if (defaultImport) {
+                      // Check if we already have this default import
+                      existing = result[modulePath].names.find(function (n) {
+                        return n.name === defaultImport && n.type === 'default';
+                      });
+                      if (!existing) {
+                        result[modulePath].names.push(_objectSpread({
+                          name: defaultImport,
+                          type: 'default'
+                        }, includeTypeDefs && {
+                          isType: true
+                        }));
+                      }
+                    }
+                    if (namespaceImport) {
+                      // Check if we already have this namespace import
+                      _existing = result[modulePath].names.find(function (n) {
+                        return n.name === namespaceImport && n.type === 'namespace';
+                      });
+                      if (!_existing) {
+                        result[modulePath].names.push(_objectSpread({
+                          name: namespaceImport,
+                          type: 'namespace'
+                        }, includeTypeDefs && {
+                          isType: true
+                        }));
+                      }
+                    }
+                    if (namedImportsStr) {
+                      // Handle named imports like { ComponentName, Component2 as Alias, type TypeName }
+                      // Clean up the string by removing comments and extra whitespace
+                      cleanedImportsStr = namedImportsStr.replace(/\/\*[\s\S]*?\*\//g, '') // Remove /* comment */ blocks
+                      .replace(/\/\/.*$/gm, '') // Remove // line comments
+                      .trim();
+                      if (cleanedImportsStr) {
+                        namedImports = cleanedImportsStr.split(',').map(function (s) {
+                          return s.trim();
+                        }).filter(function (s) {
+                          return s.length > 0;
+                        });
+                        namedImports.forEach(function (namedImport) {
+                          // Check if this specific import is a type import
+                          var isTypeImport = namedImport.trim().startsWith('type ');
+
+                          // Clean up the import name (remove 'type' keyword and handle aliases)
+                          var cleanImport = namedImport.replace(/^type\s+/, ''); // Remove leading 'type'
+
+                          // Parse original name and alias
+                          var aliasMatch = cleanImport.match(/(.+?)\s+as\s+(.+)/);
+                          var originalName = aliasMatch ? aliasMatch[1].trim() : cleanImport.trim();
+                          var alias = aliasMatch ? aliasMatch[2].trim() : undefined;
+
+                          // Only add if we have a valid name
+                          if (originalName && /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(originalName)) {
+                            // Check if we already have this named import
+                            var _existing2 = result[modulePath].names.find(function (n) {
+                              return n.name === originalName && n.type === 'named' && n.alias === alias;
+                            });
+                            if (!_existing2) {
+                              result[modulePath].names.push(_objectSpread(_objectSpread({
+                                name: originalName
+                              }, alias && {
+                                alias: alias
+                              }), {}, {
+                                type: 'named'
+                              }, (includeTypeDefs || isTypeImport) && {
+                                isType: true
+                              }));
+                            }
+                          }
+                        });
+                      }
+                    }
+                  } else {
+                    // This is an external import
+                    if (!externals[modulePath]) {
+                      externals[modulePath] = {
+                        names: []
+                      };
+                    }
+
+                    // Parse the import specifier to determine the type of import
+                    _defaultImportMatch = importSpecifier.match(/^([a-zA-Z_$][a-zA-Z0-9_$]*)\s*(?:,|$)/);
+                    _namespaceImportMatch = importSpecifier.match(/\*\s+as\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/);
+                    _namedImportsMatch = importSpecifier.match(/\{([^}]+)\}/);
+                    _defaultImport = _defaultImportMatch == null ? void 0 : _defaultImportMatch[1];
+                    _namespaceImport = _namespaceImportMatch == null ? void 0 : _namespaceImportMatch[1];
+                    _namedImportsStr = _namedImportsMatch == null ? void 0 : _namedImportsMatch[1];
+                    if (_defaultImport) {
+                      // Check if we already have this default import
+                      _existing3 = externals[modulePath].names.find(function (n) {
+                        return n.name === _defaultImport && n.type === 'default';
+                      });
+                      if (!_existing3) {
+                        externals[modulePath].names.push(_objectSpread({
+                          name: _defaultImport,
+                          type: 'default'
+                        }, includeTypeDefs && {
+                          isType: true
+                        }));
+                      }
+                    }
+                    if (_namespaceImport) {
+                      // Check if we already have this namespace import
+                      _existing4 = externals[modulePath].names.find(function (n) {
+                        return n.name === _namespaceImport && n.type === 'namespace';
+                      });
+                      if (!_existing4) {
+                        externals[modulePath].names.push(_objectSpread({
+                          name: _namespaceImport,
+                          type: 'namespace'
+                        }, includeTypeDefs && {
+                          isType: true
+                        }));
+                      }
+                    }
+                    if (_namedImportsStr) {
+                      // Handle named imports like { ComponentName, Component2 as Alias, type TypeName }
+                      // Clean up the string by removing comments and extra whitespace
+                      _cleanedImportsStr = _namedImportsStr.replace(/\/\*[\s\S]*?\*\//g, '') // Remove /* comment */ blocks
+                      .replace(/\/\/.*$/gm, '') // Remove // line comments
+                      .trim();
+                      if (_cleanedImportsStr) {
+                        _namedImports = _cleanedImportsStr.split(',').map(function (s) {
+                          return s.trim();
+                        }).filter(function (s) {
+                          return s.length > 0;
+                        });
+                        _namedImports.forEach(function (namedImport) {
+                          // Check if this specific import is a type import
+                          var isTypeImport = namedImport.trim().startsWith('type ');
+
+                          // Clean up the import name (remove 'type' keyword and handle aliases)
+                          var cleanImport = namedImport.replace(/^type\s+/, ''); // Remove leading 'type'
+
+                          // Parse original name and alias - for externals we track both
+                          var aliasMatch = cleanImport.match(/(.+?)\s+as\s+(.+)/);
+                          var originalName = aliasMatch ? aliasMatch[1].trim() : cleanImport.trim();
+                          var alias = aliasMatch ? aliasMatch[2].trim() : undefined;
+
+                          // Only add if we have a valid name
+                          if (originalName && /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(originalName)) {
+                            // Check if we already have this named import
+                            var _existing5 = externals[modulePath].names.find(function (n) {
+                              return n.name === originalName && n.type === 'named' && n.alias === alias;
+                            });
+                            if (!_existing5) {
+                              externals[modulePath].names.push(_objectSpread(_objectSpread({
+                                name: originalName
+                              }, alias && {
+                                alias: alias
+                              }), {}, {
+                                type: 'named'
+                              }, (includeTypeDefs || isTypeImport) && {
+                                isType: true
+                              }));
+                            }
+                          }
+                        });
+                      }
+                    }
+                  }
+                case 11:
+                case "end":
+                  return _context.stop();
+              }
+            }, _loop);
+          });
+        case 5:
+          if (!((match = importRegex.exec(code)) !== null)) {
+            _context2.next = 12;
+            break;
+          }
+          return _context2.delegateYield(_loop(), "t0", 7);
+        case 7:
+          _ret = _context2.t0;
+          if (!(_ret === 0)) {
+            _context2.next = 10;
+            break;
+          }
+          return _context2.abrupt("continue", 5);
+        case 10:
+          _context2.next = 5;
+          break;
+        case 12:
+          if (!((sideEffectMatch = sideEffectImportRegex.exec(code)) !== null)) {
+            _context2.next = 21;
+            break;
+          }
+          _sideEffectMatch = sideEffectMatch, _sideEffectMatch2 = _slicedToArray(_sideEffectMatch, 2), modulePathRaw = _sideEffectMatch2[1];
+          modulePath = modulePathRaw == null ? void 0 : modulePathRaw.trim();
+          if (modulePath) {
+            _context2.next = 17;
+            break;
+          }
+          return _context2.abrupt("continue", 12);
+        case 17:
+          // Check if this is a relative import
+          isRelative = modulePath.startsWith('./') || modulePath.startsWith('../');
+          if (isRelative) {
+            // Resolve the relative import to an absolute path
+            resolvedPath = path.resolve(path.dirname(_filePath), modulePath);
+            if (!result[modulePath]) {
+              result[modulePath] = {
+                path: resolvedPath,
+                names: [] // Empty names array for side-effect imports
+              };
+            }
+          } else if (!externals[modulePath]) {
+            // External side-effect import
+            externals[modulePath] = {
+              names: []
+            };
+          }
+          _context2.next = 12;
+          break;
+        case 21:
+          return _context2.abrupt("return", {
+            relative: result,
+            externals: externals
+          });
+        case 22:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee);
+  }));
+  return _parseImports.apply(this, arguments);
+}

package/{build/esm/loaderUtils/processImports.d.ts → pipeline/loaderUtils/processRelativeImports.d.ts}

@@ -8,12 +8,12 @@ export interface ProcessImportsResult {
  * source rewriting when needed (e.g., for 'flat' mode).
  *
  * @param source - The original source code
- * @param importResult - The result from resolveImports
+ * @param importResult - The result from parseImports
  * @param resolvedPathsMap - Map from import paths to resolved file paths
  * @param storeAt - How to process the imports
  * @returns Object with processed source and extraFiles mapping
  */
-export declare function processImportsWithStoreAt(source: string, importResult: Record<string, {
+export declare function processRelativeImports(source: string, importResult: Record<string, {
   path: string;
   names: string[];
 }>, resolvedPathsMap: Map<string, string>, storeAt: StoreAtMode): ProcessImportsResult;

package/pipeline/loaderUtils/processRelativeImports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processRelativeImports.d.ts","sourceRoot":"","sources":["../../../src/pipeline/loaderUtils/processRelativeImports.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,WAAW,GAAG,WAAW,GAAG,QAAQ,GAAG,MAAM,CAAC;AAE1D,MAAM,WAAW,oBAAoB;IACnC,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACpC;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,EAC/D,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EACrC,OAAO,EAAE,WAAW,GACnB,oBAAoB,CAmGtB"}

package/pipeline/loaderUtils/processRelativeImports.js

@@ -0,0 +1,329 @@
+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 { rewriteImportsToSameDirectory } from "./rewriteImports.js";
+import { isJavaScriptModule } from "./resolveModulePath.js";
+import { getFileNameFromUrl } from "./getFileNameFromUrl.js";
+/**
+ * Processes imports based on the specified storage mode, automatically handling
+ * source rewriting when needed (e.g., for 'flat' mode).
+ *
+ * @param source - The original source code
+ * @param importResult - The result from parseImports
+ * @param resolvedPathsMap - Map from import paths to resolved file paths
+ * @param storeAt - How to process the imports
+ * @returns Object with processed source and extraFiles mapping
+ */
+export function processRelativeImports(source, importResult, resolvedPathsMap, storeAt) {
+  var extraFiles = {};
+
+  // For flat mode, we need to handle naming conflicts intelligently
+  if (storeAt === 'flat') {
+    var result = processFlatMode(importResult, resolvedPathsMap);
+
+    // Create import path mapping for rewriting
+    var importPathMapping = new Map();
+
+    // Build a reverse mapping from resolved paths to extraFiles keys
+    var resolvedToExtraFile = new Map();
+    Object.entries(result.extraFiles).forEach(function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 2),
+        extraFileKey = _ref2[0],
+        fileUrl = _ref2[1];
+      var resolvedPath = fileUrl.replace('file://', '');
+      resolvedToExtraFile.set(resolvedPath, extraFileKey);
+    });
+
+    // For each import, find its resolved path and map to the corresponding extraFile key
+    Object.entries(importResult).forEach(function (_ref3) {
+      var _ref4 = _slicedToArray(_ref3, 2),
+        relativePath = _ref4[0],
+        importInfo = _ref4[1];
+      var resolvedPath = resolvedPathsMap.get(importInfo.path);
+      if (resolvedPath) {
+        var 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;
+          if (isJavascriptModule) {
+            // Handle TypeScript declaration files (.d.ts) properly
+            if (newPath.endsWith('.d.ts')) {
+              newPath = newPath.replace(/\.d\.ts$/, '');
+            } else {
+              newPath = newPath.replace(/\.[^/.]+$/, '');
+            }
+          }
+          // For non-JS modules (CSS, JSON, etc.), keep the full path with extension
+
+          importPathMapping.set(relativePath, newPath);
+        }
+      }
+    });
+
+    // Rewrite the source with the mapping
+    var rewrittenSource = rewriteImportsToSameDirectory(source, importPathMapping);
+    return {
+      processedSource: rewrittenSource,
+      extraFiles: result.extraFiles
+    };
+  }
+
+  // Process each import and generate extraFiles for non-flat modes
+  Object.entries(importResult).forEach(function (_ref5) {
+    var _ref6 = _slicedToArray(_ref5, 2),
+      relativePath = _ref6[0],
+      importInfo = _ref6[1];
+    var resolvedPath = resolvedPathsMap.get(importInfo.path);
+    if (resolvedPath) {
+      var fileExtension = getFileNameFromUrl(resolvedPath).extension;
+      var isJavascriptModule = isJavaScriptModule(relativePath);
+      var keyPath;
+      if (!isJavascriptModule) {
+        // For static assets (CSS, JSON, etc.), use the original import path as-is since it already has the extension
+        switch (storeAt) {
+          case 'canonical':
+          case 'import':
+            keyPath = relativePath;
+            break;
+          default:
+            keyPath = relativePath;
+        }
+      } else {
+        // For JS/TS modules, apply the existing logic
+        switch (storeAt) {
+          case 'canonical':
+            // Show the full resolved path including index files when they exist
+            // e.g., import '../Component' resolved to '/src/Component/index.js'
+            // becomes extraFiles: { '../Component/index.js': 'file:///src/Component/index.js' }
+            keyPath = "".concat(relativePath).concat(resolvedPath.endsWith("/index".concat(fileExtension)) ? "/index".concat(fileExtension) : fileExtension);
+            break;
+          case 'import':
+            // Use the original import path with the actual file extension
+            // e.g., import '../Component' with '/src/Component/index.js'
+            // becomes extraFiles: { '../Component.js': 'file:///src/Component/index.js' }
+            keyPath = "".concat(relativePath).concat(fileExtension);
+            break;
+          default:
+            keyPath = "".concat(relativePath).concat(fileExtension);
+        }
+      }
+      extraFiles[keyPath] = "file://".concat(resolvedPath);
+    }
+  });
+  return {
+    processedSource: source,
+    extraFiles: extraFiles
+  };
+}
+
+/**
+ * Processes flat mode with intelligent conflict resolution
+ */
+function processFlatMode(importResult, resolvedPathsMap) {
+  var extraFiles = {};
+  var fileMapping = [];
+
+  // First pass: collect all files and their path segments
+  Object.entries(importResult).forEach(function (_ref7) {
+    var _ref8 = _slicedToArray(_ref7, 2),
+      _relativePath = _ref8[0],
+      importInfo = _ref8[1];
+    var resolvedPath = resolvedPathsMap.get(importInfo.path);
+    if (resolvedPath) {
+      var fileExtension = getFileNameFromUrl(resolvedPath).extension;
+      var pathSegments = resolvedPath.split('/').filter(Boolean);
+      fileMapping.push({
+        resolvedPath: resolvedPath,
+        extension: fileExtension,
+        segments: pathSegments
+      });
+    }
+  });
+
+  // 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 candidateName = void 0;
+    if (isIndexFile) {
+      // For index files, use the parent directory name + extension
+      var parentDir = file.segments[file.segments.length - 2];
+      candidateName = "".concat(parentDir).concat(file.extension);
+    } else {
+      candidateName = fileName;
+    }
+    candidateNames.set(file.resolvedPath, candidateName);
+    if (!nameGroups.has(candidateName)) {
+      nameGroups.set(candidateName, []);
+    }
+    nameGroups.get(candidateName).push(file.resolvedPath);
+  }
+
+  // Third pass: resolve conflicts for all files in conflicting groups
+  var finalNames = new Map();
+  nameGroups.forEach(function (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;
+        });
+      });
+
+      // 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;
+      })));
+      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;
+        });
+        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
+
+          // 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('/');
+            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));
+              if (segmentsAtIndex.size === longerFiles.length) {
+                _distinguishingIndex = i;
+                return 1; // break
+              }
+            };
+            for (var i = 0; i < maxLongerLength; i += 1) {
+              if (_loop(i)) break;
+            }
+            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 distinguishingSegment = _file.segments[_distinguishingIndex];
+                  var finalName = void 0;
+                  if (_isIndexFile) {
+                    var _parentDir = _file.segments[_file.segments.length - 2];
+                    finalName = "".concat(distinguishingSegment, "/").concat(_parentDir).concat(_file.extension);
+                  } else {
+                    finalName = "".concat(distinguishingSegment, "/").concat(_fileName);
+                  }
+                  finalNames.set(_file.resolvedPath, finalName);
+                }
+
+                // For shorter files, use the candidate name as-is (no conflicts after disambiguation)
+              } catch (err) {
+                _iterator.e(err);
+              } finally {
+                _iterator.f();
+              }
+              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();
+              }
+              return; // Successfully resolved
+            }
+          }
+        }
+      }
+
+      // 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));
+        if (segmentsAtIndex.size === conflictingFiles.length) {
+          distinguishingIndex = _i2;
+          return 1; // 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(', ')));
+      }
+
+      // 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 _distinguishingSegment = _file2.segments[distinguishingIndex];
+          var _finalName = void 0;
+          if (_isIndexFile2) {
+            var _parentDir2 = _file2.segments[_file2.segments.length - 2];
+            _finalName = "".concat(_distinguishingSegment, "/").concat(_parentDir2).concat(_file2.extension);
+          } else {
+            _finalName = "".concat(_distinguishingSegment, "/").concat(_fileName2);
+          }
+          finalNames.set(_file2.resolvedPath, _finalName);
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+    }
+  });
+
+  // Fourth pass: build the extraFiles mapping
+  finalNames.forEach(function (finalName, resolvedPath) {
+    extraFiles["./".concat(finalName)] = "file://".concat(resolvedPath);
+  });
+  return {
+    processedSource: '',
+    // Will be set by caller after rewriting
+    extraFiles: extraFiles
+  };
+}