dep-context-mcp 1.0.0

package/dist/extraction/typescript.js

@@ -0,0 +1,647 @@
+/**
+ * TypeScript type extractor - parses .d.ts files using the TypeScript compiler API
+ */
+import * as ts from 'typescript';
+import { readFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { existsSync } from 'node:fs';
+import { createImportTracker } from './import-tracker.js';
+import { createExternalPackageResolver } from './external-resolver.js';
+/**
+ * Extracts JSDoc comment from a node
+ */
+function getJsDoc(node, sourceFile) {
+    const jsDocTags = ts.getJSDocTags(node);
+    if (jsDocTags.length > 0) {
+        return jsDocTags.map(tag => {
+            const tagName = tag.tagName.text;
+            const comment = typeof tag.comment === 'string'
+                ? tag.comment
+                : tag.comment?.map(c => c.text).join('') ?? '';
+            return `@${tagName} ${comment}`.trim();
+        }).join('\n');
+    }
+    // Try to get the leading comment
+    const fullText = sourceFile.getFullText();
+    const nodeStart = node.getFullStart();
+    const leadingComments = ts.getLeadingCommentRanges(fullText, nodeStart);
+    if (leadingComments && leadingComments.length > 0) {
+        const lastComment = leadingComments[leadingComments.length - 1];
+        const commentText = fullText.slice(lastComment.pos, lastComment.end);
+        // Parse JSDoc style comments
+        if (commentText.startsWith('/**')) {
+            return commentText
+                .replace(/^\/\*\*\s*/, '')
+                .replace(/\s*\*\/$/, '')
+                .split('\n')
+                .map(line => line.replace(/^\s*\*\s?/, ''))
+                .join('\n')
+                .trim();
+        }
+    }
+    return undefined;
+}
+/**
+ * Checks if a node has an export modifier
+ */
+function isExported(node) {
+    const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
+    return modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+}
+/**
+ * Extracts parameter information from a parameter declaration
+ */
+function extractParameter(param, sourceFile) {
+    const name = param.name.getText(sourceFile);
+    const type = param.type ? param.type.getText(sourceFile) : 'any';
+    const optional = param.questionToken !== undefined || param.initializer !== undefined;
+    const defaultValue = param.initializer ? param.initializer.getText(sourceFile) : undefined;
+    return { name, type, optional, defaultValue };
+}
+/**
+ * Extracts a function signature as a string
+ */
+function getFunctionSignature(node, sourceFile) {
+    const name = node.name?.getText(sourceFile) ?? 'anonymous';
+    const typeParams = node.typeParameters
+        ? `<${node.typeParameters.map(tp => tp.getText(sourceFile)).join(', ')}>`
+        : '';
+    const params = node.parameters
+        .map(p => {
+        const paramName = p.name.getText(sourceFile);
+        const paramType = p.type ? p.type.getText(sourceFile) : 'any';
+        const optional = p.questionToken ? '?' : '';
+        return `${paramName}${optional}: ${paramType}`;
+    })
+        .join(', ');
+    const returnType = node.type ? node.type.getText(sourceFile) : 'void';
+    return `${name}${typeParams}(${params}): ${returnType}`;
+}
+/**
+ * Extracts a function declaration
+ */
+function extractFunction(node, sourceFile) {
+    const name = node.name?.getText(sourceFile) ?? 'anonymous';
+    const signature = `function ${getFunctionSignature(node, sourceFile)}`;
+    const parameters = node.parameters.map(p => extractParameter(p, sourceFile));
+    const returnType = node.type ? node.type.getText(sourceFile) : 'void';
+    const jsDoc = getJsDoc(node, sourceFile);
+    const isAsync = node.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+    return { name, signature, parameters, returnType, jsDoc, isAsync };
+}
+/**
+ * Extracts a method from a class or interface
+ */
+function extractMethod(node, sourceFile) {
+    const name = node.name.getText(sourceFile);
+    const signature = getFunctionSignature(node, sourceFile);
+    const parameters = node.parameters.map(p => extractParameter(p, sourceFile));
+    const returnType = node.type ? node.type.getText(sourceFile) : 'void';
+    const jsDoc = getJsDoc(node, sourceFile);
+    let isAsync = false;
+    let isStatic = false;
+    if (ts.isMethodDeclaration(node)) {
+        const modifiers = ts.getModifiers(node);
+        isAsync = modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+        isStatic = modifiers?.some(m => m.kind === ts.SyntaxKind.StaticKeyword) ?? false;
+    }
+    return { name, signature, parameters, returnType, jsDoc, isAsync, isStatic };
+}
+/**
+ * Extracts a property from a class or interface
+ */
+function extractProperty(node, sourceFile) {
+    const name = node.name.getText(sourceFile);
+    const type = node.type ? node.type.getText(sourceFile) : 'any';
+    const optional = node.questionToken !== undefined;
+    const jsDoc = getJsDoc(node, sourceFile);
+    let readonly = false;
+    if (ts.isPropertyDeclaration(node)) {
+        const modifiers = ts.getModifiers(node);
+        readonly = modifiers?.some(m => m.kind === ts.SyntaxKind.ReadonlyKeyword) ?? false;
+    }
+    else if (ts.isPropertySignature(node)) {
+        readonly = node.modifiers?.some(m => m.kind === ts.SyntaxKind.ReadonlyKeyword) ?? false;
+    }
+    return { name, type, optional, readonly, jsDoc };
+}
+/**
+ * Extracts a class declaration
+ */
+function extractClass(node, sourceFile) {
+    const name = node.name?.getText(sourceFile) ?? 'anonymous';
+    const jsDoc = getJsDoc(node, sourceFile);
+    let constructorSignature;
+    const methods = [];
+    const properties = [];
+    for (const member of node.members) {
+        if (ts.isConstructorDeclaration(member)) {
+            const params = member.parameters
+                .map(p => {
+                const paramName = p.name.getText(sourceFile);
+                const paramType = p.type ? p.type.getText(sourceFile) : 'any';
+                const optional = p.questionToken ? '?' : '';
+                return `${paramName}${optional}: ${paramType}`;
+            })
+                .join(', ');
+            constructorSignature = `constructor(${params})`;
+        }
+        else if (ts.isMethodDeclaration(member)) {
+            // Only include public methods
+            const modifiers = ts.getModifiers(member);
+            const isPrivate = modifiers?.some(m => m.kind === ts.SyntaxKind.PrivateKeyword);
+            if (!isPrivate) {
+                methods.push(extractMethod(member, sourceFile));
+            }
+        }
+        else if (ts.isPropertyDeclaration(member)) {
+            // Only include public properties
+            const modifiers = ts.getModifiers(member);
+            const isPrivate = modifiers?.some(m => m.kind === ts.SyntaxKind.PrivateKeyword);
+            if (!isPrivate) {
+                properties.push(extractProperty(member, sourceFile));
+            }
+        }
+    }
+    return { name, constructorSignature, methods, properties, jsDoc };
+}
+/**
+ * Extracts an interface declaration
+ */
+function extractInterface(node, sourceFile) {
+    const name = node.name.getText(sourceFile);
+    const jsDoc = getJsDoc(node, sourceFile);
+    const methods = [];
+    const properties = [];
+    for (const member of node.members) {
+        if (ts.isMethodSignature(member)) {
+            methods.push(extractMethod(member, sourceFile));
+        }
+        else if (ts.isPropertySignature(member)) {
+            properties.push(extractProperty(member, sourceFile));
+        }
+    }
+    return { name, properties, methods, jsDoc };
+}
+/**
+ * Extracts a type alias declaration
+ */
+function extractTypeAlias(node, sourceFile) {
+    const name = node.name.getText(sourceFile);
+    const definition = node.type.getText(sourceFile);
+    const jsDoc = getJsDoc(node, sourceFile);
+    return { name, definition, jsDoc };
+}
+/**
+ * Extracts re-export statements from a source file
+ * Distinguishes between star exports and named re-exports
+ */
+function extractReExports(sourceFile) {
+    const result = {
+        starExports: [],
+        namedReExports: []
+    };
+    for (const statement of sourceFile.statements) {
+        if (ts.isExportDeclaration(statement) && statement.moduleSpecifier) {
+            const moduleSpecifier = statement.moduleSpecifier;
+            if (!ts.isStringLiteral(moduleSpecifier))
+                continue;
+            const sourcePath = moduleSpecifier.text;
+            if (!statement.exportClause) {
+                // export * from './module' - true star export
+                result.starExports.push(sourcePath);
+            }
+            else if (ts.isNamedExports(statement.exportClause)) {
+                // export { x, y } from './module' or export { x as y } from './module'
+                for (const element of statement.exportClause.elements) {
+                    const exportedName = element.name.text;
+                    // propertyName is the original name if aliased (export { original as exported })
+                    const originalName = element.propertyName?.text ?? exportedName;
+                    result.namedReExports.push({ exportedName, originalName, sourcePath });
+                }
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Creates an empty extraction result
+ */
+function createEmptyResult() {
+    return {
+        functions: [],
+        classes: [],
+        interfaces: [],
+        types: [],
+        reExports: [],
+        importedExports: [],
+        errors: []
+    };
+}
+/**
+ * Merges two extraction results
+ */
+function mergeResults(a, b) {
+    return {
+        functions: [...a.functions, ...b.functions],
+        classes: [...a.classes, ...b.classes],
+        interfaces: [...a.interfaces, ...b.interfaces],
+        types: [...a.types, ...b.types],
+        reExports: [...a.reExports, ...b.reExports],
+        importedExports: [...a.importedExports, ...b.importedExports],
+        errors: [...a.errors, ...b.errors]
+    };
+}
+/**
+ * Extracts all exports from a TypeScript declaration file
+ */
+export async function extract(entryPath) {
+    const result = createEmptyResult();
+    let content;
+    try {
+        content = await readFile(entryPath, 'utf-8');
+    }
+    catch (error) {
+        result.errors.push(`Failed to read file: ${entryPath}`);
+        return result;
+    }
+    let sourceFile;
+    try {
+        sourceFile = ts.createSourceFile(entryPath, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    }
+    catch (error) {
+        result.errors.push(`Failed to parse file: ${entryPath}`);
+        return result;
+    }
+    // Track imports for import-then-export pattern detection
+    const importTracker = createImportTracker(sourceFile);
+    // Extract re-exports (export * from './module' and export { x } from './module')
+    const reExportInfo = extractReExports(sourceFile);
+    result.reExports.push(...reExportInfo.starExports);
+    // Named re-exports are treated like importedExports (they need symbol extraction with renaming)
+    result.importedExports.push(...reExportInfo.namedReExports);
+    // Build a map of all declarations in the file (for export { x } resolution)
+    const declarations = new Map();
+    // First pass: collect all declarations
+    function collectDeclarations(node) {
+        if (ts.isFunctionDeclaration(node) && node.name) {
+            declarations.set(node.name.text, node);
+        }
+        if (ts.isClassDeclaration(node) && node.name) {
+            declarations.set(node.name.text, node);
+        }
+        if (ts.isInterfaceDeclaration(node)) {
+            declarations.set(node.name.text, node);
+        }
+        if (ts.isTypeAliasDeclaration(node)) {
+            declarations.set(node.name.text, node);
+        }
+        ts.forEachChild(node, collectDeclarations);
+    }
+    collectDeclarations(sourceFile);
+    // Track which symbols are exported via export { x } declarations
+    const exportedViaDeclaration = new Map(); // localName -> exportedName
+    // Walk the AST
+    function visit(node) {
+        try {
+            // Exported function declaration (with export keyword)
+            if (ts.isFunctionDeclaration(node) && isExported(node) && node.name) {
+                result.functions.push(extractFunction(node, sourceFile));
+            }
+            // Exported class declaration (with export keyword)
+            if (ts.isClassDeclaration(node) && isExported(node) && node.name) {
+                result.classes.push(extractClass(node, sourceFile));
+            }
+            // Exported interface declaration (with export keyword)
+            if (ts.isInterfaceDeclaration(node) && isExported(node)) {
+                result.interfaces.push(extractInterface(node, sourceFile));
+            }
+            // Exported type alias (with export keyword)
+            if (ts.isTypeAliasDeclaration(node) && isExported(node)) {
+                result.types.push(extractTypeAlias(node, sourceFile));
+            }
+            // Handle export declarations without module specifier (export { x, y } or export { x as y })
+            if (ts.isExportDeclaration(node) && node.exportClause && !node.moduleSpecifier) {
+                if (ts.isNamedExports(node.exportClause)) {
+                    for (const element of node.exportClause.elements) {
+                        // The exported name (what consumers see)
+                        const exportedName = element.name.text;
+                        // The local name (might be aliased: export { local as exported })
+                        const localName = element.propertyName?.text ?? exportedName;
+                        // Check if this is an imported symbol
+                        const importInfo = importTracker.getImport(localName);
+                        if (importInfo) {
+                            result.importedExports.push({
+                                exportedName,
+                                originalName: importInfo.originalName,
+                                sourcePath: importInfo.sourcePath
+                            });
+                        }
+                        else {
+                            // Not an import - check if it's a local declaration
+                            // Record it for extraction with the exported name
+                            exportedViaDeclaration.set(localName, exportedName);
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            result.errors.push(`Error processing node: ${message}`);
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    // Second pass: extract declarations that are exported via export { x } or export { x as y }
+    for (const [localName, exportedName] of exportedViaDeclaration) {
+        const decl = declarations.get(localName);
+        if (!decl)
+            continue;
+        if (ts.isFunctionDeclaration(decl) && decl.name) {
+            const extracted = extractFunction(decl, sourceFile);
+            // Rename if aliased
+            if (localName !== exportedName) {
+                extracted.name = exportedName;
+                extracted.signature = extracted.signature.replace(localName, exportedName);
+            }
+            result.functions.push(extracted);
+        }
+        if (ts.isClassDeclaration(decl) && decl.name) {
+            const extracted = extractClass(decl, sourceFile);
+            if (localName !== exportedName) {
+                extracted.name = exportedName;
+            }
+            result.classes.push(extracted);
+        }
+        if (ts.isInterfaceDeclaration(decl)) {
+            const extracted = extractInterface(decl, sourceFile);
+            if (localName !== exportedName) {
+                extracted.name = exportedName;
+            }
+            result.interfaces.push(extracted);
+        }
+        if (ts.isTypeAliasDeclaration(decl)) {
+            const extracted = extractTypeAlias(decl, sourceFile);
+            if (localName !== exportedName) {
+                extracted.name = exportedName;
+            }
+            result.types.push(extracted);
+        }
+    }
+    return result;
+}
+/**
+ * Checks if a module path is external (not relative)
+ */
+function isExternalModule(modulePath) {
+    return !modulePath.startsWith('.') && !modulePath.startsWith('/');
+}
+/**
+ * Resolves a module path to an actual file path
+ * Handles .js → .d.ts mapping and index.d.ts fallbacks
+ * For external modules, returns undefined (handled separately)
+ */
+function resolveModulePath(modulePath, baseDir) {
+    // External modules are handled separately
+    if (isExternalModule(modulePath)) {
+        return undefined;
+    }
+    let resolvedPath = resolve(baseDir, modulePath);
+    // Handle .js extension (common in ESM - maps to .d.ts)
+    if (resolvedPath.endsWith('.js')) {
+        const dtsPath = resolvedPath.replace(/\.js$/, '.d.ts');
+        if (existsSync(dtsPath)) {
+            return dtsPath;
+        }
+    }
+    // Try with .d.ts extension
+    if (!resolvedPath.endsWith('.d.ts') && !resolvedPath.endsWith('.ts')) {
+        if (existsSync(resolvedPath + '.d.ts')) {
+            return resolvedPath + '.d.ts';
+        }
+        else if (existsSync(resolvedPath + '.ts')) {
+            return resolvedPath + '.ts';
+        }
+        else if (existsSync(join(resolvedPath, 'index.d.ts'))) {
+            return join(resolvedPath, 'index.d.ts');
+        }
+    }
+    // Already has extension
+    if (existsSync(resolvedPath)) {
+        return resolvedPath;
+    }
+    return undefined;
+}
+/**
+ * Extracts specific symbols from a source file
+ * Used for import-then-export pattern resolution
+ */
+async function extractSymbolsFromSource(sourcePath, symbols, visited) {
+    const result = createEmptyResult();
+    // Skip if already visited (cycle detection)
+    if (visited.has(sourcePath)) {
+        return result;
+    }
+    visited.add(sourcePath);
+    // Extract all exports from source file
+    const sourceResult = await extract(sourcePath);
+    // Follow any re-exports in the source file first
+    const followedSource = await followReExports(sourceResult, sourcePath, visited);
+    // Filter to only the symbols we're looking for
+    const symbolNames = new Set(symbols.map(s => s.originalName));
+    result.functions = followedSource.functions.filter(f => symbolNames.has(f.name));
+    result.classes = followedSource.classes.filter(c => symbolNames.has(c.name));
+    result.interfaces = followedSource.interfaces.filter(i => symbolNames.has(i.name));
+    result.types = followedSource.types.filter(t => symbolNames.has(t.name));
+    // Handle aliased exports - rename to the exported name
+    for (const sym of symbols) {
+        if (sym.exportedName !== sym.originalName) {
+            // Rename functions
+            const fn = result.functions.find(f => f.name === sym.originalName);
+            if (fn) {
+                fn.name = sym.exportedName;
+                fn.signature = fn.signature.replace(sym.originalName, sym.exportedName);
+            }
+            // Rename classes
+            const cls = result.classes.find(c => c.name === sym.originalName);
+            if (cls) {
+                cls.name = sym.exportedName;
+            }
+            // Rename interfaces
+            const iface = result.interfaces.find(i => i.name === sym.originalName);
+            if (iface) {
+                iface.name = sym.exportedName;
+            }
+            // Rename types
+            const typ = result.types.find(t => t.name === sym.originalName);
+            if (typ) {
+                typ.name = sym.exportedName;
+            }
+        }
+    }
+    // If we didn't find some symbols, they might be in importedExports of the source
+    // (nested import-then-export pattern)
+    const foundNames = new Set([
+        ...result.functions.map(f => f.name),
+        ...result.classes.map(c => c.name),
+        ...result.interfaces.map(i => i.name),
+        ...result.types.map(t => t.name)
+    ]);
+    const missingSymbols = symbols.filter(s => !foundNames.has(s.exportedName));
+    if (missingSymbols.length > 0 && followedSource.importedExports.length > 0) {
+        // Check if missing symbols are in importedExports
+        const baseDir = dirname(sourcePath);
+        for (const missing of missingSymbols) {
+            const importedExport = followedSource.importedExports.find(ie => ie.exportedName === missing.originalName);
+            if (importedExport) {
+                const nestedPath = resolveModulePath(importedExport.sourcePath, baseDir);
+                if (nestedPath) {
+                    const nestedResult = await extractSymbolsFromSource(nestedPath, [{ exportedName: missing.exportedName, originalName: importedExport.originalName }], visited);
+                    result.functions.push(...nestedResult.functions);
+                    result.classes.push(...nestedResult.classes);
+                    result.interfaces.push(...nestedResult.interfaces);
+                    result.types.push(...nestedResult.types);
+                }
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Follows re-exports and extracts from referenced modules
+ */
+export async function followReExports(result, basePath, visited = new Set(), options = {}) {
+    const baseDir = dirname(basePath);
+    let mergedResult = { ...result };
+    const { externalResolver, maxExternalDepth = 2 } = options;
+    // Track external packages we've already processed
+    const processedExternalPackages = new Set();
+    // Follow traditional re-exports (export * from './module' or 'external-package')
+    for (const reExport of result.reExports) {
+        // Check if this is an external package
+        if (isExternalModule(reExport)) {
+            // Only follow external packages if we have a resolver
+            if (!externalResolver) {
+                continue;
+            }
+            // Extract package name (handle scoped packages)
+            const packageName = reExport.startsWith('@')
+                ? reExport.split('/').slice(0, 2).join('/')
+                : reExport.split('/')[0];
+            // Skip if already processed
+            if (processedExternalPackages.has(packageName)) {
+                continue;
+            }
+            processedExternalPackages.add(packageName);
+            // Resolve external package
+            const resolved = await externalResolver.resolve(packageName);
+            if (!resolved.success || !resolved.typesPath) {
+                mergedResult.errors.push(`Could not resolve external package: ${packageName}`);
+                continue;
+            }
+            // Skip if already visited
+            if (visited.has(resolved.typesPath)) {
+                continue;
+            }
+            visited.add(resolved.typesPath);
+            // Extract from external package (with reduced depth for externals)
+            const externalResult = await extract(resolved.typesPath);
+            // Don't follow external packages' externals too deeply
+            const followedExternal = await followReExports(externalResult, resolved.typesPath, visited, { externalResolver: maxExternalDepth > 1 ? externalResolver : undefined, maxExternalDepth: maxExternalDepth - 1 });
+            mergedResult = mergeResults(mergedResult, followedExternal);
+            continue;
+        }
+        // Handle relative paths
+        const resolvedPath = resolveModulePath(reExport, baseDir);
+        if (!resolvedPath) {
+            continue;
+        }
+        // Skip if already visited (circular reference protection)
+        if (visited.has(resolvedPath)) {
+            continue;
+        }
+        visited.add(resolvedPath);
+        // Extract from the re-exported module
+        const reExportResult = await extract(resolvedPath);
+        const followedResult = await followReExports(reExportResult, resolvedPath, visited, options);
+        mergedResult = mergeResults(mergedResult, followedResult);
+    }
+    // Follow import-then-export patterns
+    // Group by source path for efficiency
+    const importsBySource = new Map();
+    const externalImports = new Map();
+    for (const importedExport of result.importedExports) {
+        if (isExternalModule(importedExport.sourcePath)) {
+            // External package import
+            const packageName = importedExport.sourcePath.startsWith('@')
+                ? importedExport.sourcePath.split('/').slice(0, 2).join('/')
+                : importedExport.sourcePath.split('/')[0];
+            if (!externalImports.has(packageName)) {
+                externalImports.set(packageName, []);
+            }
+            externalImports.get(packageName).push({
+                exportedName: importedExport.exportedName,
+                originalName: importedExport.originalName
+            });
+        }
+        else {
+            // Relative import
+            const resolvedPath = resolveModulePath(importedExport.sourcePath, baseDir);
+            if (!resolvedPath) {
+                continue;
+            }
+            if (!importsBySource.has(resolvedPath)) {
+                importsBySource.set(resolvedPath, []);
+            }
+            importsBySource.get(resolvedPath).push({
+                exportedName: importedExport.exportedName,
+                originalName: importedExport.originalName
+            });
+        }
+    }
+    // Extract symbols from relative sources
+    for (const [sourcePath, symbols] of importsBySource) {
+        const extractedSymbols = await extractSymbolsFromSource(sourcePath, symbols, visited);
+        mergedResult = mergeResults(mergedResult, extractedSymbols);
+    }
+    // Extract symbols from external packages
+    if (externalResolver) {
+        for (const [packageName, symbols] of externalImports) {
+            // Skip if already processed
+            if (processedExternalPackages.has(packageName)) {
+                continue;
+            }
+            processedExternalPackages.add(packageName);
+            const resolved = await externalResolver.resolve(packageName);
+            if (!resolved.success || !resolved.typesPath) {
+                mergedResult.errors.push(`Could not resolve external package for imports: ${packageName}`);
+                continue;
+            }
+            // Skip if already visited
+            if (visited.has(resolved.typesPath)) {
+                continue;
+            }
+            // Extract specific symbols from external package
+            const extractedSymbols = await extractSymbolsFromSource(resolved.typesPath, symbols, visited);
+            mergedResult = mergeResults(mergedResult, extractedSymbols);
+        }
+    }
+    // Clear re-exports and importedExports from final result (they've been followed)
+    mergedResult.reExports = [];
+    mergedResult.importedExports = [];
+    return mergedResult;
+}
+/**
+ * Creates a TypeExtractor instance
+ */
+export function createTypeExtractor(projectRoot) {
+    const externalResolver = projectRoot ? createExternalPackageResolver(projectRoot) : undefined;
+    return {
+        extract,
+        followReExports: (result, basePath, visited) => followReExports(result, basePath, visited, { externalResolver }),
+        clearExternalCache: () => externalResolver?.clearCache(),
+        getExternalCacheStats: () => externalResolver?.getCacheStats() ?? { resolved: 0, failed: 0 }
+    };
+}
+//# sourceMappingURL=typescript.js.map