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

package/esm/pipeline/loadPrecomputedSitemap/loadPrecomputedSitemap.js

@@ -1,7 +1,3 @@
-import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
-import _regenerator from "@babel/runtime/helpers/esm/regenerator";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 // webpack does not like node: imports
 // eslint-disable-next-line n/prefer-node-protocol
 import path from 'path';
@@ -13,208 +9,164 @@ import { replacePrecomputeValue } from "../loadPrecomputedCodeHighlighter/replac
 import { rewriteImportsToNull } from "../loaderUtils/rewriteImports.js";
 import { createLoadServerPageIndex } from "../loadServerPageIndex/loadServerPageIndex.js";
 import { createSitemapSchema } from "../loadServerSitemap/loadServerSitemap.js";
-var functionName = 'Load Precomputed Sitemap';
-export function loadPrecomputedSitemap(_x) {
-  return _loadPrecomputedSitemap.apply(this, arguments);
-}
-function _loadPrecomputedSitemap() {
-  _loadPrecomputedSitemap = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(source) {
-    var _options$performance$, _options$performance, _options$performance$2, _options$performance2, _options$performance3;
-    var callback, options, performanceNotableMs, performanceShowWrapperMeasures, relativePath, observer, currentMark, _observer, _observer2, resourceFileUrl, sitemapCall, variants, sitemapData, rootContext, loadPageIndex, entries, results, _iterator, _step, result, precomputeData, modifiedSource, relative, importPathsToRewrite, importResult, _i, _Object$entries, _Object$entries$_i, importPath, importData, _observer3, _observer4, _t2;
-    return _regenerator().w(function (_context2) {
-      while (1) switch (_context2.p = _context2.n) {
-        case 0:
-          callback = this.async();
-          this.cacheable();
-          options = this.getOptions();
-          performanceNotableMs = (_options$performance$ = (_options$performance = options.performance) == null ? void 0 : _options$performance.notableMs) != null ? _options$performance$ : 100;
-          performanceShowWrapperMeasures = (_options$performance$2 = (_options$performance2 = options.performance) == null ? void 0 : _options$performance2.showWrapperMeasures) != null ? _options$performance$2 : false; // const resourceName = extractNameAndSlugFromUrl(
-          //   new URL('.', `file://${this.resourcePath}`).pathname,
-          // ).name;
-          relativePath = path.relative(this.rootContext || process.cwd(), this.resourcePath);
-          observer = undefined;
-          if ((_options$performance3 = options.performance) != null && _options$performance3.logging) {
-            observer = new PerformanceObserver(createPerformanceLogger(performanceNotableMs, performanceShowWrapperMeasures, relativePath));
-            observer.observe({
-              entryTypes: ['measure']
-            });
-          }
-          currentMark = nameMark(functionName, 'Start Loading', [relativePath]);
-          performance.mark(currentMark);
-          _context2.p = 1;
-          // Convert the filesystem path to a file:// URL for cross-platform compatibility
-          // pathToFileURL handles Windows drive letters correctly (e.g., C:\... → file:///C:/...)
-          resourceFileUrl = pathToFileURL(this.resourcePath).toString(); // Parse the source to find a single createSitemap call
-          _context2.n = 2;
-          return parseCreateFactoryCall(source, resourceFileUrl);
-        case 2:
-          sitemapCall = _context2.v;
-          currentMark = performanceMeasure(currentMark, {
-            mark: 'Parsed Factory',
-            measure: 'Factory Parsing'
-          }, [functionName, relativePath]);
-
-          // If no createSitemap call found, return the source unchanged
-          if (sitemapCall) {
-            _context2.n = 3;
-            break;
-          }
-          callback(null, source);
-          return _context2.a(2);
-        case 3:
-          if (!sitemapCall.options.skipPrecompute) {
-            _context2.n = 4;
-            break;
-          }
-          callback(null, source);
-          return _context2.a(2);
-        case 4:
-          // Extract the variants (imported markdown files)
-          variants = sitemapCall.variants;
-          if (!(!variants || Object.keys(variants).length === 0)) {
-            _context2.n = 5;
-            break;
-          }
-          callback(null, source);
-          return _context2.a(2);
-        case 5:
-          currentMark = performanceMeasure(currentMark, {
-            mark: 'Extracted Variants',
-            measure: 'Variant Extraction'
-          }, [functionName, relativePath]);
-
-          // Read and parse each markdown file
-          sitemapData = {}; // Create page index loader with root context
-          rootContext = this.rootContext || process.cwd();
-          loadPageIndex = createLoadServerPageIndex({
-            rootContext: rootContext
-          }); // Process all markdown files in parallel using shared logic
-          entries = Object.entries(variants);
-          _context2.n = 6;
-          return Promise.all(entries.map(/*#__PURE__*/function () {
-            var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(_ref) {
-              var _ref3, key, importPath, absolutePath, metadata, _t;
-              return _regenerator().w(function (_context) {
-                while (1) switch (_context.p = _context.n) {
-                  case 0:
-                    _ref3 = _slicedToArray(_ref, 2), key = _ref3[0], importPath = _ref3[1];
-                    // Convert file:// URLs to proper file system paths for webpack's dependency tracking
-                    // Using fileURLToPath handles Windows drive letters correctly (e.g., file:///C:/... → C:\...)
-                    absolutePath = importPath.startsWith('file://') ? fileURLToPath(importPath) : importPath;
-                    _context.p = 1;
-                    _context.n = 2;
-                    return loadPageIndex(importPath);
-                  case 2:
-                    metadata = _context.v;
-                    return _context.a(2, {
-                      key: key,
-                      absolutePath: absolutePath,
-                      metadata: metadata,
-                      error: null
-                    });
-                  case 3:
-                    _context.p = 3;
-                    _t = _context.v;
-                    return _context.a(2, {
-                      key: key,
-                      absolutePath: absolutePath,
-                      metadata: null,
-                      error: _t instanceof Error ? _t : new Error(String(_t))
-                    });
-                }
-              }, _callee, null, [[1, 3]]);
-            }));
-            return function (_x2) {
-              return _ref2.apply(this, arguments);
-            };
-          }()));
-        case 6:
-          results = _context2.v;
-          currentMark = performanceMeasure(currentMark, {
-            mark: 'Processed All Files',
-            measure: 'Process Markdown Files'
-          }, [functionName, relativePath]);
-
-          // Collect results and dependencies
-          _iterator = _createForOfIteratorHelper(results);
-          try {
-            for (_iterator.s(); !(_step = _iterator.n()).done;) {
-              result = _step.value;
-              if (result.error) {
-                // Log error but continue processing other files
-                console.error("Failed to process ".concat(result.key, " at ").concat(result.absolutePath, ":"), result.error);
-              } else if (result.metadata) {
-                sitemapData[result.key] = result.metadata;
-                // Add to dependencies for webpack watching
-                this.addDependency(result.absolutePath);
-              }
-            }
-
-            // Create sitemap with Orama schema for search indexing
-          } catch (err) {
-            _iterator.e(err);
-          } finally {
-            _iterator.f();
-          }
-          precomputeData = {
-            schema: createSitemapSchema(),
-            data: sitemapData
-          }; // Replace the factory function call with the precomputed sitemap data
-          modifiedSource = replacePrecomputeValue(source, precomputeData, sitemapCall);
-          performanceMeasure(currentMark, {
-            mark: 'replaced precompute',
-            measure: 'precompute replacement'
-          }, [functionName, relativePath]);
-
-          // Rewrite MDX imports to const declarations since we've precomputed the data
-          if (sitemapCall.importsAndComments) {
-            relative = sitemapCall.importsAndComments.relative; // Build a set of MDX imports to rewrite
-            importPathsToRewrite = new Set();
-            importResult = {};
-            for (_i = 0, _Object$entries = Object.entries(relative); _i < _Object$entries.length; _i++) {
-              _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2), importPath = _Object$entries$_i[0], importData = _Object$entries$_i[1];
-              // Check if this is an MDX file
-              if (importPath.endsWith('.mdx')) {
-                // Add to the set of imports to rewrite
-                importPathsToRewrite.add(importPath);
-                importResult[importPath] = {
-                  positions: importData.positions,
-                  names: importData.names
-                };
-              }
-            }
-
-            // Rewrite the import statements to const declarations if there are any MDX imports
-            if (importPathsToRewrite.size > 0) {
-              modifiedSource = rewriteImportsToNull(modifiedSource, importPathsToRewrite, importResult);
-              currentMark = performanceMeasure(currentMark, {
-                mark: 'rewritten imports',
-                measure: 'import rewriting'
-              }, [functionName, relativePath]);
-            }
-          }
-
-          // log any pending performance entries before completing
-          (_observer = observer) == null || (_observer = _observer.takeRecords()) == null || _observer.forEach(function (entry) {
-            return logPerformance(entry, performanceNotableMs, performanceShowWrapperMeasures, relativePath);
-          });
-          (_observer2 = observer) == null || _observer2.disconnect();
-          callback(null, modifiedSource);
-          _context2.n = 8;
-          break;
-        case 7:
-          _context2.p = 7;
-          _t2 = _context2.v;
-          // log any pending performance entries before completing
-          (_observer3 = observer) == null || (_observer3 = _observer3.takeRecords()) == null || _observer3.forEach(function (entry) {
-            return logPerformance(entry, performanceNotableMs, performanceShowWrapperMeasures, relativePath);
-          });
-          (_observer4 = observer) == null || _observer4.disconnect();
-          callback(_t2 instanceof Error ? _t2 : new Error(String(_t2)));
-        case 8:
-          return _context2.a(2);
+const functionName = 'Load Precomputed Sitemap';
+export async function loadPrecomputedSitemap(source) {
+  const callback = this.async();
+  this.cacheable();
+  const options = this.getOptions();
+  const performanceNotableMs = options.performance?.notableMs ?? 100;
+  const performanceShowWrapperMeasures = options.performance?.showWrapperMeasures ?? false;
+
+  // const resourceName = extractNameAndSlugFromUrl(
+  //   new URL('.', `file://${this.resourcePath}`).pathname,
+  // ).name;
+
+  const relativePath = path.relative(this.rootContext || process.cwd(), this.resourcePath);
+  let observer = undefined;
+  if (options.performance?.logging) {
+    observer = new PerformanceObserver(createPerformanceLogger(performanceNotableMs, performanceShowWrapperMeasures, relativePath));
+    observer.observe({
+      entryTypes: ['measure']
+    });
+  }
+  let currentMark = nameMark(functionName, 'Start Loading', [relativePath]);
+  performance.mark(currentMark);
+  try {
+    // Convert the filesystem path to a file:// URL for cross-platform compatibility
+    // pathToFileURL handles Windows drive letters correctly (e.g., C:\... → file:///C:/...)
+    const resourceFileUrl = pathToFileURL(this.resourcePath).toString();
+
+    // Parse the source to find a single createSitemap call
+    const sitemapCall = await parseCreateFactoryCall(source, resourceFileUrl);
+    currentMark = performanceMeasure(currentMark, {
+      mark: 'Parsed Factory',
+      measure: 'Factory Parsing'
+    }, [functionName, relativePath]);
+
+    // If no createSitemap call found, return the source unchanged
+    if (!sitemapCall) {
+      callback(null, source);
+      return;
+    }
+
+    // If skipPrecompute is true, return the source unchanged
+    if (sitemapCall.options.skipPrecompute) {
+      callback(null, source);
+      return;
+    }
+
+    // Extract the variants (imported markdown files)
+    const variants = sitemapCall.variants;
+    if (!variants || Object.keys(variants).length === 0) {
+      callback(null, source);
+      return;
+    }
+    currentMark = performanceMeasure(currentMark, {
+      mark: 'Extracted Variants',
+      measure: 'Variant Extraction'
+    }, [functionName, relativePath]);
+
+    // Read and parse each markdown file
+    const sitemapData = {};
+
+    // Create page index loader with root context
+    const rootContext = this.rootContext || process.cwd();
+    const loadPageIndex = createLoadServerPageIndex({
+      rootContext
+    });
+
+    // Process all markdown files in parallel using shared logic
+    const entries = Object.entries(variants);
+    const results = await Promise.all(entries.map(async ([key, importPath]) => {
+      // Convert file:// URLs to proper file system paths for webpack's dependency tracking
+      // Using fileURLToPath handles Windows drive letters correctly (e.g., file:///C:/... → C:\...)
+      const absolutePath = importPath.startsWith('file://') ? fileURLToPath(importPath) : importPath;
+      try {
+        const metadata = await loadPageIndex(importPath);
+        return {
+          key,
+          absolutePath,
+          metadata,
+          error: null
+        };
+      } catch (error) {
+        return {
+          key,
+          absolutePath,
+          metadata: null,
+          error: error instanceof Error ? error : new Error(String(error))
+        };
       }
-    }, _callee2, this, [[1, 7]]);
-  }));
-  return _loadPrecomputedSitemap.apply(this, arguments);
+    }));
+    currentMark = performanceMeasure(currentMark, {
+      mark: 'Processed All Files',
+      measure: 'Process Markdown Files'
+    }, [functionName, relativePath]);
+
+    // Collect results and dependencies
+    for (const result of results) {
+      if (result.error) {
+        // Log error but continue processing other files
+        console.error(`Failed to process ${result.key} at ${result.absolutePath}:`, result.error);
+      } else if (result.metadata) {
+        sitemapData[result.key] = result.metadata;
+        // Add to dependencies for webpack watching
+        this.addDependency(result.absolutePath);
+      }
+    }
+
+    // Create sitemap with Orama schema for search indexing
+    const precomputeData = {
+      schema: createSitemapSchema(),
+      data: sitemapData
+    };
+
+    // Replace the factory function call with the precomputed sitemap data
+    let modifiedSource = replacePrecomputeValue(source, precomputeData, sitemapCall);
+    performanceMeasure(currentMark, {
+      mark: 'replaced precompute',
+      measure: 'precompute replacement'
+    }, [functionName, relativePath]);
+
+    // Rewrite MDX imports to const declarations since we've precomputed the data
+    if (sitemapCall.importsAndComments) {
+      const {
+        relative
+      } = sitemapCall.importsAndComments;
+
+      // Build a set of MDX imports to rewrite
+      const importPathsToRewrite = new Set();
+      const importResult = {};
+      for (const [importPath, importData] of Object.entries(relative)) {
+        // Check if this is an MDX file
+        if (importPath.endsWith('.mdx')) {
+          // Add to the set of imports to rewrite
+          importPathsToRewrite.add(importPath);
+          importResult[importPath] = {
+            positions: importData.positions,
+            names: importData.names
+          };
+        }
+      }
+
+      // Rewrite the import statements to const declarations if there are any MDX imports
+      if (importPathsToRewrite.size > 0) {
+        modifiedSource = rewriteImportsToNull(modifiedSource, importPathsToRewrite, importResult);
+        currentMark = performanceMeasure(currentMark, {
+          mark: 'rewritten imports',
+          measure: 'import rewriting'
+        }, [functionName, relativePath]);
+      }
+    }
+
+    // log any pending performance entries before completing
+    observer?.takeRecords()?.forEach(entry => logPerformance(entry, performanceNotableMs, performanceShowWrapperMeasures, relativePath));
+    observer?.disconnect();
+    callback(null, modifiedSource);
+  } catch (error) {
+    // log any pending performance entries before completing
+    observer?.takeRecords()?.forEach(entry => logPerformance(entry, performanceNotableMs, performanceShowWrapperMeasures, relativePath));
+    observer?.disconnect();
+    callback(error instanceof Error ? error : new Error(String(error)));
+  }
 }

