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

package/esm/cli/runValidate.js

@@ -1,6 +1,3 @@
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-import _regenerator from "@babel/runtime/helpers/esm/regenerator";
-import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 /* eslint-disable no-console */
 import chalk from 'chalk';
 import { readdir, readFile, rm } from 'node:fs/promises';
@@ -10,288 +7,187 @@ import remarkParse from 'remark-parse';
 import remarkMdx from 'remark-mdx';
 import { nameMark, performanceMeasure } from "../pipeline/loadPrecomputedCodeHighlighter/performanceLogger.js";
 import { transformMarkdownMetadata } from "../pipeline/transformMarkdownMetadata/transformMarkdownMetadata.js";
-var completeMessage = function completeMessage(message) {
-  return "\u2713 ".concat(chalk.green(message));
-};
-var functionName = 'Run Validate';
+const completeMessage = message => `✓ ${chalk.green(message)}`;
+const functionName = 'Run Validate';
 
 /**
  * Recursively find all files matching a specific name in a directory
  */
-function findFiles(_x, _x2) {
-  return _findFiles.apply(this, arguments);
-}
-function _findFiles() {
-  _findFiles = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5(dir, fileName) {
-    var results, entries, _t3;
-    return _regenerator().w(function (_context5) {
-      while (1) switch (_context5.p = _context5.n) {
-        case 0:
-          results = [];
-          _context5.p = 1;
-          _context5.n = 2;
-          return readdir(dir, {
-            withFileTypes: true
-          });
-        case 2:
-          entries = _context5.v;
-          _context5.n = 3;
-          return Promise.all(entries.map(/*#__PURE__*/function () {
-            var _ref3 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(entry) {
-              var fullPath, subResults;
-              return _regenerator().w(function (_context4) {
-                while (1) switch (_context4.n) {
-                  case 0:
-                    fullPath = path.join(dir, entry.name);
-                    if (!entry.isDirectory()) {
-                      _context4.n = 2;
-                      break;
-                    }
-                    _context4.n = 1;
-                    return findFiles(fullPath, fileName);
-                  case 1:
-                    subResults = _context4.v;
-                    results.push.apply(results, _toConsumableArray(subResults));
-                    _context4.n = 3;
-                    break;
-                  case 2:
-                    if (entry.isFile() && entry.name === fileName) {
-                      results.push(fullPath);
-                    }
-                  case 3:
-                    return _context4.a(2);
-                }
-              }, _callee4);
-            }));
-            return function (_x5) {
-              return _ref3.apply(this, arguments);
-            };
-          }()));
-        case 3:
-          _context5.n = 5;
-          break;
-        case 4:
-          _context5.p = 4;
-          _t3 = _context5.v;
-          if (!(_t3.code !== 'ENOENT')) {
-            _context5.n = 5;
-            break;
-          }
-          throw _t3;
-        case 5:
-          return _context5.a(2, results);
+async function findFiles(dir, fileName) {
+  const results = [];
+  try {
+    const entries = await readdir(dir, {
+      withFileTypes: true
+    });
+    await Promise.all(entries.map(async entry => {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        const subResults = await findFiles(fullPath, fileName);
+        results.push(...subResults);
+      } else if (entry.isFile() && entry.name === fileName) {
+        results.push(fullPath);
       }
-    }, _callee5, null, [[1, 4]]);
-  }));
-  return _findFiles.apply(this, arguments);
+    }));
+  } catch (error) {
+    // Skip if directory doesn't exist
+    if (error.code !== 'ENOENT') {
+      throw error;
+    }
+  }
+  return results;
 }
