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

package/esm/pipeline/loaderUtils/parseImports.js

@@ -1,306 +0,0 @@
-import _regeneratorValues from "@babel/runtime/helpers/esm/regeneratorValues";
-import _regenerator from "@babel/runtime/helpers/esm/regenerator";
-import _extends from "@babel/runtime/helpers/esm/extends";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
-// webpack does not like node: imports
-// eslint-disable-next-line n/prefer-node-protocol
-import path from 'path';
-export function parseImports(_x, _x2) {
-  return _parseImports.apply(this, arguments);
-}
-function _parseImports() {
-  _parseImports = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(code, _filePath) {
-    var result, externals, importRegex, sideEffectImportRegex, match, _loop, _ret, sideEffectMatch, _sideEffectMatch, _sideEffectMatch2, modulePathRaw, modulePath, isRelative, resolvedPath;
-    return _regenerator().w(function (_context2) {
-      while (1) switch (_context2.n) {
-        case 0:
-          result = {};
-          externals = {}; // Regex to extract regular import statements with 'from' clause
-          importRegex = /import(?:\s+type)?\s*([^'"]*)\s*from\s*['"]([^'"]+)['"][;]?/g; // Regex to extract side-effect imports (without 'from' clause)
-          sideEffectImportRegex = /import\s*['"]([^'"]+)['"][;]?/g;
-          // eslint-disable-next-line no-cond-assign
-          _loop = /*#__PURE__*/_regenerator().m(function _loop() {
-            var _match, _match2, fullMatch, importSpecifierRaw, modulePathRaw, includeTypeDefs, importSpecifier, modulePath, isRelative, _resolvedPath, _resolvedPath2, defaultImportMatch, namespaceImportMatch, namedImportsMatch, defaultImport, namespaceImport, namedImportsStr, existing, _existing, cleanedImportsStr, namedImports, _defaultImportMatch, _namespaceImportMatch, _namedImportsMatch, _defaultImport, _namespaceImport, _namedImportsStr, _existing3, _existing4, _cleanedImportsStr, _namedImports;
-            return _regenerator().w(function (_context) {
-              while (1) switch (_context.n) {
-                case 0:
-                  _match = match, _match2 = _slicedToArray(_match, 3), fullMatch = _match2[0], importSpecifierRaw = _match2[1], modulePathRaw = _match2[2]; // Determine if this is a type import by checking if the full match contains "import type"
-                  includeTypeDefs = fullMatch.includes('import type');
-                  importSpecifier = importSpecifierRaw == null ? void 0 : importSpecifierRaw.trim();
-                  modulePath = modulePathRaw == null ? void 0 : modulePathRaw.trim();
-                  if (modulePath) {
-                    _context.n = 1;
-                    break;
-                  }
-                  return _context.a(2, 0);
-                case 1:
-                  // Check if this is a relative import
-                  isRelative = modulePath.startsWith('./') || modulePath.startsWith('../'); // Handle side-effect imports (no import specifier)
-                  if (importSpecifier) {
-                    _context.n = 2;
-                    break;
-                  }
-                  if (isRelative) {
-                    // Resolve the relative import to an absolute path
-                    _resolvedPath = path.resolve(path.dirname(_filePath), modulePath);
-                    if (!result[modulePath]) {
-                      result[modulePath] = {
-                        path: _resolvedPath,
-                        names: [] // Empty names array for side-effect imports
-                      };
-                    }
-                  } else if (!externals[modulePath]) {
-                    // External side-effect import
-                    externals[modulePath] = {
-                      names: []
-                    };
-                  }
-                  return _context.a(2, 0);
-                case 2:
-                  if (isRelative) {
-                    // Resolve the relative import to an absolute path
-                    _resolvedPath2 = path.resolve(path.dirname(_filePath), modulePath);
-                    if (!result[modulePath]) {
-                      result[modulePath] = _extends({
-                        path: _resolvedPath2,
-                        names: []
-                      }, includeTypeDefs && {
-                        includeTypeDefs: true
-                      });
-                    } else if (includeTypeDefs && !result[modulePath].includeTypeDefs) {
-                      result[modulePath].includeTypeDefs = true;
-                    }
-
-                    // Parse the import specifier to determine the type of import
-                    defaultImportMatch = importSpecifier.match(/^([a-zA-Z_$][a-zA-Z0-9_$]*)\s*(?:,|$)/);
-                    namespaceImportMatch = importSpecifier.match(/\*\s+as\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/);
-                    namedImportsMatch = importSpecifier.match(/\{([^}]+)\}/);
-                    defaultImport = defaultImportMatch == null ? void 0 : defaultImportMatch[1];
-                    namespaceImport = namespaceImportMatch == null ? void 0 : namespaceImportMatch[1];
-                    namedImportsStr = namedImportsMatch == null ? void 0 : namedImportsMatch[1];
-                    if (defaultImport) {
-                      // Check if we already have this default import
-                      existing = result[modulePath].names.find(function (n) {
-                        return n.name === defaultImport && n.type === 'default';
-                      });
-                      if (!existing) {
-                        result[modulePath].names.push(_extends({
-                          name: defaultImport,
-                          type: 'default'
-                        }, includeTypeDefs && {
-                          isType: true
-                        }));
-                      }
-                    }
-                    if (namespaceImport) {
-                      // Check if we already have this namespace import
-                      _existing = result[modulePath].names.find(function (n) {
-                        return n.name === namespaceImport && n.type === 'namespace';
-                      });
-                      if (!_existing) {
-                        result[modulePath].names.push(_extends({
-                          name: namespaceImport,
-                          type: 'namespace'
-                        }, includeTypeDefs && {
-                          isType: true
-                        }));
-                      }
-                    }
-                    if (namedImportsStr) {
-                      // Handle named imports like { ComponentName, Component2 as Alias, type TypeName }
-                      // Clean up the string by removing comments and extra whitespace
-                      cleanedImportsStr = namedImportsStr.replace(/\/\*[\s\S]*?\*\//g, '') // Remove /* comment */ blocks
-                      .replace(/\/\/.*$/gm, '') // Remove // line comments
-                      .trim();
-                      if (cleanedImportsStr) {
-                        namedImports = cleanedImportsStr.split(',').map(function (s) {
-                          return s.trim();
-                        }).filter(function (s) {
-                          return s.length > 0;
-                        });
-                        namedImports.forEach(function (namedImport) {
-                          // Check if this specific import is a type import
-                          var isTypeImport = namedImport.trim().startsWith('type ');
-
-                          // Clean up the import name (remove 'type' keyword and handle aliases)
-                          var cleanImport = namedImport.replace(/^type\s+/, ''); // Remove leading 'type'
-
-                          // Parse original name and alias
-                          var aliasMatch = cleanImport.match(/(.+?)\s+as\s+(.+)/);
-                          var originalName = aliasMatch ? aliasMatch[1].trim() : cleanImport.trim();
-                          var alias = aliasMatch ? aliasMatch[2].trim() : undefined;
-
-                          // Only add if we have a valid name
-                          if (originalName && /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(originalName)) {
-                            // Check if we already have this named import
-                            var _existing2 = result[modulePath].names.find(function (n) {
-                              return n.name === originalName && n.type === 'named' && n.alias === alias;
-                            });
-                            if (!_existing2) {
-                              result[modulePath].names.push(_extends(_extends({
-                                name: originalName
-                              }, alias && {
-                                alias: alias
-                              }), {}, {
-                                type: 'named'
-                              }, (includeTypeDefs || isTypeImport) && {
-                                isType: true
-                              }));
-                            }
-                          }
-                        });
-                      }
-                    }
-                  } else {
-                    // This is an external import
-                    if (!externals[modulePath]) {
-                      externals[modulePath] = {
-                        names: []
-                      };
-                    }
-
-                    // Parse the import specifier to determine the type of import
-                    _defaultImportMatch = importSpecifier.match(/^([a-zA-Z_$][a-zA-Z0-9_$]*)\s*(?:,|$)/);
-                    _namespaceImportMatch = importSpecifier.match(/\*\s+as\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/);
-                    _namedImportsMatch = importSpecifier.match(/\{([^}]+)\}/);
-                    _defaultImport = _defaultImportMatch == null ? void 0 : _defaultImportMatch[1];
-                    _namespaceImport = _namespaceImportMatch == null ? void 0 : _namespaceImportMatch[1];
-                    _namedImportsStr = _namedImportsMatch == null ? void 0 : _namedImportsMatch[1];
-                    if (_defaultImport) {
-                      // Check if we already have this default import
-                      _existing3 = externals[modulePath].names.find(function (n) {
-                        return n.name === _defaultImport && n.type === 'default';
-                      });
-                      if (!_existing3) {
-                        externals[modulePath].names.push(_extends({
-                          name: _defaultImport,
-                          type: 'default'
-                        }, includeTypeDefs && {
-                          isType: true
-                        }));
-                      }
-                    }
-                    if (_namespaceImport) {
-                      // Check if we already have this namespace import
-                      _existing4 = externals[modulePath].names.find(function (n) {
-                        return n.name === _namespaceImport && n.type === 'namespace';
-                      });
-                      if (!_existing4) {
-                        externals[modulePath].names.push(_extends({
-                          name: _namespaceImport,
-                          type: 'namespace'
-                        }, includeTypeDefs && {
-                          isType: true
-                        }));
-                      }
-                    }
-                    if (_namedImportsStr) {
-                      // Handle named imports like { ComponentName, Component2 as Alias, type TypeName }
-                      // Clean up the string by removing comments and extra whitespace
-                      _cleanedImportsStr = _namedImportsStr.replace(/\/\*[\s\S]*?\*\//g, '') // Remove /* comment */ blocks
-                      .replace(/\/\/.*$/gm, '') // Remove // line comments
-                      .trim();
-                      if (_cleanedImportsStr) {
-                        _namedImports = _cleanedImportsStr.split(',').map(function (s) {
-                          return s.trim();
-                        }).filter(function (s) {
-                          return s.length > 0;
-                        });
-                        _namedImports.forEach(function (namedImport) {
-                          // Check if this specific import is a type import
-                          var isTypeImport = namedImport.trim().startsWith('type ');
-
-                          // Clean up the import name (remove 'type' keyword and handle aliases)
-                          var cleanImport = namedImport.replace(/^type\s+/, ''); // Remove leading 'type'
-
-                          // Parse original name and alias - for externals we track both
-                          var aliasMatch = cleanImport.match(/(.+?)\s+as\s+(.+)/);
-                          var originalName = aliasMatch ? aliasMatch[1].trim() : cleanImport.trim();
-                          var alias = aliasMatch ? aliasMatch[2].trim() : undefined;
-
-                          // Only add if we have a valid name
-                          if (originalName && /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(originalName)) {
-                            // Check if we already have this named import
-                            var _existing5 = externals[modulePath].names.find(function (n) {
-                              return n.name === originalName && n.type === 'named' && n.alias === alias;
-                            });
-                            if (!_existing5) {
-                              externals[modulePath].names.push(_extends(_extends({
-                                name: originalName
-                              }, alias && {
-                                alias: alias
-                              }), {}, {
-                                type: 'named'
-                              }, (includeTypeDefs || isTypeImport) && {
-                                isType: true
-                              }));
-                            }
-                          }
-                        });
-                      }
-                    }
-                  }
-                case 3:
-                  return _context.a(2);
-              }
-            }, _loop);
-          });
-        case 1:
-          if (!((match = importRegex.exec(code)) !== null)) {
-            _context2.n = 4;
-            break;
-          }
-          return _context2.d(_regeneratorValues(_loop()), 2);
-        case 2:
-          _ret = _context2.v;
-          if (!(_ret === 0)) {
-            _context2.n = 3;
-            break;
-          }
-          return _context2.a(3, 1);
-        case 3:
-          _context2.n = 1;
-          break;
-        case 4:
-          if (!((sideEffectMatch = sideEffectImportRegex.exec(code)) !== null)) {
-            _context2.n = 6;
-            break;
-          }
-          _sideEffectMatch = sideEffectMatch, _sideEffectMatch2 = _slicedToArray(_sideEffectMatch, 2), modulePathRaw = _sideEffectMatch2[1];
-          modulePath = modulePathRaw == null ? void 0 : modulePathRaw.trim();
-          if (modulePath) {
-            _context2.n = 5;
-            break;
-          }
-          return _context2.a(3, 4);
-        case 5:
-          // Check if this is a relative import
-          isRelative = modulePath.startsWith('./') || modulePath.startsWith('../');
-          if (isRelative) {
-            // Resolve the relative import to an absolute path
-            resolvedPath = path.resolve(path.dirname(_filePath), modulePath);
-            if (!result[modulePath]) {
-              result[modulePath] = {
-                path: resolvedPath,
-                names: [] // Empty names array for side-effect imports
-              };
-            }
-          } else if (!externals[modulePath]) {
-            // External side-effect import
-            externals[modulePath] = {
-              names: []
-            };
-          }
-          _context2.n = 4;
-          break;
-        case 6:
-          return _context2.a(2, {
-            relative: result,
-            externals: externals
-          });
-      }
-    }, _callee);
-  }));
-  return _parseImports.apply(this, arguments);
-}

