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

package/esm/CodeHighlighter/CodeHighlighter.js

@@ -1,9 +1,3 @@
-import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
-import _regenerator from "@babel/runtime/helpers/esm/regenerator";
-import _typeof from "@babel/runtime/helpers/esm/typeof";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
-import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
 import { loadCodeVariant } from "../pipeline/loadCodeVariant/loadCodeVariant.js";
 import { loadCodeFallback } from "../pipeline/loadCodeVariant/loadCodeFallback.js";
@@ -14,19 +8,20 @@ import { getFileNameFromUrl, getLanguageFromExtension } from "../pipeline/loader
 import { codeToFallbackProps } from "./codeToFallbackProps.js";
 import * as Errors from "./errors.js";
 import { jsx as _jsx } from "react/jsx-runtime";
-var DEBUG = false; // Set to true for debugging purposes
+const DEBUG = false; // Set to true for debugging purposes
 
 function createClientProps(props) {
-  var highlightAfter = props.highlightAfter === 'stream' ? 'init' : props.highlightAfter;
-  var enhanceAfter = props.enhanceAfter === 'stream' ? 'init' : props.enhanceAfter;
-  var contentProps = _extends({
+  const highlightAfter = props.highlightAfter === 'stream' ? 'init' : props.highlightAfter;
+  const enhanceAfter = props.enhanceAfter === 'stream' ? 'init' : props.enhanceAfter;
+  const contentProps = {
     code: props.code || props.precompute,
     components: props.components,
     name: props.name,
     slug: props.slug,
     url: props.url,
-    variantType: props.variantType
-  }, props.contentProps);
+    variantType: props.variantType,
+    ...props.contentProps
+  };
   return {
     url: props.url,
     code: props.code,
@@ -49,386 +44,306 @@ function createClientProps(props) {
     // otherwise we will get an error because functions can't be serialized
     // On the client, in order to send data to these components, we have to set context
     fallback: props.fallback,
-    children: /*#__PURE__*/_jsx(props.Content, _extends({}, contentProps))
+    children: /*#__PURE__*/_jsx(props.Content, {
+      ...contentProps
+    })
   };
 }
-function CodeSourceLoader(_x) {
-  return _CodeSourceLoader.apply(this, arguments);
-}
-function _CodeSourceLoader() {
-  _CodeSourceLoader = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(props) {
-    var loadedCode, processedGlobalsCode, hasStringUrls, globalsPromises, variantNames, variantCodes, processedCode, errors, _iterator2, _step2, item, clientProps, _t2;
-    return _regenerator().w(function (_context2) {
-      while (1) switch (_context2.p = _context2.n) {
-        case 0:
-          // Start with the loaded code from precompute, or load it if needed
-          loadedCode = props.code || props.precompute;
-          if (loadedCode) {
-            _context2.n = 5;
-            break;
-          }
-          if (props.loadCodeMeta) {
-            _context2.n = 1;
-            break;
-          }
-          throw new Errors.ErrorCodeHighlighterServerMissingLoadCodeMeta();
-        case 1:
-          if (props.url) {
-            _context2.n = 2;
-            break;
-          }
-          throw new Errors.ErrorCodeHighlighterServerMissingUrlForLoadCodeMeta();
-        case 2:
-          _context2.p = 2;
-          _context2.n = 3;
-          return props.loadCodeMeta(props.url);
-        case 3:
-          loadedCode = _context2.v;
-          _context2.n = 5;
-          break;
-        case 4:
-          _context2.p = 4;
-          _t2 = _context2.v;
-          throw new Errors.ErrorCodeHighlighterServerLoadCodeFailure(props.url, _t2);
-        case 5:
-          // TODO: if props.variant is provided, we should only load that variant
-          // Process globalsCode: use already processed version if available, otherwise convert string URLs to Code objects
-          processedGlobalsCode = props.processedGlobalsCode;
-          if (!(!processedGlobalsCode && props.globalsCode && props.globalsCode.length > 0)) {
-            _context2.n = 8;
-            break;
-          }
-          hasStringUrls = props.globalsCode.some(function (item) {
-            return typeof item === 'string';
-          });
-          if (!(hasStringUrls && !props.loadCodeMeta)) {
-            _context2.n = 6;
-            break;
-          }
-          throw new Errors.ErrorCodeHighlighterServerMissingLoadCodeMetaForGlobals();
-        case 6:
-          // Load all string URLs in parallel, keep Code objects as-is
-          globalsPromises = props.globalsCode.map(/*#__PURE__*/function () {
-            var _ref = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(globalItem) {
-              var _t;
-              return _regenerator().w(function (_context) {
-                while (1) switch (_context.p = _context.n) {
-                  case 0:
-                    if (!(typeof globalItem === 'string')) {
-                      _context.n = 4;
-                      break;
-                    }
-                    _context.p = 1;
-                    _context.n = 2;
-                    return props.loadCodeMeta(globalItem);
-                  case 2:
-                    return _context.a(2, _context.v);
-                  case 3:
-                    _context.p = 3;
-                    _t = _context.v;
-                    throw new Errors.ErrorCodeHighlighterServerLoadGlobalsFailure(globalItem, _t);
-                  case 4:
-                    return _context.a(2, globalItem);
-                  case 5:
-                    return _context.a(2);
-                }
-              }, _callee, null, [[1, 3]]);
-            }));
-            return function (_x4) {
-              return _ref.apply(this, arguments);
-            };
-          }());
-          _context2.n = 7;
-          return Promise.all(globalsPromises);
-        case 7:
-          processedGlobalsCode = _context2.v;
-        case 8:
-          variantNames = Object.keys(props.components || loadedCode || {});
-          _context2.n = 9;
-          return Promise.all(variantNames.map(function (variantName) {
-            var variantCode = loadedCode[variantName];
-            var variantUrl = _typeof(variantCode) === 'object' && variantCode != null && variantCode.url ? variantCode.url : props.url;
+async function CodeSourceLoader(props) {
+  // Start with the loaded code from precompute, or load it if needed
+  let loadedCode = props.code || props.precompute;
+  if (!loadedCode) {
+    if (!props.loadCodeMeta) {
+      throw new Errors.ErrorCodeHighlighterServerMissingLoadCodeMeta();
+    }
+    if (!props.url) {
+      throw new Errors.ErrorCodeHighlighterServerMissingUrlForLoadCodeMeta();
+    }
+    try {
+      loadedCode = await props.loadCodeMeta(props.url);
+    } catch (error) {
+      throw new Errors.ErrorCodeHighlighterServerLoadCodeFailure(props.url, error);
+    }
+  }
+
+  // TODO: if props.variant is provided, we should only load that variant
+
+  // Process globalsCode: use already processed version if available, otherwise convert string URLs to Code objects
+  let processedGlobalsCode = props.processedGlobalsCode;
+  if (!processedGlobalsCode && props.globalsCode && props.globalsCode.length > 0) {
+    const hasStringUrls = props.globalsCode.some(item => typeof item === 'string');
+    if (hasStringUrls && !props.loadCodeMeta) {
+      throw new Errors.ErrorCodeHighlighterServerMissingLoadCodeMetaForGlobals();
+    }
 
-            // Convert processedGlobalsCode to VariantCode | string for this specific variant
-            var resolvedGlobalsCode;
-            if (processedGlobalsCode && processedGlobalsCode.length > 0) {
-              resolvedGlobalsCode = [];
-              var _iterator = _createForOfIteratorHelper(processedGlobalsCode),
-                _step;
-              try {
-                for (_iterator.s(); !(_step = _iterator.n()).done;) {
-                  var codeObj = _step.value;
-                  // Only include if this variant exists in the globalsCode
-                  var targetVariant = codeObj[variantName];
-                  if (targetVariant) {
-                    resolvedGlobalsCode.push(targetVariant);
-                  }
-                }
-              } catch (err) {
-                _iterator.e(err);
-              } finally {
-                _iterator.f();
-              }
-            }
-            var output = 'hastGzip';
-            if (props.deferParsing === 'json') {
-              output = 'hastJson';
-            } else if (props.deferParsing === 'none') {
-              output = 'hast';
-            }
-            return loadCodeVariant(variantUrl, variantName, variantCode, {
-              sourceParser: props.sourceParser,
-              loadSource: props.loadSource,
-              loadVariantMeta: props.loadVariantMeta,
-              sourceTransformers: props.sourceTransformers,
-              globalsCode: resolvedGlobalsCode,
-              output: output
-            }).then(function (variant) {
-              return {
-                name: variantName,
-                variant: variant
-              };
-            })["catch"](function (error) {
-              return {
-                error: error
-              };
-            });
-          }));
-        case 9:
-          variantCodes = _context2.v;
-          processedCode = {};
-          errors = [];
-          _iterator2 = _createForOfIteratorHelper(variantCodes);
-          try {
-            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-              item = _step2.value;
-              if ('error' in item) {
-                console.error(new Errors.ErrorCodeHighlighterServerLoadVariantFailure(props.url, item.error));
-                errors.push(item.error);
-              } else {
-                processedCode[item.name] = item.variant.code;
-              }
-            }
-          } catch (err) {
-            _iterator2.e(err);
-          } finally {
-            _iterator2.f();
-          }
-          if (!(errors.length > 0)) {
-            _context2.n = 10;
-            break;
-          }
-          throw new Errors.ErrorCodeHighlighterServerLoadVariantsFailure(props.url, errors);
-        case 10:
-          clientProps = createClientProps(_extends(_extends({}, props), {}, {
-            code: processedCode,
-            processedGlobalsCode: processedGlobalsCode
-          }));
-          return _context2.a(2, /*#__PURE__*/_jsx(CodeHighlighterClient, _extends({}, clientProps)));
+    // Load all string URLs in parallel, keep Code objects as-is
+    const globalsPromises = props.globalsCode.map(async globalItem => {
+      if (typeof globalItem === 'string') {
+        // String URL - load Code object via loadCodeMeta
+        try {
+          return await props.loadCodeMeta(globalItem);
+        } catch (error) {
+          throw new Errors.ErrorCodeHighlighterServerLoadGlobalsFailure(globalItem, error);
+        }
+      } else {
+        // Code object - return as-is
+        return globalItem;
       }
-    }, _callee2, null, [[2, 4]]);
+    });
+    processedGlobalsCode = await Promise.all(globalsPromises);
+  }
+  const variantNames = Object.keys(props.components || loadedCode || {});
+  const variantCodes = await Promise.all(variantNames.map(variantName => {
+    const variantCode = loadedCode[variantName];
+    const variantUrl = typeof variantCode === 'object' && variantCode?.url ? variantCode.url : props.url;
+
+    // Convert processedGlobalsCode to VariantCode | string for this specific variant
+    let resolvedGlobalsCode;
+    if (processedGlobalsCode && processedGlobalsCode.length > 0) {
+      resolvedGlobalsCode = [];
+      for (const codeObj of processedGlobalsCode) {
+        // Only include if this variant exists in the globalsCode
+        const targetVariant = codeObj[variantName];
+        if (targetVariant) {
+          resolvedGlobalsCode.push(targetVariant);
+        }
+      }
+    }
+    let output = 'hastGzip';
+    if (props.deferParsing === 'json') {
+      output = 'hastJson';
+    } else if (props.deferParsing === 'none') {
+      output = 'hast';
+    }
+    return loadCodeVariant(variantUrl, variantName, variantCode, {
+      sourceParser: props.sourceParser,
+      loadSource: props.loadSource,
+      loadVariantMeta: props.loadVariantMeta,
+      sourceTransformers: props.sourceTransformers,
+      globalsCode: resolvedGlobalsCode,
+      output
+    }).then(variant => ({
+      name: variantName,
+      variant
+    })).catch(error => ({
+      error
+    }));
   }));
-  return _CodeSourceLoader.apply(this, arguments);
+  const processedCode = {};
+  const errors = [];
+  for (const item of variantCodes) {
+    if ('error' in item) {
+      console.error(new Errors.ErrorCodeHighlighterServerLoadVariantFailure(props.url, item.error));
+      errors.push(item.error);
+    } else {
+      processedCode[item.name] = item.variant.code;
+    }
+  }
+  if (errors.length > 0) {
+    throw new Errors.ErrorCodeHighlighterServerLoadVariantsFailure(props.url, errors);
+  }
+  const clientProps = createClientProps({
+    ...props,
+    code: processedCode,
+    processedGlobalsCode
+  });
+  return /*#__PURE__*/_jsx(CodeHighlighterClient, {
+    ...clientProps
+  });
 }
 function renderCodeHighlighter(props) {
-  var code = props.code || props.precompute;
-  var variants = props.variants || Object.keys(props.components || code || {});
-  var allCodeVariantsLoaded = code && hasAllVariants(variants, code, true);
+  const code = props.code || props.precompute;
+  const variants = props.variants || Object.keys(props.components || code || {});
+  const allCodeVariantsLoaded = code && hasAllVariants(variants, code, true);
 
   // Check if any loader functions are available before trying async loading
-  var hasAnyLoaderFunction = !!(props.loadCodeMeta || props.loadVariantMeta || props.loadSource || props.sourceParser || props.sourceTransformers);
+  const hasAnyLoaderFunction = !!(props.loadCodeMeta || props.loadVariantMeta || props.loadSource || props.sourceParser || props.sourceTransformers);
   if (!allCodeVariantsLoaded && hasAnyLoaderFunction && !props.forceClient) {
-    return /*#__PURE__*/_jsx(CodeSourceLoader, _extends({}, props));
+    return /*#__PURE__*/_jsx(CodeSourceLoader, {
+      ...props
+    });
   }
-  var clientProps = createClientProps(props);
-  return /*#__PURE__*/_jsx(CodeHighlighterClient, _extends({}, clientProps));
+  const clientProps = createClientProps(props);
+  return /*#__PURE__*/_jsx(CodeHighlighterClient, {
+    ...clientProps
+  });
 }
 
 /**
  * Ensures that the suspense boundary is always rendered, even if none of the children have async operations.
  */
-function CodeHighlighterSuspense(_x2) {
-  return _CodeHighlighterSuspense.apply(this, arguments);
-}
-function _CodeHighlighterSuspense() {
-  _CodeHighlighterSuspense = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(props) {
-    return _regenerator().w(function (_context3) {
-      while (1) switch (_context3.n) {
-        case 0:
-          _context3.n = 1;
-          return new Promise(function (resolve) {
-            setTimeout(resolve, 0);
-          });
-        case 1:
-          return _context3.a(2, props.children);
-      }
-    }, _callee3);
-  }));
-  return _CodeHighlighterSuspense.apply(this, arguments);
+async function CodeHighlighterSuspense(props) {
+  await new Promise(resolve => {
+    setTimeout(resolve, 0);
+  });
+  return props.children;
 }
 function renderWithInitialSource(props) {
-  var _props$components;
-  var ContentLoading = props.ContentLoading;
-  var url = props.url,
-    slug = props.slug,
-    name = props.name,
-    initialVariant = props.initialVariant,
-    code = props.code,
-    initialFilename = props.initialFilename,
-    fallbackUsesExtraFiles = props.fallbackUsesExtraFiles,
-    fallbackUsesAllVariants = props.fallbackUsesAllVariants;
-  var fallbackProps = codeToFallbackProps(initialVariant, code, initialFilename, fallbackUsesExtraFiles, fallbackUsesAllVariants);
+  const ContentLoading = props.ContentLoading;
+  const {
+    url,
+    slug,
+    name,
+    initialVariant,
+    code,
+    initialFilename,
+    fallbackUsesExtraFiles,
+    fallbackUsesAllVariants
+  } = props;
+  const fallbackProps = codeToFallbackProps(initialVariant, code, initialFilename, fallbackUsesExtraFiles, fallbackUsesAllVariants);
 
   // Get the component for the selected variant
-  var component = (_props$components = props.components) == null ? void 0 : _props$components[initialVariant];
+  const component = props.components?.[initialVariant];
 
   // Only include components (plural) if we're also including extraVariants
-  var components = fallbackProps.extraVariants ? props.components : undefined;
-  var contentProps = _extends(_extends({
-    name: name,
-    slug: slug,
-    url: url,
-    initialFilename: initialFilename,
-    component: component,
-    components: components
-  }, fallbackProps), props.contentProps);
-  var fallback = /*#__PURE__*/_jsx(ContentLoading, _extends({}, contentProps));
+  const components = fallbackProps.extraVariants ? props.components : undefined;
+  const contentProps = {
+    name,
+    slug,
+    url,
+    initialFilename,
+    component,
+    components,
+    ...fallbackProps,
+    ...props.contentProps
+  };
+  const fallback = /*#__PURE__*/_jsx(ContentLoading, {
+    ...contentProps
+  });
   if (props.highlightAfter === 'stream' && !props.forceClient) {
     return /*#__PURE__*/_jsx(React.Suspense, {
       fallback: fallback,
       children: /*#__PURE__*/_jsx(CodeHighlighterSuspense, {
-        children: renderCodeHighlighter(_extends(_extends({}, props), {}, {
-          fallback: fallback,
+        children: renderCodeHighlighter({
+          ...props,
+          fallback,
           skipFallback: props.enhanceAfter === 'stream'
-        }))
+        })
       })
     });
   }
-  return renderCodeHighlighter(_extends(_extends({}, props), {}, {
-    fallback: fallback
-  }));
+  return renderCodeHighlighter({
+    ...props,
+    fallback
+  });
 }
