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

package/esm/CodeHighlighter/loadVariant.js

@@ -0,0 +1,1044 @@
+import _regeneratorValues from "@babel/runtime/helpers/esm/regeneratorValues";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _regenerator from "@babel/runtime/helpers/esm/regenerator";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import * as path from 'path-module';
+import { transformSource } from "./transformSource.js";
+import { transformParsedSource } from "./transformParsedSource.js";
+import { getFileNameFromUrl } from "../pipeline/loaderUtils/index.js";
+import { mergeExternals } from "../pipeline/loaderUtils/mergeExternals.js";
+/**
+ * Check if a path is absolute (either filesystem absolute or URL)
+ */
+function isAbsolutePath(filePath) {
+  return path.isAbsolute(filePath) || filePath.includes('://');
+}
+
+/**
+ * Generate a conflict-free filename for globalsCode files.
+ * Strategy:
+ * 1. Try original filename
+ * 2. If conflict, try "global_" prefix
+ * 3. If still conflict, add numbers: "global_filename_1.ext", "global_filename_2.ext", etc.
+ */
+function generateConflictFreeFilename(originalFilename, existingFiles) {
+  // First try the original filename
+  if (!existingFiles.has(originalFilename)) {
+    return originalFilename;
+  }
+
+  // Try with global_ prefix
+  var globalFilename = "global_".concat(originalFilename);
+  if (!existingFiles.has(globalFilename)) {
+    return globalFilename;
+  }
+
+  // Use path.parse to cleanly split filename into name and extension
+  var parsed = path.parse(originalFilename);
+  var nameWithoutExt = parsed.name;
+  var extension = parsed.ext;
+
+  // Add numbers until we find a free name, preserving extension
+  var counter = 1;
+  var candidateName;
+  do {
+    candidateName = "global_".concat(nameWithoutExt, "_").concat(counter).concat(extension);
+    counter += 1;
+  } while (existingFiles.has(candidateName));
+  return candidateName;
+}
+
+// Helper function to check if we're in production
+function isProduction() {
+  return typeof process !== 'undefined' && process.env.NODE_ENV === 'production';
+}
+
+// Helper function to convert a nested key based on the directory of the source file key
+function convertKeyBasedOnDirectory(nestedKey, sourceFileKey) {
+  // If it's an absolute path (starts with / or contains ://), keep as-is
+  if (isAbsolutePath(nestedKey)) {
+    return nestedKey;
+  }
+
+  // Treat bare filenames as relative to current directory (same as ./filename)
+  var processedNestedKey = nestedKey;
+  if (!nestedKey.startsWith('.')) {
+    processedNestedKey = "./".concat(nestedKey);
+  }
+
+  // Use path module for clean path resolution
+  var sourceDir = path.dirname(sourceFileKey);
+  var resolvedPath = path.resolve(sourceDir, processedNestedKey);
+
+  // Convert back to relative path from current directory
+  var result = path.relative('.', resolvedPath);
+
+  // Return empty string if result is '.' (current directory)
+  return result === '.' ? '' : result;
+}
+
+/**
+ * Normalize a relative path key by removing unnecessary ./ prefix and cleaning up the path
+ */
+function normalizePathKey(key) {
+  // Handle edge cases
+  if (key === '.' || key === '') {
+    return '';
+  }
+
+  // Use path.normalize to clean up the path, then remove leading './' if present
+  var normalized = path.normalize(key);
+
+  // Convert './filename' to 'filename' using path.relative
+  if (normalized.startsWith('./')) {
+    return path.relative('.', normalized);
+  }
+  return normalized === '.' ? '' : normalized;
+}
+
+/**
+ * Loads and processes extra files recursively with support for relative paths
+ * and circular dependency detection. Uses Promise.all for parallel loading.
+ */
+function loadSingleFile(_x, _x2, _x3, _x4, _x5, _x6, _x7, _x8, _x9) {
+  return _loadSingleFile.apply(this, arguments);
+}
+/**
+ * Loads and processes extra files recursively with support for relative paths
+ * and circular dependency detection. Uses Promise.all for parallel loading.
+ */
+function _loadSingleFile() {
+  _loadSingleFile = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(variantName, fileName, source, url, loadSource, sourceParser, sourceTransformers, loadSourceCache, transforms) {
+    var options,
+      allFilesListed,
+      knownExtraFiles,
+      _options$disableTrans,
+      disableTransforms,
+      _options$disableParsi,
+      disableParsing,
+      finalSource,
+      extraFilesFromSource,
+      extraDependenciesFromSource,
+      externalsFromSource,
+      loadPromise,
+      loadResult,
+      _i,
+      _Object$entries,
+      _Object$entries$_i,
+      extraFileName,
+      fileData,
+      _iterator,
+      _step,
+      dependency,
+      newFiles,
+      _i2,
+      _Object$keys,
+      extraFileKey,
+      message,
+      finalTransforms,
+      sourceString,
+      parseSource,
+      _args = arguments,
+      _t,
+      _t2,
+      _t3;
+    return _regenerator().w(function (_context) {
+      while (1) switch (_context.p = _context.n) {
+        case 0:
+          options = _args.length > 9 && _args[9] !== undefined ? _args[9] : {};
+          allFilesListed = _args.length > 10 && _args[10] !== undefined ? _args[10] : false;
+          knownExtraFiles = _args.length > 11 && _args[11] !== undefined ? _args[11] : new Set();
+          _options$disableTrans = options.disableTransforms, disableTransforms = _options$disableTrans === void 0 ? false : _options$disableTrans, _options$disableParsi = options.disableParsing, disableParsing = _options$disableParsi === void 0 ? false : _options$disableParsi;
+          finalSource = source;
+          if (finalSource) {
+            _context.n = 20;
+            break;
+          }
+          if (loadSource) {
+            _context.n = 1;
+            break;
+          }
+          throw new Error('"loadSource" function is required when source is not provided');
+        case 1:
+          if (url) {
+            _context.n = 2;
+            break;
+          }
+          throw new Error('URL is required when loading source');
+        case 2:
+          _context.p = 2;
+          // Check cache first to avoid duplicate loadSource calls
+          loadPromise = loadSourceCache.get(url);
+          if (!loadPromise) {
+            loadPromise = loadSource(url);
+            loadSourceCache.set(url, loadPromise);
+          }
+          _context.n = 3;
+          return loadPromise;
+        case 3:
+          loadResult = _context.v;
+          finalSource = loadResult.source;
+          extraFilesFromSource = loadResult.extraFiles;
+          extraDependenciesFromSource = loadResult.extraDependencies;
+          externalsFromSource = loadResult.externals;
+
+          // Validate that extraFiles from loadSource contain only absolute URLs as values
+          if (!extraFilesFromSource) {
+            _context.n = 7;
+            break;
+          }
+          _i = 0, _Object$entries = Object.entries(extraFilesFromSource);
+        case 4:
+          if (!(_i < _Object$entries.length)) {
+            _context.n = 7;
+            break;
+          }
+          _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2), extraFileName = _Object$entries$_i[0], fileData = _Object$entries$_i[1];
+          if (!isAbsolutePath(extraFileName)) {
+            _context.n = 5;
+            break;
+          }
+          throw new Error("Invalid extraFiles from loadSource: key \"".concat(extraFileName, "\" appears to be an absolute path. ") + "extraFiles keys should be relative paths from the current file.");
+        case 5:
+          if (!(typeof fileData === 'string' && fileData.startsWith('.'))) {
+            _context.n = 6;
+            break;
+          }
+          throw new Error("Invalid extraFiles from loadSource: \"".concat(extraFileName, "\" has relative path \"").concat(fileData, "\". ") + "All extraFiles values must be absolute URLs.");
+        case 6:
+          _i++;
+          _context.n = 4;
+          break;
+        case 7:
+          if (!extraDependenciesFromSource) {
+            _context.n = 15;
+            break;
+          }
+          _iterator = _createForOfIteratorHelper(extraDependenciesFromSource);
+          _context.p = 8;
+          _iterator.s();
+        case 9:
+          if ((_step = _iterator.n()).done) {
+            _context.n = 12;
+            break;
+          }
+          dependency = _step.value;
+          if (!dependency.startsWith('.')) {
+            _context.n = 10;
+            break;
+          }
+          throw new Error("Invalid extraDependencies from loadSource: \"".concat(dependency, "\" is a relative path. ") + "All extraDependencies must be absolute URLs.");
+        case 10:
+          if (!(dependency === url)) {
+            _context.n = 11;
+            break;
+          }
+          throw new Error("Invalid extraDependencies from loadSource: \"".concat(dependency, "\" is the same as the input URL. ") + "extraDependencies should not include the file being loaded.");
+        case 11:
+          _context.n = 9;
+          break;
+        case 12:
+          _context.n = 14;
+          break;
+        case 13:
+          _context.p = 13;
+          _t = _context.v;
+          _iterator.e(_t);
+        case 14:
+          _context.p = 14;
+          _iterator.f();
+          return _context.f(14);
+        case 15:
+          if (!(allFilesListed && (extraFilesFromSource || extraDependenciesFromSource))) {
+            _context.n = 17;
+            break;
+          }
+          newFiles = [];
+          if (extraFilesFromSource) {
+            // Check if any extraFiles keys are not in the known set
+            for (_i2 = 0, _Object$keys = Object.keys(extraFilesFromSource); _i2 < _Object$keys.length; _i2++) {
+              extraFileKey = _Object$keys[_i2];
+              if (!knownExtraFiles.has(extraFileKey)) {
+                newFiles.push(extraFileKey);
+              }
+            }
+          }
+          if (!(newFiles.length > 0)) {
+            _context.n = 17;
+            break;
+          }
+          message = "Unexpected files discovered via loadSource when allFilesListed=true (variant: ".concat(variantName, ", file: ").concat(fileName, "). ") + "New files: ".concat(newFiles.join(', '), ". ") + "Please update the loadVariantMeta function to provide the complete list of files upfront.";
+          if (!isProduction()) {
+            _context.n = 16;
+            break;
+          }
+          console.warn(message);
+          _context.n = 17;
+          break;
+        case 16:
+          throw new Error(message);
+        case 17:
+          _context.n = 20;
+          break;
+        case 18:
+          _context.p = 18;
+          _t2 = _context.v;
+          if (!(_t2 instanceof Error && (_t2.message.startsWith('Invalid extraFiles from loadSource:') || _t2.message.startsWith('Invalid extraDependencies from loadSource:') || _t2.message.startsWith('Unexpected files discovered via loadSource when allFilesListed=true')))) {
+            _context.n = 19;
+            break;
+          }
+          throw _t2;
+        case 19:
+          throw new Error("Failed to load source code (variant: ".concat(variantName, ", file: ").concat(fileName, ", url: ").concat(url, "): ").concat(JSON.stringify(_t2)));
+        case 20:
+          // Apply source transformers if no transforms exist and transforms are not disabled
+          finalTransforms = transforms;
+          if (!(sourceTransformers && !finalTransforms && !disableTransforms && finalSource)) {
+            _context.n = 22;
+            break;
+          }
+          _context.n = 21;
+          return transformSource(finalSource, normalizePathKey(fileName), sourceTransformers);
+        case 21:
+          finalTransforms = _context.v;
+        case 22:
+          if (!(typeof finalSource === 'string' && !disableParsing)) {
+            _context.n = 28;
+            break;
+          }
+          if (sourceParser) {
+            _context.n = 23;
+            break;
+          }
+          throw new Error('"sourceParser" function is required when source is a string and parsing is not disabled');
+        case 23:
+          _context.p = 23;
+          sourceString = finalSource;
+          _context.n = 24;
+          return sourceParser;
+        case 24:
+          parseSource = _context.v;
+          finalSource = parseSource(finalSource, fileName);
+          if (!(finalTransforms && !disableTransforms)) {
+            _context.n = 26;
+            break;
+          }
+          _context.n = 25;
+          return transformParsedSource(sourceString, finalSource, normalizePathKey(fileName), finalTransforms, parseSource);
+        case 25:
+          finalTransforms = _context.v;
+        case 26:
+          _context.n = 28;
+          break;
+        case 27:
+          _context.p = 27;
+          _t3 = _context.v;
+          throw new Error("Failed to parse source code (variant: ".concat(variantName, ", file: ").concat(fileName, ", url: ").concat(url, "): ").concat(_t3 instanceof Error ? _t3.message : ''));
+        case 28:
+          return _context.a(2, {
+            source: finalSource,
+            transforms: finalTransforms,
+            extraFiles: extraFilesFromSource,
+            extraDependencies: extraDependenciesFromSource,
+            externals: externalsFromSource
+          });
+      }
+    }, _callee, null, [[23, 27], [8, 13, 14, 15], [2, 18]]);
+  }));
+  return _loadSingleFile.apply(this, arguments);
+}
+function loadExtraFiles(_x0, _x1, _x10, _x11, _x12, _x13, _x14, _x15) {
+  return _loadExtraFiles.apply(this, arguments);
+}
+/**
+ * Loads a variant with support for recursive extra file loading.
+ * The loadSource function can now return extraFiles that will be loaded recursively.
+ * Supports both relative and absolute paths for extra files.
+ * Uses Promise.all for efficient parallel loading of extra files.
+ */
+function _loadExtraFiles() {
+  _loadExtraFiles = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(variantName, extraFiles, baseUrl, entryUrl,
+  // Track the original entry file URL
+  loadSource, sourceParser, sourceTransformers, loadSourceCache) {
+    var options,
+      allFilesListed,
+      knownExtraFiles,
+      globalsFileKeys,
+      _options$maxDepth,
+      maxDepth,
+      _options$loadedFiles,
+      loadedFiles,
+      processedExtraFiles,
+      allFilesUsed,
+      allExternals,
+      extraFilePromises,
+      extraFileResults,
+      nestedExtraFilesPromises,
+      _iterator2,
+      _step2,
+      _loop,
+      nestedExtraFilesResults,
+      _iterator3,
+      _step3,
+      _step3$value,
+      nestedExtraFiles,
+      nestedFilesUsed,
+      nestedExternals,
+      sourceFileKey,
+      mergedNestedExternals,
+      _i3,
+      _Object$entries2,
+      _Object$entries2$_i,
+      nestedKey,
+      nestedValue,
+      convertedKey,
+      normalizedConvertedKey,
+      _args4 = arguments,
+      _t5;
+    return _regenerator().w(function (_context4) {
+      while (1) switch (_context4.p = _context4.n) {
+        case 0:
+          options = _args4.length > 8 && _args4[8] !== undefined ? _args4[8] : {};
+          allFilesListed = _args4.length > 9 && _args4[9] !== undefined ? _args4[9] : false;
+          knownExtraFiles = _args4.length > 10 && _args4[10] !== undefined ? _args4[10] : new Set();
+          globalsFileKeys = _args4.length > 11 && _args4[11] !== undefined ? _args4[11] : new Set();
+          _options$maxDepth = options.maxDepth, maxDepth = _options$maxDepth === void 0 ? 10 : _options$maxDepth, _options$loadedFiles = options.loadedFiles, loadedFiles = _options$loadedFiles === void 0 ? new Set() : _options$loadedFiles;
+          if (!(maxDepth <= 0)) {
+            _context4.n = 1;
+            break;
+          }
+          throw new Error('Maximum recursion depth reached while loading extra files');
+        case 1:
+          processedExtraFiles = {};
+          allFilesUsed = [];
+          allExternals = {}; // Start loading all extra files in parallel
+          extraFilePromises = Object.entries(extraFiles).map(/*#__PURE__*/function () {
+            var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(_ref) {
+              var _ref3, fileName, fileData, fileUrl, sourceData, transforms, fileResult, filesUsedFromFile, externalsFromFile, _t4;
+              return _regenerator().w(function (_context2) {
+                while (1) switch (_context2.p = _context2.n) {
+                  case 0:
+                    _ref3 = _slicedToArray(_ref, 2), fileName = _ref3[0], fileData = _ref3[1];
+                    _context2.p = 1;
+                    if (!(typeof fileData === 'string')) {
+                      _context2.n = 3;
+                      break;
+                    }
+                    // fileData is a URL/path - use it directly, don't modify it
+                    fileUrl = fileData;
+
+                    // Check for circular dependencies
+                    if (!loadedFiles.has(fileUrl)) {
+                      _context2.n = 2;
+                      break;
+                    }
+                    throw new Error("Circular dependency detected: ".concat(fileUrl));
+                  case 2:
+                    loadedFiles.add(fileUrl);
+                    _context2.n = 4;
+                    break;
+                  case 3:
+                    // fileData is an object with source and/or transforms
+                    sourceData = fileData.source;
+                    transforms = fileData.transforms;
+                    fileUrl = baseUrl; // Use base URL as fallback
+                  case 4:
+                    _context2.n = 5;
+                    return loadSingleFile(variantName, fileName, sourceData, fileUrl, loadSource, sourceParser, sourceTransformers, loadSourceCache, transforms, _extends(_extends({}, options), {}, {
+                      maxDepth: maxDepth - 1,
+                      loadedFiles: new Set(loadedFiles)
+                    }), allFilesListed, knownExtraFiles);
+                  case 5:
+                    fileResult = _context2.v;
+                    // Collect files used from this file load
+                    filesUsedFromFile = [];
+                    if (typeof fileData === 'string') {
+                      filesUsedFromFile.push(fileUrl);
+                    }
+                    if (fileResult.extraDependencies) {
+                      filesUsedFromFile.push.apply(filesUsedFromFile, _toConsumableArray(fileResult.extraDependencies));
+                    }
+
+                    // Collect externals from this file load
+                    externalsFromFile = {};
+                    if (fileResult.externals) {
+                      Object.assign(externalsFromFile, fileResult.externals);
+                    }
+                    return _context2.a(2, {
+                      fileName: fileName,
+                      result: fileResult,
+                      filesUsed: filesUsedFromFile,
+                      externals: externalsFromFile
+                    });
+                  case 6:
+                    _context2.p = 6;
+                    _t4 = _context2.v;
+                    throw new Error("Failed to load extra file (variant: ".concat(variantName, ", file: ").concat(fileName, ", url: ").concat(baseUrl, "): ").concat(_t4 instanceof Error ? _t4.message : ''));
+                  case 7:
+                    return _context2.a(2);
+                }
+              }, _callee2, null, [[1, 6]]);
+            }));
+            return function (_x19) {
+              return _ref2.apply(this, arguments);
+            };
+          }()); // Wait for all extra files to load
+          _context4.n = 2;
+          return Promise.all(extraFilePromises);
+        case 2:
+          extraFileResults = _context4.v;
+          // Process results and handle nested extra files
+          nestedExtraFilesPromises = [];
+          _iterator2 = _createForOfIteratorHelper(extraFileResults);
+          _context4.p = 3;
+          _loop = /*#__PURE__*/_regenerator().m(function _loop() {
+            var _step2$value, fileName, result, filesUsed, externals, normalizedFileName, originalFileData, metadata, mergedExternals, sourceFileUrl, fileData;
+            return _regenerator().w(function (_context3) {
+              while (1) switch (_context3.n) {
+                case 0:
+                  _step2$value = _step2.value, fileName = _step2$value.fileName, result = _step2$value.result, filesUsed = _step2$value.filesUsed, externals = _step2$value.externals;
+                  normalizedFileName = normalizePathKey(fileName);
+                  originalFileData = extraFiles[fileName]; // Preserve metadata flag if it exists in the original data, or if this file came from globals
+                  if (typeof originalFileData !== 'string') {
+                    metadata = originalFileData.metadata;
+                  } else if (globalsFileKeys.has(fileName)) {
+                    metadata = true;
+                  }
+                  processedExtraFiles[normalizedFileName] = _extends({
+                    source: result.source,
+                    transforms: result.transforms
+                  }, metadata !== undefined && {
+                    metadata: metadata
+                  });
+
+                  // Add files used from this file load
+                  allFilesUsed.push.apply(allFilesUsed, _toConsumableArray(filesUsed));
+
+                  // Add externals from this file load using proper merging
+                  mergedExternals = mergeExternals([allExternals, externals]);
+                  Object.assign(allExternals, mergedExternals);
+
+                  // Collect promises for nested extra files with their source key
+                  if (result.extraFiles) {
+                    sourceFileUrl = baseUrl;
+                    fileData = extraFiles[fileName];
+                    if (typeof fileData === 'string') {
+                      sourceFileUrl = fileData; // Use the URL directly, don't modify it
+                    }
+                    nestedExtraFilesPromises.push(loadExtraFiles(variantName, result.extraFiles, sourceFileUrl,
+                    // Use the source file's URL as base for its extra files
+                    entryUrl,
+                    // Keep the entry URL for final conversion
+                    loadSource, sourceParser, sourceTransformers, loadSourceCache, _extends(_extends({}, options), {}, {
+                      maxDepth: maxDepth - 1,
+                      loadedFiles: new Set(loadedFiles)
+                    }), allFilesListed, knownExtraFiles, globalsFileKeys // Pass through globals file tracking
+                    ).then(function (nestedResult) {
+                      return {
+                        files: nestedResult.extraFiles,
+                        allFilesUsed: nestedResult.allFilesUsed,
+                        allExternals: nestedResult.allExternals,
+                        sourceFileKey: normalizedFileName // Pass the normalized key
+                      };
+                    }));
+                  }
+                case 1:
+                  return _context3.a(2);
+              }
+            }, _loop);
+          });
+          _iterator2.s();
+        case 4:
+          if ((_step2 = _iterator2.n()).done) {
+            _context4.n = 6;
+            break;
+          }
+          return _context4.d(_regeneratorValues(_loop()), 5);
+        case 5:
+          _context4.n = 4;
+          break;
+        case 6:
+          _context4.n = 8;
+          break;
+        case 7:
+          _context4.p = 7;
+          _t5 = _context4.v;
+          _iterator2.e(_t5);
+        case 8:
+          _context4.p = 8;
+          _iterator2.f();
+          return _context4.f(8);
+        case 9:
+          if (!(nestedExtraFilesPromises.length > 0)) {
+            _context4.n = 11;
+            break;
+          }
+          _context4.n = 10;
+          return Promise.all(nestedExtraFilesPromises);
+        case 10:
+          nestedExtraFilesResults = _context4.v;
+          _iterator3 = _createForOfIteratorHelper(nestedExtraFilesResults);
+          try {
+            for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+              _step3$value = _step3.value, nestedExtraFiles = _step3$value.files, nestedFilesUsed = _step3$value.allFilesUsed, nestedExternals = _step3$value.allExternals, sourceFileKey = _step3$value.sourceFileKey;
+              // Add nested files used
+              allFilesUsed.push.apply(allFilesUsed, _toConsumableArray(nestedFilesUsed));
+
+              // Add nested externals using proper merging
+              mergedNestedExternals = mergeExternals([allExternals, nestedExternals]);
+              Object.assign(allExternals, mergedNestedExternals);
+              for (_i3 = 0, _Object$entries2 = Object.entries(nestedExtraFiles); _i3 < _Object$entries2.length; _i3++) {
+                _Object$entries2$_i = _slicedToArray(_Object$entries2[_i3], 2), nestedKey = _Object$entries2$_i[0], nestedValue = _Object$entries2$_i[1];
+                // Convert the key based on the directory structure of the source key
+                convertedKey = convertKeyBasedOnDirectory(nestedKey, sourceFileKey);
+                normalizedConvertedKey = normalizePathKey(convertedKey);
+                processedExtraFiles[normalizedConvertedKey] = nestedValue;
+              }
+            }
+          } catch (err) {
+            _iterator3.e(err);
+          } finally {
+            _iterator3.f();
+          }
+        case 11:
+          return _context4.a(2, {
+            extraFiles: processedExtraFiles,
+            allFilesUsed: allFilesUsed,
+            allExternals: allExternals
+          });
+      }
+    }, _callee3, null, [[3, 7, 8, 9]]);
+  }));
+  return _loadExtraFiles.apply(this, arguments);
+}
+export function loadVariant(_x16, _x17, _x18) {
+  return _loadVariant.apply(this, arguments);
+}
+function _loadVariant() {
+  _loadVariant = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5(url, variantName, variant) {
+    var options,
+      sourceParser,
+      loadSource,
+      loadVariantMeta,
+      sourceTransformers,
+      globalsCode,
+      loadSourceCache,
+      _getFileNameFromUrl,
+      _fileName,
+      loadedFiles,
+      allFilesUsed,
+      allExternals,
+      knownExtraFiles,
+      _i4,
+      _Object$keys2,
+      extraFileName,
+      fileName,
+      _finalVariant,
+      mainFileResult,
+      allExtraFiles,
+      _i5,
+      _Object$keys3,
+      _extraFileName,
+      extraFilesToLoad,
+      globalsFileKeys,
+      existingFiles,
+      _i6,
+      _Object$keys4,
+      key,
+      globalsPromises,
+      globalsResults,
+      _iterator4,
+      _step4,
+      globalsResult,
+      _i7,
+      _Object$entries3,
+      _Object$entries3$_i,
+      _key,
+      value,
+      conflictFreeKey,
+      loadableFiles,
+      _i8,
+      _Object$entries4,
+      _Object$entries4$_i,
+      _key2,
+      _value,
+      _i9,
+      _Object$entries5,
+      _Object$entries5$_i,
+      _key3,
+      _value2,
+      metadata,
+      urlFilesToLoad,
+      _i0,
+      _Object$entries6,
+      _Object$entries6$_i,
+      _key4,
+      _value3,
+      extraFilesResult,
+      _extraFilesResult,
+      finalVariant,
+      _args6 = arguments,
+      _t8;
+    return _regenerator().w(function (_context6) {
+      while (1) switch (_context6.p = _context6.n) {
+        case 0:
+          options = _args6.length > 3 && _args6[3] !== undefined ? _args6[3] : {};
+          if (variant) {
+            _context6.n = 1;
+            break;
+          }
+          throw new Error("Variant is missing from code: ".concat(variantName));
+        case 1:
+          sourceParser = options.sourceParser, loadSource = options.loadSource, loadVariantMeta = options.loadVariantMeta, sourceTransformers = options.sourceTransformers, globalsCode = options.globalsCode; // Create a cache for loadSource calls scoped to this loadVariant call
+          loadSourceCache = new Map();
+          if (!(typeof variant === 'string')) {
+            _context6.n = 6;
+            break;
+          }
+          if (loadVariantMeta) {
+            _context6.n = 3;
+            break;
+          }
+          // Create a basic loadVariantMeta function as fallback
+          _getFileNameFromUrl = getFileNameFromUrl(variant), _fileName = _getFileNameFromUrl.fileName;
+          if (_fileName) {
+            _context6.n = 2;
+            break;
+          }
+          throw new Error("Cannot determine fileName from URL \"".concat(variant, "\" for variant \"").concat(variantName, "\". ") + "Please provide a loadVariantMeta function or ensure the URL has a valid file extension.");
+        case 2:
+          variant = {
+            url: variant,
+            fileName: _fileName
+          };
+          _context6.n = 6;
+          break;
+        case 3:
+          _context6.p = 3;
+          _context6.n = 4;
+          return loadVariantMeta(variantName, variant);
+        case 4:
+          variant = _context6.v;
+          _context6.n = 6;
+          break;
+        case 5:
+          _context6.p = 5;
+          _t8 = _context6.v;
+          throw new Error("Failed to load variant code (variant: ".concat(variantName, ", url: ").concat(variant, "): ").concat(JSON.stringify(_t8)));
+        case 6:
+          loadedFiles = new Set();
+          if (url) {
+            loadedFiles.add(url);
+          }
+          allFilesUsed = url ? [url] : []; // Start with the main file URL if available
+          allExternals = {}; // Collect externals from all sources
+          // Build set of known extra files from variant definition
+          knownExtraFiles = new Set();
+          if (variant.extraFiles) {
+            for (_i4 = 0, _Object$keys2 = Object.keys(variant.extraFiles); _i4 < _Object$keys2.length; _i4++) {
+              extraFileName = _Object$keys2[_i4];
+              knownExtraFiles.add(extraFileName);
+            }
+          }
+
+          // Load main file
+          fileName = variant.fileName || (url ? getFileNameFromUrl(url).fileName : undefined); // If we don't have a fileName and no URL, we can't parse or transform but can still return the code
+          if (!(!fileName && !url)) {
+            _context6.n = 7;
+            break;
+          }
+          // Return the variant as-is without parsing or transforms
+          _finalVariant = _extends(_extends({}, variant), {}, {
+            source: typeof variant.source === 'string' ? {
+              type: 'root',
+              children: [{
+                type: 'text',
+                value: variant.source || ''
+              }]
+            } : variant.source
+          });
+          return _context6.a(2, {
+            code: _finalVariant,
+            dependencies: [],
+            // No dependencies without URL
+            externals: {} // No externals without URL
+          });
+        case 7:
+          if (fileName) {
+            _context6.n = 8;
+            break;
+          }
+          throw new Error("No fileName available for variant \"".concat(variantName, "\". ") + "Please provide a fileName in the variant definition or ensure the URL has a valid file extension.");
+        case 8:
+          _context6.n = 9;
+          return loadSingleFile(variantName, fileName, variant.source, url, loadSource, sourceParser, sourceTransformers, loadSourceCache, variant.transforms, _extends(_extends({}, options), {}, {
+            loadedFiles: loadedFiles
+          }), variant.allFilesListed || false, knownExtraFiles);
+        case 9:
+          mainFileResult = _context6.v;
+          // Add files used from main file loading
+          if (mainFileResult.extraDependencies) {
+            allFilesUsed.push.apply(allFilesUsed, _toConsumableArray(mainFileResult.extraDependencies));
+          }
+
+          // Add externals from main file loading
+          if (mainFileResult.externals) {
+            allExternals = mergeExternals([allExternals, mainFileResult.externals]);
+          }
+          allExtraFiles = {}; // Validate extraFiles keys from variant definition
+          if (!variant.extraFiles) {
+            _context6.n = 12;
+            break;
+          }
+          _i5 = 0, _Object$keys3 = Object.keys(variant.extraFiles);
+        case 10:
+          if (!(_i5 < _Object$keys3.length)) {
+            _context6.n = 12;
+            break;
+          }
+          _extraFileName = _Object$keys3[_i5];
+          if (!isAbsolutePath(_extraFileName)) {
+            _context6.n = 11;
+            break;
+          }
+          throw new Error("Invalid extraFiles key in variant: \"".concat(_extraFileName, "\" appears to be an absolute path. ") + "extraFiles keys in variant definition should be relative paths from the main file.");
+        case 11:
+          _i5++;
+          _context6.n = 10;
+          break;
+        case 12:
+          // Collect extra files from variant definition and from loaded source
+          extraFilesToLoad = _extends(_extends({}, variant.extraFiles || {}), mainFileResult.extraFiles || {}); // Track which files come from globals for metadata marking
+          globalsFileKeys = new Set(); // Track globals file keys for loadExtraFiles
+          // Process globalsCode array and add to extraFiles if provided
+          if (!(globalsCode && globalsCode.length > 0)) {
+            _context6.n = 14;
+            break;
+          }
+          // Collect existing filenames to avoid conflicts
+          existingFiles = new Set(); // Add main variant filename if it exists
+          if (variant.fileName) {
+            existingFiles.add(variant.fileName);
+          }
+
+          // Add already loaded extra files
+          for (_i6 = 0, _Object$keys4 = Object.keys(extraFilesToLoad); _i6 < _Object$keys4.length; _i6++) {
+            key = _Object$keys4[_i6];
+            existingFiles.add(key);
+          }
+
+          // Process all globals items in parallel
+          globalsPromises = globalsCode.map(/*#__PURE__*/function () {
+            var _ref4 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(globalsItem) {
+              var globalsVariant, _getFileNameFromUrl2, globalsFileName, globalsResult, _t6, _t7;
+              return _regenerator().w(function (_context5) {
+                while (1) switch (_context5.p = _context5.n) {
+                  case 0:
+                    if (!(typeof globalsItem === 'string')) {
+                      _context5.n = 6;
+                      break;
+                    }
+                    if (loadVariantMeta) {
+                      _context5.n = 2;
+                      break;
+                    }
+                    // Create a basic variant as fallback
+                    _getFileNameFromUrl2 = getFileNameFromUrl(globalsItem), globalsFileName = _getFileNameFromUrl2.fileName;
+                    if (globalsFileName) {
+                      _context5.n = 1;
+                      break;
+                    }
+                    throw new Error("Cannot determine fileName from globalsCode URL \"".concat(globalsItem, "\". ") + "Please provide a loadVariantMeta function or ensure the URL has a valid file extension.");
+                  case 1:
+                    globalsVariant = {
+                      url: globalsItem,
+                      fileName: globalsFileName
+                    };
+                    _context5.n = 5;
+                    break;
+                  case 2:
+                    _context5.p = 2;
+                    _context5.n = 3;
+                    return loadVariantMeta(variantName, globalsItem);
+                  case 3:
+                    globalsVariant = _context5.v;
+                    _context5.n = 5;
+                    break;
+                  case 4:
+                    _context5.p = 4;
+                    _t6 = _context5.v;
+                    throw new Error("Failed to load globalsCode variant metadata (variant: ".concat(variantName, ", url: ").concat(globalsItem, "): ").concat(JSON.stringify(_t6)));
+                  case 5:
+                    _context5.n = 7;
+                    break;
+                  case 6:
+                    globalsVariant = globalsItem;
+                  case 7:
+                    _context5.p = 7;
+                    _context5.n = 8;
+                    return loadVariant(globalsVariant.url, variantName, globalsVariant, _extends(_extends({}, options), {}, {
+                      globalsCode: undefined
+                    }) // Prevent infinite recursion
+                    );
+                  case 8:
+                    globalsResult = _context5.v;
+                    return _context5.a(2, globalsResult);
+                  case 9:
+                    _context5.p = 9;
+                    _t7 = _context5.v;
+                    throw new Error("Failed to load globalsCode (variant: ".concat(variantName, "): ").concat(_t7 instanceof Error ? _t7.message : JSON.stringify(_t7)));
+                  case 10:
+                    return _context5.a(2);
+                }
+              }, _callee4, null, [[7, 9], [2, 4]]);
+            }));
+            return function (_x20) {
+              return _ref4.apply(this, arguments);
+            };
+          }()); // Wait for all globals to load
+          _context6.n = 13;
+          return Promise.all(globalsPromises);
+        case 13:
+          globalsResults = _context6.v;
+          // Merge results from all globals
+          _iterator4 = _createForOfIteratorHelper(globalsResults);
+          try {
+            for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+              globalsResult = _step4.value;
+              // Add globals extraFiles (but NOT the main file)
+              if (globalsResult.code.extraFiles) {
+                // Add globals extra files with conflict-free naming and metadata flag
+                for (_i7 = 0, _Object$entries3 = Object.entries(globalsResult.code.extraFiles); _i7 < _Object$entries3.length; _i7++) {
+                  _Object$entries3$_i = _slicedToArray(_Object$entries3[_i7], 2), _key = _Object$entries3$_i[0], value = _Object$entries3$_i[1];
+                  conflictFreeKey = generateConflictFreeFilename(_key, existingFiles); // Always add metadata: true flag for globals files
+                  if (typeof value === 'string') {
+                    // For string URLs, we can't easily wrap them but need to track for later metadata addition
+                    extraFilesToLoad[conflictFreeKey] = value;
+                    globalsFileKeys.add(conflictFreeKey); // Track for loadExtraFiles
+                  } else {
+                    // For object values, add metadata directly
+                    extraFilesToLoad[conflictFreeKey] = _extends(_extends({}, value), {}, {
+                      metadata: true
+                    });
+                  }
+                  existingFiles.add(conflictFreeKey); // Track the added file for subsequent iterations
+                }
+              }
+
+              // Add globals dependencies
+              allFilesUsed.push.apply(allFilesUsed, _toConsumableArray(globalsResult.dependencies));
+
+              // Add globals externals
+              allExternals = mergeExternals([allExternals, globalsResult.externals]);
+            }
+          } catch (err) {
+            _iterator4.e(err);
+          } finally {
+            _iterator4.f();
+          }
+        case 14:
+          if (!(Object.keys(extraFilesToLoad).length > 0)) {
+            _context6.n = 19;
+            break;
+          }
+          if (url) {
+            _context6.n = 17;
+            break;
+          }
+          // If there's no URL, we can only load extra files that have inline source or absolute URLs
+          loadableFiles = {};
+          for (_i8 = 0, _Object$entries4 = Object.entries(extraFilesToLoad); _i8 < _Object$entries4.length; _i8++) {
+            _Object$entries4$_i = _slicedToArray(_Object$entries4[_i8], 2), _key2 = _Object$entries4$_i[0], _value = _Object$entries4$_i[1];
+            if (typeof _value !== 'string' && _value.source !== undefined) {
+              // Inline source - can always load
+              loadableFiles[_key2] = _value;
+            } else if (typeof _value === 'string' && isAbsolutePath(_value)) {
+              // Absolute URL - can load without base URL
+              loadableFiles[_key2] = _value;
+            } else {
+              console.warn("Skipping extra file \"".concat(_key2, "\" - no URL provided and file requires loading from external source"));
+            }
+          }
+          if (!(Object.keys(loadableFiles).length > 0)) {
+            _context6.n = 16;
+            break;
+          }
+          // Process loadable files: inline sources without URL-based loading, absolute URLs with loading
+          for (_i9 = 0, _Object$entries5 = Object.entries(loadableFiles); _i9 < _Object$entries5.length; _i9++) {
+            _Object$entries5$_i = _slicedToArray(_Object$entries5[_i9], 2), _key3 = _Object$entries5$_i[0], _value2 = _Object$entries5$_i[1];
+            if (typeof _value2 !== 'string') {
+              // Inline source - preserve metadata if it was marked as globals
+              metadata = _value2.metadata || globalsFileKeys.has(_key3) ? true : undefined;
+              allExtraFiles[normalizePathKey(_key3)] = _extends({
+                source: _value2.source,
+                transforms: _value2.transforms
+              }, metadata !== undefined && {
+                metadata: metadata
+              });
+            }
+          }
+
+          // For absolute URLs, we need to load them
+          urlFilesToLoad = {};
+          for (_i0 = 0, _Object$entries6 = Object.entries(loadableFiles); _i0 < _Object$entries6.length; _i0++) {
+            _Object$entries6$_i = _slicedToArray(_Object$entries6[_i0], 2), _key4 = _Object$entries6$_i[0], _value3 = _Object$entries6$_i[1];
+            if (typeof _value3 === 'string') {
+              urlFilesToLoad[_key4] = _value3;
+            }
+          }
+          if (!(Object.keys(urlFilesToLoad).length > 0)) {
+            _context6.n = 16;
+            break;
+          }
+          _context6.n = 15;
+          return loadExtraFiles(variantName, urlFilesToLoad, '',
+          // No base URL needed for absolute URLs
+          '',
+          // No entry URL
+          loadSource, sourceParser, sourceTransformers, loadSourceCache, _extends(_extends({}, options), {}, {
+            loadedFiles: loadedFiles
+          }), variant.allFilesListed || false, knownExtraFiles, globalsFileKeys // Pass globals file tracking
+          );
+        case 15:
+          extraFilesResult = _context6.v;
+          allExtraFiles = _extends(_extends({}, allExtraFiles), extraFilesResult.extraFiles);
+          allFilesUsed.push.apply(allFilesUsed, _toConsumableArray(extraFilesResult.allFilesUsed));
+          allExternals = mergeExternals([allExternals, extraFilesResult.allExternals]);
+        case 16:
+          _context6.n = 19;
+          break;
+        case 17:
+          _context6.n = 18;
+          return loadExtraFiles(variantName, extraFilesToLoad, url, url,
+          // Entry URL is the same as the main file URL
+          loadSource, sourceParser, sourceTransformers, loadSourceCache, _extends(_extends({}, options), {}, {
+            loadedFiles: loadedFiles
+          }), variant.allFilesListed || false, knownExtraFiles, globalsFileKeys // Pass globals file tracking
+          );
+        case 18:
+          _extraFilesResult = _context6.v;
+          allExtraFiles = _extraFilesResult.extraFiles;
+          allFilesUsed.push.apply(allFilesUsed, _toConsumableArray(_extraFilesResult.allFilesUsed));
+          allExternals = mergeExternals([allExternals, _extraFilesResult.allExternals]);
+        case 19:
+          // Note: metadata marking is now handled during loadExtraFiles processing
+          finalVariant = _extends(_extends({}, variant), {}, {
+            source: mainFileResult.source,
+            transforms: mainFileResult.transforms,
+            extraFiles: Object.keys(allExtraFiles).length > 0 ? allExtraFiles : undefined,
+            externals: Object.keys(allExternals).length > 0 ? Object.keys(allExternals) : undefined
+          });
+          return _context6.a(2, {
+            code: finalVariant,
+            dependencies: Array.from(new Set(allFilesUsed)),
+            // Remove duplicates
+            externals: allExternals
+          });
+      }
+    }, _callee5, null, [[3, 5]]);
+  }));
+  return _loadVariant.apply(this, arguments);
+}