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

package/esm/pipeline/loadPrecomputedCodeHighlighter/parseFunctionArguments.js

@@ -1,4 +1,3 @@
-import _typeof from "@babel/runtime/helpers/esm/typeof";
 /**
  * Utility function for parsing function arguments and handling nested structures
  * in JavaScript/TypeScript code with structured representations.
@@ -94,7 +93,7 @@ export function isArrowFunction(value) {
  * @returns Object with properties if it's an object literal, false otherwise
  */
 export function isObjectLiteral(value) {
-  if (_typeof(value) === 'object' && value !== null && !Array.isArray(value)) {
+  if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
     return {
       properties: value
     };
@@ -130,21 +129,21 @@ export function parseFunctionArguments(str) {
  * Returns a mapping of export names to their function call information
  */
 export function parseFileExports(fileContent) {
-  var exports = {};
+  const exports = {};
 
   // Find all export statements that assign function calls
-  var exportRegex = /export\s+const\s+(\w+)\s*=\s*(\w+)\s*\(/g;
-  var match = exportRegex.exec(fileContent);
+  const exportRegex = /export\s+const\s+(\w+)\s*=\s*(\w+)\s*\(/g;
+  let match = exportRegex.exec(fileContent);
   while (match !== null) {
-    var exportName = match[1];
-    var functionName = match[2];
-    var callStartIndex = match.index;
-    var parenIndex = match.index + match[0].length - 1; // Position of opening parenthesis
+    const exportName = match[1];
+    const functionName = match[2];
+    const callStartIndex = match.index;
+    const parenIndex = match.index + match[0].length - 1; // Position of opening parenthesis
 
     // Find the matching closing parenthesis
-    var parenCount = 0;
-    var callEndIndex = -1;
-    for (var i = parenIndex; i < fileContent.length; i += 1) {
+    let parenCount = 0;
+    let callEndIndex = -1;
+    for (let i = parenIndex; i < fileContent.length; i += 1) {
       if (fileContent[i] === '(') {
         parenCount += 1;
       } else if (fileContent[i] === ')') {
@@ -157,9 +156,9 @@ export function parseFileExports(fileContent) {
     }
     if (callEndIndex !== -1) {
       // Extract the arguments content between parentheses
-      var argumentsContent = fileContent.substring(parenIndex + 1, callEndIndex);
+      const argumentsContent = fileContent.substring(parenIndex + 1, callEndIndex);
       exports[exportName] = {
-        functionName: functionName,
+        functionName,
         // Parse the arguments using existing logic
         arguments: parseFunctionArguments(argumentsContent),
         sourceRange: [callStartIndex, callEndIndex + 1]
@@ -174,100 +173,100 @@ export function parseFileExports(fileContent) {
  * Internal recursive parsing function
  */
 function parseArgumentsRecursive(str) {
-  var result = [];
-  var current = '';
-  var parenCount = 0;
-  var braceCount = 0;
-  var bracketCount = 0;
-  var angleCount = 0;
-  var inSingleLineComment = false;
-  var inMultiLineComment = false;
-  var inString = false;
-  var stringChar = '';
-  for (var i = 0; i < str.length; i += 1) {
-    var _char = str[i];
-    var nextChar = str[i + 1];
+  const result = [];
+  let current = '';
+  let parenCount = 0;
+  let braceCount = 0;
+  let bracketCount = 0;
+  let angleCount = 0;
+  let inSingleLineComment = false;
+  let inMultiLineComment = false;
+  let inString = false;
+  let stringChar = '';
+  for (let i = 0; i < str.length; i += 1) {
+    const char = str[i];
+    const nextChar = str[i + 1];
 
     // Handle comments
     if (!inString && !inSingleLineComment && !inMultiLineComment) {
-      if (_char === '/' && nextChar === '/') {
+      if (char === '/' && nextChar === '/') {
         inSingleLineComment = true;
-        current += _char;
+        current += char;
         continue;
       }
-      if (_char === '/' && nextChar === '*') {
+      if (char === '/' && nextChar === '*') {
         inMultiLineComment = true;
-        current += _char;
+        current += char;
         continue;
       }
     }
-    if (inSingleLineComment && _char === '\n') {
+    if (inSingleLineComment && char === '\n') {
       inSingleLineComment = false;
-      current += _char;
+      current += char;
       continue;
     }
-    if (inMultiLineComment && _char === '*' && nextChar === '/') {
+    if (inMultiLineComment && char === '*' && nextChar === '/') {
       inMultiLineComment = false;
-      current += _char + nextChar;
+      current += char + nextChar;
       i += 1; // Skip next character
       continue;
     }
     if (inSingleLineComment || inMultiLineComment) {
-      current += _char;
+      current += char;
       continue;
     }
 
     // Handle strings
-    if (!inString && (_char === '"' || _char === "'" || _char === '`')) {
+    if (!inString && (char === '"' || char === "'" || char === '`')) {
       inString = true;
-      stringChar = _char;
-      current += _char;
+      stringChar = char;
+      current += char;
       continue;
     }
-    if (inString && _char === stringChar && str[i - 1] !== '\\') {
+    if (inString && char === stringChar && str[i - 1] !== '\\') {
       inString = false;
       stringChar = '';
-      current += _char;
+      current += char;
       continue;
     }
     if (inString) {
-      current += _char;
+      current += char;
       continue;
     }
 
     // Handle brackets and parentheses
-    if (_char === '(') {
+    if (char === '(') {
       parenCount += 1;
-    } else if (_char === ')') {
+    } else if (char === ')') {
       parenCount -= 1;
-    } else if (_char === '{') {
+    } else if (char === '{') {
       braceCount += 1;
-    } else if (_char === '}') {
+    } else if (char === '}') {
       braceCount -= 1;
-    } else if (_char === '[') {
+    } else if (char === '[') {
       bracketCount += 1;
-    } else if (_char === ']') {
+    } else if (char === ']') {
       bracketCount -= 1;
-    } else if (_char === '<') {
+    } else if (char === '<') {
       angleCount += 1;
-    } else if (_char === '>' && str[i - 1] !== '=') {
+    } else if (char === '>' && str[i - 1] !== '=') {
       // Only count > as closing angle bracket if it's not part of =>
       angleCount -= 1;
-    } else if (_char === ',' && parenCount === 0 && braceCount === 0 && bracketCount === 0 && angleCount === 0) {
-      var trimmedPart = current.trim();
+    } else if (char === ',' && parenCount === 0 && braceCount === 0 && bracketCount === 0 && angleCount === 0) {
+      const trimmedPart = current.trim();
       if (trimmedPart) {
         result.push(parseElement(trimmedPart));
       }
       current = '';
       continue;
     }
-    current += _char;
+    current += char;
   }
 
   // Handle the last part
   if (current.trim()) {
-    var _trimmedPart = current.trim();
-    result.push(parseElement(_trimmedPart));
+    const trimmedPart = current.trim();
+    result.push(parseElement(trimmedPart));
   }
   return result;
 }
@@ -276,7 +275,7 @@ function parseArgumentsRecursive(str) {
  * Parse a single element and determine its type/structure
  */
 function parseElement(element) {
-  var trimmed = element.trim();
+  let trimmed = element.trim();
 
   // Remove comments
   trimmed = removeComments(trimmed);
@@ -314,52 +313,52 @@ function parseElement(element) {
  * Remove comments from a string
  */
 function removeComments(str) {
-  var result = '';
-  var inSingleLineComment = false;
-  var inMultiLineComment = false;
-  var inString = false;
-  var stringChar = '';
-  for (var i = 0; i < str.length; i += 1) {
-    var _char2 = str[i];
-    var nextChar = str[i + 1];
+  let result = '';
+  let inSingleLineComment = false;
+  let inMultiLineComment = false;
+  let inString = false;
+  let stringChar = '';
+  for (let i = 0; i < str.length; i += 1) {
+    const char = str[i];
+    const nextChar = str[i + 1];
 
     // Handle strings first
-    if (!inSingleLineComment && !inMultiLineComment && !inString && (_char2 === '"' || _char2 === "'" || _char2 === '`')) {
+    if (!inSingleLineComment && !inMultiLineComment && !inString && (char === '"' || char === "'" || char === '`')) {
       inString = true;
-      stringChar = _char2;
-      result += _char2;
+      stringChar = char;
+      result += char;
       continue;
     }
-    if (inString && _char2 === stringChar && str[i - 1] !== '\\') {
+    if (inString && char === stringChar && str[i - 1] !== '\\') {
       inString = false;
       stringChar = '';
-      result += _char2;
+      result += char;
       continue;
     }
     if (inString) {
-      result += _char2;
+      result += char;
       continue;
     }
 
     // Handle comments
     if (!inSingleLineComment && !inMultiLineComment) {
-      if (_char2 === '/' && nextChar === '/') {
+      if (char === '/' && nextChar === '/') {
         inSingleLineComment = true;
         i += 1; // Skip next character
         continue;
       }
-      if (_char2 === '/' && nextChar === '*') {
+      if (char === '/' && nextChar === '*') {
         inMultiLineComment = true;
         i += 1; // Skip next character
         continue;
       }
     }
-    if (inSingleLineComment && _char2 === '\n') {
+    if (inSingleLineComment && char === '\n') {
       inSingleLineComment = false;
-      result += _char2;
+      result += char;
       continue;
     }
-    if (inMultiLineComment && _char2 === '*' && nextChar === '/') {
+    if (inMultiLineComment && char === '*' && nextChar === '/') {
       inMultiLineComment = false;
       i += 1; // Skip next character
       continue;
@@ -367,7 +366,7 @@ function removeComments(str) {
     if (inSingleLineComment || inMultiLineComment) {
       continue;
     }
-    result += _char2;
+    result += char;
   }
   return result.trim();
 }
@@ -376,22 +375,21 @@ function removeComments(str) {
  * Parse object literal like { key: value, other: data }
  */
 function parseObjectLiteral(str) {
-  var content = str.slice(1, -1).trim(); // Remove { }
+  const content = str.slice(1, -1).trim(); // Remove { }
   if (!content) {
     return {};
   }
-  var obj = {};
+  const obj = {};
 
   // Parse object properties manually to handle complex types
-  var properties = parseObjectProperties(content);
-  for (var _i = 0, _properties = properties; _i < _properties.length; _i++) {
-    var prop = _properties[_i];
-    var colonIndex = prop.indexOf(':');
+  const properties = parseObjectProperties(content);
+  for (const prop of properties) {
+    const colonIndex = prop.indexOf(':');
     if (colonIndex !== -1) {
-      var key = prop.substring(0, colonIndex).trim();
-      var value = prop.substring(colonIndex + 1).trim();
+      const key = prop.substring(0, colonIndex).trim();
+      const value = prop.substring(colonIndex + 1).trim();
       // Parse the value
-      var parsedValue = parseElement(value);
+      const parsedValue = parseElement(value);
 
       // For object properties: preserve strings as-is, but only wrap array LITERALS in another array
       if (typeof parsedValue === 'string' && !Array.isArray(parsedValue)) {
@@ -399,7 +397,7 @@ function parseObjectLiteral(str) {
       } else if (Array.isArray(parsedValue)) {
         // Only double-wrap array literals (parsed from [1, 2, 3])
         // Functions and generics should remain as single arrays
-        var originalValue = value.trim();
+        const originalValue = value.trim();
         if (originalValue.startsWith('[') && originalValue.endsWith(']')) {
           // This is an array literal - double wrap it
           obj[key] = [parsedValue];
@@ -412,7 +410,7 @@ function parseObjectLiteral(str) {
       }
     } else {
       // Shorthand property like { foo } -> { foo: 'foo' }
-      var trimmed = prop.trim();
+      const trimmed = prop.trim();
       obj[trimmed] = trimmed;
     }
   }
@@ -423,30 +421,30 @@ function parseObjectLiteral(str) {
  * Parse object properties, handling complex nested types
  */
 function parseObjectProperties(content) {
-  var properties = [];
-  var current = '';
-  var depth = 0;
-  var inString = false;
-  var stringChar = '';
-  for (var i = 0; i < content.length; i += 1) {
-    var _char3 = content[i];
-    var nextChar = content[i + 1];
-    if (!inString && (_char3 === '"' || _char3 === "'" || _char3 === '`')) {
+  const properties = [];
+  let current = '';
+  let depth = 0;
+  let inString = false;
+  let stringChar = '';
+  for (let i = 0; i < content.length; i += 1) {
+    const char = content[i];
+    const nextChar = content[i + 1];
+    if (!inString && (char === '"' || char === "'" || char === '`')) {
       inString = true;
-      stringChar = _char3;
-    } else if (inString && _char3 === stringChar && content[i - 1] !== '\\') {
+      stringChar = char;
+    } else if (inString && char === stringChar && content[i - 1] !== '\\') {
       inString = false;
       stringChar = '';
     }
     if (!inString) {
-      if (_char3 === '<' || _char3 === '{' || _char3 === '(' || _char3 === '[') {
+      if (char === '<' || char === '{' || char === '(' || char === '[') {
         depth += 1;
-      } else if (_char3 === '>' && nextChar !== '=' && content[i - 1] !== '=') {
+      } else if (char === '>' && nextChar !== '=' && content[i - 1] !== '=') {
         // Only count > as closing bracket if it's not part of => or >=
         depth -= 1;
-      } else if (_char3 === '}' || _char3 === ')' || _char3 === ']') {
+      } else if (char === '}' || char === ')' || char === ']') {
         depth -= 1;
-      } else if (_char3 === ',' && depth === 0) {
+      } else if (char === ',' && depth === 0) {
         if (current.trim()) {
           properties.push(current.trim());
         }
@@ -454,7 +452,7 @@ function parseObjectProperties(content) {
         continue;
       }
     }
-    current += _char3;
+    current += char;
   }
   if (current.trim()) {
     properties.push(current.trim());
@@ -466,7 +464,7 @@ function parseObjectProperties(content) {
  * Parse array literal like [1, 2, 3]
  */
 function parseArrayLiteral(str) {
-  var content = str.slice(1, -1).trim(); // Remove [ ]
+  const content = str.slice(1, -1).trim(); // Remove [ ]
   if (!content) {
     return [];
   }
@@ -477,24 +475,24 @@ function parseArrayLiteral(str) {
  * Parse arrow function like (a) => a + 1 or (data: string): Promise<string> => Promise.resolve(data)
  */
 function parseArrowFunction(str) {
-  var arrowIndex = str.indexOf('=>');
-  var leftPart = str.substring(0, arrowIndex).trim();
-  var rightPart = str.substring(arrowIndex + 2).trim();
+  const arrowIndex = str.indexOf('=>');
+  const leftPart = str.substring(0, arrowIndex).trim();
+  const rightPart = str.substring(arrowIndex + 2).trim();
 
   // Parse arguments
-  var args = [];
-  var types;
+  let args = [];
+  let types;
   if (leftPart.startsWith('(') && leftPart.includes(')')) {
-    var parenEnd = leftPart.lastIndexOf(')');
-    var argsPart = leftPart.substring(1, parenEnd);
-    var afterParen = leftPart.substring(parenEnd + 1).trim();
+    const parenEnd = leftPart.lastIndexOf(')');
+    const argsPart = leftPart.substring(1, parenEnd);
+    const afterParen = leftPart.substring(parenEnd + 1).trim();
     args = argsPart ? parseArgumentsRecursive(argsPart) : [];
 
     // Check for return type annotation
     if (afterParen.startsWith(':')) {
-      var returnType = afterParen.substring(1).trim();
+      const returnType = afterParen.substring(1).trim();
       // Extract input types from args if they have type annotations
-      var inputTypes = args.map(function (arg) {
+      const inputTypes = args.map(arg => {
         if (typeof arg === 'string' && arg.includes(':')) {
           return arg.split(':')[1].trim();
         }
@@ -502,7 +500,7 @@ function parseArrowFunction(str) {
       });
 
       // Clean argument names (remove type annotations)
-      args = args.map(function (arg) {
+      args = args.map(arg => {
         if (typeof arg === 'string' && arg.includes(':')) {
           return arg.split(':')[0].trim();
         }
@@ -513,7 +511,7 @@ function parseArrowFunction(str) {
   } else {
     args = [leftPart];
   }
-  var returnValue = parseElement(rightPart);
+  const returnValue = parseElement(rightPart);
   if (types) {
     return [args, types, returnValue];
   }
@@ -525,13 +523,13 @@ function parseArrowFunction(str) {
  */
 function parseFunctionOrGeneric(str) {
   // Check for generics first
-  var angleStart = str.indexOf('<');
-  var parenStart = str.indexOf('(');
+  const angleStart = str.indexOf('<');
+  const parenStart = str.indexOf('(');
   if (angleStart !== -1 && (parenStart === -1 || angleStart < parenStart)) {
     return parseGeneric(str);
   }
   if (parenStart !== -1) {
-    var result = parseFunctionCall(str);
+    const result = parseFunctionCall(str);
     // If parseFunctionCall detected property access and returned [str], unwrap it
     if (Array.isArray(result) && result.length === 1 && result[0] === str) {
       return str;
@@ -545,51 +543,51 @@ function parseFunctionOrGeneric(str) {
  * Parse generic content while preserving nested structures
  */
 function parseGenericContent(content) {
-  var elements = [];
-  var current = '';
-  var parenCount = 0;
-  var braceCount = 0;
-  var bracketCount = 0;
-  var angleCount = 0;
-  var inString = false;
-  var stringChar = '';
-  for (var i = 0; i < content.length; i += 1) {
-    var _char4 = content[i];
-    if (!inString && (_char4 === '"' || _char4 === "'")) {
+  const elements = [];
+  let current = '';
+  let parenCount = 0;
+  let braceCount = 0;
+  let bracketCount = 0;
+  let angleCount = 0;
+  let inString = false;
+  let stringChar = '';
+  for (let i = 0; i < content.length; i += 1) {
+    const char = content[i];
+    if (!inString && (char === '"' || char === "'")) {
       inString = true;
-      stringChar = _char4;
-      current += _char4;
-    } else if (inString && _char4 === stringChar && content[i - 1] !== '\\') {
+      stringChar = char;
+      current += char;
+    } else if (inString && char === stringChar && content[i - 1] !== '\\') {
       inString = false;
       stringChar = '';
-      current += _char4;
+      current += char;
     } else if (!inString) {
-      if (_char4 === '(') {
+      if (char === '(') {
         parenCount += 1;
-      } else if (_char4 === ')') {
+      } else if (char === ')') {
         parenCount -= 1;
-      } else if (_char4 === '{') {
+      } else if (char === '{') {
         braceCount += 1;
-      } else if (_char4 === '}') {
+      } else if (char === '}') {
         braceCount -= 1;
-      } else if (_char4 === '[') {
+      } else if (char === '[') {
         bracketCount += 1;
-      } else if (_char4 === ']') {
+      } else if (char === ']') {
         bracketCount -= 1;
-      } else if (_char4 === '<') {
+      } else if (char === '<') {
         angleCount += 1;
-      } else if (_char4 === '>') {
+      } else if (char === '>') {
         angleCount -= 1;
-      } else if (_char4 === ',' && parenCount === 0 && braceCount === 0 && bracketCount === 0 && angleCount === 0) {
+      } else if (char === ',' && parenCount === 0 && braceCount === 0 && bracketCount === 0 && angleCount === 0) {
         if (current.trim()) {
           elements.push(parseElement(current.trim()));
         }
         current = '';
         continue;
       }
-      current += _char4;
+      current += char;
     } else {
-      current += _char4;
+      current += char;
     }
   }
   if (current.trim()) {
@@ -602,13 +600,13 @@ function parseGenericContent(content) {
  * Parse generic like Component<{ foo: string }> or Theme<"dark" | "light", Component[]>
  */
 function parseGeneric(str) {
-  var angleStart = str.indexOf('<');
-  var name = str.substring(0, angleStart).trim();
+  const angleStart = str.indexOf('<');
+  const name = str.substring(0, angleStart).trim();
 
   // Find matching closing angle bracket
-  var angleCount = 0;
-  var angleEnd = -1;
-  for (var i = angleStart; i < str.length; i += 1) {
+  let angleCount = 0;
+  let angleEnd = -1;
+  for (let i = angleStart; i < str.length; i += 1) {
     if (str[i] === '<') {
       angleCount += 1;
     } else if (str[i] === '>') {
@@ -622,16 +620,16 @@ function parseGeneric(str) {
   if (angleEnd === -1) {
     return [str];
   }
-  var genericContent = str.substring(angleStart + 1, angleEnd).trim();
-  var afterGeneric = str.substring(angleEnd + 1).trim();
+  const genericContent = str.substring(angleStart + 1, angleEnd).trim();
+  const afterGeneric = str.substring(angleEnd + 1).trim();
 
   // Parse generic content - don't split on commas within generics for unions and arrays
-  var generics = genericContent ? parseGenericContent(genericContent) : [];
+  const generics = genericContent ? parseGenericContent(genericContent) : [];
 
   // Check if there are function arguments after the generic
   if (afterGeneric.startsWith('(') && afterGeneric.endsWith(')')) {
-    var argContent = afterGeneric.slice(1, -1).trim();
-    var args = argContent ? parseArgumentsRecursive(argContent) : [];
+    const argContent = afterGeneric.slice(1, -1).trim();
+    const args = argContent ? parseArgumentsRecursive(argContent) : [];
     return [name, generics, args];
   }
 
@@ -644,13 +642,13 @@ function parseGeneric(str) {
  * Parse function call like func(a, b)
  */
 function parseFunctionCall(str) {
-  var parenStart = str.indexOf('(');
-  var name = str.substring(0, parenStart).trim();
+  const parenStart = str.indexOf('(');
+  const name = str.substring(0, parenStart).trim();
 
   // Find matching closing parenthesis
-  var parenCount = 0;
-  var parenEnd = -1;
-  for (var i = parenStart; i < str.length; i += 1) {
+  let parenCount = 0;
+  let parenEnd = -1;
+  for (let i = parenStart; i < str.length; i += 1) {
     if (str[i] === '(') {
       parenCount += 1;
     } else if (str[i] === ')') {
@@ -666,30 +664,30 @@ function parseFunctionCall(str) {
   }
 
   // Check if there's meaningful continuation after the closing parenthesis
-  var remainingLength = str.length - parenEnd - 1;
+  const remainingLength = str.length - parenEnd - 1;
   if (remainingLength > 0) {
     // Skip whitespace to find the first meaningful character
-    var _i2 = parenEnd + 1;
-    while (_i2 < str.length && (str[_i2] === ' ' || str[_i2] === '\t' || str[_i2] === '\n' || str[_i2] === '\r')) {
-      _i2 += 1;
+    let i = parenEnd + 1;
+    while (i < str.length && (str[i] === ' ' || str[i] === '\t' || str[i] === '\n' || str[i] === '\r')) {
+      i += 1;
     }
-    if (_i2 < str.length) {
-      var firstChar = str[_i2];
+    if (i < str.length) {
+      const firstChar = str[i];
       if (firstChar === '.' || firstChar === '[' || firstChar === '(' || firstChar === '!') {
         // Property access, bracket notation, chained calls, or non-null assertion
         return [str];
       }
-      if (firstChar === '?' && _i2 + 1 < str.length && str[_i2 + 1] === '.') {
+      if (firstChar === '?' && i + 1 < str.length && str[i + 1] === '.') {
         // Optional chaining
         return [str];
       }
     }
   }
-  var argContent = str.substring(parenStart + 1, parenEnd).trim();
+  const argContent = str.substring(parenStart + 1, parenEnd).trim();
   if (!argContent) {
     return [name, []];
   }
-  var args = parseArgumentsRecursive(argContent);
+  const args = parseArgumentsRecursive(argContent);
 
   // Special case: if there's a single array literal argument, flatten it
   if (args.length === 1 && Array.isArray(args[0])) {
@@ -702,14 +700,14 @@ function parseFunctionCall(str) {
  * Parse TypeScript type assertion like "Component as React.FC<Props>"
  */
 function parseTypeAssertion(str) {
-  var asIndex = str.indexOf(' as ');
+  const asIndex = str.indexOf(' as ');
   if (asIndex === -1) {
     return [str]; // fallback to string if no 'as' found
   }
-  var expression = str.substring(0, asIndex).trim();
-  var type = str.substring(asIndex + 4).trim(); // +4 for ' as '
+  const expression = str.substring(0, asIndex).trim();
+  const type = str.substring(asIndex + 4).trim(); // +4 for ' as '
 
   // Parse the expression part recursively in case it's complex
-  var parsedExpression = parseElement(expression);
+  const parsedExpression = parseElement(expression);
   return ['as', type, parsedExpression];
 }