-function CodeInitialSourceLoader(_x3) {
-  return _CodeInitialSourceLoader.apply(this, arguments);
-}
-function _CodeInitialSourceLoader() {
-  _CodeInitialSourceLoader = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(props) {
-    var url, initialVariant, highlightAfter, fallbackUsesExtraFiles, fallbackUsesAllVariants, sourceParser, loadSource, loadVariantMeta, loadCodeMeta, fileName, variants, globalsCode, ContentLoading, output, _yield$loadCodeFallba, code, initialFilename, initialSource, initialExtraFiles, processedGlobalsCode;
-    return _regenerator().w(function (_context4) {
-      while (1) switch (_context4.n) {
-        case 0:
-          url = props.url, initialVariant = props.initialVariant, highlightAfter = props.highlightAfter, fallbackUsesExtraFiles = props.fallbackUsesExtraFiles, fallbackUsesAllVariants = props.fallbackUsesAllVariants, sourceParser = props.sourceParser, loadSource = props.loadSource, loadVariantMeta = props.loadVariantMeta, loadCodeMeta = props.loadCodeMeta, fileName = props.fileName, variants = props.variants, globalsCode = props.globalsCode, ContentLoading = props.ContentLoading;
-          if (url) {
-            _context4.n = 1;
-            break;
-          }
-          throw new Errors.ErrorCodeHighlighterServerMissingUrl();
-        case 1:
-          output = 'hastGzip';
-          if (props.deferParsing === 'json') {
-            output = 'hastJson';
-          } else if (props.deferParsing === 'none') {
-            output = 'hast';
-          }
-          _context4.n = 2;
-          return loadCodeFallback(url, initialVariant, props.code, {
-            shouldHighlight: highlightAfter === 'init',
-            fallbackUsesExtraFiles: fallbackUsesExtraFiles,
-            fallbackUsesAllVariants: fallbackUsesAllVariants,
-            sourceParser: sourceParser,
-            loadSource: loadSource,
-            loadVariantMeta: loadVariantMeta,
-            loadCodeMeta: loadCodeMeta,
-            initialFilename: fileName,
-            variants: variants,
-            globalsCode: globalsCode,
-            output: output
-          });
-        case 2:
-          _yield$loadCodeFallba = _context4.v;
-          code = _yield$loadCodeFallba.code;
-          initialFilename = _yield$loadCodeFallba.initialFilename;
-          initialSource = _yield$loadCodeFallba.initialSource;
-          initialExtraFiles = _yield$loadCodeFallba.initialExtraFiles;
-          processedGlobalsCode = _yield$loadCodeFallba.processedGlobalsCode;
-          return _context4.a(2, renderWithInitialSource(_extends(_extends({}, props), {}, {
-            ContentLoading: ContentLoading,
-            code: code,
-            initialFilename: initialFilename,
-            initialSource: initialSource,
-            initialExtraFiles: initialExtraFiles,
-            processedGlobalsCode: processedGlobalsCode
-          })));
-      }
-    }, _callee4);
-  }));
-  return _CodeInitialSourceLoader.apply(this, arguments);
+async function CodeInitialSourceLoader(props) {
+  const {
+    url,
+    initialVariant,
+    highlightAfter,
+    fallbackUsesExtraFiles,
+    fallbackUsesAllVariants,
+    sourceParser,
+    loadSource,
+    loadVariantMeta,
+    loadCodeMeta,
+    fileName,
+    variants,
+    globalsCode,
+    ContentLoading
+  } = props;
+  if (!url) {
+    throw new Errors.ErrorCodeHighlighterServerMissingUrl();
+  }
+  let output = 'hastGzip';
+  if (props.deferParsing === 'json') {
+    output = 'hastJson';
+  } else if (props.deferParsing === 'none') {
+    output = 'hast';
+  }
+  const {
+    code,
+    initialFilename,
+    initialSource,
+    initialExtraFiles,
+    processedGlobalsCode
+  } = await loadCodeFallback(url, initialVariant, props.code, {
+    shouldHighlight: highlightAfter === 'init',
+    fallbackUsesExtraFiles,
+    fallbackUsesAllVariants,
+    sourceParser,
+    loadSource,
+    loadVariantMeta,
+    loadCodeMeta,
+    initialFilename: fileName,
+    variants,
+    globalsCode,
+    output
+  });
+  return renderWithInitialSource({
+    ...props,
+    ContentLoading,
+    code,
+    initialFilename,
+    initialSource,
+    initialExtraFiles,
+    processedGlobalsCode
+  });
 }
 export function CodeHighlighter(props) {
-  var _code, _props$precompute, _props$components2;
   // Validate mutually exclusive props
   if (props.children && (props.code || props.precompute)) {
     throw new Errors.ErrorCodeHighlighterServerInvalidProps();
   }
 
   // Handle children as string -> Default variant
-  var code = props.code;
+  let code = props.code;
   if (props.children && typeof props.children === 'string') {
-    var fileName = props.fileName || (props.url ? getFileNameFromUrl(props.url).fileName : undefined);
+    const fileName = props.fileName || (props.url ? getFileNameFromUrl(props.url).fileName : undefined);
     // Derive language: use explicit prop, or derive from fileName extension
-    var language = props.language;
+    let language = props.language;
     if (!language && fileName) {
-      var extension = fileName.slice(fileName.lastIndexOf('.'));
+      const extension = fileName.slice(fileName.lastIndexOf('.'));
       language = getLanguageFromExtension(extension);
     }
     code = {
       Default: {
-        fileName: fileName,
-        language: language,
+        fileName,
+        language,
         source: props.children,
         url: props.url
       }
     };
   }
-  var variants = props.variants || Object.keys(props.components || code || props.precompute || {});
+  const variants = props.variants || Object.keys(props.components || code || props.precompute || {});
   if (variants.length === 0) {
     throw new Errors.ErrorCodeHighlighterServerMissingData();
   }
 
   // Validate fileName is provided when extraFiles are present
   if (code) {
-    for (var _i = 0, _Object$entries = Object.entries(code); _i < _Object$entries.length; _i++) {
-      var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
-        variantName = _Object$entries$_i[0],
-        variantCode = _Object$entries$_i[1];
-      if (_typeof(variantCode) === 'object' && variantCode != null && variantCode.extraFiles && Object.keys(variantCode.extraFiles).length > 0 && !variantCode.fileName && !variantCode.url) {
+    for (const [variantName, variantCode] of Object.entries(code)) {
+      if (typeof variantCode === 'object' && variantCode?.extraFiles && Object.keys(variantCode.extraFiles).length > 0 && !variantCode.fileName && !variantCode.url) {
         throw new Errors.ErrorCodeHighlighterServerMissingFileName(variantName);
       }
     }
   }
-  var ContentLoading = props.ContentLoading;
+  const ContentLoading = props.ContentLoading;
   if (!ContentLoading) {
     if (props.highlightAfter === 'stream') {
       // if the user explicitly sets highlightAfter to 'stream', we need a ContentLoading component
       throw new Errors.ErrorCodeHighlighterServerMissingContentLoading();
     }
-    return renderCodeHighlighter(_extends(_extends({}, props), {}, {
-      code: code
-    }));
+    return renderCodeHighlighter({
+      ...props,
+      code
+    });
   }
-  var initialKey = props.initialVariant || props.variant || props.defaultVariant || variants[0];
-  var initial = ((_code = code) == null ? void 0 : _code[initialKey]) || ((_props$precompute = props.precompute) == null ? void 0 : _props$precompute[initialKey]);
-  if (!initial && !((_props$components2 = props.components) != null && _props$components2[initialKey])) {
+  const initialKey = props.initialVariant || props.variant || props.defaultVariant || variants[0];
+  const initial = code?.[initialKey] || props.precompute?.[initialKey];
+  if (!initial && !props.components?.[initialKey]) {
     throw new Errors.ErrorCodeHighlighterServerMissingVariant(initialKey);
   }
 
   // TODO: use initial.filesOrder to determing which source to use
 
-  var _maybeCodeInitialData = maybeCodeInitialData(variants, initialKey, code || props.precompute, undefined,
-    // TODO: use initial.filesOrder if provided?
-    props.highlightAfter === 'init', props.fallbackUsesExtraFiles, props.fallbackUsesAllVariants),
-    initialData = _maybeCodeInitialData.initialData,
-    reason = _maybeCodeInitialData.reason;
+  const {
+    initialData,
+    reason
+  } = maybeCodeInitialData(variants, initialKey, code || props.precompute, undefined,
+  // TODO: use initial.filesOrder if provided?
+  props.highlightAfter === 'init', props.fallbackUsesExtraFiles, props.fallbackUsesAllVariants);
   if (!initialData) {
     if (DEBUG) {
       // eslint-disable-next-line no-console
@@ -436,28 +351,31 @@ export function CodeHighlighter(props) {
     }
 
     // Check if any loader functions are available
-    var hasAnyLoaderFunction = !!(props.loadCodeMeta || props.loadVariantMeta || props.loadSource || props.sourceParser || props.sourceTransformers);
+    const hasAnyLoaderFunction = !!(props.loadCodeMeta || props.loadVariantMeta || props.loadSource || props.sourceParser || props.sourceTransformers);
 
     // If no loader functions are available, skip async loading and go directly to client
     if (!hasAnyLoaderFunction || props.forceClient) {
       if (props.highlightAfter === 'init') {
         throw new Errors.ErrorCodeHighlighterServerInvalidClientMode();
       }
-      return renderCodeHighlighter(_extends(_extends({}, props), {}, {
-        code: code
-      }));
+      return renderCodeHighlighter({
+        ...props,
+        code
+      });
     }
-    return /*#__PURE__*/_jsx(CodeInitialSourceLoader, _extends(_extends({}, props), {}, {
+    return /*#__PURE__*/_jsx(CodeInitialSourceLoader, {
+      ...props,
       ContentLoading: ContentLoading,
       initialVariant: initialKey
-    }));
+    });
   }
-  return renderWithInitialSource(_extends(_extends({}, props), {}, {
+  return renderWithInitialSource({
+    ...props,
     code: initialData.code,
-    ContentLoading: ContentLoading,
+    ContentLoading,
     initialVariant: initialKey,
     initialFilename: initialData.initialFilename,
     initialSource: initialData.initialSource,
     initialExtraFiles: initialData.initialExtraFiles
-  }));
+  });
 }