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

package/esm/pipeline/loadCodeVariant/loadCodeVariant.js

@@ -1,10 +1,3 @@
-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 { compress, strToU8 } from 'fflate';
 import { encode } from 'uint8-to-base64';
@@ -13,10 +6,9 @@ import { diffHast } from "./diffHast.js";
 import { getFileNameFromUrl, getLanguageFromExtension, normalizeLanguage } from "../loaderUtils/index.js";
 import { mergeExternals } from "../loaderUtils/mergeExternals.js";
 import { performanceMeasure } from "../loadPrecomputedCodeHighlighter/performanceLogger.js";
-function compressAsync(input) {
-  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  return new Promise(function (resolve, reject) {
-    compress(input, options, function (err, output) {
+function compressAsync(input, options = {}) {
+  return new Promise((resolve, reject) => {
+    compress(input, options, (err, output) => {
       if (err) {
         reject(err);
       } else {
@@ -47,21 +39,21 @@ function generateConflictFreeFilename(originalFilename, existingFiles) {
   }
 
   // Try with global_ prefix
-  var globalFilename = "global_".concat(originalFilename);
+  const globalFilename = `global_${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;
+  const parsed = path.parse(originalFilename);
+  const nameWithoutExt = parsed.name;
+  const extension = parsed.ext;
 
   // Add numbers until we find a free name, preserving extension
-  var counter = 1;
-  var candidateName;
+  let counter = 1;
+  let candidateName;
   do {
-    candidateName = "global_".concat(nameWithoutExt, "_").concat(counter).concat(extension);
+    candidateName = `global_${nameWithoutExt}_${counter}${extension}`;
     counter += 1;
   } while (existingFiles.has(candidateName));
   return candidateName;
@@ -80,13 +72,13 @@ function convertKeyBasedOnDirectory(nestedKey, sourceFileKey) {
   }
 
   // Treat bare filenames as relative to current directory (same as ./filename)
-  var processedNestedKey = nestedKey;
+  let processedNestedKey = nestedKey;
   if (!nestedKey.startsWith('.')) {
-    processedNestedKey = "./".concat(nestedKey);
+    processedNestedKey = `./${nestedKey}`;
   }
 
   // Get the directory of the source file
-  var sourceDir = path.dirname(sourceFileKey);
+  const sourceDir = path.dirname(sourceFileKey);
 
   // If sourceDir is '.' (current directory), just return the processed nested key
   // This avoids path.resolve which can produce absolute paths on Windows
@@ -97,10 +89,10 @@ function convertKeyBasedOnDirectory(nestedKey, sourceFileKey) {
 
   // Use path.join instead of path.resolve to avoid producing absolute paths
   // path.join keeps paths relative, while path.resolve can make them absolute
-  var joinedPath = path.join(sourceDir, processedNestedKey);
+  const joinedPath = path.join(sourceDir, processedNestedKey);
 
   // Normalize the path to clean up any ../ or ./ segments
-  var normalizedPath = path.normalize(joinedPath);
+  const normalizedPath = path.normalize(joinedPath);
 
   // Ensure we return a clean relative path (remove leading './' if present after normalization)
   if (normalizedPath.startsWith('./')) {
@@ -119,7 +111,7 @@ function normalizePathKey(key) {
   }
 
   // Use path.normalize to clean up the path, then remove leading './' if present
-  var normalized = path.normalize(key);
+  const normalized = path.normalize(key);
 
   // Convert './filename' to 'filename' using path.relative
   if (normalized.startsWith('./')) {
@@ -132,1092 +124,700 @@ function normalizePathKey(key) {
  * 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,
-      language,
-      _options$disableTrans,
-      disableTransforms,
-      _options$disableParsi,
-      disableParsing,
-      finalSource,
-      extraFilesFromSource,
-      extraDependenciesFromSource,
-      externalsFromSource,
-      functionName,
-      currentMark,
-      loadPromise,
-      loadResult,
-      _i,
-      _Object$entries,
-      _Object$entries$_i,
-      extraFileName,
-      fileData,
-      _iterator,
-      _step,
-      dependency,
-      newFiles,
-      _i2,
-      _Object$keys,
-      extraFileKey,
-      message,
-      finalTransforms,
-      sourceString,
-      parseSource,
-      hastGzip,
-      _args = arguments,
-      _t,
-      _t2,
-      _t3,
-      _t4;
-    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();
-          language = _args.length > 12 ? _args[12] : undefined;
-          _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;
-          functionName = 'Load Variant File';
-          currentMark = performanceMeasure(undefined, {
-            mark: 'Start',
-            measure: 'Start'
-          }, [functionName, url || fileName], true); // Load source if not provided
-          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;
-          currentMark = performanceMeasure(currentMark, {
-            mark: 'Loaded File',
-            measure: 'File Loading'
-          }, [functionName, url]);
-
-          // 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;
+
+async function loadSingleFile(variantName, fileName, source, url, loadSource, sourceParser, sourceTransformers, loadSourceCache, transforms, options = {}, allFilesListed = false, knownExtraFiles = new Set(), language) {
+  const {
+    disableTransforms = false,
+    disableParsing = false
+  } = options;
+  let finalSource = source;
+  let extraFilesFromSource;
+  let extraDependenciesFromSource;
+  let externalsFromSource;
+  const functionName = 'Load Variant File';
+  let currentMark = performanceMeasure(undefined, {
+    mark: 'Start',
+    measure: 'Start'
+  }, [functionName, url || fileName], true);
+
+  // Load source if not provided
+  if (!finalSource) {
+    if (!loadSource) {
+      throw new Error('"loadSource" function is required when source is not provided');
+    }
+    if (!url) {
+      throw new Error('URL is required when loading source');
+    }
+    try {
+      // Check cache first to avoid duplicate loadSource calls
+      let loadPromise = loadSourceCache.get(url);
+      if (!loadPromise) {
+        loadPromise = loadSource(url);
+        loadSourceCache.set(url, loadPromise);
+      }
+      const loadResult = await loadPromise;
+      finalSource = loadResult.source;
+      extraFilesFromSource = loadResult.extraFiles;
+      extraDependenciesFromSource = loadResult.extraDependencies;
+      externalsFromSource = loadResult.externals;
+      currentMark = performanceMeasure(currentMark, {
+        mark: 'Loaded File',
+        measure: 'File Loading'
+      }, [functionName, url]);
+
+      // Validate that extraFiles from loadSource contain only absolute URLs as values
+      if (extraFilesFromSource) {
+        for (const [extraFileName, fileData] of Object.entries(extraFilesFromSource)) {
+          // Validate that keys are relative paths (not absolute)
+          if (isAbsolutePath(extraFileName)) {
+            throw new Error(`Invalid extraFiles from loadSource: key "${extraFileName}" appears to be an absolute path. ` + `extraFiles keys should be relative paths from the current file.`);
+          }
+
+          // Validate that values are absolute URLs (not relative paths)
+          if (typeof fileData === 'string' && fileData.startsWith('.')) {
+            throw new Error(`Invalid extraFiles from loadSource: "${extraFileName}" has relative path "${fileData}". ` + `All extraFiles values must be absolute URLs.`);
+          }
+        }
+      }
+
+      // Validate that extraDependencies from loadSource contain only absolute URLs
+      if (extraDependenciesFromSource) {
+        for (const dependency of extraDependenciesFromSource) {
+          if (dependency.startsWith('.')) {
+            throw new Error(`Invalid extraDependencies from loadSource: "${dependency}" is a relative path. ` + `All extraDependencies must be absolute URLs.`);
           }
-          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;
+          if (dependency === url) {
+            throw new Error(`Invalid extraDependencies from loadSource: "${dependency}" is the same as the input URL. ` + `extraDependencies should not include the file being loaded.`);
           }
-          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);
-              }
+        }
+      }
+
+      // Check for new files when allFilesListed is enabled
+      if (allFilesListed && (extraFilesFromSource || extraDependenciesFromSource)) {
+        const newFiles = [];
+        if (extraFilesFromSource) {
+          // Check if any extraFiles keys are not in the known set
+          for (const extraFileKey of Object.keys(extraFilesFromSource)) {
+            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;
-          currentMark = performanceMeasure(currentMark, {
-            mark: 'Transformed File',
-            measure: 'File Transforming'
-          }, [functionName, url || fileName]);
-        case 22:
-          if (!(typeof finalSource === 'string' && !disableParsing)) {
-            _context.n = 31;
-            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, language);
-          currentMark = performanceMeasure(currentMark, {
-            mark: 'Parsed File',
-            measure: 'File Parsing'
-          }, [functionName, url || fileName]);
-          if (!(finalTransforms && !disableTransforms)) {
-            _context.n = 26;
-            break;
-          }
-          _context.n = 25;
-          return diffHast(sourceString, finalSource, normalizePathKey(fileName), finalTransforms, parseSource);
-        case 25:
-          finalTransforms = _context.v;
-          currentMark = performanceMeasure(currentMark, {
-            mark: 'Transform Parsed File',
-            measure: 'Parsed File Transforming'
-          }, [functionName, url || fileName]);
-        case 26:
-          if (!(options.output === 'hastGzip' && process.env.NODE_ENV === 'production')) {
-            _context.n = 28;
-            break;
-          }
-          _t3 = encode;
-          _context.n = 27;
-          return compressAsync(strToU8(JSON.stringify(finalSource)), {
-            consume: true,
-            level: 9
-          });
-        case 27:
-          hastGzip = _t3(_context.v);
-          finalSource = {
-            hastGzip: hastGzip
-          };
-          currentMark = performanceMeasure(currentMark, {
-            mark: 'Compressed File',
-            measure: 'File Compression'
-          }, [functionName, url || fileName]);
-          _context.n = 29;
-          break;
-        case 28:
-          if (options.output === 'hastJson' || options.output === 'hastGzip') {
-            // in development, we skip compression but still convert to JSON
-            finalSource = {
-              hastJson: JSON.stringify(finalSource)
-            };
-            performanceMeasure(currentMark, {
-              mark: 'JSON Stringified File',
-              measure: 'File Stringification'
-            }, [functionName, url || fileName]);
+        }
+        if (newFiles.length > 0) {
+          const message = `Unexpected files discovered via loadSource when allFilesListed=true (variant: ${variantName}, file: ${fileName}). ` + `New files: ${newFiles.join(', ')}. ` + `Please update the loadVariantMeta function to provide the complete list of files upfront.`;
+          if (isProduction()) {
+            console.warn(message);
+          } else {
+            throw new Error(message);
           }
-        case 29:
-          _context.n = 31;
-          break;
-        case 30:
-          _context.p = 30;
-          _t4 = _context.v;
-          throw new Error("Failed to parse source code (variant: ".concat(variantName, ", file: ").concat(fileName, ", url: ").concat(url, "): ").concat(_t4 instanceof Error ? _t4.message : ''));
-        case 31:
-          return _context.a(2, {
-            source: finalSource,
-            transforms: finalTransforms,
-            extraFiles: extraFilesFromSource,
-            extraDependencies: extraDependenciesFromSource,
-            externals: externalsFromSource
-          });
+        }
       }
-    }, _callee, null, [[23, 30], [8, 13, 14, 15], [2, 18]]);
-  }));
-  return _loadSingleFile.apply(this, arguments);
+    } catch (error) {
+      // Re-throw validation errors without wrapping them
+      if (error instanceof Error && (error.message.startsWith('Invalid extraFiles from loadSource:') || error.message.startsWith('Invalid extraDependencies from loadSource:') || error.message.startsWith('Unexpected files discovered via loadSource when allFilesListed=true'))) {
+        throw error;
+      }
+      throw new Error(`Failed to load source code (variant: ${variantName}, file: ${fileName}, url: ${url}): ${JSON.stringify(error)}`);
+    }
+  }
+
+  // Apply source transformers if no transforms exist and transforms are not disabled
+  let finalTransforms = transforms;
+  if (sourceTransformers && !finalTransforms && !disableTransforms && finalSource) {
+    finalTransforms = await transformSource(finalSource, normalizePathKey(fileName), sourceTransformers);
+    currentMark = performanceMeasure(currentMark, {
+      mark: 'Transformed File',
+      measure: 'File Transforming'
+    }, [functionName, url || fileName]);
+  }
+
+  // Parse source if it's a string and parsing is not disabled
+  if (typeof finalSource === 'string' && !disableParsing) {
+    if (!sourceParser) {
+      throw new Error('"sourceParser" function is required when source is a string and parsing is not disabled');
+    }
+    try {
+      const sourceString = finalSource;
+      const parseSource = await sourceParser;
+      finalSource = parseSource(finalSource, fileName, language);
+      currentMark = performanceMeasure(currentMark, {
+        mark: 'Parsed File',
+        measure: 'File Parsing'
+      }, [functionName, url || fileName]);
+      if (finalTransforms && !disableTransforms) {
+        finalTransforms = await diffHast(sourceString, finalSource, normalizePathKey(fileName), finalTransforms, parseSource);
+        currentMark = performanceMeasure(currentMark, {
+          mark: 'Transform Parsed File',
+          measure: 'Parsed File Transforming'
+        }, [functionName, url || fileName]);
+      }
+      if (options.output === 'hastGzip' && process.env.NODE_ENV === 'production') {
+        const hastGzip = encode(await compressAsync(strToU8(JSON.stringify(finalSource)), {
+          consume: true,
+          level: 9
+        }));
+        finalSource = {
+          hastGzip
+        };
+        currentMark = performanceMeasure(currentMark, {
+          mark: 'Compressed File',
+          measure: 'File Compression'
+        }, [functionName, url || fileName]);
+      } else if (options.output === 'hastJson' || options.output === 'hastGzip') {
+        // in development, we skip compression but still convert to JSON
+        finalSource = {
+          hastJson: JSON.stringify(finalSource)
+        };
+        performanceMeasure(currentMark, {
+          mark: 'JSON Stringified File',
+          measure: 'File Stringification'
+        }, [functionName, url || fileName]);
+      }
+    } catch (error) {
+      throw new Error(`Failed to parse source code (variant: ${variantName}, file: ${fileName}, url: ${url}): ${error instanceof Error ? error.message : ''}`);
+    }
+  }
+  return {
+    source: finalSource,
+    transforms: finalTransforms,
+    extraFiles: extraFilesFromSource,
+    extraDependencies: extraDependenciesFromSource,
+    externals: externalsFromSource
+  };
 }
-function loadExtraFiles(_x0, _x1, _x10, _x11, _x12, _x13, _x14, _x15) {
-  return _loadExtraFiles.apply(this, arguments);
+
+/**
+ * Loads and processes extra files recursively with support for relative paths
+ * and circular dependency detection. Uses Promise.all for parallel loading.
+ */
+async function loadExtraFiles(variantName, extraFiles, baseUrl, entryUrl,
+// Track the original entry file URL
+loadSource, sourceParser, sourceTransformers, loadSourceCache, options = {}, allFilesListed = false, knownExtraFiles = new Set(), globalsFileKeys = new Set() // Track which files came from globals
+) {
+  const {
+    maxDepth = 10,
+    loadedFiles = new Set()
+  } = options;
+  if (maxDepth <= 0) {
+    throw new Error('Maximum recursion depth reached while loading extra files');
+  }
+  const processedExtraFiles = {};
+  const allFilesUsed = [];
+  const allExternals = {};
+
+  // Start loading all extra files in parallel
+  const extraFilePromises = Object.entries(extraFiles).map(async ([fileName, fileData]) => {
+    try {
+      let fileUrl;
+      let sourceData;
+      let transforms;
+      if (typeof fileData === 'string') {
+        // fileData is a URL/path - use it directly, don't modify it
+        fileUrl = fileData;
+
+        // Check for circular dependencies
+        if (loadedFiles.has(fileUrl)) {
+          throw new Error(`Circular dependency detected: ${fileUrl}`);
+        }
+        loadedFiles.add(fileUrl);
+      } else {
+        // fileData is an object with source and/or transforms
+        sourceData = fileData.source;
+        transforms = fileData.transforms;
+        fileUrl = baseUrl; // Use base URL as fallback
+      }
+
+      // Derive language from fileName for extra files
+      const extraFileExtension = fileName.slice(fileName.lastIndexOf('.'));
+      const extraFileLanguage = getLanguageFromExtension(extraFileExtension);
+
+      // Load the file (this will handle recursive extra files)
+      const fileResult = await loadSingleFile(variantName, fileName, sourceData, fileUrl, loadSource, sourceParser, sourceTransformers, loadSourceCache, transforms, {
+        ...options,
+        maxDepth: maxDepth - 1,
+        loadedFiles: new Set(loadedFiles)
+      }, allFilesListed, knownExtraFiles, extraFileLanguage);
+
+      // Collect files used from this file load
+      const filesUsedFromFile = [];
+      if (typeof fileData === 'string') {
+        filesUsedFromFile.push(fileUrl);
+      }
+      if (fileResult.extraDependencies) {
+        filesUsedFromFile.push(...fileResult.extraDependencies);
+      }
+
+      // Collect externals from this file load
+      const externalsFromFile = {};
+      if (fileResult.externals) {
+        Object.assign(externalsFromFile, fileResult.externals);
+      }
+      return {
+        fileName,
+        result: fileResult,
+        filesUsed: filesUsedFromFile,
+        externals: externalsFromFile
+      };
+    } catch (error) {
+      throw new Error(`Failed to load extra file (variant: ${variantName}, file: ${fileName}, url: ${baseUrl}): ${error instanceof Error ? error.message : ''}`);
+    }
+  });
+
+  // Wait for all extra files to load
+  const extraFileResults = await Promise.all(extraFilePromises);
+
+  // Process results and handle nested extra files
+  const nestedExtraFilesPromises = [];
+  for (const {
+    fileName,
+    result,
+    filesUsed,
+    externals
+  } of extraFileResults) {
+    const normalizedFileName = normalizePathKey(fileName);
+    const originalFileData = extraFiles[fileName];
+
+    // Preserve metadata flag if it exists in the original data, or if this file came from globals
+    let metadata;
+    if (typeof originalFileData !== 'string') {
+      metadata = originalFileData.metadata;
+    } else if (globalsFileKeys.has(fileName)) {
+      metadata = true;
+    }
+
+    // Derive language from fileName extension for extra files
+    const extraFileExtension = normalizedFileName.slice(normalizedFileName.lastIndexOf('.'));
+    const extraFileLanguage = getLanguageFromExtension(extraFileExtension);
+    processedExtraFiles[normalizedFileName] = {
+      source: result.source,
+      ...(extraFileLanguage && {
+        language: extraFileLanguage
+      }),
+      ...(result.transforms && {
+        transforms: result.transforms
+      }),
+      ...(metadata !== undefined && {
+        metadata
+      })
+    };
+
+    // Add files used from this file load
+    allFilesUsed.push(...filesUsed);
+
+    // Add externals from this file load using proper merging
+    const mergedExternals = mergeExternals([allExternals, externals]);
+    Object.assign(allExternals, mergedExternals);
+
+    // Collect promises for nested extra files with their source key
+    if (result.extraFiles) {
+      let sourceFileUrl = baseUrl;
+      const 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, {
+        ...options,
+        maxDepth: maxDepth - 1,
+        loadedFiles: new Set(loadedFiles)
+      }, allFilesListed, knownExtraFiles, globalsFileKeys // Pass through globals file tracking
+      ).then(nestedResult => ({
+        files: nestedResult.extraFiles,
+        allFilesUsed: nestedResult.allFilesUsed,
+        allExternals: nestedResult.allExternals,
+        sourceFileKey: normalizedFileName // Pass the normalized key
+      })));
+    }
+  }
+
+  // Wait for all nested extra files and merge them, converting paths based on key structure
+  if (nestedExtraFilesPromises.length > 0) {
+    const nestedExtraFilesResults = await Promise.all(nestedExtraFilesPromises);
+    for (const {
+      files: nestedExtraFiles,
+      allFilesUsed: nestedFilesUsed,
+      allExternals: nestedExternals,
+      sourceFileKey
+    } of nestedExtraFilesResults) {
+      // Add nested files used
+      allFilesUsed.push(...nestedFilesUsed);
+
+      // Add nested externals using proper merging
+      const mergedNestedExternals = mergeExternals([allExternals, nestedExternals]);
+      Object.assign(allExternals, mergedNestedExternals);
+      for (const [nestedKey, nestedValue] of Object.entries(nestedExtraFiles)) {
+        // Convert the key based on the directory structure of the source key
+        const convertedKey = convertKeyBasedOnDirectory(nestedKey, sourceFileKey);
+        const normalizedConvertedKey = normalizePathKey(convertedKey);
+        processedExtraFiles[normalizedConvertedKey] = nestedValue;
+      }
+    }
+  }
+  return {
+    extraFiles: processedExtraFiles,
+    allFilesUsed,
+    allExternals
+  };
 }
+
 /**
  * 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,
-      _t6;
-    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, extraFileExtension, extraFileLanguage, fileResult, filesUsedFromFile, externalsFromFile, _t5;
-              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:
-                    // Derive language from fileName for extra files
-                    extraFileExtension = fileName.slice(fileName.lastIndexOf('.'));
-                    extraFileLanguage = getLanguageFromExtension(extraFileExtension); // Load the file (this will handle recursive extra files)
-                    _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, extraFileLanguage);
-                  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;
-                    _t5 = _context2.v;
-                    throw new Error("Failed to load extra file (variant: ".concat(variantName, ", file: ").concat(fileName, ", url: ").concat(baseUrl, "): ").concat(_t5 instanceof Error ? _t5.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, extraFileExtension, extraFileLanguage, 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;
-                  }
-
-                  // Derive language from fileName extension for extra files
-                  extraFileExtension = normalizedFileName.slice(normalizedFileName.lastIndexOf('.'));
-                  extraFileLanguage = getLanguageFromExtension(extraFileExtension);
-                  processedExtraFiles[normalizedFileName] = _extends(_extends(_extends({
-                    source: result.source
-                  }, extraFileLanguage && {
-                    language: extraFileLanguage
-                  }), result.transforms && {
-                    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;
-          _t6 = _context4.v;
-          _iterator2.e(_t6);
-        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
-          });
+export async function loadCodeVariant(url, variantName, variant, options = {}) {
+  if (!variant) {
+    throw new Error(`Variant is missing from code: ${variantName}`);
+  }
+  const {
+    sourceParser,
+    loadSource,
+    loadVariantMeta,
+    sourceTransformers,
+    globalsCode,
+    disableParsing
+  } = options;
+
+  // Create a cache for loadSource calls scoped to this loadCodeVariant call
+  const loadSourceCache = new Map();
+  const functionName = 'Load Variant';
+  let currentMark = performanceMeasure(undefined, {
+    mark: 'Start',
+    measure: 'Start'
+  }, [functionName, url || variantName], true);
+  if (typeof variant === 'string') {
+    if (!loadVariantMeta) {
+      // Create a basic loadVariantMeta function as fallback
+      const {
+        fileName
+      } = getFileNameFromUrl(variant);
+      if (!fileName) {
+        throw new Error(`Cannot determine fileName from URL "${variant}" for variant "${variantName}". ` + `Please provide a loadVariantMeta function or ensure the URL has a valid file extension.`);
       }
-    }, _callee3, null, [[3, 7, 8, 9]]);
-  }));
-  return _loadExtraFiles.apply(this, arguments);
-}
-export function loadCodeVariant(_x16, _x17, _x18) {
-  return _loadCodeVariant.apply(this, arguments);
-}
-function _loadCodeVariant() {
-  _loadCodeVariant = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5(url, variantName, variant) {
-    var options,
-      sourceParser,
-      loadSource,
-      loadVariantMeta,
-      sourceTransformers,
-      globalsCode,
-      disableParsing,
-      loadSourceCache,
-      functionName,
-      currentMark,
-      _getFileNameFromUrl,
-      _fileName,
-      loadedFiles,
-      allFilesUsed,
-      allExternals,
-      knownExtraFiles,
-      _i4,
-      _Object$keys2,
-      extraFileName,
-      fileName,
+      variant = {
+        url: variant,
+        fileName
+      };
+    } else {
+      try {
+        variant = await loadVariantMeta(variantName, variant);
+      } catch (error) {
+        throw new Error(`Failed to load variant code (variant: ${variantName}, url: ${variant}): ${JSON.stringify(error)}`);
+      }
+      currentMark = performanceMeasure(currentMark, {
+        mark: 'Loaded Variant Meta',
+        measure: 'Variant Meta Loading'
+      }, [functionName, url || variantName]);
+    }
+  }
+  const loadedFiles = new Set();
+  if (url) {
+    loadedFiles.add(url);
+  }
+  const allFilesUsed = url ? [url] : []; // Start with the main file URL if available
+  let allExternals = {}; // Collect externals from all sources
+
+  // Build set of known extra files from variant definition
+  const knownExtraFiles = new Set();
+  if (variant.extraFiles) {
+    for (const extraFileName of Object.keys(variant.extraFiles)) {
+      knownExtraFiles.add(extraFileName);
+    }
+  }
+
+  // Load main file
+  const fileName = variant.fileName || (url ? getFileNameFromUrl(url).fileName : undefined);
+
+  // Derive language from variant.language or from fileName extension
+  // Normalize the language to its canonical form (e.g., 'js' -> 'javascript')
+  let language = variant.language ? normalizeLanguage(variant.language) : undefined;
+  if (!language && fileName) {
+    const extension = fileName.slice(fileName.lastIndexOf('.'));
+    language = getLanguageFromExtension(extension);
+  }
+
+  // If we don't have a fileName and no URL, we can still parse if we have language
+  if (!fileName && !url) {
+    let finalSource = variant.source;
+
+    // Parse the source if we have language and sourceParser
+    if (typeof finalSource === 'string' && language && sourceParser && !disableParsing) {
+      const parseSource = await sourceParser;
+      finalSource = parseSource(finalSource, '', language);
+    } else if (typeof finalSource === 'string') {
+      // No language or parser - return as plain text
+      finalSource = {
+        type: 'root',
+        children: [{
+          type: 'text',
+          value: finalSource || ''
+        }]
+      };
+    }
+    const finalVariant = {
+      ...variant,
       language,
-      extension,
-      finalSource,
-      parseSource,
-      _finalVariant,
-      mainFileResult,
-      _i5,
-      _Object$keys3,
-      _extraFileName,
-      extraFilesToLoad,
-      externalsMergedMark,
-      globalsFileKeys,
-      existingFiles,
-      _i6,
-      _Object$keys4,
-      key,
-      globalsPromises,
-      globalsResults,
-      _iterator4,
-      _step4,
-      globalsResult,
-      _i7,
-      _Object$entries3,
-      _Object$entries3$_i,
-      _key,
-      value,
-      conflictFreeKey,
-      allExtraFiles,
-      loadableFiles,
-      _i8,
-      _Object$entries4,
-      _Object$entries4$_i,
-      _key2,
-      _value,
-      _i9,
-      _Object$entries5,
-      _Object$entries5$_i,
-      _key3,
-      _value2,
-      metadata,
-      _extension,
-      extraFileLanguage,
-      urlFilesToLoad,
-      _i0,
-      _Object$entries6,
-      _Object$entries6$_i,
-      _key4,
-      _value3,
-      extraFilesResult,
-      _extraFilesResult,
-      finalVariant,
-      _args6 = arguments,
-      _t9;
-    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, disableParsing = options.disableParsing; // Create a cache for loadSource calls scoped to this loadCodeVariant call
-          loadSourceCache = new Map();
-          functionName = 'Load Variant';
-          currentMark = performanceMeasure(undefined, {
-            mark: 'Start',
-            measure: 'Start'
-          }, [functionName, url || variantName], true);
-          if (!(typeof variant === 'string')) {
-            _context6.n = 7;
-            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
+      source: finalSource
+    };
+    return {
+      code: finalVariant,
+      dependencies: [],
+      // No dependencies without URL
+      externals: {} // No externals without URL
+    };
+  }
+  if (!fileName) {
+    throw new Error(`No fileName available for variant "${variantName}". ` + `Please provide a fileName in the variant definition or ensure the URL has a valid file extension.`);
+  }
+  const mainFileResult = await loadSingleFile(variantName, fileName, variant.source, url, loadSource, sourceParser, sourceTransformers, loadSourceCache, variant.transforms, {
+    ...options,
+    loadedFiles
+  }, variant.allFilesListed || false, knownExtraFiles, language);
+
+  // Add files used from main file loading
+  if (mainFileResult.extraDependencies) {
+    allFilesUsed.push(...mainFileResult.extraDependencies);
+  }
+  currentMark = performanceMeasure(currentMark, {
+    mark: 'Loaded Main File',
+    measure: 'Main File Loading'
+  }, [functionName, url || fileName], true);
+
+  // Validate extraFiles keys from variant definition
+  if (variant.extraFiles) {
+    for (const extraFileName of Object.keys(variant.extraFiles)) {
+      // Check if key is an absolute URL (should be relative)
+      if (isAbsolutePath(extraFileName)) {
+        throw new Error(`Invalid extraFiles key in variant: "${extraFileName}" appears to be an absolute path. ` + `extraFiles keys in variant definition should be relative paths from the main file.`);
+      }
+    }
+  }
+
+  // Collect extra files from variant definition and from loaded source
+  const extraFilesToLoad = {
+    ...(variant.extraFiles || {}),
+    ...(mainFileResult.extraFiles || {})
+  };
+
+  // Add externals from main file loading
+  if (mainFileResult.externals) {
+    allExternals = mergeExternals([allExternals, mainFileResult.externals]);
+  }
+  const externalsMergedMark = performanceMeasure(currentMark, {
+    mark: 'Externals Merged',
+    measure: 'Merging Externals'
+  }, [functionName, url || fileName]);
+  currentMark = externalsMergedMark;
+
+  // Track which files come from globals for metadata marking
+  const globalsFileKeys = new Set(); // Track globals file keys for loadExtraFiles
+
+  // Process globalsCode array and add to extraFiles if provided
+  if (globalsCode && globalsCode.length > 0) {
+    // Collect existing filenames to avoid conflicts
+    const existingFiles = new Set();
+
+    // Add main variant filename if it exists
+    if (variant.fileName) {
+      existingFiles.add(variant.fileName);
+    }
+
+    // Add already loaded extra files
+    for (const key of Object.keys(extraFilesToLoad)) {
+      existingFiles.add(key);
+    }
+
+    // Process all globals items in parallel
+    const globalsPromises = globalsCode.map(async globalsItem => {
+      let globalsVariant;
+      if (typeof globalsItem === 'string') {
+        // Handle string case - load the variant metadata
+        if (!loadVariantMeta) {
+          // Create a basic variant as fallback
+          const {
+            fileName: globalsFileName
+          } = getFileNameFromUrl(globalsItem);
+          if (!globalsFileName) {
+            throw new Error(`Cannot determine fileName from globalsCode URL "${globalsItem}". ` + `Please provide a loadVariantMeta function or ensure the URL has a valid file extension.`);
+          }
+          globalsVariant = {
+            url: globalsItem,
+            fileName: globalsFileName
           };
-          _context6.n = 7;
-          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;
-          _t9 = _context6.v;
-          throw new Error("Failed to load variant code (variant: ".concat(variantName, ", url: ").concat(variant, "): ").concat(JSON.stringify(_t9)));
-        case 6:
-          currentMark = performanceMeasure(currentMark, {
-            mark: 'Loaded Variant Meta',
-            measure: 'Variant Meta Loading'
-          }, [functionName, url || variantName]);
-        case 7:
-          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);
-            }
-          }
+        } else {
+          try {
+            globalsVariant = await loadVariantMeta(variantName, globalsItem);
+            currentMark = performanceMeasure(currentMark, {
+              mark: 'Globals Variant Meta Loaded',
+              measure: 'Globals Variant Meta Loading'
+            }, [functionName, globalsItem, url || fileName]);
+          } catch (error) {
+            throw new Error(`Failed to load globalsCode variant metadata (variant: ${variantName}, url: ${globalsItem}): ${JSON.stringify(error)}`);
+          }
+        }
+      } else {
+        globalsVariant = globalsItem;
+      }
 
-          // Load main file
-          fileName = variant.fileName || (url ? getFileNameFromUrl(url).fileName : undefined); // Derive language from variant.language or from fileName extension
-          // Normalize the language to its canonical form (e.g., 'js' -> 'javascript')
-          language = variant.language ? normalizeLanguage(variant.language) : undefined;
-          if (!language && fileName) {
-            extension = fileName.slice(fileName.lastIndexOf('.'));
-            language = getLanguageFromExtension(extension);
-          }
+      // Load the globals code separately without affecting allFilesListed
+      try {
+        const globalsResult = await loadCodeVariant(globalsVariant.url, variantName, globalsVariant, {
+          ...options,
+          globalsCode: undefined
+        } // Prevent infinite recursion
+        );
+        currentMark = performanceMeasure(currentMark, {
+          mark: 'Globals Variant Loaded',
+          measure: 'Globals Variant Loading'
+        }, [functionName, globalsVariant.url || variantName, url || fileName]);
+        return globalsResult;
+      } catch (error) {
+        throw new Error(`Failed to load globalsCode (variant: ${variantName}): ${error instanceof Error ? error.message : JSON.stringify(error)}`);
+      }
+    });
 
-          // If we don't have a fileName and no URL, we can still parse if we have language
-          if (!(!fileName && !url)) {
-            _context6.n = 11;
-            break;
-          }
-          finalSource = variant.source; // Parse the source if we have language and sourceParser
-          if (!(typeof finalSource === 'string' && language && sourceParser && !disableParsing)) {
-            _context6.n = 9;
-            break;
-          }
-          _context6.n = 8;
-          return sourceParser;
-        case 8:
-          parseSource = _context6.v;
-          finalSource = parseSource(finalSource, '', language);
-          _context6.n = 10;
-          break;
-        case 9:
-          if (typeof finalSource === 'string') {
-            // No language or parser - return as plain text
-            finalSource = {
-              type: 'root',
-              children: [{
-                type: 'text',
-                value: finalSource || ''
-              }]
+    // Wait for all globals to load
+    const globalsResults = await Promise.all(globalsPromises);
+
+    // Merge results from all globals
+    for (const globalsResult of globalsResults) {
+      // Add globals extraFiles (but NOT the main file)
+      if (globalsResult.code.extraFiles) {
+        // Add globals extra files with conflict-free naming and metadata flag
+        for (const [key, value] of Object.entries(globalsResult.code.extraFiles)) {
+          const 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] = {
+              ...value,
+              metadata: true
             };
           }
-        case 10:
-          _finalVariant = _extends(_extends({}, variant), {}, {
-            language: language,
-            source: finalSource
-          });
-          return _context6.a(2, {
-            code: _finalVariant,
-            dependencies: [],
-            // No dependencies without URL
-            externals: {} // No externals without URL
-          });
-        case 11:
-          if (fileName) {
-            _context6.n = 12;
-            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 12:
-          _context6.n = 13;
-          return loadSingleFile(variantName, fileName, variant.source, url, loadSource, sourceParser, sourceTransformers, loadSourceCache, variant.transforms, _extends(_extends({}, options), {}, {
-            loadedFiles: loadedFiles
-          }), variant.allFilesListed || false, knownExtraFiles, language);
-        case 13:
-          mainFileResult = _context6.v;
-          // Add files used from main file loading
-          if (mainFileResult.extraDependencies) {
-            allFilesUsed.push.apply(allFilesUsed, _toConsumableArray(mainFileResult.extraDependencies));
-          }
-          currentMark = performanceMeasure(currentMark, {
-            mark: 'Loaded Main File',
-            measure: 'Main File Loading'
-          }, [functionName, url || fileName], true);
-
-          // Validate extraFiles keys from variant definition
-          if (!variant.extraFiles) {
-            _context6.n = 16;
-            break;
-          }
-          _i5 = 0, _Object$keys3 = Object.keys(variant.extraFiles);
-        case 14:
-          if (!(_i5 < _Object$keys3.length)) {
-            _context6.n = 16;
-            break;
-          }
-          _extraFileName = _Object$keys3[_i5];
-          if (!isAbsolutePath(_extraFileName)) {
-            _context6.n = 15;
-            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 15:
-          _i5++;
-          _context6.n = 14;
-          break;
-        case 16:
-          // Collect extra files from variant definition and from loaded source
-          extraFilesToLoad = _extends(_extends({}, variant.extraFiles || {}), mainFileResult.extraFiles || {}); // Add externals from main file loading
-          if (mainFileResult.externals) {
-            allExternals = mergeExternals([allExternals, mainFileResult.externals]);
-          }
-          externalsMergedMark = performanceMeasure(currentMark, {
-            mark: 'Externals Merged',
-            measure: 'Merging Externals'
-          }, [functionName, url || fileName]);
-          currentMark = externalsMergedMark;
-
-          // 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 = 18;
-            break;
-          }
-          // Collect existing filenames to avoid conflicts
-          existingFiles = new Set(); // Add main variant filename if it exists
-          if (variant.fileName) {
-            existingFiles.add(variant.fileName);
-          }
+          existingFiles.add(conflictFreeKey); // Track the added file for subsequent iterations
+        }
+      }
 
-          // 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);
-          }
+      // Add globals dependencies
+      allFilesUsed.push(...globalsResult.dependencies);
 
-          // 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, _t7, _t8;
-              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;
-                    currentMark = performanceMeasure(currentMark, {
-                      mark: 'Globals Variant Meta Loaded',
-                      measure: 'Globals Variant Meta Loading'
-                    }, [functionName, globalsItem, url || fileName]);
-                    _context5.n = 5;
-                    break;
-                  case 4:
-                    _context5.p = 4;
-                    _t7 = _context5.v;
-                    throw new Error("Failed to load globalsCode variant metadata (variant: ".concat(variantName, ", url: ").concat(globalsItem, "): ").concat(JSON.stringify(_t7)));
-                  case 5:
-                    _context5.n = 7;
-                    break;
-                  case 6:
-                    globalsVariant = globalsItem;
-                  case 7:
-                    _context5.p = 7;
-                    _context5.n = 8;
-                    return loadCodeVariant(globalsVariant.url, variantName, globalsVariant, _extends(_extends({}, options), {}, {
-                      globalsCode: undefined
-                    }) // Prevent infinite recursion
-                    );
-                  case 8:
-                    globalsResult = _context5.v;
-                    currentMark = performanceMeasure(currentMark, {
-                      mark: 'Globals Variant Loaded',
-                      measure: 'Globals Variant Loading'
-                    }, [functionName, globalsVariant.url || variantName, url || fileName]);
-                    return _context5.a(2, globalsResult);
-                  case 9:
-                    _context5.p = 9;
-                    _t8 = _context5.v;
-                    throw new Error("Failed to load globalsCode (variant: ".concat(variantName, "): ").concat(_t8 instanceof Error ? _t8.message : JSON.stringify(_t8)));
-                  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 = 17;
-          return Promise.all(globalsPromises);
-        case 17:
-          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 18:
-          currentMark = performanceMeasure(externalsMergedMark, {
-            mark: 'Globals Loaded',
-            measure: 'Globals Loading'
-          }, [functionName, url || fileName], true);
-          allExtraFiles = {}; // Load all extra files if any exist and we have a URL
-          if (!(Object.keys(extraFilesToLoad).length > 0)) {
-            _context6.n = 24;
-            break;
-          }
-          if (url) {
-            _context6.n = 21;
-            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 = 20;
-            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; // Derive language from filename extension
-              _extension = _key3.slice(_key3.lastIndexOf('.'));
-              extraFileLanguage = getLanguageFromExtension(_extension);
-              allExtraFiles[normalizePathKey(_key3)] = _extends(_extends(_extends({
-                source: _value2.source
-              }, extraFileLanguage && {
+      // Add globals externals
+      allExternals = mergeExternals([allExternals, globalsResult.externals]);
+    }
+  }
+  currentMark = performanceMeasure(externalsMergedMark, {
+    mark: 'Globals Loaded',
+    measure: 'Globals Loading'
+  }, [functionName, url || fileName], true);
+  let allExtraFiles = {};
+
+  // Load all extra files if any exist and we have a URL
+  if (Object.keys(extraFilesToLoad).length > 0) {
+    if (!url) {
+      // If there's no URL, we can only load extra files that have inline source or absolute URLs
+      const loadableFiles = {};
+      for (const [key, value] of Object.entries(extraFilesToLoad)) {
+        if (typeof value !== 'string' && value.source !== undefined) {
+          // Inline source - can always load
+          loadableFiles[key] = value;
+        } else if (typeof value === 'string' && isAbsolutePath(value)) {
+          // Absolute URL - can load without base URL
+          loadableFiles[key] = value;
+        } else {
+          console.warn(`Skipping extra file "${key}" - no URL provided and file requires loading from external source`);
+        }
+      }
+      if (Object.keys(loadableFiles).length > 0) {
+        // Process loadable files: inline sources without URL-based loading, absolute URLs with loading
+        for (const [key, value] of Object.entries(loadableFiles)) {
+          if (typeof value !== 'string') {
+            // Inline source - preserve metadata if it was marked as globals
+            const metadata = value.metadata || globalsFileKeys.has(key) ? true : undefined;
+            // Derive language from filename extension
+            const extension = key.slice(key.lastIndexOf('.'));
+            const extraFileLanguage = getLanguageFromExtension(extension);
+            allExtraFiles[normalizePathKey(key)] = {
+              source: value.source,
+              ...(extraFileLanguage && {
                 language: extraFileLanguage
-              }), _value2.transforms && {
-                transforms: _value2.transforms
-              }), metadata !== undefined && {
-                metadata: metadata
-              });
-            }
+              }),
+              ...(value.transforms && {
+                transforms: value.transforms
+              }),
+              ...(metadata !== undefined && {
+                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 = 20;
-            break;
+        // For absolute URLs, we need to load them
+        const urlFilesToLoad = {};
+        for (const [key, value] of Object.entries(loadableFiles)) {
+          if (typeof value === 'string') {
+            urlFilesToLoad[key] = value;
           }
-          _context6.n = 19;
-          return loadExtraFiles(variantName, urlFilesToLoad, '',
+        }
+        if (Object.keys(urlFilesToLoad).length > 0) {
+          // Load absolute URL files even without base URL
+          const extraFilesResult = await 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
+          loadSource, sourceParser, sourceTransformers, loadSourceCache, {
+            ...options,
+            loadedFiles
+          }, variant.allFilesListed || false, knownExtraFiles, globalsFileKeys // Pass globals file tracking
           );
-        case 19:
-          extraFilesResult = _context6.v;
-          allExtraFiles = _extends(_extends({}, allExtraFiles), extraFilesResult.extraFiles);
-          allFilesUsed.push.apply(allFilesUsed, _toConsumableArray(extraFilesResult.allFilesUsed));
+          allExtraFiles = {
+            ...allExtraFiles,
+            ...extraFilesResult.extraFiles
+          };
+          allFilesUsed.push(...extraFilesResult.allFilesUsed);
           allExternals = mergeExternals([allExternals, extraFilesResult.allExternals]);
-        case 20:
-          _context6.n = 23;
-          break;
-        case 21:
-          _context6.n = 22;
-          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 22:
-          _extraFilesResult = _context6.v;
-          allExtraFiles = _extraFilesResult.extraFiles;
-          allFilesUsed.push.apply(allFilesUsed, _toConsumableArray(_extraFilesResult.allFilesUsed));
-          allExternals = mergeExternals([allExternals, _extraFilesResult.allExternals]);
-        case 23:
-          currentMark = performanceMeasure(currentMark, {
-            mark: 'Extra Files Loaded',
-            measure: 'Extra Files Loading'
-          }, [functionName, url || fileName], true);
-        case 24:
-          // Note: metadata marking is now handled during loadExtraFiles processing
-          finalVariant = _extends(_extends({}, variant), {}, {
-            language: language,
-            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 _loadCodeVariant.apply(this, arguments);
+    } else {
+      const extraFilesResult = await loadExtraFiles(variantName, extraFilesToLoad, url, url,
+      // Entry URL is the same as the main file URL
+      loadSource, sourceParser, sourceTransformers, loadSourceCache, {
+        ...options,
+        loadedFiles
+      }, variant.allFilesListed || false, knownExtraFiles, globalsFileKeys // Pass globals file tracking
+      );
+      allExtraFiles = extraFilesResult.extraFiles;
+      allFilesUsed.push(...extraFilesResult.allFilesUsed);
+      allExternals = mergeExternals([allExternals, extraFilesResult.allExternals]);
+    }
+    currentMark = performanceMeasure(currentMark, {
+      mark: 'Extra Files Loaded',
+      measure: 'Extra Files Loading'
+    }, [functionName, url || fileName], true);
+  }
+
+  // Note: metadata marking is now handled during loadExtraFiles processing
+
+  const finalVariant = {
+    ...variant,
+    language,
+    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 {
+    code: finalVariant,
+    dependencies: Array.from(new Set(allFilesUsed)),
+    // Remove duplicates
+    externals: allExternals
+  };
 }