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

package/esm/pipeline/loaderUtils/parseImportsAndComments.js

@@ -1,8 +1,3 @@
-import _regenerator from "@babel/runtime/helpers/esm/regenerator";
-import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
-import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
-import _extends from "@babel/runtime/helpers/esm/extends";
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import * as path from 'path-module';
 import { fileUrlToPortablePath, portablePathToFileUrl } from "./fileUrlToPortablePath.js";
 
@@ -47,16 +42,16 @@ function isStringStart(ch, withinMdx) {
  * @returns True if the comment starts with any of the specified prefixes
  */
 function matchesCommentPrefix(commentText, removeCommentsWithPrefix) {
-  return removeCommentsWithPrefix.some(function (prefix) {
+  return removeCommentsWithPrefix.some(prefix => {
     // For single-line comments, check after the //
     if (commentText.startsWith('//')) {
-      var content = commentText.slice(2).trim();
+      const content = commentText.slice(2).trim();
       return content.startsWith(prefix);
     }
     // For multi-line comments, check after the /*
     if (commentText.startsWith('/*')) {
-      var _content = commentText.slice(2, -2).trim();
-      return _content.startsWith(prefix);
+      const content = commentText.slice(2, -2).trim();
+      return content.startsWith(prefix);
     }
     return false;
   });
@@ -74,12 +69,8 @@ function stripCommentMarkers(commentText) {
   }
   // For multi-line comments, remove /* and */, split by lines, and trim each line
   if (commentText.startsWith('/*') && commentText.endsWith('*/')) {
-    var content = commentText.slice(2, -2);
-    return content.split('\n').map(function (line) {
-      return line.trim();
-    }).filter(function (line) {
-      return line !== '';
-    });
+    const content = commentText.slice(2, -2);
+    return content.split('\n').map(line => line.trim()).filter(line => line !== '');
   }
   // Fallback: return as single-item array if format is unexpected
   return [commentText];
@@ -92,8 +83,8 @@ function stripCommentMarkers(commentText) {
  * @returns The number of consecutive backticks found
  */
 function countBackticks(sourceText, startPos) {
-  var count = 0;
-  var pos = startPos;
+  let count = 0;
+  let pos = startPos;
   while (pos < sourceText.length && sourceText[pos] === '`') {
     count += 1;
     pos += 1;
@@ -114,46 +105,46 @@ function countBackticks(sourceText, startPos) {
  * @returns Object containing found import statements and optionally processed code/comments
  */
 function scanForImports(sourceCode, importDetector, isMdxFile, removeCommentsWithPrefix, notableCommentsPrefix) {
-  var statements = [];
-  var comments = {};
-  var shouldProcessComments = !!(removeCommentsWithPrefix || notableCommentsPrefix);
-  var result = shouldProcessComments ? '' : sourceCode;
+  const statements = [];
+  const comments = {};
+  const shouldProcessComments = !!(removeCommentsWithPrefix || notableCommentsPrefix);
+  let result = shouldProcessComments ? '' : sourceCode;
 
   // Position mapping from original source to processed source (after comment removal)
-  var positionMapping = new Map();
-  var processedPos = 0;
+  const positionMapping = new Map();
+  let processedPos = 0;
 
   // Helper to check if a comment matches notable prefix
-  var matchesNotablePrefix = function matchesNotablePrefix(commentText) {
+  const matchesNotablePrefix = commentText => {
     if (!notableCommentsPrefix || notableCommentsPrefix.length === 0) {
       return false; // If no notable prefix specified, don't match any comments as notable
     }
-    return notableCommentsPrefix.some(function (prefix) {
+    return notableCommentsPrefix.some(prefix => {
       if (commentText.startsWith('//')) {
-        var content = commentText.slice(2).trim();
+        const content = commentText.slice(2).trim();
         return content.startsWith(prefix);
       }
       if (commentText.startsWith('/*')) {
-        var _content2 = commentText.slice(2, -2).trim();
-        return _content2.startsWith(prefix);
+        const content = commentText.slice(2, -2).trim();
+        return content.startsWith(prefix);
       }
       return false;
     });
   };
-  var i = 0;
-  var outputLine = 0; // Line number in output code after comment removal
-  var len = sourceCode.length;
-  var state = 'code';
-  var stringQuote = null;
-  var codeblockBacktickCount = 0; // Track how many backticks opened the current code block
+  let i = 0;
+  let outputLine = 0; // Line number in output code after comment removal
+  const len = sourceCode.length;
+  let state = 'code';
+  let stringQuote = null;
+  let codeblockBacktickCount = 0; // Track how many backticks opened the current code block
   // Comment stripping variables
-  var commentStart = 0;
-  var commentStartOutputLine = 0;
-  var lineStartPos = 0;
-  var preCommentContent = '';
+  let commentStart = 0;
+  let commentStartOutputLine = 0;
+  let lineStartPos = 0;
+  let preCommentContent = '';
   while (i < len) {
-    var ch = sourceCode[i];
-    var next = sourceCode[i + 1];
+    const ch = sourceCode[i];
+    const next = sourceCode[i + 1];
     if (state === 'code') {
       // Track line numbers for newlines in code
       if (ch === '\n') {
@@ -170,7 +161,7 @@ function scanForImports(sourceCode, importDetector, isMdxFile, removeCommentsWit
       // Check for backtick sequences (3 or more backticks start code blocks in MDX)
       if (isMdxFile && ch === '`') {
         // Count consecutive backticks
-        var backtickCount = countBackticks(sourceCode, i);
+        const backtickCount = countBackticks(sourceCode, i);
         if (backtickCount >= 3) {
           state = 'codeblock';
           codeblockBacktickCount = backtickCount;
@@ -187,7 +178,7 @@ function scanForImports(sourceCode, importDetector, isMdxFile, removeCommentsWit
           commentStart = i;
           commentStartOutputLine = outputLine;
           // Remove content that was already added to result for this line
-          var contentSinceLineStart = sourceCode.slice(lineStartPos, commentStart);
+          const contentSinceLineStart = sourceCode.slice(lineStartPos, commentStart);
           result = result.slice(0, result.length - contentSinceLineStart.length);
           preCommentContent = contentSinceLineStart;
         }
@@ -201,9 +192,9 @@ function scanForImports(sourceCode, importDetector, isMdxFile, removeCommentsWit
           commentStart = i;
           commentStartOutputLine = outputLine;
           // Remove content that was already added to result for this line
-          var _contentSinceLineStart = sourceCode.slice(lineStartPos, commentStart);
-          result = result.slice(0, result.length - _contentSinceLineStart.length);
-          preCommentContent = _contentSinceLineStart;
+          const contentSinceLineStart = sourceCode.slice(lineStartPos, commentStart);
+          result = result.slice(0, result.length - contentSinceLineStart.length);
+          preCommentContent = contentSinceLineStart;
         }
         state = 'multiline-comment';
         i += 2;
@@ -226,30 +217,30 @@ function scanForImports(sourceCode, importDetector, isMdxFile, removeCommentsWit
       }
 
       // Create position mapper function
-      var positionMapper = function positionMapper(originalPos) {
+      const positionMapper = originalPos => {
         if (!shouldProcessComments) {
           return originalPos; // No comment processing, positions are unchanged
         }
         // Find the closest mapped position
-        var closest = 0;
-        positionMapping.forEach(function (procPos, origPos) {
+        let closest = 0;
+        positionMapping.forEach((procPos, origPos) => {
           if (origPos <= originalPos && origPos > closest) {
             closest = origPos;
           }
         });
-        var offset = originalPos - closest;
+        const offset = originalPos - closest;
         return (positionMapping.get(closest) || 0) + offset;
       };
 
       // Use the provided import detector on the original source code
-      var detection = importDetector(sourceCode, i, positionMapper);
+      const detection = importDetector(sourceCode, i, positionMapper);
       if (detection.found) {
         if (detection.statement) {
           statements.push(detection.statement);
         }
         // Copy the detected import to result if we're building one
         if (shouldProcessComments) {
-          var importText = sourceCode.slice(i, detection.nextPos);
+          const importText = sourceCode.slice(i, detection.nextPos);
           result += importText;
           processedPos += importText.length;
         }
@@ -267,22 +258,21 @@ function scanForImports(sourceCode, importDetector, isMdxFile, removeCommentsWit
       if (ch === '\n') {
         if (shouldProcessComments) {
           // End of single-line comment
-          var commentText = sourceCode.slice(commentStart, i);
-          var shouldStrip = removeCommentsWithPrefix && matchesCommentPrefix(commentText, removeCommentsWithPrefix);
-          var isNotable = matchesNotablePrefix(commentText);
+          const commentText = sourceCode.slice(commentStart, i);
+          const shouldStrip = removeCommentsWithPrefix && matchesCommentPrefix(commentText, removeCommentsWithPrefix);
+          const isNotable = matchesNotablePrefix(commentText);
 
           // Collect comments if they're notable (all stripped comments when no prefix specified, or notable comments when prefix specified)
-          var shouldCollect = shouldStrip && !notableCommentsPrefix || isNotable;
+          const shouldCollect = shouldStrip && !notableCommentsPrefix || isNotable;
           if (shouldCollect) {
-            var _comments$commentStar;
             if (!comments[commentStartOutputLine]) {
               comments[commentStartOutputLine] = [];
             }
-            (_comments$commentStar = comments[commentStartOutputLine]).push.apply(_comments$commentStar, _toConsumableArray(stripCommentMarkers(commentText)));
+            comments[commentStartOutputLine].push(...stripCommentMarkers(commentText));
           }
           if (shouldStrip) {
             // Check if comment is the only thing on its line (ignoring whitespace)
-            var isCommentOnlyLine = preCommentContent.trim() === '';
+            const isCommentOnlyLine = preCommentContent.trim() === '';
             if (isCommentOnlyLine) {
               // Don't add the pre-comment content or newline for comment-only lines
               // Skip the newline entirely
@@ -311,29 +301,28 @@ function scanForImports(sourceCode, importDetector, isMdxFile, removeCommentsWit
       if (ch === '*' && next === '/') {
         if (shouldProcessComments) {
           // End of multi-line comment
-          var _commentText = sourceCode.slice(commentStart, i + 2);
-          var _shouldStrip = removeCommentsWithPrefix && matchesCommentPrefix(_commentText, removeCommentsWithPrefix);
-          var _isNotable = matchesNotablePrefix(_commentText);
+          const commentText = sourceCode.slice(commentStart, i + 2);
+          const shouldStrip = removeCommentsWithPrefix && matchesCommentPrefix(commentText, removeCommentsWithPrefix);
+          const isNotable = matchesNotablePrefix(commentText);
 
           // Collect comments if they're notable (all stripped comments when no prefix specified, or notable comments when prefix specified)
-          var _shouldCollect = _shouldStrip && !notableCommentsPrefix || _isNotable;
-          if (_shouldCollect) {
-            var _comments$commentStar2;
+          const shouldCollect = shouldStrip && !notableCommentsPrefix || isNotable;
+          if (shouldCollect) {
             if (!comments[commentStartOutputLine]) {
               comments[commentStartOutputLine] = [];
             }
-            (_comments$commentStar2 = comments[commentStartOutputLine]).push.apply(_comments$commentStar2, _toConsumableArray(stripCommentMarkers(_commentText)));
+            comments[commentStartOutputLine].push(...stripCommentMarkers(commentText));
           }
-          if (_shouldStrip) {
+          if (shouldStrip) {
             // Find the end of the comment and check what's after
-            var afterCommentPos = i + 2;
-            var afterCommentContent = '';
-            var nextNewlinePos = sourceCode.indexOf('\n', afterCommentPos);
+            const afterCommentPos = i + 2;
+            let afterCommentContent = '';
+            let nextNewlinePos = sourceCode.indexOf('\n', afterCommentPos);
             if (nextNewlinePos === -1) {
               nextNewlinePos = sourceCode.length;
             }
             afterCommentContent = sourceCode.slice(afterCommentPos, nextNewlinePos).trim();
-            var isCommentOnlyLines = preCommentContent.trim() === '' && afterCommentContent === '';
+            const isCommentOnlyLines = preCommentContent.trim() === '' && afterCommentContent === '';
             if (isCommentOnlyLines) {
               // Skip the entire comment and everything up to and including the next newline
               i = nextNewlinePos;
@@ -355,9 +344,9 @@ function scanForImports(sourceCode, importDetector, isMdxFile, removeCommentsWit
           } else {
             // Keep the comment - add pre-comment content and comment
             result += preCommentContent;
-            result += _commentText;
+            result += commentText;
             // Count newlines in the kept comment to update output line
-            var newlineCount = (_commentText.match(/\n/g) || []).length;
+            const newlineCount = (commentText.match(/\n/g) || []).length;
             outputLine += newlineCount;
             i += 2;
           }
@@ -427,7 +416,7 @@ function scanForImports(sourceCode, importDetector, isMdxFile, removeCommentsWit
       }
       // Look for closing backticks that match or exceed the opening count
       if (ch === '`') {
-        var closingBacktickCount = countBackticks(sourceCode, i);
+        const closingBacktickCount = countBackticks(sourceCode, i);
         if (closingBacktickCount >= codeblockBacktickCount) {
           state = 'code';
           codeblockBacktickCount = 0;
@@ -452,46 +441,46 @@ function scanForImports(sourceCode, importDetector, isMdxFile, removeCommentsWit
 
   // Handle case where file ends with a comment
   if (shouldProcessComments && (state === 'singleline-comment' || state === 'multiline-comment')) {
-    var _commentText2 = sourceCode.slice(commentStart);
-    var _shouldStrip2 = removeCommentsWithPrefix && matchesCommentPrefix(_commentText2, removeCommentsWithPrefix);
-    var _isNotable2 = matchesNotablePrefix(_commentText2);
+    const commentText = sourceCode.slice(commentStart);
+    const shouldStrip = removeCommentsWithPrefix && matchesCommentPrefix(commentText, removeCommentsWithPrefix);
+    const isNotable = matchesNotablePrefix(commentText);
 
     // Collect comments if they're notable (all stripped comments when no prefix specified, or notable comments when prefix specified)
-    var _shouldCollect2 = _shouldStrip2 && !notableCommentsPrefix || _isNotable2;
-    if (_shouldCollect2) {
-      var _comments$commentStar3;
+    const shouldCollect = shouldStrip && !notableCommentsPrefix || isNotable;
+    if (shouldCollect) {
       if (!comments[commentStartOutputLine]) {
         comments[commentStartOutputLine] = [];
       }
-      (_comments$commentStar3 = comments[commentStartOutputLine]).push.apply(_comments$commentStar3, _toConsumableArray(stripCommentMarkers(_commentText2)));
+      comments[commentStartOutputLine].push(...stripCommentMarkers(commentText));
     }
-    if (!_shouldStrip2) {
-      result += _commentText2;
+    if (!shouldStrip) {
+      result += commentText;
     }
   }
 
   // Create the final position mapper for return
-  var finalPositionMapper = function finalPositionMapper(originalPos) {
+  const finalPositionMapper = originalPos => {
     if (!shouldProcessComments) {
       return originalPos; // No comment processing, positions are unchanged
     }
     // Find the closest mapped position
-    var closest = 0;
-    positionMapping.forEach(function (procPos, origPos) {
+    let closest = 0;
+    positionMapping.forEach((procPos, origPos) => {
       if (origPos <= originalPos && origPos > closest) {
         closest = origPos;
       }
     });
-    var offset = originalPos - closest;
+    const offset = originalPos - closest;
     return (positionMapping.get(closest) || 0) + offset;
   };
-  return _extends({
-    statements: statements
-  }, shouldProcessComments && {
-    code: result,
-    comments: comments,
-    positionMapper: finalPositionMapper
-  });
+  return {
+    statements,
+    ...(shouldProcessComments && {
+      code: result,
+      comments,
+      positionMapper: finalPositionMapper
+    })
+  };
 }
 
 /**
@@ -503,19 +492,18 @@ function scanForImports(sourceCode, importDetector, isMdxFile, removeCommentsWit
  * @param isType - Whether this is a TypeScript type-only import
  */
 function addImportName(target, name, type, alias, isType) {
-  var existing = target.find(function (n) {
-    return n.name === name && n.type === type && n.alias === alias;
-  });
+  const existing = target.find(n => n.name === name && n.type === type && n.alias === alias);
   if (!existing) {
-    target.push(_extends(_extends({
-      name: name
-    }, alias && {
-      alias: alias
-    }), {}, {
-      type: type
-    }, isType && {
-      isType: true
-    }));
+    target.push({
+      name,
+      ...(alias && {
+        alias
+      }),
+      type,
+      ...(isType && {
+        isType: true
+      })
+    });
   }
 }
 
@@ -544,7 +532,7 @@ function isWhitespace(ch) {
  * @returns The position of the next non-whitespace character
  */
 function skipWhitespace(text, start) {
-  var pos = start;
+  let pos = start;
   while (pos < text.length && isWhitespace(text[pos])) {
     pos += 1;
   }
@@ -558,8 +546,8 @@ function skipWhitespace(text, start) {
  * @returns Object containing the identifier name and the next position
  */
 function readIdentifier(text, start) {
-  var pos = start;
-  var name = '';
+  let pos = start;
+  let name = '';
 
   // First character must be letter, underscore, or dollar sign
   if (pos < text.length && /[a-zA-Z_$]/.test(text[pos])) {
@@ -573,33 +561,33 @@ function readIdentifier(text, start) {
     }
   }
   return {
-    name: name,
+    name,
     nextPos: pos
   };
 }
 
 // Helper function to read a quoted string starting at position
 function readQuotedString(text, start) {
-  var quote = text[start];
-  var pos = start + 1;
-  var value = '';
-  var pathStart = start; // Start at the opening quote
+  const quote = text[start];
+  let pos = start + 1;
+  let value = '';
+  const pathStart = start; // Start at the opening quote
 
   while (pos < text.length) {
-    var ch = text[pos];
+    const ch = text[pos];
     if (ch === '\\' && pos + 1 < text.length) {
       // Skip escaped character
       pos += 2;
       continue;
     }
     if (ch === quote) {
-      var pathEnd = pos + 1; // End after the closing quote
+      const pathEnd = pos + 1; // End after the closing quote
       pos += 1;
       return {
-        value: value,
+        value,
         nextPos: pos,
-        pathStart: pathStart,
-        pathEnd: pathEnd
+        pathStart,
+        pathEnd
       };
     }
     value += ch;
@@ -608,17 +596,17 @@ function readQuotedString(text, start) {
 
   // If we reach here, no closing quote was found - fallback
   return {
-    value: value,
+    value,
     nextPos: pos,
-    pathStart: pathStart,
+    pathStart,
     pathEnd: pos
   };
 }
 
 // Helper function to parse named imports from a brace-enclosed section
 function parseNamedImports(text, start, end) {
-  var imports = [];
-  var pos = start;
+  const imports = [];
+  let pos = start;
   while (pos < end) {
     pos = skipWhitespace(text, pos);
     if (pos >= end) {
@@ -653,7 +641,7 @@ function parseNamedImports(text, start, end) {
     }
 
     // Check for 'type' keyword
-    var isTypeImport = false;
+    let isTypeImport = false;
     if (text.slice(pos, pos + 4) === 'type' && !isIdentifierChar(text[pos + 4] || '')) {
       isTypeImport = true;
       pos += 4;
@@ -661,9 +649,10 @@ function parseNamedImports(text, start, end) {
     }
 
     // Read the import name
-    var _readIdentifier = readIdentifier(text, pos),
-      name = _readIdentifier.name,
-      nextPos = _readIdentifier.nextPos;
+    const {
+      name,
+      nextPos
+    } = readIdentifier(text, pos);
     if (!name) {
       pos += 1;
       continue;
@@ -672,22 +661,24 @@ function parseNamedImports(text, start, end) {
     pos = skipWhitespace(text, pos);
 
     // Check for 'as' keyword (alias)
-    var alias = void 0;
+    let alias;
     if (text.slice(pos, pos + 2) === 'as' && !isIdentifierChar(text[pos + 2] || '')) {
       pos += 2;
       pos = skipWhitespace(text, pos);
-      var aliasResult = readIdentifier(text, pos);
+      const aliasResult = readIdentifier(text, pos);
       alias = aliasResult.name;
       pos = aliasResult.nextPos;
       pos = skipWhitespace(text, pos);
     }
-    imports.push(_extends(_extends({
-      name: name
-    }, alias && {
-      alias: alias
-    }), isTypeImport && {
-      isType: true
-    }));
+    imports.push({
+      name,
+      ...(alias && {
+        alias
+      }),
+      ...(isTypeImport && {
+        isType: true
+      })
+    });
 
     // Skip comma if present
     if (text[pos] === ',') {
@@ -699,16 +690,16 @@ function parseNamedImports(text, start, end) {
 
 // Function to parse a single CSS @import statement
 function parseCssImportStatement(cssCode, start) {
-  var pos = start + 7; // Skip '@import'
-  var len = cssCode.length;
+  let pos = start + 7; // Skip '@import'
+  const len = cssCode.length;
 
   // Skip whitespace
   while (pos < len && /\s/.test(cssCode[pos])) {
     pos += 1;
   }
-  var modulePath = null;
-  var pathStart;
-  var pathEnd;
+  let modulePath = null;
+  let pathStart;
+  let pathEnd;
 
   // Check for url() syntax
   if (cssCode.slice(pos, pos + 4) === 'url(') {
@@ -720,10 +711,10 @@ function parseCssImportStatement(cssCode, start) {
 
     // Read the URL (quoted or unquoted)
     if (pos < len && (cssCode[pos] === '"' || cssCode[pos] === "'")) {
-      var quote = cssCode[pos];
+      const quote = cssCode[pos];
       pathStart = pos; // Start at the opening quote
       pos += 1;
-      var url = '';
+      let url = '';
       while (pos < len && cssCode[pos] !== quote) {
         // Only stop at newlines - parentheses and semicolons are valid in URLs
         if (cssCode[pos] === '\n') {
@@ -745,13 +736,13 @@ function parseCssImportStatement(cssCode, start) {
     } else {
       // Unquoted URL
       pathStart = pos;
-      var _url = '';
+      let url = '';
       while (pos < len && cssCode[pos] !== ')' && !/\s/.test(cssCode[pos])) {
-        _url += cssCode[pos];
+        url += cssCode[pos];
         pos += 1;
       }
       pathEnd = pos;
-      modulePath = _url;
+      modulePath = url;
     }
 
     // Skip to closing parenthesis - if we don't find it, the url() is malformed
@@ -769,11 +760,11 @@ function parseCssImportStatement(cssCode, start) {
     }
   } else if (pos < len && (cssCode[pos] === '"' || cssCode[pos] === "'")) {
     // Direct quoted import
-    var _quote = cssCode[pos];
+    const quote = cssCode[pos];
     pathStart = pos; // Start at the opening quote
     pos += 1;
-    var _url2 = '';
-    while (pos < len && cssCode[pos] !== _quote) {
+    let url = '';
+    while (pos < len && cssCode[pos] !== quote) {
       // Stop if we hit a newline (likely malformed), but semicolons are valid in URLs
       if (cssCode[pos] === '\n') {
         break;
@@ -782,13 +773,13 @@ function parseCssImportStatement(cssCode, start) {
         pos += 2;
         continue;
       }
-      _url2 += cssCode[pos];
+      url += cssCode[pos];
       pos += 1;
     }
-    if (pos < len && cssCode[pos] === _quote) {
+    if (pos < len && cssCode[pos] === quote) {
       pathEnd = pos + 1; // End after the closing quote
       pos += 1;
-      modulePath = _url2;
+      modulePath = url;
     }
     // If we didn't find the closing quote, don't set modulePath (malformed import)
   }
@@ -801,29 +792,29 @@ function parseCssImportStatement(cssCode, start) {
     pos += 1;
   }
   return {
-    modulePath: modulePath,
+    modulePath,
     nextPos: pos,
-    pathStart: pathStart,
-    pathEnd: pathEnd
+    pathStart,
+    pathEnd
   };
 }
 
 // CSS import detector function
 function detectCssImport(sourceText, pos, cssResult, cssExternals, cssFilePath, positionMapper) {
-  var ch = sourceText[pos];
+  const ch = sourceText[pos];
 
   // Look for '@import' keyword
   if (ch === '@' && sourceText.slice(pos, pos + 7) === '@import' && /\s/.test(sourceText[pos + 7] || '')) {
     // Parse the @import statement
-    var importResult = parseCssImportStatement(sourceText, pos);
+    const importResult = parseCssImportStatement(sourceText, pos);
     if (importResult.modulePath && importResult.pathStart !== undefined && importResult.pathEnd !== undefined) {
       // In CSS, imports are relative unless they have a protocol/hostname
       // Examples of external: "http://...", "https://...", "//example.com/style.css"
       // Examples of relative: "print.css", "./local.css", "../parent.css"
-      var hasProtocol = /^https?:\/\//.test(importResult.modulePath);
-      var hasHostname = /^\/\//.test(importResult.modulePath);
-      var isExternal = hasProtocol || hasHostname;
-      var position = {
+      const hasProtocol = /^https?:\/\//.test(importResult.modulePath);
+      const hasHostname = /^\/\//.test(importResult.modulePath);
+      const isExternal = hasProtocol || hasHostname;
+      const position = {
         start: positionMapper(importResult.pathStart),
         end: positionMapper(importResult.pathEnd)
       };
@@ -837,11 +828,11 @@ function detectCssImport(sourceText, pos, cssResult, cssExternals, cssFilePath,
         cssExternals[importResult.modulePath].positions.push(position);
       } else {
         // Treat as relative import - normalize the path if it doesn't start with ./ or ../
-        var normalizedPath = importResult.modulePath;
+        let normalizedPath = importResult.modulePath;
         if (!normalizedPath.startsWith('./') && !normalizedPath.startsWith('../')) {
-          normalizedPath = "./".concat(normalizedPath);
+          normalizedPath = `./${normalizedPath}`;
         }
-        var resolvedPath = path.resolve(path.dirname(cssFilePath), normalizedPath);
+        const resolvedPath = path.resolve(path.dirname(cssFilePath), normalizedPath);
         if (!cssResult[importResult.modulePath]) {
           cssResult[importResult.modulePath] = {
             url: portablePathToFileUrl(resolvedPath),
@@ -875,17 +866,17 @@ function detectCssImport(sourceText, pos, cssResult, cssExternals, cssFilePath,
  */
 function parseCssImports(cssCode, cssFilePath, cssResult, cssExternals, removeCommentsWithPrefix, notableCommentsPrefix) {
   // Use the generic scanner with a bound detector function
-  var scanResult = scanForImports(cssCode, function (sourceText, pos, positionMapper) {
-    return detectCssImport(sourceText, pos, cssResult, cssExternals, cssFilePath, positionMapper);
-  }, false, removeCommentsWithPrefix, notableCommentsPrefix);
-  return _extends(_extends({
+  const scanResult = scanForImports(cssCode, (sourceText, pos, positionMapper) => detectCssImport(sourceText, pos, cssResult, cssExternals, cssFilePath, positionMapper), false, removeCommentsWithPrefix, notableCommentsPrefix);
+  return {
     relative: cssResult,
-    externals: cssExternals
-  }, scanResult.code && {
-    code: scanResult.code
-  }), scanResult.comments && {
-    comments: scanResult.comments
-  });
+    externals: cssExternals,
+    ...(scanResult.code && {
+      code: scanResult.code
+    }),
+    ...(scanResult.comments && {
+      comments: scanResult.comments
+    })
+  };
 }
 
 /**
@@ -901,211 +892,62 @@ function parseCssImports(cssCode, cssFilePath, cssResult, cssExternals, removeCo
  */
 function parseJSImports(code, filePath, result, externals, isMdxFile, removeCommentsWithPrefix, notableCommentsPrefix) {
   // Scan code for JavaScript import statements
-  var scanResult = scanForImports(code, detectJavaScriptImport, isMdxFile, removeCommentsWithPrefix, notableCommentsPrefix);
+  const scanResult = scanForImports(code, detectJavaScriptImport, isMdxFile, removeCommentsWithPrefix, notableCommentsPrefix);
 
   // Now, parse each import statement using character-by-character parsing
-  var _iterator = _createForOfIteratorHelper(scanResult.statements),
-    _step;
-  try {
-    var _loop = function _loop() {
-        var _step$value = _step.value,
-          start = _step$value.start,
-          text = _step$value.text;
-        var pos = 0;
-        var textLen = text.length;
-
-        // Skip 'import'
-        pos = 6; // We know it starts with 'import'
-        pos = skipWhitespace(text, pos);
-
-        // Check for 'type' keyword
-        var isTypeImport = false;
-        if (text.slice(pos, pos + 4) === 'type' && !isIdentifierChar(text[pos + 4] || '')) {
-          isTypeImport = true;
-          pos += 4;
-          pos = skipWhitespace(text, pos);
-        }
-
-        // Check if this is a side-effect import (starts with quote)
-        if (pos < textLen && (text[pos] === '"' || text[pos] === "'")) {
-          var _readQuotedString = readQuotedString(text, pos),
-            _modulePath = _readQuotedString.value,
-            _pathStart = _readQuotedString.pathStart,
-            _pathEnd = _readQuotedString.pathEnd;
-          if (_modulePath) {
-            // Calculate the position in the original source code
-            var _originalPathStart = start + _pathStart;
-            var _originalPathEnd = start + _pathEnd;
-
-            // Apply position mapping if available (for comment-stripped positions)
-            var _mappedStart = _originalPathStart;
-            var _mappedEnd = _originalPathEnd;
-            if (scanResult.positionMapper) {
-              _mappedStart = scanResult.positionMapper(_originalPathStart);
-              _mappedEnd = scanResult.positionMapper(_originalPathEnd);
-            }
-            var _position = {
-              start: _mappedStart,
-              end: _mappedEnd
-            };
-            var _isRelative = _modulePath.startsWith('./') || _modulePath.startsWith('../');
-            if (_isRelative) {
-              var resolvedPath = path.resolve(path.dirname(filePath), _modulePath);
-              if (!result[_modulePath]) {
-                result[_modulePath] = {
-                  url: portablePathToFileUrl(resolvedPath),
-                  names: [],
-                  positions: []
-                };
-              }
-              result[_modulePath].positions.push(_position);
-            } else {
-              if (!externals[_modulePath]) {
-                externals[_modulePath] = {
-                  names: [],
-                  positions: []
-                };
-              }
-              externals[_modulePath].positions.push(_position);
-            }
-          }
-          return 0; // continue
-        }
-
-        // Parse import specifiers
-        var defaultImport;
-        var namespaceImport;
-        var namedImports = [];
-
-        // Check for default import (identifier not followed by 'from')
-        if (pos < textLen && /[a-zA-Z_$]/.test(text[pos])) {
-          var _readIdentifier2 = readIdentifier(text, pos),
-            name = _readIdentifier2.name,
-            nextPos = _readIdentifier2.nextPos;
-          var afterName = skipWhitespace(text, nextPos);
-
-          // If next non-whitespace is comma or 'from', this is a default import
-          if (afterName >= textLen || text[afterName] === ',' || text.slice(afterName, afterName + 4) === 'from') {
-            defaultImport = name;
-            pos = afterName;
-
-            // Skip comma if present
-            if (pos < textLen && text[pos] === ',') {
-              pos += 1;
-              pos = skipWhitespace(text, pos);
-            }
-          }
-        }
-
-        // Check for namespace import (* as Name)
-        if (pos < textLen && text[pos] === '*') {
-          pos += 1;
-          pos = skipWhitespace(text, pos);
-
-          // Expect 'as'
-          if (text.slice(pos, pos + 2) === 'as') {
-            pos += 2;
-            pos = skipWhitespace(text, pos);
-            var _readIdentifier3 = readIdentifier(text, pos),
-              _name = _readIdentifier3.name;
-            if (_name) {
-              namespaceImport = _name;
-              pos = readIdentifier(text, pos).nextPos;
-              pos = skipWhitespace(text, pos);
-            }
-          }
-        }
-
-        // Check for named imports ({ ... })
-        if (pos < textLen && text[pos] === '{') {
-          pos += 1;
-          var braceStart = pos;
-
-          // Find the closing brace
-          var braceDepth = 1;
-          while (pos < textLen && braceDepth > 0) {
-            if (text[pos] === '{') {
-              braceDepth += 1;
-            } else if (text[pos] === '}') {
-              braceDepth -= 1;
-            }
-            pos += 1;
-          }
-          if (braceDepth === 0) {
-            var braceEnd = pos - 1;
-            namedImports = parseNamedImports(text, braceStart, braceEnd);
-          }
-        }
-
-        // Skip to 'from' keyword
-        pos = skipWhitespace(text, pos);
-        while (pos < textLen && text.slice(pos, pos + 4) !== 'from') {
-          pos += 1;
-        }
-        if (pos >= textLen || text.slice(pos, pos + 4) !== 'from') {
-          return 0; // continue
-          // No 'from' found, skip this import
-        }
-        pos += 4;
-        pos = skipWhitespace(text, pos);
+  for (const {
+    start,
+    text
+  } of scanResult.statements) {
+    let pos = 0;
+    const textLen = text.length;
+
+    // Skip 'import'
+    pos = 6; // We know it starts with 'import'
+    pos = skipWhitespace(text, pos);
 
-        // Read module path
-        if (pos >= textLen || !(text[pos] === '"' || text[pos] === "'")) {
-          return 0; // continue
-          // No quoted module path found
-        }
-        var _readQuotedString2 = readQuotedString(text, pos),
-          modulePath = _readQuotedString2.value,
-          pathStart = _readQuotedString2.pathStart,
-          pathEnd = _readQuotedString2.pathEnd;
-        if (!modulePath) {
-          return 0; // continue
-        }
+    // Check for 'type' keyword
+    let isTypeImport = false;
+    if (text.slice(pos, pos + 4) === 'type' && !isIdentifierChar(text[pos + 4] || '')) {
+      isTypeImport = true;
+      pos += 4;
+      pos = skipWhitespace(text, pos);
+    }
 
+    // Check if this is a side-effect import (starts with quote)
+    if (pos < textLen && (text[pos] === '"' || text[pos] === "'")) {
+      const {
+        value: modulePath,
+        pathStart,
+        pathEnd
+      } = readQuotedString(text, pos);
+      if (modulePath) {
         // Calculate the position in the original source code
-        var originalPathStart = start + pathStart;
-        var originalPathEnd = start + pathEnd;
-        var isRelative = modulePath.startsWith('./') || modulePath.startsWith('../');
+        const originalPathStart = start + pathStart;
+        const originalPathEnd = start + pathEnd;
 
         // Apply position mapping if available (for comment-stripped positions)
-        var mappedStart = originalPathStart;
-        var mappedEnd = originalPathEnd;
+        let mappedStart = originalPathStart;
+        let mappedEnd = originalPathEnd;
         if (scanResult.positionMapper) {
           mappedStart = scanResult.positionMapper(originalPathStart);
           mappedEnd = scanResult.positionMapper(originalPathEnd);
         }
-        var position = {
+        const position = {
           start: mappedStart,
           end: mappedEnd
         };
+        const isRelative = modulePath.startsWith('./') || modulePath.startsWith('../');
         if (isRelative) {
-          var _resolvedPath = path.resolve(path.dirname(filePath), modulePath);
+          const resolvedPath = path.resolve(path.dirname(filePath), modulePath);
           if (!result[modulePath]) {
-            result[modulePath] = _extends({
-              url: portablePathToFileUrl(_resolvedPath),
+            result[modulePath] = {
+              url: portablePathToFileUrl(resolvedPath),
               names: [],
               positions: []
-            }, isTypeImport && {
-              includeTypeDefs: true
-            });
-          } else if (isTypeImport && !result[modulePath].includeTypeDefs) {
-            result[modulePath].includeTypeDefs = true;
+            };
           }
-
-          // Add position information
           result[modulePath].positions.push(position);
-          if (defaultImport) {
-            addImportName(result[modulePath].names, defaultImport, 'default', undefined, isTypeImport);
-          }
-          if (namespaceImport) {
-            addImportName(result[modulePath].names, namespaceImport, 'namespace', undefined, isTypeImport);
-          }
-          namedImports.forEach(function (_ref) {
-            var name = _ref.name,
-              alias = _ref.alias,
-              isType = _ref.isType;
-            addImportName(result[modulePath].names, name, 'named', alias, isTypeImport || isType);
-          });
         } else {
           if (!externals[modulePath]) {
             externals[modulePath] = {
@@ -1113,41 +955,184 @@ function parseJSImports(code, filePath, result, externals, isMdxFile, removeComm
               positions: []
             };
           }
-
-          // Add position information
           externals[modulePath].positions.push(position);
-          if (defaultImport) {
-            addImportName(externals[modulePath].names, defaultImport, 'default', undefined, isTypeImport);
-          }
-          if (namespaceImport) {
-            addImportName(externals[modulePath].names, namespaceImport, 'namespace', undefined, isTypeImport);
-          }
-          namedImports.forEach(function (_ref2) {
-            var name = _ref2.name,
-              alias = _ref2.alias,
-              isType = _ref2.isType;
-            addImportName(externals[modulePath].names, name, 'named', alias, isTypeImport || isType);
-          });
         }
-      },
-      _ret;
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      _ret = _loop();
-      if (_ret === 0) continue;
+      }
+      continue;
+    }
+
+    // Parse import specifiers
+    let defaultImport;
+    let namespaceImport;
+    let namedImports = [];
+
+    // Check for default import (identifier not followed by 'from')
+    if (pos < textLen && /[a-zA-Z_$]/.test(text[pos])) {
+      const {
+        name,
+        nextPos
+      } = readIdentifier(text, pos);
+      const afterName = skipWhitespace(text, nextPos);
+
+      // If next non-whitespace is comma or 'from', this is a default import
+      if (afterName >= textLen || text[afterName] === ',' || text.slice(afterName, afterName + 4) === 'from') {
+        defaultImport = name;
+        pos = afterName;
+
+        // Skip comma if present
+        if (pos < textLen && text[pos] === ',') {
+          pos += 1;
+          pos = skipWhitespace(text, pos);
+        }
+      }
+    }
+
+    // Check for namespace import (* as Name)
+    if (pos < textLen && text[pos] === '*') {
+      pos += 1;
+      pos = skipWhitespace(text, pos);
+
+      // Expect 'as'
+      if (text.slice(pos, pos + 2) === 'as') {
+        pos += 2;
+        pos = skipWhitespace(text, pos);
+        const {
+          name
+        } = readIdentifier(text, pos);
+        if (name) {
+          namespaceImport = name;
+          pos = readIdentifier(text, pos).nextPos;
+          pos = skipWhitespace(text, pos);
+        }
+      }
+    }
+
+    // Check for named imports ({ ... })
+    if (pos < textLen && text[pos] === '{') {
+      pos += 1;
+      const braceStart = pos;
+
+      // Find the closing brace
+      let braceDepth = 1;
+      while (pos < textLen && braceDepth > 0) {
+        if (text[pos] === '{') {
+          braceDepth += 1;
+        } else if (text[pos] === '}') {
+          braceDepth -= 1;
+        }
+        pos += 1;
+      }
+      if (braceDepth === 0) {
+        const braceEnd = pos - 1;
+        namedImports = parseNamedImports(text, braceStart, braceEnd);
+      }
+    }
+
+    // Skip to 'from' keyword
+    pos = skipWhitespace(text, pos);
+    while (pos < textLen && text.slice(pos, pos + 4) !== 'from') {
+      pos += 1;
+    }
+    if (pos >= textLen || text.slice(pos, pos + 4) !== 'from') {
+      continue; // No 'from' found, skip this import
+    }
+    pos += 4;
+    pos = skipWhitespace(text, pos);
+
+    // Read module path
+    if (pos >= textLen || !(text[pos] === '"' || text[pos] === "'")) {
+      continue; // No quoted module path found
+    }
+    const {
+      value: modulePath,
+      pathStart,
+      pathEnd
+    } = readQuotedString(text, pos);
+    if (!modulePath) {
+      continue;
+    }
+
+    // Calculate the position in the original source code
+    const originalPathStart = start + pathStart;
+    const originalPathEnd = start + pathEnd;
+    const isRelative = modulePath.startsWith('./') || modulePath.startsWith('../');
+
+    // Apply position mapping if available (for comment-stripped positions)
+    let mappedStart = originalPathStart;
+    let mappedEnd = originalPathEnd;
+    if (scanResult.positionMapper) {
+      mappedStart = scanResult.positionMapper(originalPathStart);
+      mappedEnd = scanResult.positionMapper(originalPathEnd);
+    }
+    const position = {
+      start: mappedStart,
+      end: mappedEnd
+    };
+    if (isRelative) {
+      const resolvedPath = path.resolve(path.dirname(filePath), modulePath);
+      if (!result[modulePath]) {
+        result[modulePath] = {
+          url: portablePathToFileUrl(resolvedPath),
+          names: [],
+          positions: [],
+          ...(isTypeImport && {
+            includeTypeDefs: true
+          })
+        };
+      } else if (isTypeImport && !result[modulePath].includeTypeDefs) {
+        result[modulePath].includeTypeDefs = true;
+      }
+
+      // Add position information
+      result[modulePath].positions.push(position);
+      if (defaultImport) {
+        addImportName(result[modulePath].names, defaultImport, 'default', undefined, isTypeImport);
+      }
+      if (namespaceImport) {
+        addImportName(result[modulePath].names, namespaceImport, 'namespace', undefined, isTypeImport);
+      }
+      namedImports.forEach(({
+        name,
+        alias,
+        isType
+      }) => {
+        addImportName(result[modulePath].names, name, 'named', alias, isTypeImport || isType);
+      });
+    } else {
+      if (!externals[modulePath]) {
+        externals[modulePath] = {
+          names: [],
+          positions: []
+        };
+      }
+
+      // Add position information
+      externals[modulePath].positions.push(position);
+      if (defaultImport) {
+        addImportName(externals[modulePath].names, defaultImport, 'default', undefined, isTypeImport);
+      }
+      if (namespaceImport) {
+        addImportName(externals[modulePath].names, namespaceImport, 'namespace', undefined, isTypeImport);
+      }
+      namedImports.forEach(({
+        name,
+        alias,
+        isType
+      }) => {
+        addImportName(externals[modulePath].names, name, 'named', alias, isTypeImport || isType);
+      });
     }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
   }
-  return _extends(_extends({
+  return {
     relative: result,
-    externals: externals
-  }, scanResult.code && {
-    code: scanResult.code
-  }), scanResult.comments && {
-    comments: scanResult.comments
-  });
+    externals,
+    ...(scanResult.code && {
+      code: scanResult.code
+    }),
+    ...(scanResult.comments && {
+      comments: scanResult.comments
+    })
+  };
 }
 
 /**
@@ -1158,23 +1143,23 @@ function parseJSImports(code, filePath, result, externals, isMdxFile, removeComm
  * @returns Object indicating if an import was found, the next position, and statement details
  */
 function detectJavaScriptImport(sourceText, pos, _positionMapper) {
-  var ch = sourceText[pos];
+  const ch = sourceText[pos];
 
   // Look for 'import' keyword (not part of an identifier, and not preceded by @)
   if (ch === 'i' && sourceText.slice(pos, pos + 6) === 'import' && (pos === 0 || /[^a-zA-Z0-9_$@]/.test(sourceText[pos - 1])) && /[^a-zA-Z0-9_$]/.test(sourceText[pos + 6] || '')) {
     // Mark start of import statement
-    var importStart = pos;
-    var len = sourceText.length;
+    const importStart = pos;
+    const len = sourceText.length;
 
     // Now, scan forward to find the end of the statement (semicolon or proper end for side-effect imports)
-    var j = pos + 6;
-    var importState = 'code';
-    var importQuote = null;
-    var braceDepth = 0;
-    var foundFrom = false;
-    var foundModulePath = false;
+    let j = pos + 6;
+    let importState = 'code';
+    let importQuote = null;
+    let braceDepth = 0;
+    let foundFrom = false;
+    let foundModulePath = false;
     while (j < len) {
-      var cj = sourceText[j];
+      const cj = sourceText[j];
       if (importState === 'code') {
         if (cj === ';') {
           j += 1;
@@ -1184,7 +1169,7 @@ function detectJavaScriptImport(sourceText, pos, _positionMapper) {
         if (cj === '\n' && !foundFrom && !foundModulePath && braceDepth === 0) {
           // This might be a side-effect import or end of statement
           // Look ahead to see if there's content that could be part of the import
-          var k = j + 1;
+          let k = j + 1;
           while (k < len && /\s/.test(sourceText[k])) {
             k += 1;
           }
@@ -1217,15 +1202,15 @@ function detectJavaScriptImport(sourceText, pos, _positionMapper) {
         // If we found a module path and we're back to normal code, we might be done
         if (foundModulePath && braceDepth === 0 && /\s/.test(cj)) {
           // Look ahead for semicolon or end of statement
-          var _k = j;
-          while (_k < len && /\s/.test(sourceText[_k])) {
-            _k += 1;
+          let k = j;
+          while (k < len && /\s/.test(sourceText[k])) {
+            k += 1;
           }
-          if (_k >= len || sourceText[_k] === ';' || sourceText[_k] === '\n') {
-            if (sourceText[_k] === ';') {
-              j = _k + 1;
+          if (k >= len || sourceText[k] === ';' || sourceText[k] === '\n') {
+            if (sourceText[k] === ';') {
+              j = k + 1;
             } else {
-              j = _k;
+              j = k;
             }
             break;
           }
@@ -1254,7 +1239,7 @@ function detectJavaScriptImport(sourceText, pos, _positionMapper) {
       }
       j += 1;
     }
-    var importText = sourceText.slice(importStart, j);
+    const importText = sourceText.slice(importStart, j);
     return {
       found: true,
       nextPos: j,
@@ -1305,30 +1290,25 @@ function detectJavaScriptImport(sourceText, pos, _positionMapper) {
  * // result.relative['./Button'] contains the Button import with url: 'file:///src/Button'
  * ```
  */
-export function parseImportsAndComments(_x, _x2, _x3) {
-  return _parseImportsAndComments.apply(this, arguments);
-}
-function _parseImportsAndComments() {
-  _parseImportsAndComments = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(code, fileUrl, options) {
-    var result, externals, filePath, isCssFile, isMdxFile;
-    return _regenerator().w(function (_context) {
-      while (1) switch (_context.n) {
-        case 0:
-          result = {};
-          externals = {}; // Convert file:// URL or OS path to portable path format for cross-platform compatibility
-          // Portable paths always use forward slashes and start with / (even on Windows: /C:/...)
-          filePath = fileUrlToPortablePath(fileUrl); // Check if this is a CSS file
-          isCssFile = filePath.toLowerCase().endsWith('.css'); // Check if this is an MDX file (which can contain code blocks with triple backticks)
-          isMdxFile = filePath.toLowerCase().endsWith('.mdx'); // If this is a CSS file, parse CSS @import statements instead
-          if (!isCssFile) {
-            _context.n = 1;
-            break;
-          }
-          return _context.a(2, parseCssImports(code, filePath, result, externals, options == null ? void 0 : options.removeCommentsWithPrefix, options == null ? void 0 : options.notableCommentsPrefix));
-        case 1:
-          return _context.a(2, parseJSImports(code, filePath, result, externals, isMdxFile, options == null ? void 0 : options.removeCommentsWithPrefix, options == null ? void 0 : options.notableCommentsPrefix));
-      }
-    }, _callee);
-  }));
-  return _parseImportsAndComments.apply(this, arguments);
+export async function parseImportsAndComments(code, fileUrl, options) {
+  const result = {};
+  const externals = {};
+
+  // Convert file:// URL or OS path to portable path format for cross-platform compatibility
+  // Portable paths always use forward slashes and start with / (even on Windows: /C:/...)
+  const filePath = fileUrlToPortablePath(fileUrl);
+
+  // Check if this is a CSS file
+  const isCssFile = filePath.toLowerCase().endsWith('.css');
+
+  // Check if this is an MDX file (which can contain code blocks with triple backticks)
+  const isMdxFile = filePath.toLowerCase().endsWith('.mdx');
+
+  // If this is a CSS file, parse CSS @import statements instead
+  if (isCssFile) {
+    return parseCssImports(code, filePath, result, externals, options?.removeCommentsWithPrefix, options?.notableCommentsPrefix);
+  }
+
+  // Parse JavaScript import statements
+  return parseJSImports(code, filePath, result, externals, isMdxFile, options?.removeCommentsWithPrefix, options?.notableCommentsPrefix);
 }