package/esm/pipeline/transformHtmlCode/index.d.ts

@@ -1,2 +0,0 @@
-import { transformHtmlCode } from "./transformHtmlCode.js";
-export default transformHtmlCode;

package/esm/pipeline/transformHtmlCode/index.js

@@ -1,4 +0,0 @@
-// This is the export format expected by a remark plugin.
-
-import { transformHtmlCode } from "./transformHtmlCode.js";
-export default transformHtmlCode;

package/esm/pipeline/transformHtmlCode/transformHtmlCode.d.ts

@@ -1,13 +0,0 @@
-import type { Plugin } from 'unified';
-/**
- * Rehype plugin that transforms pre > code elements to use loadVariant
- *
- * This plugin:
- * 1. Finds pre elements in the HTML AST
- * 2. Collects all code children within each pre element
- * 3. Creates variants from multiple code elements or single Default variant
- * 4. Uses loadVariant to process each variant
- * 5. Stores the combined precompute data on the pre element
- * 6. Clears all code element contents
- */
-export declare const transformHtmlCode: Plugin;

package/esm/pipeline/transformHtmlCode/transformHtmlCode.js

@@ -1,300 +0,0 @@
-import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
-import _regenerator from "@babel/runtime/helpers/esm/regenerator";
-import _typeof from "@babel/runtime/helpers/esm/typeof";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
-import { visit } from 'unist-util-visit';
-import { loadVariant } from "../../CodeHighlighter/loadVariant.js";
-import { createParseSource } from "../parseSource/index.js";
-import { TypescriptToJavascriptTransformer } from "../transformTypescriptToJavascript/index.js";
-/**
- * Maps common language class names to file extensions
- * Only includes languages that have corresponding grammars in parseSource/grammars.ts
- */
-var LANGUAGE_TO_EXTENSION = {
-  // JavaScript
-  javascript: 'js',
-  js: 'js',
-  // TypeScript
-  typescript: 'ts',
-  ts: 'ts',
-  // TSX/JSX
-  tsx: 'tsx',
-  jsx: 'jsx',
-  // Maps to .jsx but uses tsx grammar
-
-  // JSON
-  json: 'json',
-  // Markdown
-  markdown: 'md',
-  md: 'md',
-  // MDX
-  mdx: 'mdx',
-  // HTML
-  html: 'html',
-  // CSS
-  css: 'css',
-  // Shell
-  shell: 'sh',
-  bash: 'sh',
-  sh: 'sh',
-  // YAML
-  yaml: 'yaml',
-  yml: 'yaml'
-};
-
-/**
- * Extracts the language from className attribute
- */
-function extractLanguageFromClassName(className) {
-  if (!className) {
-    return null;
-  }
-
-  // Handle array of class names (HAST format)
-  var classString = Array.isArray(className) ? className.join(' ') : className;
-  var match = classString.match(/(?:^|\s)language-(\w+)(?:\s|$)/);
-  return match ? match[1] : null;
-}
-
-/**
- * Gets the filename from data-filename attribute or derives it from language
- * Returns undefined if no explicit filename and no recognizable language
- */
-function getFileName(codeElement) {
-  var _codeElement$properti, _codeElement$properti2;
-  // Check for explicit data-filename attribute
-  var dataFilename = (_codeElement$properti = codeElement.properties) == null ? void 0 : _codeElement$properti.dataFilename;
-  if (dataFilename && typeof dataFilename === 'string') {
-    return dataFilename;
-  }
-
-  // Extract language from className
-  var className = (_codeElement$properti2 = codeElement.properties) == null ? void 0 : _codeElement$properti2.className;
-  var language = extractLanguageFromClassName(className);
-  if (language && LANGUAGE_TO_EXTENSION[language]) {
-    return "index.".concat(LANGUAGE_TO_EXTENSION[language]);
-  }
-
-  // Return undefined instead of a fallback - let the system handle gracefully
-  return undefined;
-}
-
-/**
- * Extracts text content from HAST nodes
- */
-function extractTextContent(node) {
-  if (node.type === 'text') {
-    return node.value;
-  }
-  if (node.type === 'element' && node.children) {
-    return node.children.map(function (child) {
-      return extractTextContent(child);
-    }).join('');
-  }
-  return '';
-}
-
-/**
- * Creates variants from multiple code elements within a pre element
- */
-function createVariantsFromCodeElements(codeElements) {
-  var variants = {};
-  if (codeElements.length === 1) {
-    var _codeElement$properti3;
-    // Single code element - use "Default" as variant name
-    var codeElement = codeElements[0];
-    var sourceCode = extractTextContent(codeElement);
-    var fileName = getFileName(codeElement);
-    var variant = {
-      source: sourceCode,
-      skipTransforms: !((_codeElement$properti3 = codeElement.properties) != null && _codeElement$properti3.dataTransform)
-    };
-
-    // Only add fileName if we have one
-    if (fileName) {
-      variant.fileName = fileName;
-    }
-    variants.Default = variant;
-  } else {
-    // Multiple code elements - create appropriate variant names
-    var languages = codeElements.map(function (element) {
-      var _element$properties;
-      var className = (_element$properties = element.properties) == null ? void 0 : _element$properties.className;
-      return extractLanguageFromClassName(className);
-    });
-
-    // Check if all languages are the same (or all null)
-    var uniqueLanguages = Array.from(new Set(languages.filter(Boolean)));
-    var shouldUseLanguageNames = uniqueLanguages.length > 1;
-    codeElements.forEach(function (codeElement, index) {
-      var _codeElement$properti4, _codeElement$properti5;
-      var sourceCode = extractTextContent(codeElement);
-      var fileName = getFileName(codeElement);
-
-      // Check for explicit variant name
-      var dataVariant = (_codeElement$properti4 = codeElement.properties) == null ? void 0 : _codeElement$properti4.dataVariant;
-      var variantName;
-      if (dataVariant && typeof dataVariant === 'string') {
-        variantName = dataVariant;
-      } else if (shouldUseLanguageNames && languages[index]) {
-        // Use language name if languages differ
-        variantName = languages[index].charAt(0).toUpperCase() + languages[index].slice(1);
-      } else {
-        // Use numbered variants if languages are the same or unknown
-        variantName = "Variant ".concat(index + 1);
-      }
-      var variant = {
-        source: sourceCode,
-        skipTransforms: !((_codeElement$properti5 = codeElement.properties) != null && _codeElement$properti5.dataTransform)
-      };
-
-      // Only add fileName if we have one
-      if (fileName) {
-        variant.fileName = fileName;
-      }
-      variants[variantName] = variant;
-    });
-  }
-  return variants;
-}
-
-/**
- * Rehype plugin that transforms pre > code elements to use loadVariant
- *
- * This plugin:
- * 1. Finds pre elements in the HTML AST
- * 2. Collects all code children within each pre element
- * 3. Creates variants from multiple code elements or single Default variant
- * 4. Uses loadVariant to process each variant
- * 5. Stores the combined precompute data on the pre element
- * 6. Clears all code element contents
- */
-export var transformHtmlCode = function transformHtmlCode() {
-  return /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(tree) {
-      var transformPromises, sourceParser, sourceTransformers;
-      return _regenerator().w(function (_context3) {
-        while (1) switch (_context3.n) {
-          case 0:
-            transformPromises = []; // Get the source parser and transformers
-            sourceParser = createParseSource();
-            sourceTransformers = [TypescriptToJavascriptTransformer];
-            visit(tree, 'element', function (node) {
-              // Look for pre elements
-              if (node.tagName === 'pre' && node.children && node.children.length > 0) {
-                // Find all code elements within this pre
-                var codeElements = node.children.filter(function (child) {
-                  return child.type === 'element' && child.tagName === 'code';
-                });
-                if (codeElements.length > 0) {
-                  var transformPromise = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2() {
-                    var variants, processedCode, variantPromises, variantResults, _iterator, _step, result, _t;
-                    return _regenerator().w(function (_context2) {
-                      while (1) switch (_context2.p = _context2.n) {
-                        case 0:
-                          _context2.p = 0;
-                          // Create variants from all code elements
-                          variants = createVariantsFromCodeElements(codeElements); // Process each variant with loadVariant
-                          processedCode = {};
-                          variantPromises = Object.entries(variants).map(/*#__PURE__*/function () {
-                            var _ref4 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(_ref3) {
-                              var _ref5, variantName, variantData, result;
-                              return _regenerator().w(function (_context) {
-                                while (1) switch (_context.n) {
-                                  case 0:
-                                    _ref5 = _slicedToArray(_ref3, 2), variantName = _ref5[0], variantData = _ref5[1];
-                                    if (!(variantData && _typeof(variantData) === 'object')) {
-                                      _context.n = 2;
-                                      break;
-                                    }
-                                    _context.n = 1;
-                                    return loadVariant(undefined,
-                                    // url - not needed for inline code
-                                    variantName, variantData, {
-                                      sourceParser: sourceParser,
-                                      loadSource: undefined,
-                                      // loadSource - not needed since we have the data
-                                      loadVariantMeta: undefined,
-                                      // loadVariantMeta - not needed since we have the data
-                                      sourceTransformers: sourceTransformers,
-                                      disableTransforms: variantData.skipTransforms || false
-                                    });
-                                  case 1:
-                                    result = _context.v;
-                                    return _context.a(2, {
-                                      variantName: variantName,
-                                      processedVariant: result.code
-                                    });
-                                  case 2:
-                                    return _context.a(2, null);
-                                }
-                              }, _callee);
-                            }));
-                            return function (_x2) {
-                              return _ref4.apply(this, arguments);
-                            };
-                          }());
-                          _context2.n = 1;
-                          return Promise.all(variantPromises);
-                        case 1:
-                          variantResults = _context2.v;
-                          _iterator = _createForOfIteratorHelper(variantResults);
-                          try {
-                            for (_iterator.s(); !(_step = _iterator.n()).done;) {
-                              result = _step.value;
-                              if (result) {
-                                processedCode[result.variantName] = result.processedVariant;
-                              }
-                            }
-
-                            // Clear all code element contents and replace with error message
-                          } catch (err) {
-                            _iterator.e(err);
-                          } finally {
-                            _iterator.f();
-                          }
-                          codeElements.forEach(function (codeElement) {
-                            codeElement.children = [];
-                          });
-
-                          // Replace pre element children with error message for CodeHighlighter
-                          node.children = [{
-                            type: 'text',
-                            value: 'Error: expected pre tag to be handled by CodeHighlighter'
-                          }];
-
-                          // Set the precompute data on the pre element directly on properties for immediate HTML serialization
-                          if (!node.properties) {
-                            node.properties = {};
-                          }
-                          node.properties.dataPrecompute = JSON.stringify(processedCode);
-                          _context2.n = 3;
-                          break;
-                        case 2:
-                          _context2.p = 2;
-                          _t = _context2.v;
-                          console.warn('Failed to transform code block:', _t);
-                        case 3:
-                          return _context2.a(2);
-                      }
-                    }, _callee2, null, [[0, 2]]);
-                  }))();
-                  transformPromises.push(transformPromise);
-                }
-              }
-            });
-
-            // Wait for all transformations to complete
-            _context3.n = 1;
-            return Promise.all(transformPromises);
-          case 1:
-            return _context3.a(2);
-        }
-      }, _callee3);
-    }));
-    return function (_x) {
-      return _ref.apply(this, arguments);
-    };
-  }();
-};