@mui/internal-docs-infra 0.2.0-alpha.1 → 0.2.0

package/esm/pipeline/loaderUtils/parseImportsAndComments.js

@@ -0,0 +1,1329 @@
+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";
+// webpack does not like node: imports
+// eslint-disable-next-line n/prefer-node-protocol
+import path from 'path';
+
+/**
+ * Represents a single import name with its properties.
+ */
+
+/**
+ * Represents the position of an import path in the source code.
+ */
+
+/**
+ * Represents an import from a relative path (starts with ./ or ../).
+ */
+
+/**
+ * Represents an import from an external package (node_modules).
+ */
+
+/**
+ * The result of parsing import statements from source code.
+ */
+
+/**
+ * Checks if a character starts a string literal.
+ * @param ch - The character to check
+ * @param withinMdx - Whether we're parsing within an MDX file (affects quote handling)
+ * @returns True if the character starts a string literal
+ */
+function isStringStart(ch, withinMdx) {
+  if (withinMdx) {
+    // quotes in MDX don't create strings
+    return ch === '`';
+  }
+  return ch === '"' || ch === "'" || ch === '`';
+}
+
+/**
+ * Checks if a comment matches any of the specified prefixes for removal.
+ * @param commentText - The full comment text including comment markers
+ * @param removeCommentsWithPrefix - Array of prefixes to match against
+ * @returns True if the comment starts with any of the specified prefixes
+ */
+function matchesCommentPrefix(commentText, removeCommentsWithPrefix) {
+  return removeCommentsWithPrefix.some(function (prefix) {
+    // For single-line comments, check after the //
+    if (commentText.startsWith('//')) {
+      var 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);
+    }
+    return false;
+  });
+}
+
+/**
+ * Removes comment markers from comment text and returns the content as an array of lines.
+ * @param commentText - The full comment text including markers
+ * @returns Array of comment content lines with markers removed and whitespace trimmed
+ */
+function stripCommentMarkers(commentText) {
+  // For single-line comments, remove // and trim, return as single-item array
+  if (commentText.startsWith('//')) {
+    return [commentText.slice(2).trim()];
+  }
+  // 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 !== '';
+    });
+  }
+  // Fallback: return as single-item array if format is unexpected
+  return [commentText];
+}
+
+/**
+ * Counts consecutive backticks starting at a given position (used for MDX code blocks).
+ * @param sourceText - The source text to scan
+ * @param startPos - The position to start counting from
+ * @returns The number of consecutive backticks found
+ */
+function countBackticks(sourceText, startPos) {
+  var count = 0;
+  var pos = startPos;
+  while (pos < sourceText.length && sourceText[pos] === '`') {
+    count += 1;
+    pos += 1;
+  }
+  return count;
+}
+
+/**
+ * Generic function to scan source code character-by-character, finding import statements
+ * while correctly handling strings, comments, and template literals. Optionally processes
+ * comments for removal and collection.
+ *
+ * @param sourceCode - The source code to scan
+ * @param importDetector - Function that detects import statements at a given position
+ * @param isMdxFile - Whether this is an MDX file (affects string and code block handling)
+ * @param removeCommentsWithPrefix - Optional array of prefixes for comments to remove
+ * @param notableCommentsPrefix - Optional array of prefixes for comments to collect
+ * @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;
+
+  // Position mapping from original source to processed source (after comment removal)
+  var positionMapping = new Map();
+  var processedPos = 0;
+
+  // Helper to check if a comment matches notable prefix
+  var matchesNotablePrefix = function 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) {
+      if (commentText.startsWith('//')) {
+        var content = commentText.slice(2).trim();
+        return content.startsWith(prefix);
+      }
+      if (commentText.startsWith('/*')) {
+        var _content2 = commentText.slice(2, -2).trim();
+        return _content2.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
+  // Comment stripping variables
+  var commentStart = 0;
+  var commentStartOutputLine = 0;
+  var lineStartPos = 0;
+  var preCommentContent = '';
+  while (i < len) {
+    var ch = sourceCode[i];
+    var next = sourceCode[i + 1];
+    if (state === 'code') {
+      // Track line numbers for newlines in code
+      if (ch === '\n') {
+        if (shouldProcessComments) {
+          result += ch;
+          processedPos += 1;
+        }
+        outputLine += 1;
+        lineStartPos = i + 1;
+        i += 1;
+        continue;
+      }
+
+      // Check for backtick sequences (3 or more backticks start code blocks in MDX)
+      if (isMdxFile && ch === '`') {
+        // Count consecutive backticks
+        var backtickCount = countBackticks(sourceCode, i);
+        if (backtickCount >= 3) {
+          state = 'codeblock';
+          codeblockBacktickCount = backtickCount;
+          if (shouldProcessComments) {
+            result += sourceCode.slice(i, i + backtickCount);
+          }
+          i += backtickCount;
+          continue;
+        }
+      }
+      // Start of single-line comment
+      if (ch === '/' && next === '/') {
+        if (shouldProcessComments) {
+          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;
+        }
+        state = 'singleline-comment';
+        i += 2;
+        continue;
+      }
+      // Start of multi-line comment
+      if (ch === '/' && next === '*') {
+        if (shouldProcessComments) {
+          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;
+        }
+        state = 'multiline-comment';
+        i += 2;
+        continue;
+      }
+      // Start of string
+      if (isStringStart(ch, isMdxFile)) {
+        state = ch === '`' ? 'template' : 'string';
+        stringQuote = ch;
+        if (shouldProcessComments) {
+          result += ch;
+        }
+        i += 1;
+        continue;
+      }
+
+      // Update position mapping for current position
+      if (shouldProcessComments) {
+        positionMapping.set(i, processedPos);
+      }
+
+      // Create position mapper function
+      var positionMapper = function 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) {
+          if (origPos <= originalPos && origPos > closest) {
+            closest = origPos;
+          }
+        });
+        var 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);
+      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);
+          result += importText;
+          processedPos += importText.length;
+        }
+        i = detection.nextPos;
+        continue;
+      }
+      if (shouldProcessComments) {
+        result += ch;
+        processedPos += 1;
+      }
+      i += 1;
+      continue;
+    }
+    if (state === 'singleline-comment') {
+      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);
+
+          // 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$commentStar;
+            if (!comments[commentStartOutputLine]) {
+              comments[commentStartOutputLine] = [];
+            }
+            (_comments$commentStar = comments[commentStartOutputLine]).push.apply(_comments$commentStar, _toConsumableArray(stripCommentMarkers(commentText)));
+          }
+          if (shouldStrip) {
+            // Check if comment is the only thing on its line (ignoring whitespace)
+            var isCommentOnlyLine = preCommentContent.trim() === '';
+            if (isCommentOnlyLine) {
+              // Don't add the pre-comment content or newline for comment-only lines
+              // Skip the newline entirely
+            } else {
+              // Comment is inline, keep the pre-comment content and newline
+              result += preCommentContent;
+              result += '\n';
+              outputLine += 1;
+            }
+          } else {
+            // Keep the comment and newline
+            result += preCommentContent;
+            result += commentText;
+            result += '\n';
+            outputLine += 1;
+          }
+          preCommentContent = '';
+          lineStartPos = i + 1;
+        }
+        state = 'code';
+      }
+      i += 1;
+      continue;
+    }
+    if (state === 'multiline-comment') {
+      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);
+
+          // 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;
+            if (!comments[commentStartOutputLine]) {
+              comments[commentStartOutputLine] = [];
+            }
+            (_comments$commentStar2 = comments[commentStartOutputLine]).push.apply(_comments$commentStar2, _toConsumableArray(stripCommentMarkers(_commentText)));
+          }
+          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);
+            if (nextNewlinePos === -1) {
+              nextNewlinePos = sourceCode.length;
+            }
+            afterCommentContent = sourceCode.slice(afterCommentPos, nextNewlinePos).trim();
+            var isCommentOnlyLines = preCommentContent.trim() === '' && afterCommentContent === '';
+            if (isCommentOnlyLines) {
+              // Skip the entire comment and everything up to and including the next newline
+              i = nextNewlinePos;
+              if (i < len && sourceCode[i] === '\n') {
+                // Skip the newline entirely - advance to the character after it
+                i += 1;
+                lineStartPos = i;
+              } else {
+                lineStartPos = i;
+              }
+              state = 'code';
+              preCommentContent = '';
+              continue;
+            } else {
+              // Comment is inline or mixed with code, add pre-comment content
+              result += preCommentContent;
+              i += 2;
+            }
+          } else {
+            // Keep the comment - add pre-comment content and comment
+            result += preCommentContent;
+            result += _commentText;
+            // Count newlines in the kept comment to update output line
+            var newlineCount = (_commentText.match(/\n/g) || []).length;
+            outputLine += newlineCount;
+            i += 2;
+          }
+          preCommentContent = '';
+        } else {
+          i += 2;
+        }
+        state = 'code';
+        continue;
+      }
+      i += 1;
+      continue;
+    }
+    if (state === 'string') {
+      if (ch === '\n') {
+        outputLine += 1;
+        lineStartPos = i + 1;
+      }
+      if (ch === '\\\\') {
+        if (shouldProcessComments) {
+          result += sourceCode.slice(i, i + 2);
+        }
+        i += 2;
+        continue;
+      }
+      if (ch === stringQuote) {
+        state = 'code';
+        stringQuote = null;
+      }
+      if (shouldProcessComments) {
+        result += ch;
+      }
+      i += 1;
+      continue;
+    }
+    if (state === 'template') {
+      if (ch === '\n') {
+        outputLine += 1;
+        lineStartPos = i + 1;
+      }
+      if (ch === '`') {
+        state = 'code';
+        stringQuote = null;
+        if (shouldProcessComments) {
+          result += ch;
+        }
+        i += 1;
+        continue;
+      }
+      if (ch === '\\\\') {
+        if (shouldProcessComments) {
+          result += sourceCode.slice(i, i + 2);
+        }
+        i += 2;
+        continue;
+      }
+      if (shouldProcessComments) {
+        result += ch;
+      }
+      i += 1;
+      continue;
+    }
+    if (state === 'codeblock') {
+      if (ch === '\n') {
+        outputLine += 1;
+        lineStartPos = i + 1;
+      }
+      // Look for closing backticks that match or exceed the opening count
+      if (ch === '`') {
+        var closingBacktickCount = countBackticks(sourceCode, i);
+        if (closingBacktickCount >= codeblockBacktickCount) {
+          state = 'code';
+          codeblockBacktickCount = 0;
+          if (shouldProcessComments) {
+            result += sourceCode.slice(i, i + closingBacktickCount);
+          }
+          i += closingBacktickCount;
+          continue;
+        }
+      }
+      if (shouldProcessComments) {
+        result += ch;
+      }
+      i += 1;
+      continue;
+    }
+    if (shouldProcessComments) {
+      result += ch;
+    }
+    i += 1;
+  }
+
+  // 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);
+
+    // 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;
+      if (!comments[commentStartOutputLine]) {
+        comments[commentStartOutputLine] = [];
+      }
+      (_comments$commentStar3 = comments[commentStartOutputLine]).push.apply(_comments$commentStar3, _toConsumableArray(stripCommentMarkers(_commentText2)));
+    }
+    if (!_shouldStrip2) {
+      result += _commentText2;
+    }
+  }
+
+  // Create the final position mapper for return
+  var finalPositionMapper = function 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) {
+      if (origPos <= originalPos && origPos > closest) {
+        closest = origPos;
+      }
+    });
+    var offset = originalPos - closest;
+    return (positionMapping.get(closest) || 0) + offset;
+  };
+  return _extends({
+    statements: statements
+  }, shouldProcessComments && {
+    code: result,
+    comments: comments,
+    positionMapper: finalPositionMapper
+  });
+}
+
+/**
+ * Adds an import name to the target array if it doesn't already exist.
+ * @param target - The array of import names to add to
+ * @param name - The name of the import
+ * @param type - The type of import (default, named, or namespace)
+ * @param alias - Optional alias for the import
+ * @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;
+  });
+  if (!existing) {
+    target.push(_extends(_extends({
+      name: name
+    }, alias && {
+      alias: alias
+    }), {}, {
+      type: type
+    }, isType && {
+      isType: true
+    }));
+  }
+}
+
+/**
+ * Checks if a character is a valid JavaScript identifier character.
+ * @param ch - The character to check
+ * @returns True if the character can be part of a JavaScript identifier
+ */
+function isIdentifierChar(ch) {
+  return /[a-zA-Z0-9_$]/.test(ch);
+}
+
+/**
+ * Checks if a character is whitespace.
+ * @param ch - The character to check
+ * @returns True if the character is whitespace
+ */
+function isWhitespace(ch) {
+  return /\s/.test(ch);
+}
+
+/**
+ * Skips whitespace characters and returns the next non-whitespace position.
+ * @param text - The text to scan
+ * @param start - The starting position
+ * @returns The position of the next non-whitespace character
+ */
+function skipWhitespace(text, start) {
+  var pos = start;
+  while (pos < text.length && isWhitespace(text[pos])) {
+    pos += 1;
+  }
+  return pos;
+}
+
+/**
+ * Reads a JavaScript identifier starting at the given position.
+ * @param text - The text to read from
+ * @param start - The starting position
+ * @returns Object containing the identifier name and the next position
+ */
+function readIdentifier(text, start) {
+  var pos = start;
+  var name = '';
+
+  // First character must be letter, underscore, or dollar sign
+  if (pos < text.length && /[a-zA-Z_$]/.test(text[pos])) {
+    name += text[pos];
+    pos += 1;
+
+    // Subsequent characters can be letters, digits, underscore, or dollar sign
+    while (pos < text.length && isIdentifierChar(text[pos])) {
+      name += text[pos];
+      pos += 1;
+    }
+  }
+  return {
+    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
+
+  while (pos < text.length) {
+    var 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
+      pos += 1;
+      return {
+        value: value,
+        nextPos: pos,
+        pathStart: pathStart,
+        pathEnd: pathEnd
+      };
+    }
+    value += ch;
+    pos += 1;
+  }
+
+  // If we reach here, no closing quote was found - fallback
+  return {
+    value: value,
+    nextPos: pos,
+    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;
+  while (pos < end) {
+    pos = skipWhitespace(text, pos);
+    if (pos >= end) {
+      break;
+    }
+
+    // Handle comments within named imports
+    if (pos + 1 < end && text[pos] === '/' && text[pos + 1] === '/') {
+      // Skip single-line comment
+      while (pos < end && text[pos] !== '\n') {
+        pos += 1;
+      }
+      continue;
+    }
+    if (pos + 1 < end && text[pos] === '/' && text[pos + 1] === '*') {
+      // Skip multi-line comment
+      pos += 2;
+      while (pos + 1 < end) {
+        if (text[pos] === '*' && text[pos + 1] === '/') {
+          pos += 2;
+          break;
+        }
+        pos += 1;
+      }
+      continue;
+    }
+
+    // Skip comma if we encounter it
+    if (text[pos] === ',') {
+      pos += 1;
+      continue;
+    }
+
+    // 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);
+    }
+
+    // Read the import name
+    var _readIdentifier = readIdentifier(text, pos),
+      name = _readIdentifier.name,
+      nextPos = _readIdentifier.nextPos;
+    if (!name) {
+      pos += 1;
+      continue;
+    }
+    pos = nextPos;
+    pos = skipWhitespace(text, pos);
+
+    // Check for 'as' keyword (alias)
+    var alias = void 0;
+    if (text.slice(pos, pos + 2) === 'as' && !isIdentifierChar(text[pos + 2] || '')) {
+      pos += 2;
+      pos = skipWhitespace(text, pos);
+      var 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
+    }));
+
+    // Skip comma if present
+    if (text[pos] === ',') {
+      pos += 1;
+    }
+  }
+  return imports;
+}
+
+// Function to parse a single CSS @import statement
+function parseCssImportStatement(cssCode, start) {
+  var pos = start + 7; // Skip '@import'
+  var len = cssCode.length;
+
+  // Skip whitespace
+  while (pos < len && /\s/.test(cssCode[pos])) {
+    pos += 1;
+  }
+  var modulePath = null;
+  var pathStart;
+  var pathEnd;
+
+  // Check for url() syntax
+  if (cssCode.slice(pos, pos + 4) === 'url(') {
+    pos += 4;
+    // Skip whitespace
+    while (pos < len && /\s/.test(cssCode[pos])) {
+      pos += 1;
+    }
+
+    // Read the URL (quoted or unquoted)
+    if (pos < len && (cssCode[pos] === '"' || cssCode[pos] === "'")) {
+      var quote = cssCode[pos];
+      pathStart = pos; // Start at the opening quote
+      pos += 1;
+      var url = '';
+      while (pos < len && cssCode[pos] !== quote) {
+        // Only stop at newlines - parentheses and semicolons are valid in URLs
+        if (cssCode[pos] === '\n') {
+          break;
+        }
+        if (cssCode[pos] === '\\') {
+          pos += 2;
+          continue;
+        }
+        url += cssCode[pos];
+        pos += 1;
+      }
+      if (pos < len && cssCode[pos] === quote) {
+        pathEnd = pos + 1; // End after the closing quote
+        pos += 1;
+        modulePath = url;
+      }
+      // If we didn't find the closing quote, don't set modulePath (malformed)
+    } else {
+      // Unquoted URL
+      pathStart = pos;
+      var _url = '';
+      while (pos < len && cssCode[pos] !== ')' && !/\s/.test(cssCode[pos])) {
+        _url += cssCode[pos];
+        pos += 1;
+      }
+      pathEnd = pos;
+      modulePath = _url;
+    }
+
+    // Skip to closing parenthesis - if we don't find it, the url() is malformed
+    while (pos < len && cssCode[pos] !== ')' && cssCode[pos] !== ';' && cssCode[pos] !== '\n') {
+      pos += 1;
+    }
+    if (pos < len && cssCode[pos] === ')') {
+      pos += 1;
+      // Only consider this a valid URL if we found the closing parenthesis
+    } else {
+      // Malformed url() - don't set modulePath
+      modulePath = null;
+      pathStart = undefined;
+      pathEnd = undefined;
+    }
+  } else if (pos < len && (cssCode[pos] === '"' || cssCode[pos] === "'")) {
+    // Direct quoted import
+    var _quote = cssCode[pos];
+    pathStart = pos; // Start at the opening quote
+    pos += 1;
+    var _url2 = '';
+    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;
+      }
+      if (cssCode[pos] === '\\') {
+        pos += 2;
+        continue;
+      }
+      _url2 += cssCode[pos];
+      pos += 1;
+    }
+    if (pos < len && cssCode[pos] === _quote) {
+      pathEnd = pos + 1; // End after the closing quote
+      pos += 1;
+      modulePath = _url2;
+    }
+    // If we didn't find the closing quote, don't set modulePath (malformed import)
+  }
+
+  // Skip to semicolon or end of statement
+  while (pos < len && cssCode[pos] !== ';' && cssCode[pos] !== '\n') {
+    pos += 1;
+  }
+  if (pos < len && cssCode[pos] === ';') {
+    pos += 1;
+  }
+  return {
+    modulePath: modulePath,
+    nextPos: pos,
+    pathStart: pathStart,
+    pathEnd: pathEnd
+  };
+}
+
+// CSS import detector function
+function detectCssImport(sourceText, pos, cssResult, cssExternals, cssFilePath, positionMapper) {
+  var 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);
+    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 = {
+        start: positionMapper(importResult.pathStart),
+        end: positionMapper(importResult.pathEnd)
+      };
+      if (isExternal) {
+        if (!cssExternals[importResult.modulePath]) {
+          cssExternals[importResult.modulePath] = {
+            names: [],
+            positions: []
+          };
+        }
+        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;
+        if (!normalizedPath.startsWith('./') && !normalizedPath.startsWith('../')) {
+          normalizedPath = "./".concat(normalizedPath);
+        }
+        var resolvedPath = path.resolve(path.dirname(cssFilePath), normalizedPath);
+        if (!cssResult[importResult.modulePath]) {
+          cssResult[importResult.modulePath] = {
+            path: resolvedPath,
+            names: [],
+            positions: []
+          };
+        }
+        cssResult[importResult.modulePath].positions.push(position);
+      }
+    }
+    return {
+      found: true,
+      nextPos: importResult.nextPos
+    };
+  }
+  return {
+    found: false,
+    nextPos: pos
+  };
+}
+
+/**
+ * Parses CSS @import statements from CSS source code.
+ * @param cssCode - The CSS source code to parse
+ * @param cssFilePath - The CSS file path for resolving relative imports
+ * @param cssResult - Object to store relative CSS import results
+ * @param cssExternals - Object to store external CSS import results
+ * @param removeCommentsWithPrefix - Optional prefixes for comments to remove
+ * @param notableCommentsPrefix - Optional prefixes for comments to collect
+ * @returns The parsed CSS import results with optional processed code and comments
+ */
+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({
+    relative: cssResult,
+    externals: cssExternals
+  }, scanResult.code && {
+    code: scanResult.code
+  }), scanResult.comments && {
+    comments: scanResult.comments
+  });
+}
+
+/**
+ * Parses JavaScript/TypeScript import statements from source code.
+ * @param code - The source code to parse
+ * @param filePath - The file path for resolving relative imports
+ * @param result - Object to store relative import results
+ * @param externals - Object to store external import results
+ * @param isMdxFile - Whether this is an MDX file
+ * @param removeCommentsWithPrefix - Optional prefixes for comments to remove
+ * @param notableCommentsPrefix - Optional prefixes for comments to collect
+ * @returns The parsed import results with optional processed code and comments
+ */
+function parseJSImports(code, filePath, result, externals, isMdxFile, removeCommentsWithPrefix, notableCommentsPrefix) {
+  // Scan code for JavaScript import statements
+  var 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] = {
+                  path: 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);
+
+        // 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
+        }
+
+        // Calculate the position in the original source code
+        var originalPathStart = start + pathStart;
+        var originalPathEnd = start + pathEnd;
+        var isRelative = modulePath.startsWith('./') || modulePath.startsWith('../');
+
+        // 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
+        };
+        if (isRelative) {
+          var _resolvedPath = path.resolve(path.dirname(filePath), modulePath);
+          if (!result[modulePath]) {
+            result[modulePath] = _extends({
+              path: _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] = {
+              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(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;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return _extends(_extends({
+    relative: result,
+    externals: externals
+  }, scanResult.code && {
+    code: scanResult.code
+  }), scanResult.comments && {
+    comments: scanResult.comments
+  });
+}
+
+/**
+ * Detects JavaScript import statements at a given position in source code.
+ * @param sourceText - The source text to scan
+ * @param pos - The current position in the text
+ * @param positionMapper - Function to map original positions to processed positions
+ * @returns Object indicating if an import was found, the next position, and statement details
+ */
+function detectJavaScriptImport(sourceText, pos, _positionMapper) {
+  var 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;
+
+    // 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;
+    while (j < len) {
+      var cj = sourceText[j];
+      if (importState === 'code') {
+        if (cj === ';') {
+          j += 1;
+          break;
+        }
+        // Check if we're at a bare import statement (no 'from')
+        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;
+          while (k < len && /\s/.test(sourceText[k])) {
+            k += 1;
+          }
+          if (k >= len || sourceText.slice(k, k + 4) === 'from' || isStringStart(sourceText[k])) {
+            // Continue, this newline is within the import
+          } else {
+            // This looks like the end of a side-effect import
+            j += 1;
+            break;
+          }
+        }
+        if (isStringStart(cj)) {
+          importState = cj === '`' ? 'template' : 'string';
+          importQuote = cj;
+          if (foundFrom) {
+            foundModulePath = true;
+          }
+          j += 1;
+          continue;
+        }
+        if (cj === '{') {
+          braceDepth += 1;
+        }
+        if (cj === '}') {
+          braceDepth -= 1;
+        }
+        if (sourceText.slice(j, j + 4) === 'from' && /\s/.test(sourceText[j + 4] || '')) {
+          foundFrom = true;
+        }
+        // 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;
+          }
+          if (_k >= len || sourceText[_k] === ';' || sourceText[_k] === '\n') {
+            if (sourceText[_k] === ';') {
+              j = _k + 1;
+            } else {
+              j = _k;
+            }
+            break;
+          }
+        }
+      } else if (importState === 'string') {
+        if (cj === '\\') {
+          j += 2;
+          continue;
+        }
+        if (cj === importQuote) {
+          importState = 'code';
+          importQuote = null;
+        }
+        j += 1;
+        continue;
+      } else if (importState === 'template') {
+        if (cj === '`') {
+          importState = 'code';
+          importQuote = null;
+        } else if (cj === '\\') {
+          j += 2;
+          continue;
+        }
+        j += 1;
+        continue;
+      }
+      j += 1;
+    }
+    var importText = sourceText.slice(importStart, j);
+    return {
+      found: true,
+      nextPos: j,
+      statement: {
+        start: importStart,
+        end: j,
+        text: importText
+      }
+    };
+  }
+  return {
+    found: false,
+    nextPos: pos
+  };
+}
+
+/**
+ * Parse import statements from JavaScript/TypeScript/CSS code.
+ *
+ * This function analyzes source code to extract all import statements, categorizing them
+ * as either relative imports (local files) or external imports (packages). It supports
+ * JavaScript, TypeScript, CSS, and MDX files.
+ *
+ * Comment processing (stripping/collecting) is performed during import parsing
+ * for efficiency. Since we must already parse the entire file character-by-character
+ * to correctly identify imports while avoiding false positives in strings, comments,
+ * and template literals, it's most efficient to handle comment processing in this
+ * same pass rather than requiring separate parsing steps.
+ *
+ * @param code - The source code to parse
+ * @param filePath - The file path, used to determine file type and resolve relative imports
+ * @param options - Optional configuration for comment processing
+ * @param options.removeCommentsWithPrefix - Array of prefixes; comments starting with these will be stripped from output
+ * @param options.notableCommentsPrefix - Array of prefixes; comments starting with these will be collected regardless of stripping
+ * @returns Promise resolving to parsed import data, optionally including processed code and collected comments
+ *
+ * @example
+ * ```typescript
+ * const result = await parseImportsAndComments(
+ *   'import React from "react";\nimport { Button } from "./Button";',
+ *   '/src/App.tsx'
+ * );
+ * // result.externals['react'] contains the React import
+ * // result.relative['./Button'] contains the Button import
+ * ```
+ */
+export function parseImportsAndComments(_x, _x2, _x3) {
+  return _parseImportsAndComments.apply(this, arguments);
+}
+function _parseImportsAndComments() {
+  _parseImportsAndComments = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(code, filePath, options) {
+    var result, externals, isCssFile, isMdxFile;
+    return _regenerator().w(function (_context) {
+      while (1) switch (_context.n) {
+        case 0:
+          result = {};
+          externals = {}; // 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);
+}