@mui/internal-docs-infra 0.12.1-canary.2 → 0.12.1-canary.21

package/pipeline/loadServerTypes/loadServerTypes.mjs

@@ -6,7 +6,12 @@ import { highlightTypes } from "./highlightTypes.mjs";
 import { highlightTypesMeta } from "./highlightTypesMeta.mjs";
 import { syncTypes } from "../syncTypes/index.mjs";
 import { loadServerTypesText } from "../loadServerTypesText/index.mjs";
+import { resolveTypesCacheKey } from "../loadServerTypesText/resolveTypesCacheKey.mjs";
+import { withFileCache } from "../cacheUtils/index.mjs";
 const functionName = 'Load Server Types';
+
+/** Cache namespace for the enhanced (highlighted) loadServerTypes result. */
+const TYPES_ENHANCED_CACHE_NAMESPACE = 'types-enhanced';
 /**
  * Server-side function for loading and processing TypeScript types.
  *
@@ -28,21 +33,77 @@ export async function loadServerTypes(options) {
     formattingOptions,
     sync = false,
     output = 'hast',
-    codeBlockEmphasisOptions
+    codeBlockEmphasisOptions,
+    cacheDir
   } = options;
 
   // Derive relative path for logging
   const relativePath = path.relative(rootContext, typesMarkdownPath);
-  let currentMark = nameMark(functionName, 'Start Loading', [relativePath]);
-  performance.mark(currentMark);
+  const startMark = nameMark(functionName, 'Start Loading', [relativePath]);
+  performance.mark(startMark);
 
   // Either sync types from source or load from existing markdown
-  const syncResult = sync ? await syncTypes(options) : await loadServerTypesText(pathToFileURL(typesMarkdownPath).href, options.ordering);
-  currentMark = performanceMeasure(currentMark, {
+  const syncResult = sync ? await syncTypes(options) : await loadServerTypesText(pathToFileURL(typesMarkdownPath).href, options.ordering, {
+    cacheDir,
+    rootContext
+  });
+  performanceMeasure(startMark, {
     mark: 'types loaded',
     measure: sync ? 'type syncing' : 'types.md loading'
   }, [functionName, relativePath]);
 
+  // The enhanced (highlighted) result is cached keyed by the loaded types plus the options that
+  // affect the output, so a hit skips highlightTypes/highlightTypesMeta. `allDependencies` (the
+  // webpack watch list) and the transient `updated` flag are excluded from both the hash and the
+  // cached value: allDependencies is re-attached fresh from syncResult below. `syncResult` is hashed
+  // before the slug mutation in enhanceTypes (slugs are derived deterministically, part of the cache).
+  const cacheRef = cacheDir ? {
+    cacheDir,
+    namespace: TYPES_ENHANCED_CACHE_NAMESPACE,
+    cacheKey: resolveTypesCacheKey(typesMarkdownPath, rootContext)
+  } : undefined;
+  const enhanced = await withFileCache({
+    ref: cacheRef,
+    readOrigin: () => syncResult,
+    getCacheContent: source => JSON.stringify({
+      // Exclude allDependencies (re-attached fresh below) so a dep-list change does not needlessly
+      // invalidate the cached highlighting, and the transient `updated` flag for hash stability.
+      source: {
+        ...source,
+        allDependencies: undefined,
+        updated: undefined
+      },
+      output,
+      formattingOptions: formattingOptions ?? null,
+      codeBlockEmphasisOptions: codeBlockEmphasisOptions ?? null
+    }),
+    processor: source => enhanceTypes(source, {
+      output,
+      formattingOptions,
+      codeBlockEmphasisOptions,
+      relativePath
+    })
+  });
+
+  // allDependencies is the webpack watch list — always take it FRESH from syncResult, never a
+  // possibly-stale cached value, so a cache hit can't omit a newly-added source file (missed rebuild).
+  return {
+    ...enhanced,
+    allDependencies: syncResult.allDependencies
+  };
+}
+
+/**
+ * Applies syntax highlighting/enhancement to the loaded types and builds the anchor map. Extracted
+ * so loadServerTypes can cache it via withFileCache. Returns everything except `allDependencies`
+ * (the watch list), which loadServerTypes re-attaches fresh so a cache hit never serves a stale one.
+ */
+async function enhanceTypes(syncResult, {
+  output,
+  formattingOptions,
+  codeBlockEmphasisOptions,
+  relativePath
+}) {
   // Compute slugs for all types
   // Determine the common component prefix from the first dotted name (e.g., "Accordion")
   let componentPrefix = '';
@@ -186,7 +247,7 @@ export async function loadServerTypes(options) {
     start: highlightStart,
     end: highlightEnd
   });