package/esm/pipeline/loadServerCodeMeta/loadServerCodeMeta.js

@@ -1,6 +1,3 @@
-import _regenerator from "@babel/runtime/helpers/esm/regenerator";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import { readFile } from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
 import { resolveVariantPathsWithFs } from "./resolveModulePathWithFs.js";
@@ -12,7 +9,7 @@ import { getFileNameFromUrl } from "../loaderUtils/index.js";
  * It reads the demo file, parses it to find `createDemo` calls with variants, and resolves the paths for those variants.
  * It returns a Code object mapping variant names to their resolved file URLs.
  */
-export var loadServerCodeMeta = createLoadServerCodeMeta();
+export const loadServerCodeMeta = createLoadServerCodeMeta();
 
 /**
  * Creates a loadCodeMeta function that resolves variant paths from demo files.
@@ -28,65 +25,46 @@ export var loadServerCodeMeta = createLoadServerCodeMeta();
  * @param options - Configuration options (currently unused)
  * @returns LoadCodeMeta function that takes a URL and returns Promise<Code>
  */
-export function createLoadServerCodeMeta() {
-  var _options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  return /*#__PURE__*/function () {
-    var _loadCodeMeta = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(url) {
-      var filePath, source, demoCall, code, resolvedVariantMap;
-      return _regenerator().w(function (_context) {
-        while (1) switch (_context.n) {
-          case 0:
-            // Convert file:// URL to proper file system path for reading the file
-            // Using fileURLToPath handles Windows drive letters correctly (e.g., file:///C:/... → C:\...)
-            filePath = url.startsWith('file://') ? fileURLToPath(url) : url; // Read the source file to find createDemo calls
-            _context.n = 1;
-            return readFile(filePath, 'utf-8');
-          case 1:
-            source = _context.v;
-            _context.n = 2;
-            return parseCreateFactoryCall(source, url);
-          case 2:
-            demoCall = _context.v;
-            if (!(!demoCall || !demoCall.variants)) {
-              _context.n = 3;
-              break;
-            }
-            return _context.a(2, {});
-          case 3:
-            code = {}; // Resolve all variant paths and get them as file URLs
-            _context.n = 4;
-            return resolveVariantPathsWithFs(demoCall.variants || {});
-          case 4:
-            resolvedVariantMap = _context.v;
-            // Build Code object from the resolved variant map
-            Array.from(resolvedVariantMap.entries()).forEach(function (_ref) {
-              var _demoCall$namedExport;
-              var _ref2 = _slicedToArray(_ref, 2),
-                variantName = _ref2[0],
-                fileUrl = _ref2[1];
-              var namedExport = (_demoCall$namedExport = demoCall.namedExports) == null ? void 0 : _demoCall$namedExport[variantName];
-              code[variantName] = fileUrl;
-              if (namedExport) {
-                var _getFileNameFromUrl = getFileNameFromUrl(fileUrl),
-                  fileName = _getFileNameFromUrl.fileName;
-                if (!fileName) {
-                  throw new Error("Cannot determine fileName from URL \"".concat(fileUrl, "\" for variant \"").concat(variantName, "\". ") + "Please ensure the URL has a valid file extension.");
-                }
-                code[variantName] = {
-                  url: fileUrl,
-                  fileName: fileName,
-                  namedExport: namedExport
-                };
-              }
-              // TODO: will this cause loadVariantMeta not to run? Maybe we should always run it
-            });
-            return _context.a(2, code);
-        }
-      }, _callee);
-    }));
-    function loadCodeMeta(_x) {
-      return _loadCodeMeta.apply(this, arguments);
+export function createLoadServerCodeMeta(_options = {}) {
+  return async function loadCodeMeta(url) {
+    // Convert file:// URL to proper file system path for reading the file
+    // Using fileURLToPath handles Windows drive letters correctly (e.g., file:///C:/... → C:\...)
+    const filePath = url.startsWith('file://') ? fileURLToPath(url) : url;
+
+    // Read the source file to find createDemo calls
+    const source = await readFile(filePath, 'utf-8');
+
+    // Parse the source to find createDemo call with variants
+    // Pass the original URL to parseCreateFactoryCall for cross-platform path handling
+    const demoCall = await parseCreateFactoryCall(source, url);
+    if (!demoCall || !demoCall.variants) {
+      // Return empty code object if no variants found
+      return {};
     }
-    return loadCodeMeta;
-  }();
+    const code = {};
+
+    // Resolve all variant paths and get them as file URLs
+    const resolvedVariantMap = await resolveVariantPathsWithFs(demoCall.variants || {});
+
+    // Build Code object from the resolved variant map
+    Array.from(resolvedVariantMap.entries()).forEach(([variantName, fileUrl]) => {
+      const namedExport = demoCall.namedExports?.[variantName];
+      code[variantName] = fileUrl;
+      if (namedExport) {
+        const {
+          fileName
+        } = getFileNameFromUrl(fileUrl);
+        if (!fileName) {
+          throw new Error(`Cannot determine fileName from URL "${fileUrl}" for variant "${variantName}". ` + `Please ensure the URL has a valid file extension.`);
+        }
+        code[variantName] = {
+          url: fileUrl,
+          fileName,
+          namedExport
+        };
+      }
+      // TODO: will this cause loadVariantMeta not to run? Maybe we should always run it
+    });
+    return code;
+  };
 }

