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

package/esm/pipeline/loadServerSource/loadServerSource.js

@@ -1,7 +1,3 @@
-import _regenerator from "@babel/runtime/helpers/esm/regenerator";
-import _extends from "@babel/runtime/helpers/esm/extends";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 // webpack does not like node: imports
 // eslint-disable-next-line n/prefer-node-protocol
 import { readFile } from 'fs/promises';
@@ -17,7 +13,7 @@ import { isJavaScriptModule } from "../loaderUtils/resolveModulePath.js";
  * It reads the source file, resolves its imports, and returns the processed source along with any
  * additional files and dependencies that were found.
  */
-export var loadServerSource = createLoadServerSource();
+export const loadServerSource = createLoadServerSource();
 
 /**
  * Creates a loadSource function that reads a file and extracts its dependencies.
@@ -27,151 +23,128 @@ export var loadServerSource = createLoadServerSource();
  *   - 'import': Import path with file extension (e.g., '../Component.js')
  *   - 'flat': Flattened to current directory with rewritten imports (e.g., './Component.js')
  */
-export function createLoadServerSource() {
-  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var _options$includeDepen = options.includeDependencies,
-    includeDependencies = _options$includeDepen === void 0 ? true : _options$includeDepen,
-    _options$storeAt = options.storeAt,
-    storeAt = _options$storeAt === void 0 ? 'flat' : _options$storeAt;
-  return /*#__PURE__*/function () {
-    var _loadSource = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(url) {
-      var filePath, source, isJavascriptModuleFile, isCssFile, _yield$parseImportsAn, importResult, externals, transformedExternals, _i, _Object$entries, _Object$entries$_i, modulePath, externalImport, processedSource, extraFiles, extraDependencies, importsCompatible, _i2, _Object$entries2, _Object$entries2$_i, importPath, _Object$entries2$_i$, importUrl, names, positions, result, relativeImportsCompatible, _i3, _Object$entries3, _Object$entries3$_i, _importPath, _Object$entries3$_i$, _importUrl, _names, includeTypeDefs, _positions, resolvedPathsMap, _result;
-      return _regenerator().w(function (_context) {
-        while (1) switch (_context.n) {
-          case 0:
-            // Convert file:// URL to proper file system path for reading the file
-            // Using fileURLToPath handles Windows drive letters correctly (e.g., file:///C:/... → C:\...)
-            filePath = url.startsWith('file://') ? fileURLToPath(url) : url; // Read the file
-            _context.n = 1;
-            return readFile(filePath, 'utf8');
-          case 1:
-            source = _context.v;
-            if (includeDependencies) {
-              _context.n = 2;
-              break;
-            }
-            return _context.a(2, {
-              source: source
-            });
-          case 2:
-            // Check if this is a static asset file (non-JS/TS modules)
-            isJavascriptModuleFile = isJavaScriptModule(filePath);
-            isCssFile = filePath.toLowerCase().endsWith('.css');
-            if (!(!isJavascriptModuleFile && !isCssFile)) {
-              _context.n = 3;
-              break;
-            }
-            return _context.a(2, {
-              source: source
-            });
-          case 3:
-            _context.n = 4;
-            return parseImportsAndComments(source, url);
-          case 4:
-            _yield$parseImportsAn = _context.v;
-            importResult = _yield$parseImportsAn.relative;
-            externals = _yield$parseImportsAn.externals;
-            // Transform externals from parseImportsAndComments format to simplified format
-            transformedExternals = {};
-            for (_i = 0, _Object$entries = Object.entries(externals); _i < _Object$entries.length; _i++) {
-              _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2), modulePath = _Object$entries$_i[0], externalImport = _Object$entries$_i[1];
-              transformedExternals[modulePath] = externalImport.names.map(function (importName) {
-                return {
-                  name: importName.name,
-                  type: importName.type,
-                  isType: importName.isType
-                };
-              });
-            }
-            if (!(Object.keys(importResult).length === 0)) {
-              _context.n = 5;
-              break;
-            }
-            return _context.a(2, {
-              source: source,
-              externals: Object.keys(transformedExternals).length > 0 ? transformedExternals : undefined
-            });
-          case 5:
-            // Convert import result to the format expected by processImports, preserving position data
-            importsCompatible = {};
-            for (_i2 = 0, _Object$entries2 = Object.entries(importResult); _i2 < _Object$entries2.length; _i2++) {
-              _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2), importPath = _Object$entries2$_i[0], _Object$entries2$_i$ = _Object$entries2$_i[1], importUrl = _Object$entries2$_i$.url, names = _Object$entries2$_i$.names, positions = _Object$entries2$_i$.positions;
-              importsCompatible[importPath] = {
-                url: importUrl,
-                names: names.map(function (_ref) {
-                  var name = _ref.name,
-                    alias = _ref.alias;
-                  return alias || name;
-                }),
-                positions: positions
-              };
-            }
-            if (!isCssFile) {
-              _context.n = 6;
-              break;
-            }
-            // For CSS files, we don't need complex path resolution
-            // The parseImportsAndComments function already resolved paths for CSS
-            result = processRelativeImports(source, importsCompatible, storeAt);
-            processedSource = result.processedSource;
-            extraFiles = result.extraFiles;
+export function createLoadServerSource(options = {}) {
+  const {
+    includeDependencies = true,
+    storeAt = 'flat'
+  } = options;
+  return async function loadSource(url) {
+    // Convert file:// URL to proper file system path for reading the file
+    // Using fileURLToPath handles Windows drive letters correctly (e.g., file:///C:/... → C:\...)
+    const filePath = url.startsWith('file://') ? fileURLToPath(url) : url;
 
-            // Build dependencies list for recursive loading (CSS files use direct paths)
-            extraDependencies = Object.values(importResult).map(function (_ref2) {
-              var importUrl = _ref2.url;
-              return importUrl;
-            });
-            _context.n = 8;
-            break;
-          case 6:
-            // For JavaScript/TypeScript files, resolve paths first
-            relativeImportsCompatible = {};
-            for (_i3 = 0, _Object$entries3 = Object.entries(importResult); _i3 < _Object$entries3.length; _i3++) {
-              _Object$entries3$_i = _slicedToArray(_Object$entries3[_i3], 2), _importPath = _Object$entries3$_i[0], _Object$entries3$_i$ = _Object$entries3$_i[1], _importUrl = _Object$entries3$_i$.url, _names = _Object$entries3$_i$.names, includeTypeDefs = _Object$entries3$_i$.includeTypeDefs, _positions = _Object$entries3$_i$.positions;
-              relativeImportsCompatible[_importPath] = _extends({
-                url: _importUrl,
-                names: _names.map(function (_ref3) {
-                  var name = _ref3.name,
-                    alias = _ref3.alias;
-                  return alias || name;
-                }),
-                // Use alias if available
-                positions: _positions
-              }, includeTypeDefs && {
-                includeTypeDefs: includeTypeDefs
-              });
-            }
+    // Read the file
+    const source = await readFile(filePath, 'utf8');
+    if (!includeDependencies) {
+      return {
+        source
+      };
+    }
+
+    // Check if this is a static asset file (non-JS/TS modules)
+    const isJavascriptModuleFile = isJavaScriptModule(filePath);
+    const isCssFile = filePath.toLowerCase().endsWith('.css');
+    if (!isJavascriptModuleFile && !isCssFile) {
+      // Static assets (CSS, JSON, etc.) don't have imports to resolve
+      return {
+        source
+      };
+    }
+
+    // Get all relative imports from this file
+    // Pass the original URL to parseImportsAndComments for cross-platform path handling
+    const {
+      relative: importResult,
+      externals
+    } = await parseImportsAndComments(source, url);
+
+    // Transform externals from parseImportsAndComments format to simplified format
+    const transformedExternals = {};
+    for (const [modulePath, externalImport] of Object.entries(externals)) {
+      transformedExternals[modulePath] = externalImport.names.map(importName => ({
+        name: importName.name,
+        type: importName.type,
+        isType: importName.isType
+      }));
+    }
+    if (Object.keys(importResult).length === 0) {
+      return {
+        source,
+        externals: Object.keys(transformedExternals).length > 0 ? transformedExternals : undefined
+      };
+    }
+    let processedSource;
+    let extraFiles;
+    let extraDependencies;
+
+    // Convert import result to the format expected by processImports, preserving position data
+    const importsCompatible = {};
+    for (const [importPath, {
+      url: importUrl,
+      names,
+      positions
+    }] of Object.entries(importResult)) {
+      importsCompatible[importPath] = {
+        url: importUrl,
+        names: names.map(({
+          name,
+          alias
+        }) => alias || name),
+        positions
+      };
+    }
+    if (isCssFile) {
+      // For CSS files, we don't need complex path resolution
+      // The parseImportsAndComments function already resolved paths for CSS
+      const result = processRelativeImports(source, importsCompatible, storeAt);
+      processedSource = result.processedSource;
+      extraFiles = result.extraFiles;
+
+      // Build dependencies list for recursive loading (CSS files use direct paths)
+      extraDependencies = Object.values(importResult).map(({
+        url: importUrl
+      }) => importUrl);
+    } else {
+      // For JavaScript/TypeScript files, resolve paths first
+      const relativeImportsCompatible = {};
+      for (const [importPath, {
+        url: importUrl,
+        names,
+        includeTypeDefs,
+        positions
+      }] of Object.entries(importResult)) {
+        relativeImportsCompatible[importPath] = {
+          url: importUrl,
+          names: names.map(({
+            name,
+            alias
+          }) => alias || name),
+          // Use alias if available
+          positions,
+          ...(includeTypeDefs && {
+            includeTypeDefs
+          })
+        };
+      }
+
+      // Resolve import paths, handling JS/TS modules and static assets appropriately
+      const resolvedPathsMap = await resolveImportResultWithFs(relativeImportsCompatible);
 
-            // Resolve import paths, handling JS/TS modules and static assets appropriately
-            _context.n = 7;
-            return resolveImportResultWithFs(relativeImportsCompatible);
-          case 7:
-            resolvedPathsMap = _context.v;
-            // Process imports using the unified helper function
-            _result = processRelativeImports(source, importsCompatible, storeAt, true, resolvedPathsMap);
-            processedSource = _result.processedSource;
-            extraFiles = _result.extraFiles;
+      // Process imports using the unified helper function
+      const result = processRelativeImports(source, importsCompatible, storeAt, true, resolvedPathsMap);
+      processedSource = result.processedSource;
+      extraFiles = result.extraFiles;
 
-            // Build dependencies list for recursive loading
-            extraDependencies = Object.values(importResult).map(function (_ref4) {
-              var importUrl = _ref4.url;
-              return resolvedPathsMap.get(importUrl);
-            }).filter(function (resolved) {
-              return resolved !== undefined;
-            });
-          case 8:
-            return _context.a(2, {
-              source: processedSource,
-              extraFiles: Object.keys(extraFiles).length > 0 ? extraFiles : undefined,
-              extraDependencies: extraDependencies.length > 0 ? extraDependencies : undefined,
-              externals: Object.keys(transformedExternals).length > 0 ? transformedExternals : undefined
-            });
-        }
-      }, _callee);
-    }));
-    function loadSource(_x) {
-      return _loadSource.apply(this, arguments);
+      // Build dependencies list for recursive loading
+      extraDependencies = Object.values(importResult).map(({
+        url: importUrl
+      }) => resolvedPathsMap.get(importUrl)).filter(resolved => resolved !== undefined);
     }
-    return loadSource;
-  }();
+    return {
+      source: processedSource,
+      extraFiles: Object.keys(extraFiles).length > 0 ? extraFiles : undefined,
+      extraDependencies: extraDependencies.length > 0 ? extraDependencies : undefined,
+      externals: Object.keys(transformedExternals).length > 0 ? transformedExternals : undefined
+    };
+  };
 }