-  currentMark = nameMark(functionName, 'types highlighted and enhanced', [relativePath]);
+  const currentMark = nameMark(functionName, 'types highlighted and enhanced', [relativePath]);
 
   // Use variantTypeNames directly from syncResult
   const {
@@ -265,7 +326,6 @@ export async function loadServerTypes(options) {
     additionalTypes,
     variantOnlyAdditionalTypes,
     variantTypeNames,
-    allDependencies: syncResult.allDependencies,
     typeNameMap: syncResult.typeNameMap,
     anchorMap: {
       js: anchorMap

package/pipeline/loadServerTypesMeta/createOptimizedProgram.d.mts

@@ -1,4 +1,5 @@
-import ts, { type CompilerOptions } from 'typescript';
+import ts from 'typescript';
+import type { CompilerOptions } from 'typescript';
 import type { PerformanceTracker } from "./performanceTracking.mjs";
 export interface TypesMetaOptions {
   /**

package/pipeline/loadServerTypesMeta/formatClass.d.mts

@@ -1,6 +1,6 @@
 import type * as tae from 'typescript-api-extractor';
-import { type FormattedParameter, type FormatInlineTypeOptions, type DescriptionReplacement } from "./format.mjs";
-import { type TypeRewriteContext } from "./rewriteTypes.mjs";
+import type { FormattedParameter, FormatInlineTypeOptions, DescriptionReplacement } from "./format.mjs";
+import type { TypeRewriteContext } from "./rewriteTypes.mjs";
 import type { ExternalTypesCollector } from "./externalTypes.mjs";
 import type { HastRoot } from "../../CodeHighlighter/types.mjs";
 /**

package/pipeline/loadServerTypesMeta/formatComponent.d.mts

@@ -1,6 +1,6 @@
 import type * as tae from 'typescript-api-extractor';
-import { type FormattedProperty, type FormattedEnumMember, type FormatInlineTypeOptions, type DescriptionReplacement } from "./format.mjs";
-import { type TypeRewriteContext } from "./rewriteTypes.mjs";
+import type { FormattedProperty, FormattedEnumMember, FormatInlineTypeOptions, DescriptionReplacement } from "./format.mjs";
+import type { TypeRewriteContext } from "./rewriteTypes.mjs";
 import type { ExternalTypesCollector } from "./externalTypes.mjs";
 import type { HastRoot } from "../../CodeHighlighter/types.mjs";
 import type { OrderingConfig } from "../loadServerTypesText/order.mjs";

package/pipeline/loadServerTypesMeta/formatFunction.d.mts

@@ -1,6 +1,6 @@
 import type * as tae from 'typescript-api-extractor';
-import { type FormattedParameter, type FormattedProperty, type FormatInlineTypeOptions, type DescriptionReplacement } from "./format.mjs";
-import { type TypeRewriteContext } from "./rewriteTypes.mjs";
+import type { FormattedParameter, FormattedProperty, FormatInlineTypeOptions, DescriptionReplacement } from "./format.mjs";
+import type { TypeRewriteContext } from "./rewriteTypes.mjs";
 import type { ExternalTypesCollector } from "./externalTypes.mjs";
 import type { HastRoot } from "../../CodeHighlighter/types.mjs";
 /**

package/pipeline/loadServerTypesMeta/formatHook.d.mts

@@ -1,6 +1,6 @@
 import type * as tae from 'typescript-api-extractor';
-import { type FormattedProperty, type FormattedParameter, type FormatInlineTypeOptions, type DescriptionReplacement } from "./format.mjs";
-import { type TypeRewriteContext } from "./rewriteTypes.mjs";
+import type { FormattedProperty, FormattedParameter, FormatInlineTypeOptions, DescriptionReplacement } from "./format.mjs";
+import type { TypeRewriteContext } from "./rewriteTypes.mjs";
 import type { ExternalTypesCollector } from "./externalTypes.mjs";
 import type { HastRoot } from "../../CodeHighlighter/types.mjs";
 export type HookTypeMeta = {

package/pipeline/loadServerTypesMeta/formatRaw.d.mts

@@ -1,6 +1,6 @@
 import type * as tae from 'typescript-api-extractor';
-import { type FormattedProperty, type FormatInlineTypeOptions, type DescriptionReplacement } from "./format.mjs";
-import { type TypeRewriteContext } from "./rewriteTypes.mjs";
+import type { FormattedProperty, FormatInlineTypeOptions, DescriptionReplacement } from "./format.mjs";
+import type { TypeRewriteContext } from "./rewriteTypes.mjs";
 import type { ExternalTypesCollector } from "./externalTypes.mjs";
 import type { HastRoot } from "../../CodeHighlighter/types.mjs";
 /**

package/pipeline/loadServerTypesMeta/formatType.d.mts

@@ -1,5 +1,5 @@
 import type * as tae from 'typescript-api-extractor';
-import { type ExternalTypesCollector } from "./externalTypes.mjs";
+import type { ExternalTypesCollector } from "./externalTypes.mjs";
 export interface FormatTypeOptions {
   removeUndefined?: boolean;
   jsdocTags?: tae.DocumentationTag[];

package/pipeline/loadServerTypesMeta/loadServerTypesMeta.d.mts

@@ -1,11 +1,11 @@
-import { type ClassTypeMeta as ClassType } from "./formatClass.mjs";
-import { type ComponentTypeMeta as ComponentType } from "./formatComponent.mjs";
-import { type HookTypeMeta as HookType } from "./formatHook.mjs";
-import { type FunctionTypeMeta as FunctionType } from "./formatFunction.mjs";
-import { type RawTypeMeta as RawType, type ReExportInfo } from "./formatRaw.mjs";
-import { type FormattedProperty, type FormattedEnumMember, type FormattedParameter, type FormatInlineTypeOptions, type DescriptionReplacement } from "./format.mjs";
+import type { ClassTypeMeta as ClassType } from "./formatClass.mjs";
+import type { ComponentTypeMeta as ComponentType } from "./formatComponent.mjs";
+import type { HookTypeMeta as HookType } from "./formatHook.mjs";
+import type { FunctionTypeMeta as FunctionType } from "./formatFunction.mjs";
+import type { RawTypeMeta as RawType, ReExportInfo } from "./formatRaw.mjs";
+import type { FormattedProperty, FormattedEnumMember, FormattedParameter, FormatInlineTypeOptions, DescriptionReplacement } from "./format.mjs";
 import type { OrderingConfig } from "../loadServerTypesText/order.mjs";
-import { type OrganizeTypesResult } from "../loadServerTypesText/organizeTypesByExport.mjs";
+import type { OrganizeTypesResult } from "../loadServerTypesText/organizeTypesByExport.mjs";
 export type ClassTypeMeta = ClassType;
 export type ComponentTypeMeta = ComponentType;
 export type HookTypeMeta = HookType;

package/pipeline/loadServerTypesMeta/loadServerTypesMeta.mjs

@@ -88,7 +88,7 @@ export async function loadServerTypesMeta(options) {
       // Convert file:// URL to filesystem path for Node.js fs APIs
       const fsEntrypoint = fileURLToPath(entrypointUrl);
       const sourceCode = await readFile(fsEntrypoint, 'utf-8');
-      const parsed = await parseImportsAndComments(sourceCode, entrypointUrl);
+      const parsed = parseImportsAndComments(sourceCode, entrypointUrl);
 
       // Look for relative exports (e.g., '../menu/', './Button', etc.)
       await Promise.all(Object.keys(parsed.relative || {}).map(async exportPath => {

package/pipeline/loadServerTypesMeta/processTypes.d.mts

@@ -1,6 +1,6 @@
 import type { CompilerOptions } from 'typescript';
-import { type ExportNode } from 'typescript-api-extractor';
-import { type PerformanceLog } from "./performanceTracking.mjs";
+import type { ExportNode } from 'typescript-api-extractor';
+import type { PerformanceLog } from "./performanceTracking.mjs";
 export interface VariantResult {
   exports: ExportNode[];
   allTypes: ExportNode[];

package/pipeline/loadServerTypesMeta/worker.d.mts

@@ -1,2 +1,2 @@
-import { type WorkerRequest, type WorkerResponse, type VariantResult } from "./processTypes.mjs";
+import type { WorkerRequest, WorkerResponse, VariantResult } from "./processTypes.mjs";
 export type { WorkerRequest, WorkerResponse, VariantResult };

package/pipeline/loadServerTypesText/loadServerTypesText.d.mts

@@ -1,5 +1,5 @@
 import type { TypesMeta } from "../loadServerTypesMeta/index.mjs";
-import { type OrganizeTypesResult } from "./organizeTypesByExport.mjs";
+import type { OrganizeTypesResult } from "./organizeTypesByExport.mjs";
 import type { OrderingConfig } from "./order.mjs";
 /**
  * Common data returned by both syncTypes and loadServerTypesText.
@@ -18,10 +18,24 @@ export interface TypesSourceData extends OrganizeTypesResult<TypesMeta> {
   /** Whether the types.md file was updated (false if loaded from existing file) */
   updated: boolean;
 }
+/**
+ * Options for the types.md parse cache.
+ *
+ * When both are set, the parse of types.md is cached at `{cacheDir}/types-text/{route}.json`,
+ * keyed by the sha256 of the file content (plus ordering), mirroring the page-index cache.
+ */
+export interface LoadServerTypesTextCacheOptions {
+  /** Directory for the sha256-validated JSON cache of parsed types.md files. */
+  cacheDir?: string;
+  /** Root context directory used to derive the cache key/route. */
+  rootContext?: string;
+}
 /**
  * Load and parse a types.md file into TypesMeta[].
  *
  * @param fileUrl - file:// URL to the types.md file
+ * @param ordering - optional ordering config that affects how types are sorted
+ * @param cache - optional parse-cache configuration
  * @returns Parsed types and external types
  */
-export declare function loadServerTypesText(fileUrl: string, ordering?: OrderingConfig): Promise<TypesSourceData>;
+export declare function loadServerTypesText(fileUrl: string, ordering?: OrderingConfig, cache?: LoadServerTypesTextCacheOptions): Promise<TypesSourceData>;

package/pipeline/loadServerTypesText/loadServerTypesText.mjs

@@ -1,25 +1,47 @@
 import { readFile } from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
+import { withFileCache } from "../cacheUtils/index.mjs";
 import { parseTypesMarkdown } from "./parseTypesMarkdown.mjs";
+import { TYPES_TEXT_CACHE_NAMESPACE, resolveTypesCacheKey, buildTypesTextCacheContent } from "./resolveTypesCacheKey.mjs";
 
 /**
  * Common data returned by both syncTypes and loadServerTypesText.
  * This is the shared contract consumed by loadServerTypes.
  */
 
+/**
+ * Options for the types.md parse cache.
+ *
+ * When both are set, the parse of types.md is cached at `{cacheDir}/types-text/{route}.json`,
+ * keyed by the sha256 of the file content (plus ordering), mirroring the page-index cache.
+ */
+
 /**
  * Load and parse a types.md file into TypesMeta[].
  *
  * @param fileUrl - file:// URL to the types.md file
+ * @param ordering - optional ordering config that affects how types are sorted
+ * @param cache - optional parse-cache configuration
  * @returns Parsed types and external types
  */
-export async function loadServerTypesText(fileUrl, ordering) {
-  // Read the file
+export function loadServerTypesText(fileUrl, ordering, cache) {
   const filePath = fileURLToPath(fileUrl);
-  const content = await readFile(filePath, 'utf-8');
-  return {
-    ...(await parseTypesMarkdown(content, ordering)),
-    allDependencies: [filePath],
-    updated: false
-  };
+  const cacheRef = cache?.cacheDir && cache.rootContext ? {
+    cacheDir: cache.cacheDir,
+    namespace: TYPES_TEXT_CACHE_NAMESPACE,
+    cacheKey: resolveTypesCacheKey(filePath, cache.rootContext)
+  } : undefined;
+
+  // The cache stores the parsed TypesSourceData keyed by the markdown + ordering hash, so a hit
+  // skips parseTypesMarkdown (the expensive step).
+  return withFileCache({
+    ref: cacheRef,
+    readOrigin: () => readFile(filePath, 'utf-8'),
+    getCacheContent: content => buildTypesTextCacheContent(content, ordering),
+    processor: async content => ({
+      ...(await parseTypesMarkdown(content, ordering)),
+      allDependencies: [filePath],
+      updated: false
+    })
+  });
 }

package/pipeline/loadServerTypesText/normalizeTypesSourceDataForCache.d.mts

@@ -0,0 +1,2 @@
+import type { TypesSourceData } from "./loadServerTypesText.mjs";
+export declare function normalizeTypesSourceDataForCache(data: TypesSourceData): TypesSourceData;

package/pipeline/loadServerTypesText/normalizeTypesSourceDataForCache.mjs

@@ -0,0 +1,144 @@
+function stripPositionFields(value) {
+  if (Array.isArray(value)) {
+    return value.map(stripPositionFields);
+  }
+  if (typeof value !== 'object' || value === null) {
+    return value;
+  }
+  const result = {};
+  for (const [key, child] of Object.entries(value)) {
+    if (key === 'position') {
+      continue;
+    }
+    const normalized = stripPositionFields(child);
+    if (normalized !== undefined) {
+      result[key] = normalized;
+    }
+  }
+  return result;
+}
+function normalizeTypeMetaForCache(typeMeta) {
+  if (typeMeta.type === 'component') {
+    const {
+      name,
+      props,
+      dataAttributes,
+      cssVariables,
+      descriptionText,
+      description,
+      ...rest
+    } = typeMeta.data;
+    return {
+      ...typeMeta,
+      data: {
+        name,
+        props,
+        dataAttributes,
+        cssVariables,
+        ...(descriptionText ? {
+          descriptionText
+        } : {}),
+        ...(description ? {
+          description
+        } : {}),
+        ...rest
+      }
+    };
+  }
+  if (typeMeta.type === 'hook' || typeMeta.type === 'function') {
+    const {
+      name,
+      parameters,
+      expandedProperties,
+      returnValue,
+      descriptionText,
+      description,
+      returnValueDescriptionText,
+      returnValueDescription,
+      ...rest
+    } = typeMeta.data;
+    return {
+      ...typeMeta,
+      data: {
+        name,
+        ...(expandedProperties ? {
+          expandedProperties
+        } : {
+          parameters
+        }),
+        returnValue,
+        ...(descriptionText ? {
+          descriptionText
+        } : {}),
+        ...(description ? {
+          description
+        } : {}),
+        ...(returnValueDescriptionText ? {
+          returnValueDescriptionText
+        } : {}),
+        ...(returnValueDescription ? {
+          returnValueDescription
+        } : {}),
+        ...rest
+      }
+    };
+  }
+  if (typeMeta.type === 'raw') {
+    const {
+      name,
+      formattedCode,
+      descriptionText,
+      description,
+      reExportOf,
+      ...rest
+    } = typeMeta.data;
+    return {
+      ...typeMeta,
+      data: {
+        name,
+        formattedCode,
+        ...(descriptionText ? {
+          descriptionText
+        } : {}),
+        ...(description ? {
+          description
+        } : {}),
+        ...(reExportOf ? {
+          reExportOf
+        } : {}),
+        ...rest
+      }
+    };
+  }
+  return typeMeta;
+}
+function normalizeTypesByExportForCache(exports) {
+  const normalized = {};
+  for (const [exportName, exportData] of Object.entries(exports)) {
+    normalized[exportName] = {
+      type: normalizeTypeMetaForCache(exportData.type),
+      additionalTypes: exportData.additionalTypes.map(normalizeTypeMetaForCache)
+    };
+  }
+  return normalized;
+}
+function normalizeVariantOnlyTypesForCache(variantOnlyAdditionalTypes) {
+  const normalized = {};
+  for (const [variantName, types] of Object.entries(variantOnlyAdditionalTypes)) {
+    normalized[variantName] = types.map(normalizeTypeMetaForCache);
+  }
+  return normalized;
+}
+export function normalizeTypesSourceDataForCache(data) {
+  return stripPositionFields({
+    exports: normalizeTypesByExportForCache(data.exports),
+    additionalTypes: data.additionalTypes.map(normalizeTypeMetaForCache),
+    variantOnlyAdditionalTypes: normalizeVariantOnlyTypesForCache(data.variantOnlyAdditionalTypes),
+    externalTypes: data.externalTypes,
+    typeNameMap: data.typeNameMap,
+    variantTypeNameMaps: data.variantTypeNameMaps,
+    variantTypeNames: data.variantTypeNames,
+    allDependencies: data.allDependencies,
+    updated: data.updated
+  });
+}

package/pipeline/loadServerTypesText/resolveTypesCacheKey.d.mts

@@ -0,0 +1,19 @@
+import type { OrderingConfig } from "./order.mjs";
+/** Cache namespace for the types.md parse cache (TypesSourceData), mirroring the page-index cache. */
+export declare const TYPES_TEXT_CACHE_NAMESPACE = "types-text";
+/**
+ * Derives the cache key for a types.md file from its path, reusing the page route
+ * derivation so a writer (syncTypes) and reader (loadServerTypesText) of the same
+ * types.md agree on the cache location.
+ *
+ * @example
+ * resolveTypesCacheKey('/root/src/app/components/accordion/types.md', '/root') // 'components/accordion'
+ */
+export declare function resolveTypesCacheKey(typesMarkdownPath: string, rootContext: string): string;
+/**
+ * Builds the hash-validation content for the types.md parse cache. Includes the
+ * ordering config because it changes `parseTypesMarkdown`'s output, so the cache is
+ * invalidated when either the markdown or the ordering changes. The writer (syncTypes)
+ * and reader (loadServerTypesText) must build this identically for their hashes to match.
+ */
+export declare function buildTypesTextCacheContent(markdown: string, ordering?: OrderingConfig): string;

package/pipeline/loadServerTypesText/resolveTypesCacheKey.mjs

@@ -0,0 +1,29 @@
+import { extractPrefixAndTitle } from "../loadServerPageIndex/extractPrefixAndTitle.mjs";
+/** Cache namespace for the types.md parse cache (TypesSourceData), mirroring the page-index cache. */
+export const TYPES_TEXT_CACHE_NAMESPACE = 'types-text';
+
+/**
+ * Derives the cache key for a types.md file from its path, reusing the page route
+ * derivation so a writer (syncTypes) and reader (loadServerTypesText) of the same
+ * types.md agree on the cache location.
+ *
+ * @example
+ * resolveTypesCacheKey('/root/src/app/components/accordion/types.md', '/root') // 'components/accordion'
+ */
+export function resolveTypesCacheKey(typesMarkdownPath, rootContext) {
+  const {
+    prefix
+  } = extractPrefixAndTitle(typesMarkdownPath, rootContext);
+  const segments = prefix.split('/').filter(Boolean);
+  return segments.length > 0 ? segments.join('/') : 'index';
+}
+
+/**
+ * Builds the hash-validation content for the types.md parse cache. Includes the
+ * ordering config because it changes `parseTypesMarkdown`'s output, so the cache is
+ * invalidated when either the markdown or the ordering changes. The writer (syncTypes)
+ * and reader (loadServerTypesText) must build this identically for their hashes to match.
+ */
+export function buildTypesTextCacheContent(markdown, ordering) {
+  return `${JSON.stringify(ordering ?? null)}\n${markdown}`;
+}

package/pipeline/loaderUtils/parseImportsAndComments.d.mts

@@ -85,16 +85,18 @@ export interface ImportsAndComments {
  * parsed straight out of remote sources without first being mapped onto a
  * placeholder `file://` URL.
  *
+ * Parsing is fully synchronous — no I/O, no `await`.
+ *
  * @param code - The source code to parse
  * @param fileUrl - The file URL (`file://`, `http://`, `https://`) or path, used to determine file type and resolve relative imports
  * @param options - Optional configuration for comment processing
  * @param options.removeCommentsWithPrefix - Array of prefixes; comments starting with these will be stripped from output
  * @param options.notableCommentsPrefix - Array of prefixes; comments starting with these will be collected regardless of stripping
- * @returns Promise resolving to parsed import data, optionally including processed code and collected comments
+ * @returns Parsed import data, optionally including processed code and collected comments
  *
  * @example
  * ```typescript
- * const result = await parseImportsAndComments(
+ * const result = parseImportsAndComments(
  *   'import React from "react";\nimport { Button } from "./Button";\nexport { Icon } from "./Icon";',
  *   '/src/App.tsx'
  * );
@@ -106,4 +108,4 @@ export interface ImportsAndComments {
 export declare function parseImportsAndComments(code: string, fileUrl: string, options?: {
   removeCommentsWithPrefix?: string[];
   notableCommentsPrefix?: string[];
-}): Promise<ImportsAndComments>;
+}): ImportsAndComments;