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

package/esm/CodeHighlighter/loadFallbackCode.js

@@ -0,0 +1,679 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _regenerator from "@babel/runtime/helpers/esm/regenerator";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { loadVariant } from "./loadVariant.js";
+import { getFileNameFromUrl } from "../pipeline/loaderUtils/index.js";
+
+// Helper function to get the source for a specific filename from a variant
+function getFileSource(_x, _x2, _x3) {
+  return _getFileSource.apply(this, arguments);
+}
+function _getFileSource() {
+  _getFileSource = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(variant, requestedFilename, loadSource) {
+    var filename, extraFile, loadResult;
+    return _regenerator().w(function (_context) {
+      while (1) switch (_context.n) {
+        case 0:
+          filename = requestedFilename || variant.fileName;
+          if (filename) {
+            _context.n = 2;
+            break;
+          }
+          if (!(variant.source !== undefined)) {
+            _context.n = 1;
+            break;
+          }
+          return _context.a(2, {
+            source: variant.source,
+            filename: undefined
+          });
+        case 1:
+          throw new Error('No filename available and no source in variant');
+        case 2:
+          if (!(filename === variant.fileName && variant.source !== undefined)) {
+            _context.n = 3;
+            break;
+          }
+          return _context.a(2, {
+            source: variant.source,
+            filename: filename
+          });
+        case 3:
+          if (!(filename !== variant.fileName && variant.extraFiles)) {
+            _context.n = 7;
+            break;
+          }
+          extraFile = variant.extraFiles[filename];
+          if (!(extraFile && typeof extraFile !== 'string' && extraFile.source !== undefined)) {
+            _context.n = 4;
+            break;
+          }
+          return _context.a(2, {
+            source: extraFile.source,
+            filename: filename
+          });
+        case 4:
+          if (!(typeof extraFile === 'string' && loadSource)) {
+            _context.n = 6;
+            break;
+          }
+          _context.n = 5;
+          return loadSource(extraFile);
+        case 5:
+          loadResult = _context.v;
+          return _context.a(2, {
+            source: loadResult.source,
+            filename: filename
+          });
+        case 6:
+          if (!(extraFile && typeof extraFile !== 'string' && !extraFile.source && loadSource)) {
+            _context.n = 7;
+            break;
+          }
+          throw new Error("Extra file ".concat(filename, " has no source or URL to load from"));
+        case 7:
+          throw new Error("File ".concat(filename, " not found in variant or cannot be loaded"));
+        case 8:
+          return _context.a(2);
+      }
+    }, _callee);
+  }));
+  return _getFileSource.apply(this, arguments);
+}
+export function loadFallbackCode(_x4, _x5, _x6) {
+  return _loadFallbackCode.apply(this, arguments);
+}
+function _loadFallbackCode() {
+  _loadFallbackCode = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(url, initialVariant, loaded) {
+    var options,
+      shouldHighlight,
+      fallbackUsesExtraFiles,
+      fallbackUsesAllVariants,
+      sourceParser,
+      loadSource,
+      loadVariantMeta,
+      loadCodeMeta,
+      initialFilename,
+      variants,
+      globalsCode,
+      initial,
+      _allFileNames,
+      fileSource,
+      actualFilename,
+      result,
+      parseSource,
+      quickVariant,
+      _allFileNames2,
+      _fileSource,
+      _actualFilename,
+      _result,
+      _parseSource,
+      globalsCodeObjects,
+      hasStringUrls,
+      globalsPromises,
+      resolvedGlobalsCode,
+      _iterator,
+      _step,
+      codeObj,
+      targetVariant,
+      _yield$loadVariant,
+      loadedVariant,
+      allFileNames,
+      allVariants,
+      variantPromises,
+      variantResults,
+      finalInitial,
+      finalFileSource,
+      finalFilename,
+      _result2,
+      _args4 = arguments,
+      _t4,
+      _t5,
+      _t6,
+      _t7,
+      _t8,
+      _t9,
+      _t0,
+      _t1;
+    return _regenerator().w(function (_context4) {
+      while (1) switch (_context4.p = _context4.n) {
+        case 0:
+          options = _args4.length > 3 && _args4[3] !== undefined ? _args4[3] : {};
+          shouldHighlight = options.shouldHighlight, fallbackUsesExtraFiles = options.fallbackUsesExtraFiles, fallbackUsesAllVariants = options.fallbackUsesAllVariants, sourceParser = options.sourceParser, loadSource = options.loadSource, loadVariantMeta = options.loadVariantMeta, loadCodeMeta = options.loadCodeMeta, initialFilename = options.initialFilename, variants = options.variants, globalsCode = options.globalsCode;
+          loaded = _extends({}, loaded);
+
+          // Step 1: Ensure we have the initial variant loaded
+          initial = loaded[initialVariant];
+          if (initial) {
+            _context4.n = 5;
+            break;
+          }
+          if (loadCodeMeta) {
+            _context4.n = 1;
+            break;
+          }
+          throw new Error('"loadCodeMeta" function is required when initial variant is not provided');
+        case 1:
+          _context4.p = 1;
+          _context4.n = 2;
+          return loadCodeMeta(url);
+        case 2:
+          loaded = _context4.v;
+          _context4.n = 4;
+          break;
+        case 3:
+          _context4.p = 3;
+          _t4 = _context4.v;
+          throw new Error("Failed to load code from URL: ".concat(url, ". Error: ").concat(JSON.stringify(_t4)));
+        case 4:
+          initial = loaded[initialVariant];
+          if (initial) {
+            _context4.n = 5;
+            break;
+          }
+          throw new Error("Initial variant \"".concat(initialVariant, "\" not found in loaded code."));
+        case 5:
+          if (!(typeof initial !== 'string' && initial.allFilesListed && !fallbackUsesExtraFiles && !fallbackUsesAllVariants)) {
+            _context4.n = 16;
+            break;
+          }
+          // Collect all file names from the loaded code
+          _allFileNames = new Set();
+          if (initial.fileName) {
+            _allFileNames.add(initial.fileName);
+          }
+          if (initial.extraFiles) {
+            Object.keys(initial.extraFiles).forEach(function (fileName) {
+              return _allFileNames.add(fileName);
+            });
+          }
+
+          // Get the source for the requested filename (or main file if not specified)
+          _context4.p = 6;
+          _context4.n = 7;
+          return getFileSource(initial, initialFilename, loadSource);
+        case 7:
+          result = _context4.v;
+          fileSource = result.source;
+          actualFilename = result.filename;
+          _context4.n = 9;
+          break;
+        case 8:
+          _context4.p = 8;
+          _t5 = _context4.v;
+          throw new Error("Failed to get source for file ".concat(initialFilename || initial.fileName, " in variant ").concat(initialVariant, ": ").concat(_t5));
+        case 9:
+          if (!(shouldHighlight && typeof fileSource === 'string' && sourceParser && actualFilename)) {
+            _context4.n = 14;
+            break;
+          }
+          _context4.p = 10;
+          _context4.n = 11;
+          return sourceParser;
+        case 11:
+          parseSource = _context4.v;
+          fileSource = parseSource(fileSource, actualFilename);
+          _context4.n = 13;
+          break;
+        case 12:
+          _context4.p = 12;
+          _t6 = _context4.v;
+          throw new Error("Failed to parse source for highlighting (variant: ".concat(initialVariant, ", file: ").concat(actualFilename, "): ").concat(JSON.stringify(_t6)));
+        case 13:
+          _context4.n = 15;
+          break;
+        case 14:
+          if (shouldHighlight && typeof fileSource === 'string' && !actualFilename) {
+            // Create basic HAST node when we can't parse due to missing filename
+            // This marks that the source has passed through the parsing pipeline
+            fileSource = {
+              type: 'root',
+              children: [{
+                type: 'text',
+                value: fileSource
+              }]
+            };
+          }
+        case 15:
+          // Update the loaded code with any changes we made
+          if (actualFilename && actualFilename === initial.fileName) {
+            initial = _extends(_extends({}, initial), {}, {
+              source: fileSource
+            });
+            loaded = _extends(_extends({}, loaded), {}, _defineProperty({}, initialVariant, initial));
+          } else if (!actualFilename && !initial.fileName) {
+            // If both are undefined, we're dealing with the main source
+            initial = _extends(_extends({}, initial), {}, {
+              source: fileSource
+            });
+            loaded = _extends(_extends({}, loaded), {}, _defineProperty({}, initialVariant, initial));
+          }
+
+          // Early return - we have all the info we need
+          return _context4.a(2, {
+            code: loaded,
+            initialFilename: actualFilename,
+            initialSource: fileSource,
+            initialExtraFiles: initial.extraFiles || {},
+            allFileNames: Array.from(_allFileNames)
+          });
+        case 16:
+          if (!(typeof initial === 'string')) {
+            _context4.n = 33;
+            break;
+          }
+          _context4.p = 17;
+          if (!loadVariantMeta) {
+            _context4.n = 19;
+            break;
+          }
+          _context4.n = 18;
+          return loadVariantMeta(initialVariant, initial);
+        case 18:
+          quickVariant = _context4.v;
+          _context4.n = 20;
+          break;
+        case 19:
+          // Create a basic variant using fallback logic
+          quickVariant = {
+            url: initial,
+            fileName: getFileNameFromUrl(initial).fileName
+          };
+        case 20:
+          loaded = _extends(_extends({}, loaded), {}, _defineProperty({}, initialVariant, quickVariant));
+          initial = quickVariant;
+
+          // If we have all files listed and don't need extra file processing, we can optimize
+          if (!(quickVariant.allFilesListed && !fallbackUsesExtraFiles && !fallbackUsesAllVariants)) {
+            _context4.n = 31;
+            break;
+          }
+          // Collect all file names from the quick load
+          _allFileNames2 = new Set();
+          if (quickVariant.fileName) {
+            _allFileNames2.add(quickVariant.fileName);
+          }
+          if (quickVariant.extraFiles) {
+            Object.keys(quickVariant.extraFiles).forEach(function (fileName) {
+              return _allFileNames2.add(fileName);
+            });
+          }
+
+          // Get the source for the requested filename (or main file if not specified)
+          _context4.p = 21;
+          _context4.n = 22;
+          return getFileSource(quickVariant, initialFilename, loadSource);
+        case 22:
+          _result = _context4.v;
+          _fileSource = _result.source;
+          _actualFilename = _result.filename;
+          _context4.n = 24;
+          break;
+        case 23:
+          _context4.p = 23;
+          _t7 = _context4.v;
+          throw new Error("Failed to get source for file ".concat(initialFilename || quickVariant.fileName, " in variant ").concat(initialVariant, ": ").concat(_t7));
+        case 24:
+          if (!(shouldHighlight && typeof _fileSource === 'string' && sourceParser && _actualFilename)) {
+            _context4.n = 29;
+            break;
+          }
+          _context4.p = 25;
+          _context4.n = 26;
+          return sourceParser;
+        case 26:
+          _parseSource = _context4.v;
+          _fileSource = _parseSource(_fileSource, _actualFilename);
+          _context4.n = 28;
+          break;
+        case 27:
+          _context4.p = 27;
+          _t8 = _context4.v;
+          throw new Error("Failed to parse source for highlighting (variant: ".concat(initialVariant, ", file: ").concat(_actualFilename, "): ").concat(JSON.stringify(_t8)));
+        case 28:
+          _context4.n = 30;
+          break;
+        case 29:
+          if (shouldHighlight && typeof _fileSource === 'string' && !_actualFilename) {
+            // Create basic HAST node when we can't parse due to missing filename
+            // This marks that the source has passed through the parsing pipeline
+            _fileSource = {
+              type: 'root',
+              children: [{
+                type: 'text',
+                value: _fileSource
+              }]
+            };
+          }
+        case 30:
+          // Update the loaded code with any changes we made
+          if (_actualFilename && _actualFilename === quickVariant.fileName) {
+            initial = _extends(_extends({}, quickVariant), {}, {
+              source: _fileSource
+            });
+            loaded = _extends(_extends({}, loaded), {}, _defineProperty({}, initialVariant, initial));
+          } else if (!_actualFilename && !quickVariant.fileName) {
+            // If both are undefined, we're dealing with the main source
+            initial = _extends(_extends({}, quickVariant), {}, {
+              source: _fileSource
+            });
+            loaded = _extends(_extends({}, loaded), {}, _defineProperty({}, initialVariant, initial));
+          }
+
+          // Early return - we have all the info we need
+          return _context4.a(2, {
+            code: loaded,
+            initialFilename: _actualFilename,
+            initialSource: _fileSource,
+            initialExtraFiles: quickVariant.extraFiles || {},
+            allFileNames: Array.from(_allFileNames2)
+          });
+        case 31:
+          _context4.n = 33;
+          break;
+        case 32:
+          _context4.p = 32;
+          _t9 = _context4.v;
+          throw new Error("Failed to load initial variant code (variant: ".concat(initialVariant, ", url: ").concat(initial, "): ").concat(JSON.stringify(_t9)));
+        case 33:
+          if (!(globalsCode && globalsCode.length > 0)) {
+            _context4.n = 36;
+            break;
+          }
+          hasStringUrls = globalsCode.some(function (item) {
+            return typeof item === 'string';
+          });
+          if (!(hasStringUrls && !loadCodeMeta)) {
+            _context4.n = 34;
+            break;
+          }
+          throw new Error('loadCodeMeta function is required when globalsCode contains string URLs');
+        case 34:
+          // Load all string URLs in parallel, keep Code objects as-is
+          globalsPromises = globalsCode.map(/*#__PURE__*/function () {
+            var _ref = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(globalItem) {
+              var _t;
+              return _regenerator().w(function (_context2) {
+                while (1) switch (_context2.p = _context2.n) {
+                  case 0:
+                    if (!(typeof globalItem === 'string')) {
+                      _context2.n = 4;
+                      break;
+                    }
+                    _context2.p = 1;
+                    _context2.n = 2;
+                    return loadCodeMeta(globalItem);
+                  case 2:
+                    return _context2.a(2, _context2.v);
+                  case 3:
+                    _context2.p = 3;
+                    _t = _context2.v;
+                    throw new Error("Failed to load globalsCode from URL: ".concat(globalItem, ". Error: ").concat(JSON.stringify(_t)));
+                  case 4:
+                    return _context2.a(2, globalItem);
+                  case 5:
+                    return _context2.a(2);
+                }
+              }, _callee2, null, [[1, 3]]);
+            }));
+            return function (_x7) {
+              return _ref.apply(this, arguments);
+            };
+          }());
+          _context4.n = 35;
+          return Promise.all(globalsPromises);
+        case 35:
+          globalsCodeObjects = _context4.v;
+        case 36:
+          if (globalsCodeObjects && globalsCodeObjects.length > 0) {
+            resolvedGlobalsCode = [];
+            _iterator = _createForOfIteratorHelper(globalsCodeObjects);
+            try {
+              for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                codeObj = _step.value;
+                // Only use the variant that matches the current initialVariant
+                targetVariant = codeObj[initialVariant];
+                if (targetVariant) {
+                  resolvedGlobalsCode.push(targetVariant);
+                }
+              }
+            } catch (err) {
+              _iterator.e(err);
+            } finally {
+              _iterator.f();
+            }
+          }
+          _context4.p = 37;
+          _context4.n = 38;
+          return loadVariant(url, initialVariant, initial, {
+            sourceParser: sourceParser,
+            loadSource: loadSource,
+            loadVariantMeta: loadVariantMeta,
+            sourceTransformers: undefined,
+            // sourceTransformers - skip transforms for fallback
+            disableTransforms: true,
+            // Don't apply transforms for fallback
+            disableParsing: !shouldHighlight,
+            // Only parse if highlighting is needed
+            globalsCode: resolvedGlobalsCode // Pass resolved globalsCode
+          });
+        case 38:
+          _yield$loadVariant = _context4.v;
+          loadedVariant = _yield$loadVariant.code;
+          // Update the loaded code with the processed variant
+          loaded = _extends(_extends({}, loaded), {}, _defineProperty({}, initialVariant, loadedVariant));
+          initial = loadedVariant;
+          _context4.n = 40;
+          break;
+        case 39:
+          _context4.p = 39;
+          _t0 = _context4.v;
+          throw new Error("Failed to load initial variant using loadVariant (variant: ".concat(initialVariant, ", url: ").concat(url, "): ").concat(JSON.stringify(_t0)));
+        case 40:
+          // Step 3: Collect all file names
+          allFileNames = new Set();
+          if (initial.fileName) {
+            allFileNames.add(initial.fileName);
+          }
+
+          // Add extra files from the initial variant
+          if (initial.extraFiles) {
+            Object.keys(initial.extraFiles).forEach(function (fileName) {
+              return allFileNames.add(fileName);
+            });
+          }
+
+          // Step 4: Handle fallbackUsesAllVariants - load all variants to get all possible files
+          if (!fallbackUsesAllVariants) {
+            _context4.n = 43;
+            break;
+          }
+          // Determine all variants to process - use provided variants or infer from loaded code
+          allVariants = variants || Object.keys(loaded || {});
+          if (!(allVariants.length === 0)) {
+            _context4.n = 41;
+            break;
+          }
+          console.warn('No variants found for fallbackUsesAllVariants processing');
+          _context4.n = 43;
+          break;
+        case 41:
+          // Process all required variants, not just the ones already loaded
+          variantPromises = allVariants.map(/*#__PURE__*/function () {
+            var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(variantName) {
+              var _loaded;
+              var variant, allCode, _yield$loadVariant2, _loadedVariant, fileNames, _t2, _t3;
+              return _regenerator().w(function (_context3) {
+                while (1) switch (_context3.p = _context3.n) {
+                  case 0:
+                    if (!(variantName === initialVariant)) {
+                      _context3.n = 1;
+                      break;
+                    }
+                    return _context3.a(2, {
+                      variantName: variantName,
+                      loadedVariant: null,
+                      fileNames: []
+                    });
+                  case 1:
+                    variant = (_loaded = loaded) == null ? void 0 : _loaded[variantName]; // If variant is not loaded yet, load it first using loadCodeMeta
+                    if (!(!variant && loadCodeMeta)) {
+                      _context3.n = 5;
+                      break;
+                    }
+                    _context3.p = 2;
+                    _context3.n = 3;
+                    return loadCodeMeta(url);
+                  case 3:
+                    allCode = _context3.v;
+                    variant = allCode[variantName];
+                    // Update loaded with all variants from loadCodeMeta
+                    loaded = _extends(_extends({}, loaded), allCode);
+                    _context3.n = 5;
+                    break;
+                  case 4:
+                    _context3.p = 4;
+                    _t2 = _context3.v;
+                    console.warn("Failed to load code meta for variant ".concat(variantName, ": ").concat(_t2));
+                    return _context3.a(2, {
+                      variantName: variantName,
+                      loadedVariant: null,
+                      fileNames: []
+                    });
+                  case 5:
+                    if (variant) {
+                      _context3.n = 6;
+                      break;
+                    }
+                    console.warn("Variant ".concat(variantName, " not found after loading code meta"));
+                    return _context3.a(2, {
+                      variantName: variantName,
+                      loadedVariant: null,
+                      fileNames: []
+                    });
+                  case 6:
+                    _context3.p = 6;
+                    _context3.n = 7;
+                    return loadVariant(url, variantName, variant, {
+                      sourceParser: sourceParser,
+                      loadSource: loadSource,
+                      loadVariantMeta: loadVariantMeta,
+                      sourceTransformers: undefined,
+                      // sourceTransformers
+                      disableTransforms: true,
+                      disableParsing: !shouldHighlight,
+                      globalsCode: globalsCodeObjects && globalsCodeObjects.length > 0 ? function () {
+                        // Convert globalsCodeObjects to VariantCode | string for this specific variant
+                        var variantGlobalsCode = [];
+                        var _iterator2 = _createForOfIteratorHelper(globalsCodeObjects),
+                          _step2;
+                        try {
+                          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                            var _codeObj = _step2.value;
+                            // Only use the variant that matches the current variantName
+                            var _targetVariant = _codeObj[variantName];
+                            if (_targetVariant) {
+                              variantGlobalsCode.push(_targetVariant);
+                            }
+                          }
+                        } catch (err) {
+                          _iterator2.e(err);
+                        } finally {
+                          _iterator2.f();
+                        }
+                        return variantGlobalsCode;
+                      }() : undefined
+                    });
+                  case 7:
+                    _yield$loadVariant2 = _context3.v;
+                    _loadedVariant = _yield$loadVariant2.code;
+                    // Collect file names from this variant
+                    fileNames = _loadedVariant.fileName ? [_loadedVariant.fileName] : [];
+                    if (_loadedVariant.extraFiles) {
+                      fileNames.push.apply(fileNames, _toConsumableArray(Object.keys(_loadedVariant.extraFiles)));
+                    }
+                    return _context3.a(2, {
+                      variantName: variantName,
+                      loadedVariant: _loadedVariant,
+                      fileNames: fileNames
+                    });
+                  case 8:
+                    _context3.p = 8;
+                    _t3 = _context3.v;
+                    // Log but don't fail - we want to get as many file names as possible
+                    console.warn("Failed to load variant ".concat(variantName, " for file listing: ").concat(_t3));
+                    return _context3.a(2, {
+                      variantName: variantName,
+                      loadedVariant: null,
+                      fileNames: []
+                    });
+                }
+              }, _callee3, null, [[6, 8], [2, 4]]);
+            }));
+            return function (_x8) {
+              return _ref2.apply(this, arguments);
+            };
+          }());
+          _context4.n = 42;
+          return Promise.all(variantPromises);
+        case 42:
+          variantResults = _context4.v;
+          // Update loaded code and collect file names
+          variantResults.forEach(function (_ref3) {
+            var variantName = _ref3.variantName,
+              loadedVariant = _ref3.loadedVariant,
+              fileNames = _ref3.fileNames;
+            if (loadedVariant) {
+              loaded = _extends(_extends({}, loaded), {}, _defineProperty({}, variantName, loadedVariant));
+            }
+            fileNames.forEach(function (fileName) {
+              return allFileNames.add(fileName);
+            });
+          });
+        case 43:
+          // Ensure we have the latest initial variant data
+          finalInitial = loaded[initialVariant];
+          if (!(!finalInitial || typeof finalInitial === 'string')) {
+            _context4.n = 44;
+            break;
+          }
+          throw new Error("Failed to process initial variant: ".concat(initialVariant));
+        case 44:
+          _context4.p = 44;
+          _context4.n = 45;
+          return getFileSource(finalInitial, initialFilename, loadSource);
+        case 45:
+          _result2 = _context4.v;
+          finalFileSource = _result2.source;
+          finalFilename = _result2.filename;
+          _context4.n = 48;
+          break;
+        case 46:
+          _context4.p = 46;
+          _t1 = _context4.v;
+          if (!(!finalInitial.fileName && !finalInitial.source)) {
+            _context4.n = 47;
+            break;
+          }
+          throw new Error("Cannot determine filename for initial variant \"".concat(initialVariant, "\". ") + "No fileName available in variant definition, no initialFilename provided, and no source available.");
+        case 47:
+          // Fall back to the main file with proper validation
+          finalFileSource = finalInitial.source || '';
+          finalFilename = finalInitial.fileName;
+        case 48:
+          return _context4.a(2, {
+            code: loaded,
+            initialFilename: finalFilename,
+            initialSource: finalFileSource,
+            initialExtraFiles: finalInitial.extraFiles || {},
+            allFileNames: Array.from(allFileNames),
+            processedGlobalsCode: globalsCodeObjects
+          });
+      }
+    }, _callee4, null, [[44, 46], [37, 39], [25, 27], [21, 23], [17, 32], [10, 12], [6, 8], [1, 3]]);
+  }));
+  return _loadFallbackCode.apply(this, arguments);
+}

package/esm/CodeHighlighter/loadVariant.d.ts

@@ -0,0 +1,12 @@
+import type { VariantCode, LoadVariantOptions, Externals } from "./types.js";
+/**
+ * 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.
+ */
+export declare function loadVariant(url: string | undefined, variantName: string, variant: VariantCode | string | undefined, options?: LoadVariantOptions): Promise<{
+  code: VariantCode;
+  dependencies: string[];
+  externals: Externals;
+}>;