package/esm/pipeline/loaderUtils/externalsToPackages.js

@@ -1,13 +1,13 @@
 export function externalsToPackages(externals) {
-  var packages = {};
-  externals.forEach(function (external) {
+  const packages = {};
+  externals.forEach(external => {
     // Filter out path aliases that start with @/
     if (external.startsWith('@/')) {
       return;
     }
 
     // Extract package name from import path
-    var packageName = extractPackageName(external);
+    const packageName = extractPackageName(external);
     if (packageName) {
       packages[packageName] = true;
     }
@@ -32,15 +32,15 @@ function extractPackageName(importPath) {
 
   // Handle scoped packages (starting with @)
   if (importPath.startsWith('@')) {
-    var _parts = importPath.split('/');
-    if (_parts.length >= 2) {
+    const parts = importPath.split('/');
+    if (parts.length >= 2) {
       // Return @scope/package-name
-      return "".concat(_parts[0], "/").concat(_parts[1]);
+      return `${parts[0]}/${parts[1]}`;
     }
     return null;
   }
 
   // Handle regular packages
-  var parts = importPath.split('/');
+  const parts = importPath.split('/');
   return parts[0] || null;
 }

package/esm/pipeline/loaderUtils/extractNameAndSlugFromUrl.js

@@ -39,9 +39,7 @@ function camelToTitleCase(camelCase) {
   // Insert spaces before letters that follow numbers
   .replace(/([0-9])([a-zA-Z])/g, '$1 $2')
   // Capitalize the first letter
-  .replace(/^./, function (str) {
-    return str.toUpperCase();
-  });
+  .replace(/^./, str => str.toUpperCase());
 }
 
 /**
@@ -51,9 +49,7 @@ function camelToTitleCase(camelCase) {
  */
 function kebabToTitleCase(kebabCase) {
   return kebabCase.split(/[-_]/) // Split on both hyphens and underscores
-  .map(function (word) {
-    return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
-  }).join(' ');
+  .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(' ');
 }
 
 /**
@@ -86,19 +82,19 @@ function toKebabCase(str) {
 function extractLastSegment(url) {
   // Convert to portable path format for consistent handling across platforms
   // This handles file:// URLs, Windows paths with backslashes, and regular paths
-  var path = fileUrlToPortablePath(url);
+  const path = fileUrlToPortablePath(url);
 
   // Strip query parameters and hash fragments before processing
-  var cleanPath = path.split('?')[0].split('#')[0];
+  const cleanPath = path.split('?')[0].split('#')[0];
 
   // Split the path into segments and filter out empty ones
-  var segments = cleanPath.split('/').filter(Boolean);
+  const segments = cleanPath.split('/').filter(Boolean);
   if (segments.length === 0) {
     throw new Error('Could not extract meaningful segment from URL');
   }
 
   // Get the last segment
-  var lastSegment = segments[segments.length - 1];
+  let lastSegment = segments[segments.length - 1];
 
   // Handle index files - any file that starts with 'index.'
   if (lastSegment.startsWith('index.')) {
@@ -110,7 +106,7 @@ function extractLastSegment(url) {
   } else {
     // Strip everything after the first dot from non-index files
     // This handles all extensions: .js, .d.ts, .module.css, .config.dev.js, etc.
-    var firstDotIndex = lastSegment.indexOf('.');
+    const firstDotIndex = lastSegment.indexOf('.');
     if (firstDotIndex !== -1) {
       lastSegment = lastSegment.substring(0, firstDotIndex);
     }
@@ -143,7 +139,7 @@ function extractLastSegment(url) {
  * // Returns: { name: 'Getting Started', slug: 'getting-started' }
  */
 export function extractNameAndSlugFromUrl(url) {
-  var segment = extractLastSegment(url);
+  const segment = extractLastSegment(url);
 
   // Check if the segment is camelCase and handle it appropriately
   if (isCamelCase(segment)) {

package/esm/pipeline/loaderUtils/fileUrlToPortablePath.js

@@ -28,10 +28,10 @@ export function fileUrlToPortablePath(fileUrl) {
   // If it's not a file:// URL, check if it's already a portable path
   if (!fileUrl.startsWith('file://')) {
     // Normalize backslashes to forward slashes
-    var normalized = fileUrl.replace(/\\/g, '/');
+    const normalized = fileUrl.replace(/\\/g, '/');
     // If it doesn't start with /, it's likely a Windows path - add leading slash
     if (!normalized.startsWith('/') && /^[a-zA-Z]:\//.test(normalized)) {
-      return "/".concat(normalized);
+      return `/${normalized}`;
     }
     return normalized;
   }
@@ -39,14 +39,14 @@ export function fileUrlToPortablePath(fileUrl) {
   // Strip the file:// prefix
   // file:///home/user/file.ts => /home/user/file.ts (Unix)
   // file:///C:/Users/file.ts => /C:/Users/file.ts (Windows - keep the leading slash)
-  var path = fileUrl.slice(7); // Remove 'file://'
+  let path = fileUrl.slice(7); // Remove 'file://'
 
   // Normalize any backslashes that might have snuck in
   path = path.replace(/\\/g, '/');
 
   // If it doesn't start with /, add one (should already have one for valid file:// URLs)
   if (!path.startsWith('/')) {
-    path = "/".concat(path);
+    path = `/${path}`;
   }
   return path;
 }
@@ -76,5 +76,5 @@ export function portablePathToFileUrl(portablePath) {
   // For Windows portable paths like /C:/Users/..., we need file:// + path
   // For Unix paths like /home/user/..., we need file:// + path
   // Both cases: file:// + /path = file:///path
-  return "file://".concat(portablePath);
+  return `file://${portablePath}`;
 }

package/esm/pipeline/loaderUtils/getFileNameFromUrl.js

@@ -1,8 +1,7 @@
-import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
 /**
  * Known compound extensions that should be treated as a single unit
  */
-var COMPOUND_EXTENSIONS = ['.module.css', '.module.scss', '.module.sass', '.module.less', '.d.ts', '.test.js', '.test.jsx', '.test.ts', '.test.tsx', '.spec.js', '.spec.jsx', '.spec.ts', '.spec.tsx', '.config.js', '.config.ts', '.setup.js', '.setup.ts', '.stories.js', '.stories.jsx', '.stories.ts', '.stories.tsx'];
+const COMPOUND_EXTENSIONS = ['.module.css', '.module.scss', '.module.sass', '.module.less', '.d.ts', '.test.js', '.test.jsx', '.test.ts', '.test.tsx', '.spec.js', '.spec.jsx', '.spec.ts', '.spec.tsx', '.config.js', '.config.ts', '.setup.js', '.setup.ts', '.stories.js', '.stories.jsx', '.stories.ts', '.stories.tsx'];
 
 /**
  * Extracts the filename and extension from a URL or file path.
@@ -15,14 +14,14 @@ var COMPOUND_EXTENSIONS = ['.module.css', '.module.scss', '.module.sass', '.modu
 export function getFileNameFromUrl(url) {
   try {
     // Use URL constructor to handle various URL formats
-    var urlObj = new URL(url);
-    var pathname = urlObj.pathname;
-    var fileName = pathname.split('/').pop() || '';
+    const urlObj = new URL(url);
+    const pathname = urlObj.pathname;
+    const fileName = pathname.split('/').pop() || '';
     return extractFileNameAndExtension(fileName);
-  } catch (_unused) {
+  } catch {
     // If URL parsing fails, fall back to simple string manipulation
-    var _fileName = url.split('/').pop() || url;
-    return extractFileNameAndExtension(_fileName);
+    const fileName = url.split('/').pop() || url;
+    return extractFileNameAndExtension(fileName);
   }
 }
 
@@ -38,29 +37,20 @@ function extractFileNameAndExtension(fileName) {
   }
 
   // Check for compound extensions first
-  var _iterator = _createForOfIteratorHelper(COMPOUND_EXTENSIONS),
-    _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var compoundExt = _step.value;
-      if (fileName.endsWith(compoundExt)) {
-        return {
-          fileName: fileName,
-          extension: compoundExt
-        };
-      }
+  for (const compoundExt of COMPOUND_EXTENSIONS) {
+    if (fileName.endsWith(compoundExt)) {
+      return {
+        fileName,
+        extension: compoundExt
+      };
     }
-
-    // Fall back to simple extension detection
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
   }
-  var lastDotIndex = fileName.lastIndexOf('.');
-  var extension = lastDotIndex > 0 ? fileName.substring(lastDotIndex) : '';
+
+  // Fall back to simple extension detection
+  const lastDotIndex = fileName.lastIndexOf('.');
+  const extension = lastDotIndex > 0 ? fileName.substring(lastDotIndex) : '';
   return {
-    fileName: fileName,
-    extension: extension
+    fileName,
+    extension
   };
 }

package/esm/pipeline/loaderUtils/getLanguageFromExtension.js

@@ -2,7 +2,7 @@
  * Maps file extensions to language names.
  * These are user-friendly names that can be used in the `language` prop.
  */
-export var languageMap = {
+export const languageMap = {
   '.js': 'javascript',
   '.ts': 'typescript',
   '.jsx': 'jsx',
@@ -22,7 +22,7 @@ export var languageMap = {
  * Used to normalize short language names (e.g., from className like 'language-js')
  * to their full names.
  */
-export var languageAliasMap = {
+export const languageAliasMap = {
   js: 'javascript',
   ts: 'typescript',
   javascript: 'javascript',
@@ -58,6 +58,5 @@ export function getLanguageFromExtension(extension) {
  * @returns The canonical language name, or the input if not a known alias
  */
 export function normalizeLanguage(language) {
-  var _languageAliasMap$lan;
-  return (_languageAliasMap$lan = languageAliasMap[language]) != null ? _languageAliasMap$lan : language;
+  return languageAliasMap[language] ?? language;
 }

package/esm/pipeline/loaderUtils/mergeExternals.js

@@ -1,6 +1,3 @@
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
 /**
  * Merges multiple externals objects into a single object, combining imports from the same module.
  * Deduplicates imports by name and type within each module.
@@ -32,41 +29,24 @@ import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIt
  * ```
  */
 export function mergeExternals(externalsArray) {
-  var merged = {};
-  var _iterator = _createForOfIteratorHelper(externalsArray),
-    _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var externals = _step.value;
-      var _loop = function _loop() {
-        var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
-          modulePath = _Object$entries$_i[0],
-          imports = _Object$entries$_i[1];
-        if (!merged[modulePath]) {
-          // First time seeing this module, copy all imports
-          merged[modulePath] = _toConsumableArray(imports);
-        } else {
-          // Module already exists, merge imports and deduplicate
-          var existingImports = merged[modulePath];
-          var newImports = imports.filter(function (newImport) {
-            // Check if this import already exists (same name, type, and isType)
-            return !existingImports.some(function (existingImport) {
-              return existingImport.name === newImport.name && existingImport.type === newImport.type && existingImport.isType === newImport.isType;
-            });
-          });
+  const merged = {};
+  for (const externals of externalsArray) {
+    for (const [modulePath, imports] of Object.entries(externals)) {
+      if (!merged[modulePath]) {
+        // First time seeing this module, copy all imports
+        merged[modulePath] = [...imports];
+      } else {
+        // Module already exists, merge imports and deduplicate
+        const existingImports = merged[modulePath];
+        const newImports = imports.filter(newImport => {
+          // Check if this import already exists (same name, type, and isType)
+          return !existingImports.some(existingImport => existingImport.name === newImport.name && existingImport.type === newImport.type && existingImport.isType === newImport.isType);
+        });
 
-          // Add only the new imports that don't already exist
-          merged[modulePath] = [].concat(_toConsumableArray(existingImports), _toConsumableArray(newImports));
-        }
-      };
-      for (var _i = 0, _Object$entries = Object.entries(externals); _i < _Object$entries.length; _i++) {
-        _loop();
+        // Add only the new imports that don't already exist
+        merged[modulePath] = [...existingImports, ...newImports];
       }
     }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
   }
   return merged;
 }