package/esm/pipeline/loadServerCodeMeta/resolveModulePathWithFs.js

@@ -1,5 +1,3 @@
-import _regenerator from "@babel/runtime/helpers/esm/regenerator";
-import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 // webpack does not like node: imports
 // eslint-disable-next-line n/prefer-node-protocol
 import { readdir } from 'fs/promises';
@@ -13,34 +11,18 @@ import { resolveModulePath, resolveModulePaths, resolveImportResult, resolveVari
  *
  * The input is a file:// URL. We convert it to a filesystem path using fileURLToPath.
  */
-var nodeDirectoryReader = /*#__PURE__*/function () {
-  var _ref = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(fileUrl) {
-    var fsPath, entries;
-    return _regenerator().w(function (_context) {
-      while (1) switch (_context.n) {
-        case 0:
-          // Convert file:// URL to filesystem path for Node.js fs APIs
-          fsPath = fileURLToPath(fileUrl);
-          _context.n = 1;
-          return readdir(fsPath, {
-            withFileTypes: true
-          });
-        case 1:
-          entries = _context.v;
-          return _context.a(2, entries.map(function (entry) {
-            return {
-              name: entry.name,
-              isFile: entry.isFile(),
-              isDirectory: entry.isDirectory()
-            };
-          }));
-      }
-    }, _callee);
+const nodeDirectoryReader = async fileUrl => {
+  // Convert file:// URL to filesystem path for Node.js fs APIs
+  const fsPath = fileURLToPath(fileUrl);
+  const entries = await readdir(fsPath, {
+    withFileTypes: true
+  });
+  return entries.map(entry => ({
+    name: entry.name,
+    isFile: entry.isFile(),
+    isDirectory: entry.isDirectory()
   }));
-  return function nodeDirectoryReader(_x) {
-    return _ref.apply(this, arguments);
-  };
-}();
+};
 
 /**
  * Resolves a module path using Node.js filesystem APIs.
@@ -52,8 +34,8 @@ var nodeDirectoryReader = /*#__PURE__*/function () {
  * @returns Promise<string | TypeAwareResolveResult> - The resolved file path(s), or throws if not found
  */
 
-export function resolveModulePathWithFs(_x2) {
-  return _resolveModulePathWithFs.apply(this, arguments);
+export async function resolveModulePathWithFs(moduleUrl, options = {}, includeTypeDefs) {
+  return resolveModulePath(moduleUrl, nodeDirectoryReader, options, includeTypeDefs);
 }
 
 /**
@@ -64,24 +46,8 @@ export function resolveModulePathWithFs(_x2) {
  * @param options - Configuration options
  * @returns Promise<Map<string, string>> - Map from input path to resolved file path
  */
-function _resolveModulePathWithFs() {
-  _resolveModulePathWithFs = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(moduleUrl) {
-    var options,
-      includeTypeDefs,
-      _args2 = arguments;
-    return _regenerator().w(function (_context2) {
-      while (1) switch (_context2.n) {
-        case 0:
-          options = _args2.length > 1 && _args2[1] !== undefined ? _args2[1] : {};
-          includeTypeDefs = _args2.length > 2 ? _args2[2] : undefined;
-          return _context2.a(2, resolveModulePath(moduleUrl, nodeDirectoryReader, options, includeTypeDefs));
-      }
-    }, _callee2);
-  }));
-  return _resolveModulePathWithFs.apply(this, arguments);
-}
-export function resolveModulePathsWithFs(_x3) {
-  return _resolveModulePathsWithFs.apply(this, arguments);
+export async function resolveModulePathsWithFs(moduleUrls, options = {}) {
+  return resolveModulePaths(moduleUrls, nodeDirectoryReader, options);
 }
 
 /**
@@ -94,22 +60,8 @@ export function resolveModulePathsWithFs(_x3) {
  * @param options - Configuration options for module resolution
  * @returns Promise<Map<string, string>> - Map from import path to resolved file path
  */
-function _resolveModulePathsWithFs() {
-  _resolveModulePathsWithFs = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(moduleUrls) {
-    var options,
-      _args3 = arguments;
-    return _regenerator().w(function (_context3) {
-      while (1) switch (_context3.n) {
-        case 0:
-          options = _args3.length > 1 && _args3[1] !== undefined ? _args3[1] : {};
-          return _context3.a(2, resolveModulePaths(moduleUrls, nodeDirectoryReader, options));
-      }
-    }, _callee3);
-  }));
-  return _resolveModulePathsWithFs.apply(this, arguments);
-}
-export function resolveImportResultWithFs(_x4) {
-  return _resolveImportResultWithFs.apply(this, arguments);
+export async function resolveImportResultWithFs(importResult, options = {}) {
+  return resolveImportResult(importResult, nodeDirectoryReader, options);
 }
 
 /**
@@ -121,36 +73,8 @@ export function resolveImportResultWithFs(_x4) {
  * @param options - Configuration options for module resolution
  * @returns Promise<Map<string, string>> - Map from variant name to resolved file URL
  */
-function _resolveImportResultWithFs() {
-  _resolveImportResultWithFs = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(importResult) {
-    var options,
-      _args4 = arguments;
-    return _regenerator().w(function (_context4) {
-      while (1) switch (_context4.n) {
-        case 0:
-          options = _args4.length > 1 && _args4[1] !== undefined ? _args4[1] : {};
-          return _context4.a(2, resolveImportResult(importResult, nodeDirectoryReader, options));
-      }
-    }, _callee4);
-  }));
-  return _resolveImportResultWithFs.apply(this, arguments);
-}
-export function resolveVariantPathsWithFs(_x5) {
-  return _resolveVariantPathsWithFs.apply(this, arguments);
+export async function resolveVariantPathsWithFs(variants, options = {}) {
+  return resolveVariantPaths(variants, nodeDirectoryReader, options);
 }
 
-// Re-export types for convenience
-function _resolveVariantPathsWithFs() {
-  _resolveVariantPathsWithFs = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5(variants) {
-    var options,
-      _args5 = arguments;
-    return _regenerator().w(function (_context5) {
-      while (1) switch (_context5.n) {
-        case 0:
-          options = _args5.length > 1 && _args5[1] !== undefined ? _args5[1] : {};
-          return _context5.a(2, resolveVariantPaths(variants, nodeDirectoryReader, options));
-      }
-    }, _callee5);
-  }));
-  return _resolveVariantPathsWithFs.apply(this, arguments);
-}
+// Re-export types for convenience