-var runValidate = {
+const runValidate = {
   command: 'validate [paths...]',
   describe: 'Ensures that committed files match expected output',
-  builder: function builder(yargs) {
+  builder: yargs => {
     return yargs.option('command', {
       type: 'string',
       description: 'Command to suggest when indexes are out of date',
-      "default": 'pnpm docs-infra validate'
+      default: 'pnpm docs-infra validate'
     }).option('useVisibleDescription', {
       type: 'boolean',
       description: 'Use the first visible paragraph as description in extracted index instead of meta tag',
-      "default": false
+      default: false
     }).positional('paths', {
       type: 'string',
       array: true,
       description: 'Optional paths to validate (e.g., docs-infra/components docs-infra/functions)',
-      "default": []
+      default: []
     });
   },
-  handler: function () {
-    var _handler = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(args) {
-      var cwd, _args$paths, paths, _args$command, command, _args$useVisibleDescr, useVisibleDescription, ci;
-      return _regenerator().w(function (_context3) {
-        while (1) switch (_context3.n) {
-          case 0:
-            cwd = process.cwd();
-            _args$paths = args.paths, paths = _args$paths === void 0 ? [] : _args$paths, _args$command = args.command, command = _args$command === void 0 ? 'pnpm docs-infra validate' : _args$command, _args$useVisibleDescr = args.useVisibleDescription, useVisibleDescription = _args$useVisibleDescr === void 0 ? false : _args$useVisibleDescr;
-            ci = Boolean(process.env.CI);
-            _context3.n = 1;
-            return Promise.all([_asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2() {
-              var startMark, currentMark, markerDir, markerDirPath, searchDirs, pageMdxFilesPerDir, pageMdxFiles, hasSrcAppFiles, hasAppFiles, includePatterns, processor, hasErrors, updatedIndexes, generatedFiles, pathsArg, updatedPaths, _t2;
-              return _regenerator().w(function (_context2) {
-                while (1) switch (_context2.p = _context2.n) {
-                  case 0:
-                    console.log(chalk.cyan('Validating committed files match expected output...'));
-                    startMark = nameMark(functionName, 'Start Validation', []);
-                    currentMark = startMark;
-                    performance.mark(currentMark);
-                    markerDir = '.next/cache/docs-infra/index-updates';
-                    markerDirPath = path.join(cwd, markerDir); // Remove the marker directory if it exists
-                    _context2.p = 1;
-                    _context2.n = 2;
-                    return rm(markerDirPath, {
-                      recursive: true,
-                      force: true
-                    });
-                  case 2:
-                    _context2.n = 4;
-                    break;
-                  case 3:
-                    _context2.p = 3;
-                    _t2 = _context2.v;
-                  case 4:
-                    if (paths.length > 0) {
-                      // If paths are provided, search in those specific paths
-                      searchDirs = paths.flatMap(function (p) {
-                        return [path.join(cwd, 'src/app', p), path.join(cwd, 'app', p)];
-                      });
-                    } else {
-                      // Otherwise search all app directories
-                      searchDirs = [path.join(cwd, 'src/app'), path.join(cwd, 'app')];
-                    }
-                    _context2.n = 5;
-                    return Promise.all(searchDirs.map(function (dir) {
-                      return findFiles(dir, 'page.mdx');
-                    }));
-                  case 5:
-                    pageMdxFilesPerDir = _context2.v;
-                    pageMdxFiles = pageMdxFilesPerDir.flat();
-                    console.log(chalk.yellow("\nProcessing ".concat(pageMdxFiles.length, " page.mdx files...\n")));
+  handler: async args => {
+    const cwd = process.cwd();
+    const {
+      paths = [],
+      command = 'pnpm docs-infra validate',
+      useVisibleDescription = false
+    } = args;
+    const ci = Boolean(process.env.CI);
+    await Promise.all([(async () => {
+      console.log(chalk.cyan('Validating committed files match expected output...'));
+      const startMark = nameMark(functionName, 'Start Validation', []);
+      let currentMark = startMark;
+      performance.mark(currentMark);
+      const markerDir = '.next/cache/docs-infra/index-updates';
+      const markerDirPath = path.join(cwd, markerDir);
+
+      // Remove the marker directory if it exists
+      try {
+        await rm(markerDirPath, {
+          recursive: true,
+          force: true
+        });
+      } catch (error) {
+        // Ignore errors if directory doesn't exist
+      }
+
+      // Find all page.mdx files in src/app/ or app/ directories
+      let searchDirs;
+      if (paths.length > 0) {
+        // If paths are provided, search in those specific paths
+        searchDirs = paths.flatMap(p => [path.join(cwd, 'src/app', p), path.join(cwd, 'app', p)]);
+      } else {
+        // Otherwise search all app directories
+        searchDirs = [path.join(cwd, 'src/app'), path.join(cwd, 'app')];
+      }
+      const pageMdxFilesPerDir = await Promise.all(searchDirs.map(dir => findFiles(dir, 'page.mdx')));
+      const pageMdxFiles = pageMdxFilesPerDir.flat();
+      console.log(chalk.yellow(`\nProcessing ${pageMdxFiles.length} page.mdx files...\n`));
+
+      // Process each file through the unified pipeline
+      // Auto-detect include paths based on which directories actually contain files
+      const hasSrcAppFiles = pageMdxFilesPerDir.slice(0, Math.ceil(searchDirs.length / 2)) // First half are src/app paths
+      .some(files => files.length > 0);
+      const hasAppFiles = pageMdxFilesPerDir.slice(Math.ceil(searchDirs.length / 2)) // Second half are app paths
+      .some(files => files.length > 0);
+      const includePatterns = [];
+      if (hasSrcAppFiles) {
+        includePatterns.push('src/app');
+      }
+      if (hasAppFiles) {
+        includePatterns.push('app');
+      }
+      // Fallback to 'app' if neither has files (shouldn't happen but be safe)
+      if (includePatterns.length === 0) {
+        includePatterns.push('app');
+      }
+      const processor = unified().use(remarkParse).use(remarkMdx).use(transformMarkdownMetadata, {
+        extractToIndex: {
+          include: includePatterns,
+          exclude: [],
+          baseDir: cwd,
+          onlyUpdateIndexes: true,
+          markerDir,
+          useVisibleDescription
+        }
+      });
+      let hasErrors = false;
+      await Promise.all(pageMdxFiles.map(async filePath => {
+        try {
+          const content = await readFile(filePath, 'utf-8');
+          const vfile = {
+            path: filePath,
+            value: content
+          };
+          // Use run() instead of process() since we don't need HTML output
+          await processor.run(processor.parse(vfile), vfile);
+        } catch (error) {
+          hasErrors = true;
+          console.error(chalk.red(`Error processing ${filePath}:`), error);
+        }
+      }));
 
-                    // Process each file through the unified pipeline
-                    // Auto-detect include paths based on which directories actually contain files
-                    hasSrcAppFiles = pageMdxFilesPerDir.slice(0, Math.ceil(searchDirs.length / 2)) // First half are src/app paths
-                    .some(function (files) {
-                      return files.length > 0;
-                    });
-                    hasAppFiles = pageMdxFilesPerDir.slice(Math.ceil(searchDirs.length / 2)) // Second half are app paths
-                    .some(function (files) {
-                      return files.length > 0;
-                    });
-                    includePatterns = [];
-                    if (hasSrcAppFiles) {
-                      includePatterns.push('src/app');
-                    }
-                    if (hasAppFiles) {
-                      includePatterns.push('app');
-                    }
-                    // Fallback to 'app' if neither has files (shouldn't happen but be safe)
-                    if (includePatterns.length === 0) {
-                      includePatterns.push('app');
-                    }
-                    processor = unified().use(remarkParse).use(remarkMdx).use(transformMarkdownMetadata, {
-                      extractToIndex: {
-                        include: includePatterns,
-                        exclude: [],
-                        baseDir: cwd,
-                        onlyUpdateIndexes: true,
-                        markerDir: markerDir,
-                        useVisibleDescription: useVisibleDescription
-                      }
-                    });
-                    hasErrors = false;
-                    _context2.n = 6;
-                    return Promise.all(pageMdxFiles.map(/*#__PURE__*/function () {
-                      var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(filePath) {
-                        var content, vfile, _t;
-                        return _regenerator().w(function (_context) {
-                          while (1) switch (_context.p = _context.n) {
-                            case 0:
-                              _context.p = 0;
-                              _context.n = 1;
-                              return readFile(filePath, 'utf-8');
-                            case 1:
-                              content = _context.v;
-                              vfile = {
-                                path: filePath,
-                                value: content
-                              }; // Use run() instead of process() since we don't need HTML output
-                              _context.n = 2;
-                              return processor.run(processor.parse(vfile), vfile);
-                            case 2:
-                              _context.n = 4;
-                              break;
-                            case 3:
-                              _context.p = 3;
-                              _t = _context.v;
-                              hasErrors = true;
-                              console.error(chalk.red("Error processing ".concat(filePath, ":")), _t);
-                            case 4:
-                              return _context.a(2);
-                          }
-                        }, _callee, null, [[0, 3]]);
-                      }));
-                      return function (_x4) {
-                        return _ref2.apply(this, arguments);
-                      };
-                    }()));
-                  case 6:
-                    _context2.n = 7;
-                    return findFiles(markerDirPath, 'page.mdx');
-                  case 7:
-                    updatedIndexes = _context2.v;
-                    if (updatedIndexes.length > 0) {
-                      console.log(chalk.yellow('\nUpdated index files:'));
-                      updatedIndexes.forEach(function (markerPath) {
-                        // Convert marker path back to actual index path
-                        var relativePath = path.relative(markerDirPath, markerPath);
-                        console.log(chalk.gray("  ".concat(relativePath)));
-                      });
-                      console.log(chalk.yellow("\nTotal: ".concat(updatedIndexes.length, " indexes updated\n")));
-                    } else {
-                      console.log(chalk.green('\nNo indexes needed updating\n'));
-                    }
-                    generatedFiles = updatedIndexes.length;
-                    currentMark = performanceMeasure(currentMark, {
-                      mark: 'Validated Files',
-                      measure: 'Validating Files'
-                    }, [functionName], true);
-                    console.log(completeMessage("".concat(generatedFiles, " index files updated in ").concat((performance.measure(nameMark(functionName, 'Validation', []), startMark, currentMark).duration / 1000).toPrecision(3), "s")));
-                    if (hasErrors) {
-                      console.error(chalk.red('\n✗ Validation failed with errors\n'));
-                      process.exit(1);
-                    }
-                    if (ci && generatedFiles > 0) {
-                      pathsArg = '';
-                      if (paths.length > 0) {
-                        // Use the paths that were provided
-                        pathsArg = " ".concat(paths.join(' '));
-                      } else {
-                        // Derive paths from the updated indexes
-                        updatedPaths = new Set();
-                        updatedIndexes.forEach(function (markerPath) {
-                          var relativePath = path.relative(markerDirPath, markerPath);
-                          // Extract the directory path (e.g., 'app/docs-infra/components/page.mdx' -> 'docs-infra/components')
-                          var dir = path.dirname(relativePath);
-                          // Remove 'app/' or 'src/app/' prefix if present
-                          var cleanDir = dir.replace(/^(src\/)?app\//, '');
-                          if (cleanDir) {
-                            updatedPaths.add(cleanDir);
-                          }
-                        });
-                        if (updatedPaths.size > 0) {
-                          pathsArg = " ".concat(Array.from(updatedPaths).map(function (p) {
-                            return /^[a-zA-Z0-9/_.-]+$/.test(p) ? p : "\"".concat(p, "\"");
-                          }).join(' '));
-                        }
-                      }
-                      console.error(chalk.red('\n✗ Index files are out of date. Run this command locally:\n'));
-                      console.error(chalk.cyan("  ".concat(command).concat(pathsArg)));
-                      console.error(chalk.red('\nThen commit the results.\n'));
-                      process.exit(1);
-                    }
-                  case 8:
-                    return _context2.a(2);
-                }
-              }, _callee2, null, [[1, 3]]);
-            }))()]);
-          case 1:
-            return _context3.a(2);
+      // Find all marker files to see which indexes were updated
+      const updatedIndexes = await findFiles(markerDirPath, 'page.mdx');
+      if (updatedIndexes.length > 0) {
+        console.log(chalk.yellow('\nUpdated index files:'));
+        updatedIndexes.forEach(markerPath => {
+          // Convert marker path back to actual index path
+          const relativePath = path.relative(markerDirPath, markerPath);
+          console.log(chalk.gray(`  ${relativePath}`));
+        });
+        console.log(chalk.yellow(`\nTotal: ${updatedIndexes.length} indexes updated\n`));
+      } else {
+        console.log(chalk.green('\nNo indexes needed updating\n'));
+      }
+      const generatedFiles = updatedIndexes.length;
+      currentMark = performanceMeasure(currentMark, {
+        mark: 'Validated Files',
+        measure: 'Validating Files'
+      }, [functionName], true);
+      console.log(completeMessage(`${generatedFiles} index files updated in ${(performance.measure(nameMark(functionName, 'Validation', []), startMark, currentMark).duration / 1000).toPrecision(3)}s`));
+      if (hasErrors) {
+        console.error(chalk.red('\n✗ Validation failed with errors\n'));
+        process.exit(1);
+      }
+      if (ci && generatedFiles > 0) {
+        let pathsArg = '';
+        if (paths.length > 0) {
+          // Use the paths that were provided
+          pathsArg = ` ${paths.join(' ')}`;
+        } else {
+          // Derive paths from the updated indexes
+          const updatedPaths = new Set();
+          updatedIndexes.forEach(markerPath => {
+            const relativePath = path.relative(markerDirPath, markerPath);
+            // Extract the directory path (e.g., 'app/docs-infra/components/page.mdx' -> 'docs-infra/components')
+            const dir = path.dirname(relativePath);
+            // Remove 'app/' or 'src/app/' prefix if present
+            const cleanDir = dir.replace(/^(src\/)?app\//, '');
+            if (cleanDir) {
+              updatedPaths.add(cleanDir);
+            }
+          });
+          if (updatedPaths.size > 0) {
+            pathsArg = ` ${Array.from(updatedPaths).map(p => /^[a-zA-Z0-9/_.-]+$/.test(p) ? p : `"${p}"`).join(' ')}`;
+          }
         }
-      }, _callee3);
-    }));
-    function handler(_x3) {
-      return _handler.apply(this, arguments);
-    }
-    return handler;
-  }()
+        console.error(chalk.red('\n✗ Index files are out of date. Run this command locally:\n'));
+        console.error(chalk.cyan(`  ${command}${pathsArg}`));
+        console.error(chalk.red('\nThen commit the results.\n'));
+        process.exit(1);
+      }
+    })()]);
+  }
 };
 export default runValidate;

