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

package/esm/pipeline/loadPrecomputedCodeHighlighter/performanceLogger.js

@@ -1,6 +1,3 @@
-import _arrayLikeToArray from "@babel/runtime/helpers/esm/arrayLikeToArray";
-import _toArray from "@babel/runtime/helpers/esm/toArray";
-import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
 export function logPerformance(entry, notableMs, showWrapperMeasures, filterContext) {
   if (entry.duration < notableMs) {
     return;
@@ -10,8 +7,8 @@ export function logPerformance(entry, notableMs, showWrapperMeasures, filterCont
   if (filterContext && !entry.name.includes(filterContext)) {
     return;
   }
-  var delim = '-';
-  var message = entry.name;
+  let delim = '-';
+  let message = entry.name;
   if (message.startsWith('| ')) {
     if (!showWrapperMeasures) {
       return;
@@ -19,29 +16,19 @@ export function logPerformance(entry, notableMs, showWrapperMeasures, filterCont
     delim = '|';
     message = message.slice(2);
   }
-  var duration = Math.round(entry.duration).toString().padStart(4, ' ');
-  console.warn("".concat(duration, "ms ").concat(delim, " ").concat(message));
+  const duration = Math.round(entry.duration).toString().padStart(4, ' ');
+  console.warn(`${duration}ms ${delim} ${message}`);
 }
 export function createPerformanceLogger(notableMs, showWrapperMeasures, filterContext) {
-  var performanceLogger = function performanceLogger(list) {
-    var _iterator = _createForOfIteratorHelper(list.getEntries()),
-      _step;
-    try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var entry = _step.value;
-        logPerformance(entry, notableMs, showWrapperMeasures, filterContext);
-      }
-    } catch (err) {
-      _iterator.e(err);
-    } finally {
-      _iterator.f();
+  const performanceLogger = list => {
+    for (const entry of list.getEntries()) {
+      logPerformance(entry, notableMs, showWrapperMeasures, filterContext);
     }
   };
   return performanceLogger;
 }
-export function nameMark(functionName, event, context) {
-  var wrapper = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
-  return "".concat(wrapper ? '| ' : '').concat(functionName, " ").concat(wrapper ? '|' : '-', " ").concat(event, " - ").concat(context.join(' - '));
+export function nameMark(functionName, event, context, wrapper = false) {
+  return `${wrapper ? '| ' : ''}${functionName} ${wrapper ? '|' : '-'} ${event} - ${context.join(' - ')}`;
 }
 
 /**
@@ -63,14 +50,11 @@ export function nameMark(functionName, event, context) {
  * );
  * ```
  */
-export function performanceMeasure(startMark, names, context) {
-  var wrapper = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
-  var _context = _toArray(context),
-    functionName = _context[0],
-    restContext = _arrayLikeToArray(_context).slice(1);
-  var prefix = 'prefix' in names && names.prefix ? "".concat(names.prefix, " ") : '';
-  var markName = nameMark(functionName, "".concat(prefix).concat(names.mark), restContext, wrapper);
-  var measureName = nameMark(functionName, "".concat(prefix).concat(names.measure), restContext, wrapper);
+export function performanceMeasure(startMark, names, context, wrapper = false) {
+  const [functionName, ...restContext] = context;
+  const prefix = 'prefix' in names && names.prefix ? `${names.prefix} ` : '';
+  const markName = nameMark(functionName, `${prefix}${names.mark}`, restContext, wrapper);
+  const measureName = nameMark(functionName, `${prefix}${names.measure}`, restContext, wrapper);
   performance.mark(markName);
   performance.measure(measureName, startMark, markName);
   return markName;

package/esm/pipeline/loadPrecomputedCodeHighlighter/replacePrecomputeValue.js

@@ -1,4 +1,3 @@
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import { serializeFunctionArguments } from "./serializeFunctionArguments.js";
 /**
  * Adds or replaces precompute data in createDemo function calls.
@@ -10,30 +9,29 @@ import { serializeFunctionArguments } from "./serializeFunctionArguments.js";
  * @param options.passPrecomputeAsIs - Whether to pass precompute data as-is without JSON stringifying (default: false)
  * @returns The modified source code with precompute data injected
  */
-export function replacePrecomputeValue(source, precomputeData, demoCallInfo) {
-  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+export function replacePrecomputeValue(source, precomputeData, demoCallInfo, options = {}) {
   // If no demoCallInfo provided, return unchanged
   if (!demoCallInfo) {
     return source;
   }
-  var hasOptions = demoCallInfo.hasOptions,
-    argumentsStartIndex = demoCallInfo.argumentsStartIndex,
-    argumentsEndIndex = demoCallInfo.argumentsEndIndex,
-    structuredUrl = demoCallInfo.structuredUrl,
-    structuredVariants = demoCallInfo.structuredVariants,
-    structuredOptions = demoCallInfo.structuredOptions;
-  var _options$passPrecompu = options.passPrecomputeAsIs,
-    passPrecomputeAsIs = _options$passPrecompu === void 0 ? false : _options$passPrecompu;
+  const {
+    hasOptions,
+    argumentsStartIndex,
+    argumentsEndIndex,
+    structuredUrl,
+    structuredVariants,
+    structuredOptions
+  } = demoCallInfo;
+  const {
+    passPrecomputeAsIs = false
+  } = options;
 
   // Create new options object with precompute data
-  var newOptions = {};
+  const newOptions = {};
 
   // First, copy all existing options to preserve their order
   if (hasOptions && structuredOptions) {
-    Object.entries(structuredOptions).forEach(function (_ref) {
-      var _ref2 = _slicedToArray(_ref, 2),
-        key = _ref2[0],
-        value = _ref2[1];
+    Object.entries(structuredOptions).forEach(([key, value]) => {
       if (key !== 'precompute') {
         // Skip existing precompute, we'll replace it
         newOptions[key] = value;
@@ -45,7 +43,7 @@ export function replacePrecomputeValue(source, precomputeData, demoCallInfo) {
   newOptions.precompute = passPrecomputeAsIs ? precomputeData : JSON.stringify(precomputeData, null, 2);
 
   // Serialize all arguments using the standard function
-  var args;
+  let args;
 
   // Build arguments array based on what's available
   if (hasOptions || Object.keys(newOptions).length > 0) {
@@ -64,10 +62,10 @@ export function replacePrecomputeValue(source, precomputeData, demoCallInfo) {
     // Only URL argument
     args = [structuredUrl];
   }
-  var serializedArgs = serializeFunctionArguments(args);
+  const serializedArgs = serializeFunctionArguments(args);
 
   // Replace the arguments section
-  var before = source.substring(0, argumentsStartIndex);
-  var after = source.substring(argumentsEndIndex);
-  return "".concat(before).concat(serializedArgs).concat(after);
+  const before = source.substring(0, argumentsStartIndex);
+  const after = source.substring(argumentsEndIndex);
+  return `${before}${serializedArgs}${after}`;
 }

package/esm/pipeline/loadPrecomputedCodeHighlighter/serializeFunctionArguments.js

@@ -1,5 +1,3 @@
-import _typeof from "@babel/runtime/helpers/esm/typeof";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 /**
  * Utility function for serializing structured function arguments back to string format
  * This is the inverse of parseFunctionArguments - it takes structured data and creates
@@ -13,9 +11,7 @@ import { isArray, isFunction, isGeneric, isArrowFunction, isObjectLiteral, isTyp
  * Uses JSON.stringify for object values for performance and reliability
  */
 export function serializeFunctionArguments(args) {
-  return args.map(function (arg) {
-    return serializeArgument(arg);
-  }).join(', ');
+  return args.map(arg => serializeArgument(arg)).join(', ');
 }
 
 /**
@@ -30,60 +26,48 @@ function serializeArgument(arg) {
   }
 
   // Check structured types using type guards
-  var arrayCheck = isArray(arg);
+  const arrayCheck = isArray(arg);
   if (arrayCheck) {
-    return "[".concat(arrayCheck.items.map(function (item) {
-      return serializeArgument(item);
-    }).join(', '), "]");
+    return `[${arrayCheck.items.map(item => serializeArgument(item)).join(', ')}]`;
   }
-  var functionCheck = isFunction(arg);
+  const functionCheck = isFunction(arg);
   if (functionCheck) {
-    var args = functionCheck.arguments.map(function (p) {
-      return serializeArgument(p);
-    }).join(', ');
-    return "".concat(functionCheck.name, "(").concat(args, ")");
+    const args = functionCheck.arguments.map(p => serializeArgument(p)).join(', ');
+    return `${functionCheck.name}(${args})`;
   }
-  var genericCheck = isGeneric(arg);
+  const genericCheck = isGeneric(arg);
   if (genericCheck) {
-    var generics = genericCheck.generics.map(function (g) {
-      return serializeArgument(g);
-    }).join(', ');
+    const generics = genericCheck.generics.map(g => serializeArgument(g)).join(', ');
     if (genericCheck.arguments === null) {
       // Type generic like Theme<"dark" | "light">
-      return "".concat(genericCheck.name, "<").concat(generics, ">");
+      return `${genericCheck.name}<${generics}>`;
     }
     // Function generic like Component<Props>(args) - only add () if there are actual arguments
     if (genericCheck.arguments.length > 0) {
-      var _args = genericCheck.arguments.map(function (p) {
-        return serializeArgument(p);
-      }).join(', ');
-      return "".concat(genericCheck.name, "<").concat(generics, ">(").concat(_args, ")");
+      const args = genericCheck.arguments.map(p => serializeArgument(p)).join(', ');
+      return `${genericCheck.name}<${generics}>(${args})`;
     }
     // Generic without function call - like Component<Props>
-    return "".concat(genericCheck.name, "<").concat(generics, ">");
+    return `${genericCheck.name}<${generics}>`;
   }
-  var arrowCheck = isArrowFunction(arg);
+  const arrowCheck = isArrowFunction(arg);
   if (arrowCheck) {
-    var _args2 = arrowCheck.args.map(function (p) {
-      return serializeArgument(p);
-    }).join(', ');
-    var argStr = arrowCheck.args.length === 1 ? _args2 : "(".concat(_args2, ")");
+    const args = arrowCheck.args.map(p => serializeArgument(p)).join(', ');
+    const argStr = arrowCheck.args.length === 1 ? args : `(${args})`;
     if (arrowCheck.types) {
       // Typed arrow function
-      var _arrowCheck$types = _slicedToArray(arrowCheck.types, 2),
-        inputTypes = _arrowCheck$types[0],
-        outputTypes = _arrowCheck$types[1];
-      var inputTypeStr = Array.isArray(inputTypes) ? inputTypes.join(', ') : inputTypes;
-      return "(".concat(_args2, ": ").concat(inputTypeStr, "): ").concat(outputTypes, " => ").concat(serializeArgument(arrowCheck.returnValue));
+      const [inputTypes, outputTypes] = arrowCheck.types;
+      const inputTypeStr = Array.isArray(inputTypes) ? inputTypes.join(', ') : inputTypes;
+      return `(${args}: ${inputTypeStr}): ${outputTypes} => ${serializeArgument(arrowCheck.returnValue)}`;
     }
     // Simple arrow function
-    return "".concat(argStr, " => ").concat(serializeArgument(arrowCheck.returnValue));
+    return `${argStr} => ${serializeArgument(arrowCheck.returnValue)}`;
   }
-  var typeAssertionCheck = isTypeAssertion(arg);
+  const typeAssertionCheck = isTypeAssertion(arg);
   if (typeAssertionCheck) {
-    return "".concat(serializeArgument(typeAssertionCheck.expression), " as ").concat(typeAssertionCheck.type);
+    return `${serializeArgument(typeAssertionCheck.expression)} as ${typeAssertionCheck.type}`;
   }
-  var objectCheck = isObjectLiteral(arg);
+  const objectCheck = isObjectLiteral(arg);
   if (objectCheck) {
     return serializeObject(objectCheck.properties);
   }
@@ -93,22 +77,18 @@ function serializeArgument(arg) {
     // Check if this is a double-wrapped array literal from parseArrayLiteral
     // parseArrayLiteral calls parseArgumentsRecursive which returns an array,
     // so we get [[item1, item2]] instead of [item1, item2]
-    var doubleWrappedCheck = isArray(arg);
+    const doubleWrappedCheck = isArray(arg);
     if (doubleWrappedCheck) {
       // This is a double-wrapped array literal - unwrap it
-      return "[".concat(arg[0].map(function (item) {
-        return serializeArgument(item);
-      }).join(', '), "]");
+      return `[${arg[0].map(item => serializeArgument(item)).join(', ')}]`;
     }
 
     // Regular array
-    return "[".concat(arg.map(function (item) {
-      return serializeArgument(item);
-    }).join(', '), "]");
+    return `[${arg.map(item => serializeArgument(item)).join(', ')}]`;
   }
 
   // Object but not a structured type - serialize as object literal
-  if (_typeof(arg) === 'object' && arg !== null) {
+  if (typeof arg === 'object' && arg !== null) {
     return serializeObject(arg);
   }
 
@@ -123,19 +103,16 @@ function serializeObject(obj) {
   if (Object.keys(obj).length === 0) {
     return '{}';
   }
-  var entries = Object.entries(obj).map(function (_ref) {
-    var _ref2 = _slicedToArray(_ref, 2),
-      key = _ref2[0],
-      value = _ref2[1];
-    var serializedValue = serializeObjectValue(value);
+  const entries = Object.entries(obj).map(([key, value]) => {
+    const serializedValue = serializeObjectValue(value);
 
     // Handle shorthand properties (key === value)
     if (typeof value === 'string' && key === value) {
       return key;
     }
-    return "".concat(key, ": ").concat(serializedValue);
+    return `${key}: ${serializedValue}`;
   });
-  return "{ ".concat(entries.join(', '), " }");
+  return `{ ${entries.join(', ')} }`;
 } /**
   * Serialize an object value, using JSON.stringify when appropriate
   */
@@ -145,13 +122,11 @@ function serializeObjectValue(value) {
   // This MUST come before the structured type check to prevent it being treated as a structured array
   if (isArray(value)) {
     // This is a double-wrapped array literal - unwrap it
-    return "[".concat(value[0].map(function (item) {
-      return serializeObjectValue(item);
-    }).join(', '), "]");
+    return `[${value[0].map(item => serializeObjectValue(item)).join(', ')}]`;
   }
 
   // For structured types, recursively serialize first
-  if (_typeof(value) === 'object' && value !== null && isStructuredType(value)) {
+  if (typeof value === 'object' && value !== null && isStructuredType(value)) {
     return serializeArgument(value);
   }
 
@@ -168,27 +143,18 @@ function serializeObjectValue(value) {
   }
 
   // For plain objects and arrays, serialize keys/values individually
-  if (_typeof(value) === 'object' && value !== null && !isStructuredType(value)) {
+  if (typeof value === 'object' && value !== null && !isStructuredType(value)) {
     if (Array.isArray(value)) {
       // Check if this is a double-wrapped array literal
       if (isArray(value)) {
         // This is a double-wrapped array literal - unwrap it
-        return "[".concat(value[0].map(function (item) {
-          return serializeObjectValue(item);
-        }).join(', '), "]");
+        return `[${value[0].map(item => serializeObjectValue(item)).join(', ')}]`;
       }
       // Regular array
-      return "[".concat(value.map(function (item) {
-        return serializeObjectValue(item);
-      }).join(', '), "]");
+      return `[${value.map(item => serializeObjectValue(item)).join(', ')}]`;
     }
-    var pairs = Object.entries(value).map(function (_ref3) {
-      var _ref4 = _slicedToArray(_ref3, 2),
-        key = _ref4[0],
-        val = _ref4[1];
-      return "".concat(key, ": ").concat(serializeObjectValue(val));
-    });
-    return "{ ".concat(pairs.join(', '), " }");
+    const pairs = Object.entries(value).map(([key, val]) => `${key}: ${serializeObjectValue(val)}`);
+    return `{ ${pairs.join(', ')} }`;
   }
 
   // Fallback

package/esm/pipeline/loadPrecomputedCodeHighlighterClient/filterRuntimeExternals.js

@@ -1,18 +1,12 @@
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 /**
  * Filters out type-only imports from externals since they don't exist at runtime.
  * This is essential for client-side code where type imports are stripped during compilation.
  */
 export function filterRuntimeExternals(externals) {
-  var runtimeExternals = {};
-  for (var _i = 0, _Object$entries = Object.entries(externals); _i < _Object$entries.length; _i++) {
-    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
-      modulePath = _Object$entries$_i[0],
-      imports = _Object$entries$_i[1];
+  const runtimeExternals = {};
+  for (const [modulePath, imports] of Object.entries(externals)) {
     // Filter out imports where isType is true
-    var runtimeImports = imports.filter(function (importItem) {
-      return !importItem.isType;
-    });
+    const runtimeImports = imports.filter(importItem => !importItem.isType);
 
     // Only include the module if it has runtime imports
     if (runtimeImports.length > 0) {

package/esm/pipeline/loadPrecomputedCodeHighlighterClient/generateImportStatements.js

@@ -1,5 +1,3 @@
-import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 /**
  * Generates a unique import name based on module path and original name
  */
@@ -14,30 +12,30 @@ function generateUniqueImportName(originalName, modulePath, type, usedNames) {
   // - Named imports from simple test cases (lib1, lib2, etc.): use numbered suffixes
   // - Other cases: try module-based names first
 
-  var wantsNumberedSuffix = type === 'namespace' || modulePath.startsWith('lib') && /^lib\d+$/.test(modulePath);
+  const wantsNumberedSuffix = type === 'namespace' || modulePath.startsWith('lib') && /^lib\d+$/.test(modulePath);
   if (wantsNumberedSuffix) {
     // Use numbered suffixes
-    var attempt = 1;
-    var _uniqueName = "".concat(originalName).concat(attempt);
-    while (usedNames.has(_uniqueName)) {
+    let attempt = 1;
+    let uniqueName = `${originalName}${attempt}`;
+    while (usedNames.has(uniqueName)) {
       attempt += 1;
-      _uniqueName = "".concat(originalName).concat(attempt);
+      uniqueName = `${originalName}${attempt}`;
     }
-    return _uniqueName;
+    return uniqueName;
   }
 
   // For real modules, try module-based names first
-  var moduleKey = modulePath.replace(/[@/.-]/g, '') // Remove special characters
+  const moduleKey = modulePath.replace(/[@/.-]/g, '') // Remove special characters
   .toLowerCase().slice(0, 20); // Limit length
 
-  var uniqueName = "".concat(originalName).concat(moduleKey);
+  let uniqueName = `${originalName}${moduleKey}`;
 
   // If that's still taken, try numbered suffixes
   if (usedNames.has(uniqueName)) {
-    var _attempt = 1;
+    let attempt = 1;
     do {
-      uniqueName = "".concat(originalName).concat(_attempt);
-      _attempt += 1;
+      uniqueName = `${originalName}${attempt}`;
+      attempt += 1;
     } while (usedNames.has(uniqueName));
   }
   return uniqueName;
@@ -48,100 +46,76 @@ function generateUniqueImportName(originalName, modulePath, type, usedNames) {
  * Returns just the import lines needed to bring in the dependencies
  */
 export function generateImportStatements(externals) {
-  var moduleImports = {};
-  var usedNames = new Set();
-  var seenImports = new Set();
+  const moduleImports = {};
+  const usedNames = new Set();
+  const seenImports = new Set();
 
   // First pass: collect all imports and resolve naming conflicts
-  for (var _i = 0, _Object$entries = Object.entries(externals); _i < _Object$entries.length; _i++) {
-    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
-      modulePath = _Object$entries$_i[0],
-      importItems = _Object$entries$_i[1];
+  for (const [modulePath, importItems] of Object.entries(externals)) {
     if (!moduleImports[modulePath]) {
       moduleImports[modulePath] = {
         named: [],
         namespace: []
       };
     }
-    var _iterator = _createForOfIteratorHelper(importItems),
-      _step;
-    try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var _step$value = _step.value,
-          originalName = _step$value.name,
-          type = _step$value.type,
-          isType = _step$value.isType;
-        // Skip type-only imports and empty names
-        if (isType || !originalName.trim()) {
-          continue;
-        }
-        var importKey = "".concat(modulePath, ":").concat(originalName, ":").concat(type);
+    for (const {
+      name: originalName,
+      type,
+      isType
+    } of importItems) {
+      // Skip type-only imports and empty names
+      if (isType || !originalName.trim()) {
+        continue;
+      }
+      const importKey = `${modulePath}:${originalName}:${type}`;
 
-        // Skip duplicates
-        if (seenImports.has(importKey)) {
-          continue;
-        }
-        seenImports.add(importKey);
-        var uniqueName = generateUniqueImportName(originalName, modulePath, type, usedNames);
-        usedNames.add(uniqueName);
-        if (type === 'default') {
-          moduleImports[modulePath]["default"] = uniqueName;
-        } else if (type === 'named') {
-          moduleImports[modulePath].named.push({
-            original: originalName,
-            unique: uniqueName
-          });
-        } else if (type === 'namespace') {
-          moduleImports[modulePath].namespace.push(uniqueName);
-        }
+      // Skip duplicates
+      if (seenImports.has(importKey)) {
+        continue;
+      }
+      seenImports.add(importKey);
+      const uniqueName = generateUniqueImportName(originalName, modulePath, type, usedNames);
+      usedNames.add(uniqueName);
+      if (type === 'default') {
+        moduleImports[modulePath].default = uniqueName;
+      } else if (type === 'named') {
+        moduleImports[modulePath].named.push({
+          original: originalName,
+          unique: uniqueName
+        });
+      } else if (type === 'namespace') {
+        moduleImports[modulePath].namespace.push(uniqueName);
       }
-    } catch (err) {
-      _iterator.e(err);
-    } finally {
-      _iterator.f();
     }
   }
 
   // Second pass: generate consolidated import statements
-  var imports = [];
-  for (var _i2 = 0, _Object$entries2 = Object.entries(moduleImports); _i2 < _Object$entries2.length; _i2++) {
-    var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
-      _modulePath = _Object$entries2$_i[0],
-      moduleImport = _Object$entries2$_i[1];
-    var importParts = [];
+  const imports = [];
+  for (const [modulePath, moduleImport] of Object.entries(moduleImports)) {
+    const importParts = [];
 
     // Add default import
-    if (moduleImport["default"]) {
-      importParts.push(moduleImport["default"]);
+    if (moduleImport.default) {
+      importParts.push(moduleImport.default);
     }
 
     // Add named imports (consolidated into one statement)
     if (moduleImport.named.length > 0) {
-      var namedImports = moduleImport.named.map(function (_ref) {
-        var original = _ref.original,
-          unique = _ref.unique;
-        return original === unique ? original : "".concat(original, " as ").concat(unique);
-      }).join(', ');
-      importParts.push("{ ".concat(namedImports, " }"));
+      const namedImports = moduleImport.named.map(({
+        original,
+        unique
+      }) => original === unique ? original : `${original} as ${unique}`).join(', ');
+      importParts.push(`{ ${namedImports} }`);
     }
 
     // Generate import statement
     if (importParts.length > 0) {
-      imports.push("import ".concat(importParts.join(', '), " from '").concat(_modulePath, "';"));
+      imports.push(`import ${importParts.join(', ')} from '${modulePath}';`);
     }
 
     // Add namespace imports (separate statements as they can't be combined)
-    var _iterator2 = _createForOfIteratorHelper(moduleImport.namespace),
-      _step2;
-    try {
-      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-        var namespaceName = _step2.value;
-        imports.push("import * as ".concat(namespaceName, " from '").concat(_modulePath, "';"));
-      }
-    } catch (err) {
-      _iterator2.e(err);
-    } finally {
-      _iterator2.f();
+    for (const namespaceName of moduleImport.namespace) {
+      imports.push(`import * as ${namespaceName} from '${modulePath}';`);
     }
   }
   return imports;