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

package/esm/pipeline/loadPrecomputedCodeHighlighter/parseCreateFactoryCall.js

@@ -1,9 +1,3 @@
-import _regenerator from "@babel/runtime/helpers/esm/regenerator";
-import _extends from "@babel/runtime/helpers/esm/extends";
-import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
-import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
-import _typeof from "@babel/runtime/helpers/esm/typeof";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import { parseImportsAndComments } from "../loaderUtils/index.js";
 import { parseFunctionArguments, isTypeAssertion, isFunction, isGeneric, isArray, isArrowFunction, isObjectLiteral } from "./parseFunctionArguments.js";
 
@@ -20,7 +14,7 @@ function extractStringValue(value) {
   }
 
   // Remove surrounding quotes if present
-  var trimmed = value.trim();
+  const trimmed = value.trim();
   if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
     return trimmed.slice(1, -1);
   }
@@ -40,79 +34,66 @@ function cleanStructuredData(data) {
   // Check all structured data types first using the parser helpers
 
   // Check for function calls
-  var functionCall = isFunction(data);
+  const functionCall = isFunction(data);
   if (functionCall) {
     // Build a function call string like "console.log('test')"
-    var argStr = functionCall.arguments.map(function (arg) {
+    const argStr = functionCall.arguments.map(arg => {
       if (Array.isArray(arg)) {
-        return arg.map(function (a) {
-          return typeof a === 'string' ? a : String(a);
-        }).join(', ');
+        return arg.map(a => typeof a === 'string' ? a : String(a)).join(', ');
       }
       return typeof arg === 'string' ? arg : String(arg);
     }).join(', ');
-    return "".concat(functionCall.name, "(").concat(argStr, ")");
+    return `${functionCall.name}(${argStr})`;
   }
 
   // Check for generic structures
-  var generic = isGeneric(data);
+  const generic = isGeneric(data);
   if (generic) {
     // Build a generic string like "Component<{ foo: string }>"
-    var genericsStr = generic.generics.map(function (g) {
-      return typeof g === 'string' ? g : JSON.stringify(g);
-    }).join(', ');
+    const genericsStr = generic.generics.map(g => typeof g === 'string' ? g : JSON.stringify(g)).join(', ');
     if (generic.arguments && generic.arguments.length > 0) {
       // Function with generics: Component<T>(args)
-      var argsStr = generic.arguments.map(function (p) {
-        return typeof p === 'string' ? p : String(p);
-      }).join(', ');
-      return "".concat(generic.name, "<").concat(genericsStr, ">(").concat(argsStr, ")");
+      const argsStr = generic.arguments.map(p => typeof p === 'string' ? p : String(p)).join(', ');
+      return `${generic.name}<${genericsStr}>(${argsStr})`;
     }
     // Type with generics: Component<T>
-    return "".concat(generic.name, "<").concat(genericsStr, ">");
+    return `${generic.name}<${genericsStr}>`;
   }
 
   // Check for type assertions
-  var typeAssertion = isTypeAssertion(data);
+  const typeAssertion = isTypeAssertion(data);
   if (typeAssertion) {
-    var cleanedExpression = cleanStructuredData(typeAssertion.expression);
-    return "".concat(cleanedExpression, " as ").concat(typeAssertion.type);
+    const cleanedExpression = cleanStructuredData(typeAssertion.expression);
+    return `${cleanedExpression} as ${typeAssertion.type}`;
   }
 
   // Check for arrow functions
-  var arrowFunction = isArrowFunction(data);
+  const arrowFunction = isArrowFunction(data);
   if (arrowFunction) {
-    var _argsStr = arrowFunction.args.map(function (p) {
-      return typeof p === 'string' ? p : String(p);
-    }).join(', ');
+    const argsStr = arrowFunction.args.map(p => typeof p === 'string' ? p : String(p)).join(', ');
     if (arrowFunction.types) {
       // Typed arrow function
-      var _arrowFunction$types = _slicedToArray(arrowFunction.types, 2),
-        inputType = _arrowFunction$types[0],
-        outputType = _arrowFunction$types[1];
-      var _returnValue = cleanStructuredData(arrowFunction.returnValue);
-      return "(".concat(_argsStr, ": ").concat(inputType, "): ").concat(outputType, " => ").concat(_returnValue);
+      const [inputType, outputType] = arrowFunction.types;
+      const returnValue = cleanStructuredData(arrowFunction.returnValue);
+      return `(${argsStr}: ${inputType}): ${outputType} => ${returnValue}`;
     }
 
     // Simple arrow function
-    var returnValue = cleanStructuredData(arrowFunction.returnValue);
-    return "(".concat(_argsStr, ") => ").concat(returnValue);
+    const returnValue = cleanStructuredData(arrowFunction.returnValue);
+    return `(${argsStr}) => ${returnValue}`;
   }
 
   // Check for literal arrays
-  var arrayLiteral = isArray(data);
+  const arrayLiteral = isArray(data);
   if (arrayLiteral) {
     return arrayLiteral.items[0].map(cleanStructuredData);
   }
 
   // Check for object literals
-  var objectLiteral = isObjectLiteral(data);
+  const objectLiteral = isObjectLiteral(data);
   if (objectLiteral) {
-    var cleaned = {};
-    for (var _i = 0, _Object$entries = Object.entries(objectLiteral.properties); _i < _Object$entries.length; _i++) {
-      var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
-        key = _Object$entries$_i[0],
-        value = _Object$entries$_i[1];
+    const cleaned = {};
+    for (const [key, value] of Object.entries(objectLiteral.properties)) {
       cleaned[key] = cleanStructuredData(value);
     }
     return cleaned;
@@ -122,7 +103,7 @@ function cleanStructuredData(data) {
 
   if (typeof data === 'string') {
     // First extract string value (handle quotes)
-    var extracted = extractStringValue(data);
+    const extracted = extractStringValue(data);
 
     // Then try type conversion
     if (extracted === 'true') {
@@ -134,7 +115,7 @@ function cleanStructuredData(data) {
 
     // Check if it's a number (but be conservative about version strings like "1.0")
     if (/^\d+(\.\d+)?$/.test(extracted)) {
-      var num = Number(extracted);
+      const num = Number(extracted);
       if (!Number.isNaN(num) && Number.isFinite(num)) {
         // Don't convert simple version-like patterns (e.g., "1.0", "2.0", but convert "123.45")
         if (extracted.includes('.')) {
@@ -155,16 +136,13 @@ function cleanStructuredData(data) {
     // Fallback for arrays that don't match structured patterns
     return data.map(cleanStructuredData);
   }
-  if (data && _typeof(data) === 'object') {
+  if (data && typeof data === 'object') {
     // Fallback for objects that don't match structured patterns
-    var _cleaned = {};
-    for (var _i2 = 0, _Object$entries2 = Object.entries(data); _i2 < _Object$entries2.length; _i2++) {
-      var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
-        _key = _Object$entries2$_i[0],
-        _value = _Object$entries2$_i[1];
-      _cleaned[_key] = cleanStructuredData(_value);
+    const cleaned = {};
+    for (const [key, value] of Object.entries(data)) {
+      cleaned[key] = cleanStructuredData(value);
     }
-    return _cleaned;
+    return cleaned;
   }
   return data;
 }
@@ -184,26 +162,25 @@ function cleanStructuredData(data) {
  * Parse variants from object representation (new format)
  */
 function parseVariantsObjectFromObject(obj, importMap, namedExportsMap, functionName, filePath) {
-  var demoImports = {};
-  var namedExports = {};
-  for (var _i3 = 0, _Object$entries3 = Object.entries(obj); _i3 < _Object$entries3.length; _i3++) {
-    var _Object$entries3$_i = _slicedToArray(_Object$entries3[_i3], 2),
-      key = _Object$entries3$_i[0],
-      value = _Object$entries3$_i[1];
+  const demoImports = {};
+  const namedExports = {};
+  for (const [key, value] of Object.entries(obj)) {
     // Handle both string values and structured values (arrays for TypeScript generics)
-    var importName = void 0;
+    let importName;
 
     // Use type discriminators to determine the structure type
-    var typeAssertion = isTypeAssertion(value);
+    const typeAssertion = isTypeAssertion(value);
     if (typeAssertion) {
       // This is a structured type assertion: ['as', 'React.FC<Props>', 'Component']
       // Extract the actual component name from the expression
-      var expression = typeAssertion.expression;
+      const {
+        expression
+      } = typeAssertion;
       importName = typeof expression === 'string' ? expression : String(expression);
     } else if (typeof value === 'string') {
       // Simple string value - strip TypeScript type assertions and typeof expressions
-      var processedValue = value.trim();
-      var asIndex = processedValue.indexOf(' as ');
+      let processedValue = value.trim();
+      const asIndex = processedValue.indexOf(' as ');
       if (asIndex !== -1) {
         processedValue = processedValue.substring(0, asIndex).trim();
       }
@@ -214,9 +191,9 @@ function parseVariantsObjectFromObject(obj, importMap, namedExportsMap, function
       importName = processedValue;
     } else {
       // Handle other structured types (functions, generics, arrays)
-      var functionCall = isFunction(value);
-      var generic = isGeneric(value);
-      var arrayLiteral = isArray(value);
+      const functionCall = isFunction(value);
+      const generic = isGeneric(value);
+      const arrayLiteral = isArray(value);
       if (functionCall) {
         // Function call: ['Component', [...]]
         importName = functionCall.name;
@@ -225,30 +202,30 @@ function parseVariantsObjectFromObject(obj, importMap, namedExportsMap, function
         importName = generic.name;
       } else if (arrayLiteral) {
         // Array literal: handle first element
-        var firstItem = arrayLiteral.items[0];
+        const firstItem = arrayLiteral.items[0];
         importName = typeof firstItem === 'string' ? firstItem : String(firstItem);
       } else if (Array.isArray(value) && value.length > 0) {
         // Fallback for unrecognized array structures
-        var componentExpression = String(value[0]);
-        var _asIndex = componentExpression.indexOf(' as ');
-        importName = _asIndex !== -1 ? componentExpression.substring(0, _asIndex).trim() : componentExpression.trim();
+        const componentExpression = String(value[0]);
+        const asIndex = componentExpression.indexOf(' as ');
+        importName = asIndex !== -1 ? componentExpression.substring(0, asIndex).trim() : componentExpression.trim();
       } else {
         // Final fallback - convert to string and extract
-        var valueStr = String(value);
-        var _asIndex2 = valueStr.indexOf(' as ');
-        importName = _asIndex2 !== -1 ? valueStr.substring(0, _asIndex2).trim() : valueStr.trim();
+        const valueStr = String(value);
+        const asIndex = valueStr.indexOf(' as ');
+        importName = asIndex !== -1 ? valueStr.substring(0, asIndex).trim() : valueStr.trim();
       }
     }
     if (importMap.has(importName)) {
       demoImports[key] = importMap.get(importName);
       namedExports[key] = namedExportsMap.get(importName);
     } else {
-      throw new Error("Invalid variants argument in ".concat(functionName, " call in ").concat(filePath, ". ") + "Component '".concat(importName, "' is not imported. Make sure to import it first."));
+      throw new Error(`Invalid variants argument in ${functionName} call in ${filePath}. ` + `Component '${importName}' is not imported. Make sure to import it first.`);
     }
   }
   return {
     variants: demoImports,
-    namedExports: namedExports
+    namedExports
   };
 }
 
@@ -257,31 +234,31 @@ function parseVariantsObjectFromObject(obj, importMap, namedExportsMap, function
  * that maps import names to their resolved URLs
  */
 function buildImportMap(importResult, allowExternalVariants) {
-  var importMap = new Map();
-  Object.values(importResult.relative).forEach(function (_ref) {
-    var url = _ref.url,
-      names = _ref.names;
-    names.forEach(function (_ref2) {
-      var name = _ref2.name,
-        alias = _ref2.alias;
+  const importMap = new Map();
+  Object.values(importResult.relative).forEach(({
+    url,
+    names
+  }) => {
+    names.forEach(({
+      name,
+      alias
+    }) => {
       // Use alias if available, otherwise use the original name
-      var nameToUse = alias || name;
+      const nameToUse = alias || name;
       importMap.set(nameToUse, url);
     });
   });
 
   // Include external imports if allowExternalVariants is enabled
   if (allowExternalVariants) {
-    Object.entries(importResult.externals).forEach(function (_ref3) {
-      var _ref4 = _slicedToArray(_ref3, 2),
-        modulePath = _ref4[0],
-        externalImport = _ref4[1];
+    Object.entries(importResult.externals).forEach(([modulePath, externalImport]) => {
       if (externalImport && externalImport.names) {
-        externalImport.names.forEach(function (_ref5) {
-          var name = _ref5.name,
-            alias = _ref5.alias;
+        externalImport.names.forEach(({
+          name,
+          alias
+        }) => {
           // Use alias if available, otherwise use the original name
-          var nameToUse = alias || name;
+          const nameToUse = alias || name;
           importMap.set(nameToUse, modulePath);
         });
       }
@@ -294,15 +271,17 @@ function buildImportMap(importResult, allowExternalVariants) {
  * Helper function to build a mapping from import aliases to their original named exports
  */
 function buildNamedExportsMap(importResult, allowExternalVariants) {
-  var namedExportsMap = new Map();
-  Object.values(importResult.relative).forEach(function (_ref6) {
-    var names = _ref6.names;
-    names.forEach(function (_ref7) {
-      var name = _ref7.name,
-        alias = _ref7.alias,
-        type = _ref7.type;
+  const namedExportsMap = new Map();
+  Object.values(importResult.relative).forEach(({
+    names
+  }) => {
+    names.forEach(({
+      name,
+      alias,
+      type
+    }) => {
       // Use alias if available, otherwise use the original name as key
-      var nameToUse = alias || name;
+      const nameToUse = alias || name;
 
       // Only map to the original export name for named imports
       // Default imports should map to undefined since they don't have a specific named export
@@ -316,16 +295,15 @@ function buildNamedExportsMap(importResult, allowExternalVariants) {
 
   // Include external imports if allowExternalVariants is enabled
   if (allowExternalVariants) {
-    Object.entries(importResult.externals).forEach(function (_ref8) {
-      var _ref9 = _slicedToArray(_ref8, 2),
-        externalImport = _ref9[1];
+    Object.entries(importResult.externals).forEach(([, externalImport]) => {
       if (externalImport && externalImport.names) {
-        externalImport.names.forEach(function (_ref0) {
-          var name = _ref0.name,
-            alias = _ref0.alias,
-            type = _ref0.type;
+        externalImport.names.forEach(({
+          name,
+          alias,
+          type
+        }) => {
           // Use alias if available, otherwise use the original name as key
-          var nameToUse = alias || name;
+          const nameToUse = alias || name;
 
           // Only map to the original export name for named imports
           // Default imports should map to undefined since they don't have a specific named export
@@ -344,55 +322,46 @@ function buildNamedExportsMap(importResult, allowExternalVariants) {
  * Parses a variants object using pre-parsed structured data
  */
 function parseVariantsObjectFromStructured(structuredData, importMap, namedExportsMap, functionName, filePath) {
-  var demoImports = {};
-  var namedExports = {};
-  var _iterator = _createForOfIteratorHelper(structuredData),
-    _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var item = _step.value;
-      // If it's a string, process it directly
-      if (typeof item === 'string') {
-        var trimmedPart = item.trim();
-
-        // Check if this part contains a colon (key: value syntax)
-        var colonIndex = trimmedPart.indexOf(':');
-        if (colonIndex !== -1) {
-          // Handle "key: value" syntax
-          var key = trimmedPart.substring(0, colonIndex).trim();
-          var valueExpression = trimmedPart.substring(colonIndex + 1).trim();
-
-          // Strip TypeScript type assertions (e.g., "Component as React.ComponentType<...>" -> "Component")
-          var asIndex = valueExpression.indexOf(' as ');
-          var importName = asIndex !== -1 ? valueExpression.substring(0, asIndex).trim() : valueExpression;
-          if (importMap.has(importName)) {
-            demoImports[key] = importMap.get(importName);
-            namedExports[key] = namedExportsMap.get(importName);
-          } else {
-            throw new Error("Invalid variants argument in ".concat(functionName, " call in ").concat(filePath, ". ") + "Component '".concat(importName, "' is not imported. Make sure to import it first."));
-          }
+  const demoImports = {};
+  const namedExports = {};
+  for (const item of structuredData) {
+    // If it's a string, process it directly
+    if (typeof item === 'string') {
+      const trimmedPart = item.trim();
+
+      // Check if this part contains a colon (key: value syntax)
+      const colonIndex = trimmedPart.indexOf(':');
+      if (colonIndex !== -1) {
+        // Handle "key: value" syntax
+        const key = trimmedPart.substring(0, colonIndex).trim();
+        const valueExpression = trimmedPart.substring(colonIndex + 1).trim();
+
+        // Strip TypeScript type assertions (e.g., "Component as React.ComponentType<...>" -> "Component")
+        const asIndex = valueExpression.indexOf(' as ');
+        const importName = asIndex !== -1 ? valueExpression.substring(0, asIndex).trim() : valueExpression;
+        if (importMap.has(importName)) {
+          demoImports[key] = importMap.get(importName);
+          namedExports[key] = namedExportsMap.get(importName);
         } else {
-          // Handle shorthand syntax (just the component name)
-          var _importName = trimmedPart;
-          if (importMap.has(_importName)) {
-            demoImports[_importName] = importMap.get(_importName);
-            namedExports[_importName] = namedExportsMap.get(_importName);
-          } else {
-            throw new Error("Invalid variants argument in ".concat(functionName, " call in ").concat(filePath, ". ") + "Component '".concat(_importName, "' is not imported. Make sure to import it first."));
-          }
+          throw new Error(`Invalid variants argument in ${functionName} call in ${filePath}. ` + `Component '${importName}' is not imported. Make sure to import it first.`);
+        }
+      } else {
+        // Handle shorthand syntax (just the component name)
+        const importName = trimmedPart;
+        if (importMap.has(importName)) {
+          demoImports[importName] = importMap.get(importName);
+          namedExports[importName] = namedExportsMap.get(importName);
+        } else {
+          throw new Error(`Invalid variants argument in ${functionName} call in ${filePath}. ` + `Component '${importName}' is not imported. Make sure to import it first.`);
         }
       }
-      // If it's an array (nested structure), we don't expect this in variants parsing
-      // but we could handle it if needed in the future
     }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
+    // If it's an array (nested structure), we don't expect this in variants parsing
+    // but we could handle it if needed in the future
   }
   return {
     variants: demoImports,
-    namedExports: namedExports
+    namedExports
   };
 }
 
@@ -401,7 +370,7 @@ function parseVariantsObjectFromStructured(structuredData, importMap, namedExpor
  */
 function parseVariantsArgumentFromStructured(structuredVariants, importMap, namedExportsMap, functionName, filePath) {
   // If it's an object (Record<string, string>)
-  if (_typeof(structuredVariants) === 'object' && !Array.isArray(structuredVariants)) {
+  if (typeof structuredVariants === 'object' && !Array.isArray(structuredVariants)) {
     // We have an object with key-value pairs
     return parseVariantsObjectFromObject(structuredVariants, importMap, namedExportsMap, functionName, filePath);
   }
@@ -414,10 +383,10 @@ function parseVariantsArgumentFromStructured(structuredVariants, importMap, name
 
   // If it's a single identifier string
   if (typeof structuredVariants === 'string') {
-    var componentName = structuredVariants.trim();
+    let componentName = structuredVariants.trim();
 
     // Handle TypeScript type assertions in single component syntax
-    var asIndex = componentName.indexOf(' as ');
+    const asIndex = componentName.indexOf(' as ');
     if (asIndex !== -1) {
       componentName = componentName.substring(0, asIndex).trim();
     }
@@ -438,11 +407,11 @@ function parseVariantsArgumentFromStructured(structuredVariants, importMap, name
     }
 
     // Throw error if the identifier is not found in imports
-    throw new Error("Invalid variants argument in ".concat(functionName, " call in ").concat(filePath, ". ") + "Component '".concat(componentName, "' is not imported. Make sure to import it first."));
+    throw new Error(`Invalid variants argument in ${functionName} call in ${filePath}. ` + `Component '${componentName}' is not imported. Make sure to import it first.`);
   }
 
   // If we reach here, the structured data format is unexpected
-  throw new Error("Unexpected structured variants format in ".concat(functionName, " call in ").concat(filePath, ". ") + "Expected string, array, or object but got: ".concat(_typeof(structuredVariants)));
+  throw new Error(`Unexpected structured variants format in ${functionName} call in ${filePath}. ` + `Expected string, array, or object but got: ${typeof structuredVariants}`);
 }
 
 /**
@@ -456,20 +425,20 @@ function parseGenericDefinitions(genericContent) {
   }
 
   // Handle object literals directly (most common case)
-  var trimmed = genericContent.trim();
+  const trimmed = genericContent.trim();
   if (trimmed.startsWith('{') && trimmed.endsWith('}')) {
     // Parse as object literal using the existing parser
-    var _parsed = parseFunctionArguments(trimmed);
-    if (_parsed.length === 1 && _typeof(_parsed[0]) === 'object' && !Array.isArray(_parsed[0])) {
-      return _parsed[0];
+    const parsed = parseFunctionArguments(trimmed);
+    if (parsed.length === 1 && typeof parsed[0] === 'object' && !Array.isArray(parsed[0])) {
+      return parsed[0];
     }
   }
 
   // Parse the generic content using the existing parser
-  var parsed = parseFunctionArguments(genericContent);
+  const parsed = parseFunctionArguments(genericContent);
 
   // If it's a single object, return it
-  if (parsed.length === 1 && _typeof(parsed[0]) === 'object' && !Array.isArray(parsed[0])) {
+  if (parsed.length === 1 && typeof parsed[0] === 'object' && !Array.isArray(parsed[0])) {
     return parsed[0];
   }
 
@@ -482,11 +451,11 @@ function parseGenericDefinitions(genericContent) {
 
   // If it's multiple elements, try to interpret as an object
   if (parsed.length > 1) {
-    var result = {};
-    parsed.forEach(function (item, index) {
+    const result = {};
+    parsed.forEach((item, index) => {
       if (typeof item === 'string') {
-        result["Variant".concat(index + 1)] = item;
-      } else if (_typeof(item) === 'object' && item !== null) {
+        result[`Variant${index + 1}`] = item;
+      } else if (typeof item === 'object' && item !== null) {
         Object.assign(result, item);
       }
     });
@@ -499,7 +468,7 @@ function parseGenericDefinitions(genericContent) {
  * Validates that a URL argument follows the expected convention
  */
 function validateUrlArgument(url, functionName, filePath) {
-  var trimmedUrl = url.trim();
+  const trimmedUrl = url.trim();
 
   // Only accept import.meta.url
   if (trimmedUrl === 'import.meta.url') {
@@ -508,8 +477,8 @@ function validateUrlArgument(url, functionName, filePath) {
 
   // For error messages, show the argument as parsed by parseFunctionArguments
   // Simple string literals preserve their quotes, complex expressions are shown as parsed
-  var errorUrl = trimmedUrl;
-  throw new Error("Invalid URL argument in ".concat(functionName, " call in ").concat(filePath, ". ") + "Expected 'import.meta.url' but got: ".concat(errorUrl));
+  const errorUrl = trimmedUrl;
+  throw new Error(`Invalid URL argument in ${functionName} call in ${filePath}. ` + `Expected 'import.meta.url' but got: ${errorUrl}`);
 }
 
 /**
@@ -517,23 +486,23 @@ function validateUrlArgument(url, functionName, filePath) {
  */
 function validateVariantsArgument(structuredVariants, functionName, filePath) {
   if (!structuredVariants) {
-    throw new Error("Invalid variants argument in ".concat(functionName, " call in ").concat(filePath, ". ") + "Expected an object mapping variant names to imports or a single component identifier.");
+    throw new Error(`Invalid variants argument in ${functionName} call in ${filePath}. ` + `Expected an object mapping variant names to imports or a single component identifier.`);
   }
 
   // Check if it's a valid single identifier (string)
   if (typeof structuredVariants === 'string') {
-    var trimmed = structuredVariants.trim();
+    const trimmed = structuredVariants.trim();
     if (!trimmed || !/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(trimmed)) {
-      throw new Error("Invalid variants argument in ".concat(functionName, " call in ").concat(filePath, ". ") + "Expected a valid component identifier, but got: \"".concat(trimmed, "\""));
+      throw new Error(`Invalid variants argument in ${functionName} call in ${filePath}. ` + `Expected a valid component identifier, but got: "${trimmed}"`);
     }
     return; // Valid identifier
   }
 
   // Check if it's an array (object literal structure) or object (parsed key-value pairs)
-  if (Array.isArray(structuredVariants) || _typeof(structuredVariants) === 'object' && structuredVariants !== null) {
+  if (Array.isArray(structuredVariants) || typeof structuredVariants === 'object' && structuredVariants !== null) {
     return; // Valid object structure
   }
-  throw new Error("Invalid variants argument in ".concat(functionName, " call in ").concat(filePath, ". ") + "Expected an object mapping variant names to imports or a single component identifier, but got: ".concat(_typeof(structuredVariants)));
+  throw new Error(`Invalid variants argument in ${functionName} call in ${filePath}. ` + `Expected an object mapping variant names to imports or a single component identifier, but got: ${typeof structuredVariants}`);
 }
 
 /**
@@ -541,260 +510,197 @@ function validateVariantsArgument(structuredVariants, functionName, filePath) {
  * Returns the parsed result with remaining content included
  * Returns null if no create* call is found
  */
-export function parseCreateFactoryCall(_x, _x2) {
-  return _parseCreateFactoryCall.apply(this, arguments);
+export async function parseCreateFactoryCall(code, filePath, parseOptions = {}, importsAndComments) {
+  // Find the first create* call in the code
+  const match = findFirstCreateFactoryCall(code, filePath, parseOptions);
+
+  // Return null if no create* call found
+  if (!match) {
+    return null;
+  }
+
+  // Check for multiple create* calls if allowMultipleFactories is false
+  if (!parseOptions.allowMultipleFactories) {
+    const secondMatch = findFirstCreateFactoryCall(code, filePath, parseOptions, match.functionEndIndex + 1);
+    if (secondMatch) {
+      throw new Error(`Multiple create* factory calls found in ${filePath}. Only one create* call per file is supported. Found 2 calls.`);
+    }
+  }
+  // Get import mappings from precomputed imports or parse them
+  importsAndComments = importsAndComments || (await parseImportsAndComments(code, filePath));
+
+  // Process the match using shared logic
+  const parsed = await processCreateFactoryMatch(match, code, filePath, parseOptions, importsAndComments);
+
+  // Calculate remaining content after the function call
+  const remaining = code.substring(match.functionEndIndex + 1);
+  return {
+    ...parsed,
+    remaining,
+    importsAndComments // Include import data for reuse
+  };
 }
 
 /**
  * Parses all create* factory calls in a file sequentially
  * Returns a record of export names mapped to their parsed factory calls
  */
-function _parseCreateFactoryCall() {
-  _parseCreateFactoryCall = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(code, filePath) {
-    var parseOptions,
-      importsAndComments,
-      match,
-      secondMatch,
-      parsed,
-      remaining,
-      _args = arguments,
-      _t;
-    return _regenerator().w(function (_context) {
-      while (1) switch (_context.n) {
-        case 0:
-          parseOptions = _args.length > 2 && _args[2] !== undefined ? _args[2] : {};
-          importsAndComments = _args.length > 3 ? _args[3] : undefined;
-          // Find the first create* call in the code
-          match = findFirstCreateFactoryCall(code, filePath, parseOptions); // Return null if no create* call found
-          if (match) {
-            _context.n = 1;
-            break;
-          }
-          return _context.a(2, null);
-        case 1:
-          if (parseOptions.allowMultipleFactories) {
-            _context.n = 2;
-            break;
-          }
-          secondMatch = findFirstCreateFactoryCall(code, filePath, parseOptions, match.functionEndIndex + 1);
-          if (!secondMatch) {
-            _context.n = 2;
-            break;
-          }
-          throw new Error("Multiple create* factory calls found in ".concat(filePath, ". Only one create* call per file is supported. Found 2 calls."));
-        case 2:
-          _t = importsAndComments;
-          if (_t) {
-            _context.n = 4;
-            break;
-          }
-          _context.n = 3;
-          return parseImportsAndComments(code, filePath);
-        case 3:
-          _t = _context.v;
-        case 4:
-          importsAndComments = _t;
-          _context.n = 5;
-          return processCreateFactoryMatch(match, code, filePath, parseOptions, importsAndComments);
-        case 5:
-          parsed = _context.v;
-          // Calculate remaining content after the function call
-          remaining = code.substring(match.functionEndIndex + 1);
-          return _context.a(2, _extends(_extends({}, parsed), {}, {
-            remaining: remaining,
-            importsAndComments: importsAndComments // Include import data for reuse
-          }));
-      }
-    }, _callee);
-  }));
-  return _parseCreateFactoryCall.apply(this, arguments);
-}
-export function parseAllCreateFactoryCalls(_x3, _x4) {
-  return _parseAllCreateFactoryCalls.apply(this, arguments);
+export async function parseAllCreateFactoryCalls(code, filePath, parseOptions = {}) {
+  const results = {};
+  let importsAndComments;
+  let searchIndex = 0;
+
+  // Process the code using single-pass approach
+  while (searchIndex < code.length) {
+    // Find the next create* call
+    const match = findFirstCreateFactoryCall(code, filePath, parseOptions, searchIndex);
+    if (!match) {
+      // No more create* calls found
+      break;
+    }
+
+    // Extract export name from the function call context
+    const beforeMatch = code.substring(0, match.functionStartIndex);
+    const exportMatch = beforeMatch.match(/export\s+const\s+(\w+)\s*=\s*$/m);
+    const exportName = exportMatch?.[1] || 'unknown';
+
+    // Get import mappings from precomputed imports or parse them
+    // eslint-disable-next-line no-await-in-loop
+    importsAndComments = importsAndComments || (await parseImportsAndComments(code, filePath));
+
+    // Process the match using shared logic
+    // eslint-disable-next-line no-await-in-loop
+    const parsedFactory = await processCreateFactoryMatch(match, code, filePath, parseOptions, importsAndComments);
+    results[exportName] = parsedFactory;
+
+    // Continue searching from after this function call
+    searchIndex = match.functionEndIndex + 1;
+  }
+  return results;
 }
 
 /**
  * Processes a matched create* factory call into a ParsedCreateFactory object
  * Handles all the common logic for validation, parsing, and transformation
  */
-function _parseAllCreateFactoryCalls() {
-  _parseAllCreateFactoryCalls = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(code, filePath) {
-    var parseOptions,
-      results,
-      importsAndComments,
-      searchIndex,
-      match,
-      beforeMatch,
-      exportMatch,
-      exportName,
-      parsedFactory,
-      _args2 = arguments,
-      _t2;
-    return _regenerator().w(function (_context2) {
-      while (1) switch (_context2.n) {
-        case 0:
-          parseOptions = _args2.length > 2 && _args2[2] !== undefined ? _args2[2] : {};
-          results = {};
-          searchIndex = 0; // Process the code using single-pass approach
-        case 1:
-          if (!(searchIndex < code.length)) {
-            _context2.n = 6;
-            break;
-          }
-          // Find the next create* call
-          match = findFirstCreateFactoryCall(code, filePath, parseOptions, searchIndex);
-          if (match) {
-            _context2.n = 2;
-            break;
-          }
-          return _context2.a(3, 6);
-        case 2:
-          // Extract export name from the function call context
-          beforeMatch = code.substring(0, match.functionStartIndex);
-          exportMatch = beforeMatch.match(/export\s+const\s+(\w+)\s*=\s*$/m);
-          exportName = (exportMatch == null ? void 0 : exportMatch[1]) || 'unknown'; // Get import mappings from precomputed imports or parse them
-          // eslint-disable-next-line no-await-in-loop
-          _t2 = importsAndComments;
-          if (_t2) {
-            _context2.n = 4;
-            break;
-          }
-          _context2.n = 3;
-          return parseImportsAndComments(code, filePath);
-        case 3:
-          _t2 = _context2.v;
-        case 4:
-          importsAndComments = _t2;
-          _context2.n = 5;
-          return processCreateFactoryMatch(match, code, filePath, parseOptions, importsAndComments);
-        case 5:
-          parsedFactory = _context2.v;
-          results[exportName] = parsedFactory;
-
-          // Continue searching from after this function call
-          searchIndex = match.functionEndIndex + 1;
-          _context2.n = 1;
-          break;
-        case 6:
-          return _context2.a(2, results);
+async function processCreateFactoryMatch(match, code, filePath, parseOptions, importsAndComments) {
+  const {
+    functionName,
+    fullMatch,
+    urlArg,
+    structuredVariants,
+    optionsStructured,
+    hasOptions,
+    argumentsStartIndex,
+    argumentsEndIndex
+  } = match;
+  const allowExternalVariants = parseOptions.allowExternalVariants || false;
+  const importMap = buildImportMap(importsAndComments, allowExternalVariants);
+  const namedExportsMap = buildNamedExportsMap(importsAndComments, allowExternalVariants);
+  const externals = importsAndComments.externals;
+
+  // Validate URL argument
+  validateUrlArgument(urlArg, functionName, filePath);
+
+  // Validate variants argument (skip in metadata-only mode)
+  const {
+    metadataOnly = false
+  } = parseOptions;
+  if (!metadataOnly && structuredVariants !== undefined) {
+    validateVariantsArgument(structuredVariants, functionName, filePath);
+  }
+
+  // Extract URL (typically import.meta.url)
+  const url = urlArg.trim();
+
+  // Resolve variants using structured data (skip in metadata-only mode)
+  let variants;
+  let namedExports;
+  if (!metadataOnly) {
+    if (structuredVariants !== undefined) {
+      // Use regular variants argument
+      const variantsResult = parseVariantsArgumentFromStructured(structuredVariants, importMap, namedExportsMap, functionName, filePath);
+      variants = variantsResult.variants;
+      namedExports = variantsResult.namedExports;
+    } else if (match.hasGenerics && match.structuredGenerics && Object.keys(match.structuredGenerics).length > 0) {
+      // Use generics as variants when no variants argument is provided and generics are not empty
+      const variantsResult = parseVariantsArgumentFromStructured(match.structuredGenerics, importMap, namedExportsMap, functionName, filePath);
+      variants = variantsResult.variants;
+      namedExports = variantsResult.namedExports;
+    }
+  }
+
+  // Parse options object
+  // Initialize with all options from structured data, then override specific fields
+  const options = optionsStructured && typeof optionsStructured === 'object' ? cleanStructuredData(optionsStructured) : {};
+
+  // Override with specific processing for known fields that need special handling
+  if (optionsStructured && typeof optionsStructured === 'object') {
+    if ('name' in optionsStructured) {
+      options.name = extractStringValue(optionsStructured.name);
+    }
+    if ('slug' in optionsStructured) {
+      options.slug = extractStringValue(optionsStructured.slug);
+    }
+    if ('skipPrecompute' in optionsStructured) {
+      const skipPrecomputeValue = optionsStructured.skipPrecompute;
+      if (skipPrecomputeValue === 'true' || skipPrecomputeValue === true) {
+        options.skipPrecompute = true;
+      } else if (skipPrecomputeValue === 'false' || skipPrecomputeValue === false) {
+        options.skipPrecompute = false;
       }
-    }, _callee2);
-  }));
-  return _parseAllCreateFactoryCalls.apply(this, arguments);
-}
-function processCreateFactoryMatch(_x5, _x6, _x7, _x8, _x9) {
-  return _processCreateFactoryMatch.apply(this, arguments);
+    }
+
+    // Handle precompute from structured data - clean for user consumption
+    if ('precompute' in optionsStructured) {
+      options.precompute = cleanStructuredData(optionsStructured.precompute);
+    }
+  }
+
+  // Transform externals from parseImportsAndComments format to simplified format
+  // Only include side-effect imports (where names array is empty)
+  const transformedExternals = {};
+  for (const [modulePath, externalImport] of Object.entries(externals)) {
+    // Only include side-effect imports (empty names array)
+    if (externalImport.names.length === 0) {
+      transformedExternals[modulePath] = []; // Empty array for side-effect imports
+    }
+  }
+  return {
+    functionName,
+    url,
+    variants,
+    namedExports,
+    options,
+    fullMatch,
+    hasOptions,
+    externals: transformedExternals,
+    argumentsStartIndex,
+    argumentsEndIndex,
+    // Add structured data for serialization - this preserves quotes for proper output
+    structuredUrl: urlArg,
+    structuredVariants,
+    structuredOptions: optionsStructured,
+    // Use original structured data, not cleaned options
+    hasGenerics: match.hasGenerics,
+    structuredGenerics: match.structuredGenerics
+  };
 }
+
 /**
  * Finds the first create* factory call in code, starting from a given index
  * Returns null if no create* call is found
  */
-function _processCreateFactoryMatch() {
-  _processCreateFactoryMatch = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(match, code, filePath, parseOptions, importsAndComments) {
-    var functionName, fullMatch, urlArg, structuredVariants, optionsStructured, hasOptions, argumentsStartIndex, argumentsEndIndex, allowExternalVariants, importMap, namedExportsMap, externals, _parseOptions$metadat2, metadataOnly, url, variants, namedExports, variantsResult, _variantsResult, options, skipPrecomputeValue, transformedExternals, _i5, _Object$entries4, _Object$entries4$_i, modulePath, externalImport;
-    return _regenerator().w(function (_context3) {
-      while (1) switch (_context3.n) {
-        case 0:
-          functionName = match.functionName, fullMatch = match.fullMatch, urlArg = match.urlArg, structuredVariants = match.structuredVariants, optionsStructured = match.optionsStructured, hasOptions = match.hasOptions, argumentsStartIndex = match.argumentsStartIndex, argumentsEndIndex = match.argumentsEndIndex;
-          allowExternalVariants = parseOptions.allowExternalVariants || false;
-          importMap = buildImportMap(importsAndComments, allowExternalVariants);
-          namedExportsMap = buildNamedExportsMap(importsAndComments, allowExternalVariants);
-          externals = importsAndComments.externals; // Validate URL argument
-          validateUrlArgument(urlArg, functionName, filePath);
-
-          // Validate variants argument (skip in metadata-only mode)
-          _parseOptions$metadat2 = parseOptions.metadataOnly, metadataOnly = _parseOptions$metadat2 === void 0 ? false : _parseOptions$metadat2;
-          if (!metadataOnly && structuredVariants !== undefined) {
-            validateVariantsArgument(structuredVariants, functionName, filePath);
-          }
-
-          // Extract URL (typically import.meta.url)
-          url = urlArg.trim(); // Resolve variants using structured data (skip in metadata-only mode)
-          if (!metadataOnly) {
-            if (structuredVariants !== undefined) {
-              // Use regular variants argument
-              variantsResult = parseVariantsArgumentFromStructured(structuredVariants, importMap, namedExportsMap, functionName, filePath);
-              variants = variantsResult.variants;
-              namedExports = variantsResult.namedExports;
-            } else if (match.hasGenerics && match.structuredGenerics && Object.keys(match.structuredGenerics).length > 0) {
-              // Use generics as variants when no variants argument is provided and generics are not empty
-              _variantsResult = parseVariantsArgumentFromStructured(match.structuredGenerics, importMap, namedExportsMap, functionName, filePath);
-              variants = _variantsResult.variants;
-              namedExports = _variantsResult.namedExports;
-            }
-          }
-
-          // Parse options object
-          // Initialize with all options from structured data, then override specific fields
-          options = optionsStructured && _typeof(optionsStructured) === 'object' ? cleanStructuredData(optionsStructured) : {}; // Override with specific processing for known fields that need special handling
-          if (optionsStructured && _typeof(optionsStructured) === 'object') {
-            if ('name' in optionsStructured) {
-              options.name = extractStringValue(optionsStructured.name);
-            }
-            if ('slug' in optionsStructured) {
-              options.slug = extractStringValue(optionsStructured.slug);
-            }
-            if ('skipPrecompute' in optionsStructured) {
-              skipPrecomputeValue = optionsStructured.skipPrecompute;
-              if (skipPrecomputeValue === 'true' || skipPrecomputeValue === true) {
-                options.skipPrecompute = true;
-              } else if (skipPrecomputeValue === 'false' || skipPrecomputeValue === false) {
-                options.skipPrecompute = false;
-              }
-            }
-
-            // Handle precompute from structured data - clean for user consumption
-            if ('precompute' in optionsStructured) {
-              options.precompute = cleanStructuredData(optionsStructured.precompute);
-            }
-          }
-
-          // Transform externals from parseImportsAndComments format to simplified format
-          // Only include side-effect imports (where names array is empty)
-          transformedExternals = {};
-          for (_i5 = 0, _Object$entries4 = Object.entries(externals); _i5 < _Object$entries4.length; _i5++) {
-            _Object$entries4$_i = _slicedToArray(_Object$entries4[_i5], 2), modulePath = _Object$entries4$_i[0], externalImport = _Object$entries4$_i[1];
-            // Only include side-effect imports (empty names array)
-            if (externalImport.names.length === 0) {
-              transformedExternals[modulePath] = []; // Empty array for side-effect imports
-            }
-          }
-          return _context3.a(2, {
-            functionName: functionName,
-            url: url,
-            variants: variants,
-            namedExports: namedExports,
-            options: options,
-            fullMatch: fullMatch,
-            hasOptions: hasOptions,
-            externals: transformedExternals,
-            argumentsStartIndex: argumentsStartIndex,
-            argumentsEndIndex: argumentsEndIndex,
-            // Add structured data for serialization - this preserves quotes for proper output
-            structuredUrl: urlArg,
-            structuredVariants: structuredVariants,
-            structuredOptions: optionsStructured,
-            // Use original structured data, not cleaned options
-            hasGenerics: match.hasGenerics,
-            structuredGenerics: match.structuredGenerics
-          });
-      }
-    }, _callee3);
-  }));
-  return _processCreateFactoryMatch.apply(this, arguments);
-}
-function findFirstCreateFactoryCall(code, filePath) {
-  var parseOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  var startIndex = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
-  var createFunctionRegex = /\b(create\w*)\s*/g;
+function findFirstCreateFactoryCall(code, filePath, parseOptions = {}, startIndex = 0) {
+  const createFunctionRegex = /\b(create\w*)\s*/g;
   createFunctionRegex.lastIndex = startIndex;
-  var match = createFunctionRegex.exec(code);
+  const match = createFunctionRegex.exec(code);
   if (!match) {
     return null;
   }
-  var functionName = match[1];
-  var matchStartIndex = match.index;
-  var currentIndex = match.index + match[0].length;
+  const functionName = match[1];
+  const matchStartIndex = match.index;
+  let currentIndex = match.index + match[0].length;
 
   // Skip any whitespace after function name
   while (currentIndex < code.length && /\s/.test(code[currentIndex])) {
@@ -804,21 +710,21 @@ function findFirstCreateFactoryCall(code, filePath) {
     // No opening parenthesis found, try to find the next create* call
     return findFirstCreateFactoryCall(code, filePath, parseOptions, match.index + match[0].length);
   }
-  var genericContent = '';
-  var hasGenerics = false;
+  let genericContent = '';
+  let hasGenerics = false;
 
   // Check if we have generics (starts with <)
   if (code[currentIndex] === '<') {
     hasGenerics = true;
-    var angleCount = 1;
-    var genericEndIndex = -1;
+    let angleCount = 1;
+    let genericEndIndex = -1;
 
     // Find the matching closing angle bracket, handling nesting
-    for (var i = currentIndex + 1; i < code.length; i += 1) {
-      var _char = code[i];
-      if (_char === '<') {
+    for (let i = currentIndex + 1; i < code.length; i += 1) {
+      const char = code[i];
+      if (char === '<') {
         angleCount += 1;
-      } else if (_char === '>') {
+      } else if (char === '>') {
         angleCount -= 1;
         if (angleCount === 0) {
           genericEndIndex = i;
@@ -844,18 +750,18 @@ function findFirstCreateFactoryCall(code, filePath) {
     // No opening parenthesis found, try to find the next create* call
     return findFirstCreateFactoryCall(code, filePath, parseOptions, match.index + match[0].length);
   }
-  var parenIndex = currentIndex;
+  const parenIndex = currentIndex;
 
   // Find the matching closing parenthesis
-  var parenCount = 0;
-  var endIndex = -1;
-  for (var _i4 = parenIndex; _i4 < code.length; _i4 += 1) {
-    if (code[_i4] === '(') {
+  let parenCount = 0;
+  let endIndex = -1;
+  for (let i = parenIndex; i < code.length; i += 1) {
+    if (code[i] === '(') {
       parenCount += 1;
-    } else if (code[_i4] === ')') {
+    } else if (code[i] === ')') {
       parenCount -= 1;
       if (parenCount === 0) {
-        endIndex = _i4;
+        endIndex = i;
         break;
       }
     }
@@ -864,53 +770,53 @@ function findFirstCreateFactoryCall(code, filePath) {
     // Unmatched parentheses, try to find the next create* call
     return findFirstCreateFactoryCall(code, filePath, parseOptions, match.index + match[0].length);
   }
-  var fullMatch = code.substring(matchStartIndex, endIndex + 1);
-  var content = code.substring(parenIndex + 1, endIndex);
+  const fullMatch = code.substring(matchStartIndex, endIndex + 1);
+  const content = code.substring(parenIndex + 1, endIndex);
 
   // Parse generic content if present
-  var structuredGenerics;
+  let structuredGenerics;
   if (hasGenerics) {
     // Parse the generic content as TypeScript type definitions
     structuredGenerics = parseGenericDefinitions(genericContent);
   }
 
   // Split by commas at the top level, handling nested structures and comments
-  var structured = parseFunctionArguments(content);
+  const structured = parseFunctionArguments(content);
 
   // Validate the function follows the convention
-  var _parseOptions$metadat = parseOptions.metadataOnly,
-    metadataOnly = _parseOptions$metadat === void 0 ? false : _parseOptions$metadat;
+  const {
+    metadataOnly = false
+  } = parseOptions;
   if (metadataOnly) {
     // For metadata-only mode: expect 1-2 arguments (url, options?)
     if (structured.length < 1 || structured.length > 2) {
-      throw new Error("Invalid ".concat(functionName, " call in ").concat(filePath, ". ") + "Expected 1-2 arguments (url, options?) but got ".concat(structured.length, " arguments. ") + "In metadata-only mode, functions should follow: create*(url, options?)");
+      throw new Error(`Invalid ${functionName} call in ${filePath}. ` + `Expected 1-2 arguments (url, options?) but got ${structured.length} arguments. ` + `In metadata-only mode, functions should follow: create*(url, options?)`);
     }
   } else if (hasGenerics && structured.length <= 2) {
     // When generics are present AND we have 1-2 arguments, expect (url, options?)
     if (structured.length < 1 || structured.length > 2) {
-      throw new Error("Invalid ".concat(functionName, " call in ").concat(filePath, ". ") + "Expected 1-2 arguments (url, options?) but got ".concat(structured.length, " arguments. ") + "Functions with TypeScript generics should follow: create*<variants>(url, options?)");
+      throw new Error(`Invalid ${functionName} call in ${filePath}. ` + `Expected 1-2 arguments (url, options?) but got ${structured.length} arguments. ` + `Functions with TypeScript generics should follow: create*<variants>(url, options?)`);
     }
   } else if (!hasGenerics && (structured.length < 2 || structured.length > 3)) {
     // Normal mode: expect 2-3 arguments (url, variants, options?)
-    throw new Error("Invalid ".concat(functionName, " call in ").concat(filePath, ". ") + "Expected 2-3 arguments (url, variants, options?) but got ".concat(structured.length, " arguments. ") + "Functions starting with 'create' must follow the convention: create*(url, variants, options?)");
+    throw new Error(`Invalid ${functionName} call in ${filePath}. ` + `Expected 2-3 arguments (url, variants, options?) but got ${structured.length} arguments. ` + `Functions starting with 'create' must follow the convention: create*(url, variants, options?)`);
   }
 
   // Handle different argument patterns based on mode
   if (metadataOnly) {
     // Metadata-only mode: expect 1-2 arguments (url, options?)
     if (structured.length === 1) {
-      var _structured = _slicedToArray(structured, 1),
-        urlArg = _structured[0];
+      const [urlArg] = structured;
       return {
-        functionName: functionName,
-        fullMatch: fullMatch,
+        functionName,
+        fullMatch,
         urlArg: typeof urlArg === 'string' ? urlArg.trim() : String(urlArg),
         structuredVariants: hasGenerics ? structuredGenerics : undefined,
         // Use generics as variants in metadata-only mode
         optionsStructured: undefined,
         hasOptions: false,
-        hasGenerics: hasGenerics,
-        structuredGenerics: structuredGenerics,
+        hasGenerics,
+        structuredGenerics,
         functionStartIndex: matchStartIndex,
         functionEndIndex: endIndex,
         argumentsStartIndex: parenIndex + 1,
@@ -918,24 +824,22 @@ function findFirstCreateFactoryCall(code, filePath) {
       };
     }
     if (structured.length === 2) {
-      var _structured2 = _slicedToArray(structured, 2),
-        _urlArg = _structured2[0],
-        optionsStructured = _structured2[1];
+      const [urlArg, optionsStructured] = structured;
 
       // Options should be an object
-      if (typeof optionsStructured === 'string' || !Array.isArray(optionsStructured) && _typeof(optionsStructured) !== 'object') {
-        throw new Error("Invalid options argument in ".concat(functionName, " call in ").concat(filePath, ". ") + "Expected an object but got: ".concat(typeof optionsStructured === 'string' ? optionsStructured : JSON.stringify(optionsStructured)));
+      if (typeof optionsStructured === 'string' || !Array.isArray(optionsStructured) && typeof optionsStructured !== 'object') {
+        throw new Error(`Invalid options argument in ${functionName} call in ${filePath}. ` + `Expected an object but got: ${typeof optionsStructured === 'string' ? optionsStructured : JSON.stringify(optionsStructured)}`);
       }
       return {
-        functionName: functionName,
-        fullMatch: fullMatch,
-        urlArg: typeof _urlArg === 'string' ? _urlArg.trim() : String(_urlArg),
+        functionName,
+        fullMatch,
+        urlArg: typeof urlArg === 'string' ? urlArg.trim() : String(urlArg),
         structuredVariants: hasGenerics ? structuredGenerics : undefined,
         // Use generics as variants in metadata-only mode
-        optionsStructured: _typeof(optionsStructured) === 'object' && optionsStructured !== null ? optionsStructured : undefined,
+        optionsStructured: typeof optionsStructured === 'object' && optionsStructured !== null ? optionsStructured : undefined,
         hasOptions: true,
-        hasGenerics: hasGenerics,
-        structuredGenerics: structuredGenerics,
+        hasGenerics,
+        structuredGenerics,
         functionStartIndex: matchStartIndex,
         functionEndIndex: endIndex,
         argumentsStartIndex: parenIndex + 1,
@@ -944,18 +848,17 @@ function findFirstCreateFactoryCall(code, filePath) {
     }
   } else if (!metadataOnly && hasGenerics && structured.length === 1) {
     // Generics-only mode (non-metadata): expect 1 argument (url) - use generics as variants
-    var _structured3 = _slicedToArray(structured, 1),
-      _urlArg2 = _structured3[0];
+    const [urlArg] = structured;
     return {
-      functionName: functionName,
-      fullMatch: fullMatch,
-      urlArg: typeof _urlArg2 === 'string' ? _urlArg2.trim() : String(_urlArg2),
+      functionName,
+      fullMatch,
+      urlArg: typeof urlArg === 'string' ? urlArg.trim() : String(urlArg),
       structuredVariants: undefined,
       // No explicit variants, will use generics later
       optionsStructured: undefined,
       hasOptions: false,
-      hasGenerics: hasGenerics,
-      structuredGenerics: structuredGenerics,
+      hasGenerics,
+      structuredGenerics,
       functionStartIndex: matchStartIndex,
       functionEndIndex: endIndex,
       argumentsStartIndex: parenIndex + 1,
@@ -964,21 +867,19 @@ function findFirstCreateFactoryCall(code, filePath) {
   } else if (!metadataOnly && structured.length >= 2) {
     // Normal mode: expect 2-3 arguments (url, variants, options?)
     if (structured.length === 2) {
-      var _structured4 = _slicedToArray(structured, 2),
-        _urlArg3 = _structured4[0],
-        secondArg = _structured4[1];
+      const [urlArg, secondArg] = structured;
       if (hasGenerics) {
         // With generics: 2 arguments means (url, options) - use generics as variants
         return {
-          functionName: functionName,
-          fullMatch: fullMatch,
-          urlArg: typeof _urlArg3 === 'string' ? _urlArg3.trim() : String(_urlArg3),
+          functionName,
+          fullMatch,
+          urlArg: typeof urlArg === 'string' ? urlArg.trim() : String(urlArg),
           structuredVariants: undefined,
           // Use generics
-          optionsStructured: _typeof(secondArg) === 'object' && secondArg !== null ? secondArg : undefined,
+          optionsStructured: typeof secondArg === 'object' && secondArg !== null ? secondArg : undefined,
           hasOptions: true,
-          hasGenerics: hasGenerics,
-          structuredGenerics: structuredGenerics,
+          hasGenerics,
+          structuredGenerics,
           functionStartIndex: matchStartIndex,
           functionEndIndex: endIndex,
           argumentsStartIndex: parenIndex + 1,
@@ -987,14 +888,14 @@ function findFirstCreateFactoryCall(code, filePath) {
       }
       // Without generics: 2 arguments means (url, variants) - use second arg as variants
       return {
-        functionName: functionName,
-        fullMatch: fullMatch,
-        urlArg: typeof _urlArg3 === 'string' ? _urlArg3.trim() : String(_urlArg3),
+        functionName,
+        fullMatch,
+        urlArg: typeof urlArg === 'string' ? urlArg.trim() : String(urlArg),
         structuredVariants: secondArg,
         optionsStructured: undefined,
         hasOptions: false,
-        hasGenerics: hasGenerics,
-        structuredGenerics: structuredGenerics,
+        hasGenerics,
+        structuredGenerics,
         functionStartIndex: matchStartIndex,
         functionEndIndex: endIndex,
         argumentsStartIndex: parenIndex + 1,
@@ -1002,25 +903,22 @@ function findFirstCreateFactoryCall(code, filePath) {
       };
     }
     if (structured.length === 3) {
-      var _structured5 = _slicedToArray(structured, 3),
-        _urlArg4 = _structured5[0],
-        variantsStructured = _structured5[1],
-        _optionsStructured = _structured5[2];
+      const [urlArg, variantsStructured, optionsStructured] = structured;
 
       // Options should be an object (Record<string, any>) or an empty object
-      if (typeof _optionsStructured === 'string' || !Array.isArray(_optionsStructured) && _typeof(_optionsStructured) !== 'object') {
-        throw new Error("Invalid options argument in ".concat(functionName, " call in ").concat(filePath, ". ") + "Expected an object but got: ".concat(typeof _optionsStructured === 'string' ? _optionsStructured : JSON.stringify(_optionsStructured)));
+      if (typeof optionsStructured === 'string' || !Array.isArray(optionsStructured) && typeof optionsStructured !== 'object') {
+        throw new Error(`Invalid options argument in ${functionName} call in ${filePath}. ` + `Expected an object but got: ${typeof optionsStructured === 'string' ? optionsStructured : JSON.stringify(optionsStructured)}`);
       }
       return {
-        functionName: functionName,
-        fullMatch: fullMatch,
-        urlArg: typeof _urlArg4 === 'string' ? _urlArg4.trim() : String(_urlArg4),
+        functionName,
+        fullMatch,
+        urlArg: typeof urlArg === 'string' ? urlArg.trim() : String(urlArg),
         structuredVariants: variantsStructured,
-        optionsStructured: _typeof(_optionsStructured) === 'object' && _optionsStructured !== null ? _optionsStructured : undefined,
+        optionsStructured: typeof optionsStructured === 'object' && optionsStructured !== null ? optionsStructured : undefined,
         hasOptions: true,
         // Options argument was provided
-        hasGenerics: hasGenerics,
-        structuredGenerics: structuredGenerics,
+        hasGenerics,
+        structuredGenerics,
         functionStartIndex: matchStartIndex,
         functionEndIndex: endIndex,
         argumentsStartIndex: parenIndex + 1,