package/esm/createDemoData/createDemoData.js

@@ -9,26 +9,25 @@ import { extractNameAndSlugFromUrl } from "../pipeline/loaderUtils/index.js";
  * @param meta Additional meta for the demo.
  */
 export function createDemoDataWithVariants(url, variants, meta) {
-  var _meta$name, _meta$slug;
   if (!url.startsWith('file:')) {
     throw new Error('createDemoData() requires the `url` argument to be a file URL. Use `import.meta.url` to get the current file URL.');
   }
   if (!meta || !meta.precompute && !meta.skipPrecompute) {
-    throw new Error("createDemoData() was unable to precompute the code in ".concat(url, ". Ensure the createDemoData() function is called within a path used for demo indexes. This is typically app/**/demos/*/index.ts but may be overridden in next.config.js"));
+    throw new Error(`createDemoData() was unable to precompute the code in ${url}. Ensure the createDemoData() function is called within a path used for demo indexes. This is typically app/**/demos/*/index.ts but may be overridden in next.config.js`);
   }
-  var precompute = meta.precompute;
+  const precompute = meta.precompute;
 
   // Generate name and slug from URL if not provided in meta
-  var generatedMeta = extractNameAndSlugFromUrl(url);
-  var name = (_meta$name = meta.name) != null ? _meta$name : generatedMeta.name;
-  var slug = (_meta$slug = meta.slug) != null ? _meta$slug : generatedMeta.slug;
-  var displayName = (meta == null ? void 0 : meta.displayName) || "".concat(name.replace(/ /g, ''), "Demo");
+  const generatedMeta = extractNameAndSlugFromUrl(url);
+  const name = meta.name ?? generatedMeta.name;
+  const slug = meta.slug ?? generatedMeta.slug;
+  const displayName = meta?.displayName || `${name.replace(/ /g, '')}Demo`;
   return {
-    name: name,
-    slug: slug,
-    displayName: displayName,
-    precompute: precompute,
-    url: url,
+    name,
+    slug,
+    displayName,
+    precompute,
+    url,
     components: variants
   };
 }

package/esm/createSitemap/createSitemap.js

@@ -29,14 +29,14 @@ export function createSitemap(sourceUrl, pages, meta) {
   }
 
   // If precompute data exists or skipPrecompute is set, use the precomputed data
-  if (meta != null && meta.precompute || meta != null && meta.skipPrecompute) {
+  if (meta?.precompute || meta?.skipPrecompute) {
     return meta.precompute;
   }
 
   // In Next.js context, precomputation should have happened via webpack loader
   // If it didn't, throw an error to help developers fix their configuration
   if (isNextJsContext()) {
-    throw new Error("createSitemap() was unable to precompute the sitemap data in ".concat(sourceUrl, ". Ensure the createSitemap() function is called within a path used for sitemap indexes. This is typically app/sitemap/index.ts but may be overridden in next.config.js"));
+    throw new Error(`createSitemap() was unable to precompute the sitemap data in ${sourceUrl}. Ensure the createSitemap() function is called within a path used for sitemap indexes. This is typically app/sitemap/index.ts but may be overridden in next.config.js`);
   }
 
   // Outside Next.js, return undefined (sync function can't do async loading)

package/esm/pipeline/getFileConventions/fileConventions.js

@@ -1,4 +1,4 @@
-export var fileConventions = [{
+export const fileConventions = [{
   rule: './app/**/demos/*/index.ts',
   loader: 'loadPrecomputedCodeHighlighter'
 }];

package/esm/pipeline/getFileConventions/getFileConventions.js

@@ -1,17 +1,4 @@
-import _regenerator from "@babel/runtime/helpers/esm/regenerator";
-import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import { fileConventions } from "./fileConventions.js";
-export function getFileConventions() {
-  return _getFileConventions.apply(this, arguments);
-}
-function _getFileConventions() {
-  _getFileConventions = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
-    return _regenerator().w(function (_context) {
-      while (1) switch (_context.n) {
-        case 0:
-          return _context.a(2, fileConventions);
-      }
-    }, _callee);
-  }));
-  return _getFileConventions.apply(this, arguments);
+export async function getFileConventions() {
+  return fileConventions; // TODO: Parse the next.config.js file to get convention overrides.
 }

package/esm/pipeline/hastUtils/hastUtils.js

@@ -1,4 +1,3 @@
-import _typeof from "@babel/runtime/helpers/esm/typeof";
 import { Fragment, jsx, jsxs } from 'react/jsx-runtime';
 import { toText } from 'hast-util-to-text';
 import { toJsxRuntime } from 'hast-util-to-jsx-runtime';
@@ -6,50 +5,50 @@ import { decompressSync, strFromU8 } from 'fflate';
 import { decode } from 'uint8-to-base64';
 export function hastToJsx(hast) {
   return toJsxRuntime(hast, {
-    Fragment: Fragment,
-    jsx: jsx,
-    jsxs: jsxs
+    Fragment,
+    jsx,
+    jsxs
   });
 }
 export function hastOrJsonToJsx(hastOrJson) {
-  var hast;
+  let hast;
   if ('hastJson' in hastOrJson) {
     try {
       hast = JSON.parse(hastOrJson.hastJson);
     } catch (error) {
-      throw new Error("Failed to parse hastJson: ".concat(JSON.stringify(error)));
+      throw new Error(`Failed to parse hastJson: ${JSON.stringify(error)}`);
     }
   } else if ('hastGzip' in hastOrJson) {
     try {
       hast = JSON.parse(strFromU8(decompressSync(decode(hastOrJson.hastGzip))));
     } catch (error) {
-      throw new Error("Failed to parse hastGzip: ".concat(JSON.stringify(error)));
+      throw new Error(`Failed to parse hastGzip: ${JSON.stringify(error)}`);
     }
   } else {
     hast = hastOrJson;
   }
   return toJsxRuntime(hast, {
-    Fragment: Fragment,
-    jsx: jsx,
-    jsxs: jsxs
+    Fragment,
+    jsx,
+    jsxs
   });
 }
 export function stringOrHastToString(source) {
   if (typeof source === 'string') {
     return source;
   }
-  var hast;
+  let hast;
   if ('hastJson' in source) {
     try {
       hast = JSON.parse(source.hastJson);
     } catch (error) {
-      throw new Error("Failed to parse hastJson: ".concat(JSON.stringify(error)));
+      throw new Error(`Failed to parse hastJson: ${JSON.stringify(error)}`);
     }
   } else if ('hastGzip' in source) {
     try {
       hast = JSON.parse(strFromU8(decompressSync(decode(source.hastGzip))));
     } catch (error) {
-      throw new Error("Failed to parse hastGzip: ".concat(JSON.stringify(error)));
+      throw new Error(`Failed to parse hastGzip: ${JSON.stringify(error)}`);
     }
   } else {
     hast = source;
@@ -62,23 +61,23 @@ export function stringOrHastToJsx(source, highlighted) {
   if (typeof source === 'string') {
     return source;
   }
-  var hast;
+  let hast;
   if ('hastJson' in source) {
     try {
       hast = JSON.parse(source.hastJson);
     } catch (error) {
-      throw new Error("Failed to parse hastJson: ".concat(JSON.stringify(error)));
+      throw new Error(`Failed to parse hastJson: ${JSON.stringify(error)}`);
     }
   } else if ('hastGzip' in source) {
     try {
       hast = JSON.parse(strFromU8(decompressSync(decode(source.hastGzip))));
     } catch (error) {
-      throw new Error("Failed to parse hastGzip: ".concat(JSON.stringify(error)));
+      throw new Error(`Failed to parse hastGzip: ${JSON.stringify(error)}`);
     }
   } else {
     hast = source;
   }
-  if (highlighted && _typeof(hast) === 'object') {
+  if (highlighted && typeof hast === 'object') {
     return hastToJsx(hast);
   }
   return toText(hast, {