knip 5.86.0 → 6.0.0-0

package/dist/ConfigurationChief.d.ts

@@ -411,6 +411,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        oxfmt?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         oxlint?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -837,6 +842,7 @@ export declare class ConfigurationChief {
         nyc?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         oclif?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "openapi-ts"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        oxfmt?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         oxlint?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         parcel?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         payload?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;

package/dist/DependencyDeputy.d.ts

@@ -1,5 +1,5 @@
 import type { Workspace } from './ConfigurationChief.ts';
-import type { ConfigurationHint, Counters, Issue, Issues, SymbolIssueType } from './types/issues.ts';
+import type { ConfigurationHint, Counters, Issue, Issues, IssueType } from './types/issues.ts';
 import type { PackageJson } from './types/package-json.ts';
 import type { DependencyArray, DependencySet, HostDependencies, InstalledBinaries, WorkspaceManifests } from './types/workspace.ts';
 import type { MainOptions } from './util/create-options.ts';
@@ -65,8 +65,8 @@ export declare class DependencyDeputy {
         devDependencyIssues: Issue[];
         optionalPeerDependencyIssues: Issue[];
     };
-    handleIgnoredDependencies(issues: Issues, counters: Counters, type: SymbolIssueType): void;
-    handleIgnoredBinaries(issues: Issues, counters: Counters, type: SymbolIssueType): void;
+    handleIgnoredDependencies(issues: Issues, counters: Counters, type: IssueType): void;
+    handleIgnoredBinaries(issues: Issues, counters: Counters, type: IssueType): void;
     handleIgnoredUnresolved(issues: Issues, counters: Counters): void;
     removeIgnoredIssues({ issues, counters }: {
         issues: Issues;

package/dist/IssueCollector.d.ts

@@ -43,7 +43,7 @@ export declare class IssueCollector {
     addIssue(issue: Issue): true | undefined;
     addConfigurationHint(issue: ConfigurationHint): void;
     addTagHint(issue: TagHint): void;
-    purge(): import("./types/issues.ts").IssueSet;
+    purge(): Set<string>;
     getIssues(): {
         issues: import("./types/issues.ts").Issues;
         counters: import("./types/issues.ts").Counters;

package/dist/IssueCollector.js

@@ -122,9 +122,10 @@ export class IssueCollector {
             }
             if (this.shouldIgnoreIssue(filePath, 'files'))
                 continue;
-            this.issues.files.add(filePath);
             const symbol = relative(this.cwd, filePath);
-            this.issues._files[symbol] = [{ type: 'files', filePath, symbol, severity: this.rules.files }];
+            this.issues.files[symbol] = {
+                [symbol]: { type: 'files', filePath, symbol, workspace: '', severity: this.rules.files, fixes: [] },
+            };
             this.counters.files++;
             this.counters.processed++;
         }
@@ -160,7 +161,11 @@ export class IssueCollector {
         this.tagHints.add(issue);
     }
     purge() {
-        const unusedFiles = this.issues.files;
+        const unusedFiles = new Set();
+        for (const issues of Object.values(this.issues.files)) {
+            for (const issue of Object.values(issues))
+                unusedFiles.add(issue.filePath);
+        }
         this.issues = initIssues();
         this.counters = initCounters();
         return unusedFiles;

package/dist/IssueFixer.js

@@ -46,7 +46,7 @@ class IssueFixer {
     async removeUnusedFiles(issues) {
         if (!this.options.isFixFiles)
             return;
-        for (const issue of Object.values(issues._files).flatMap(Object.values)) {
+        for (const issue of Object.values(issues.files).flatMap(Object.values)) {
             await rm(issue.filePath);
             issue.isFixed = true;
         }
@@ -54,7 +54,7 @@ class IssueFixer {
     async removeUnusedExports(issues) {
         const touchedFiles = new Set();
         const types = [
-            ...(this.options.isFixUnusedTypes ? ['types', 'nsTypes', 'classMembers', 'enumMembers'] : []),
+            ...(this.options.isFixUnusedTypes ? ['types', 'nsTypes', 'enumMembers'] : []),
             ...(this.options.isFixUnusedExports ? ['exports', 'nsExports'] : []),
         ];
         if (types.length === 0)

package/dist/ProjectPrincipal.d.ts

@@ -1,10 +1,9 @@
-import ts from 'typescript';
+import { type ParseResult } from 'oxc-parser';
 import { CacheConsultant } from './CacheConsultant.ts';
 import type { AsyncCompilers, SyncCompilers } from './compilers/types.ts';
-import type { GetImportsAndExportsOptions, IgnoreExportsUsedInFile, Visitors } from './types/config.ts';
-import type { Export, ExportMember, FileNode, ModuleGraph } from './types/module-graph.ts';
-import type { Paths, PrincipalOptions } from './types/project.ts';
-import type { ResolveModuleNames } from './typescript/resolve-module-names.ts';
+import type { GetImportsAndExportsOptions, IgnoreExportsUsedInFile, PluginVisitorContext, PluginVisitorObject } from './types/config.ts';
+import type { FileNode, ModuleGraph } from './types/module-graph.ts';
+import type { Paths } from './types/project.ts';
 import { SourceFileManager } from './typescript/SourceFileManager.ts';
 import type { MainOptions } from './util/create-options.ts';
 import type { ToSourceFilePath } from './util/to-source-path.ts';
@@ -13,30 +12,24 @@ export declare class ProjectPrincipal {
     projectPaths: Set<string>;
     programPaths: Set<string>;
     skipExportsAnalysis: Set<string>;
-    visitors: Visitors;
-    cwd: string;
-    compilerOptions: ts.CompilerOptions;
-    extensions: Set<string>;
+    pluginCtx: PluginVisitorContext;
+    pluginVisitorObjects: PluginVisitorObject[];
+    private _visitor;
     syncCompilers: SyncCompilers;
     asyncCompilers: AsyncCompilers;
-    isWatch: boolean;
+    private paths;
+    private extensions;
     cache: CacheConsultant<FileNode>;
     toSourceFilePath: ToSourceFilePath;
-    backend: {
-        fileManager: SourceFileManager;
-        compilerHost?: ts.CompilerHost;
-        resolveModuleNames: ResolveModuleNames;
-        program?: ts.Program;
-        typeChecker?: ts.TypeChecker;
-        languageServiceHost: ts.LanguageServiceHost;
-    };
-    findReferences?: ts.LanguageService['findReferences'];
-    getImplementationAtPosition?: ts.LanguageService['getImplementationAtPosition'];
-    constructor(options: MainOptions, { compilerOptions, compilers, pkgName, toSourceFilePath }: PrincipalOptions);
-    init(): void;
-    addPaths(paths: Paths, basePath: string): void;
+    fileManager: SourceFileManager;
+    private resolver;
+    resolvedFiles: Set<string>;
+    deletedFiles: Set<string>;
+    constructor(options: MainOptions, toSourceFilePath: ToSourceFilePath);
     addCompilers(compilers: [SyncCompilers, AsyncCompilers]): void;
-    private createProgram;
+    addPaths(paths: Paths, basePath: string): void;
+    init(): void;
+    readFile(filePath: string): string;
     private hasAcceptedExtension;
     addEntryPath(filePath: string, options?: {
         skipExportsAnalysis: boolean;
@@ -46,15 +39,15 @@ export declare class ProjectPrincipal {
     }): void;
     addProgramPath(filePath: string): void;
     addProjectPath(filePath: string): void;
-    deletedFiles: Set<unknown>;
     removeProjectPath(filePath: string): void;
     runAsyncCompilers(): Promise<void>;
+    walkAndAnalyze(analyzeFile: (filePath: string, parseResult: ParseResult | undefined, sourceText: string) => Iterable<string> | undefined): void;
+    private followImportsLightweight;
     getUsedResolvedFiles(): string[];
-    private getProgramSourceFiles;
+    private resolveSpecifier;
     getUnreferencedFiles(): string[];
-    analyzeSourceFile(filePath: string, options: GetImportsAndExportsOptions, ignoreExportsUsedInFile: IgnoreExportsUsedInFile): FileNode;
+    analyzeSourceFile(filePath: string, options: GetImportsAndExportsOptions, ignoreExportsUsedInFile: IgnoreExportsUsedInFile, parseResult?: ParseResult, sourceText?: string): FileNode;
+    private buildVisitor;
     invalidateFile(filePath: string): void;
-    findUnusedMembers(filePath: string, members: ExportMember[]): ExportMember[];
-    hasExternalReferences(filePath: string, exportedItem: Export): boolean;
     reconcileCache(graph: ModuleGraph): void;
 }

package/dist/ProjectPrincipal.js

@@ -1,104 +1,114 @@
-import ts from 'typescript';
+import { parseSync, Visitor, rawTransferSupported } from 'oxc-parser';
+import { isStringLiteral, getStringValue, stripQuotes } from "./typescript/visitors/helpers.js";
 import { CacheConsultant } from "./CacheConsultant.js";
 import { getCompilerExtensions } from "./compilers/index.js";
-import { ANONYMOUS, DEFAULT_EXTENSIONS, MEMBER_FLAGS, PUBLIC_TAG } from "./constants.js";
-import { createHosts } from "./typescript/create-hosts.js";
+import { DEFAULT_EXTENSIONS } from "./constants.js";
 import { _getImportsAndExports } from "./typescript/get-imports-and-exports.js";
+import { createBunShellVisitor } from "./typescript/visitors/script-visitors.js";
+import { coreVisitorObject } from "./typescript/visitors/walk.js";
+import { createCustomModuleResolver } from "./typescript/resolve-module-names.js";
 import { SourceFileManager } from "./typescript/SourceFileManager.js";
 import { compact } from "./util/array.js";
 import { timerify } from "./util/Performance.js";
 import { extname, isInNodeModules, toAbsolute } from "./util/path.js";
-const baseCompilerOptions = {
-    allowJs: true,
-    allowSyntheticDefaultImports: true,
-    declaration: false,
-    declarationMap: false,
-    esModuleInterop: true,
-    inlineSourceMap: false,
-    inlineSources: false,
-    jsx: ts.JsxEmit.Preserve,
-    jsxImportSource: undefined,
-    lib: [],
-    noEmit: true,
-    skipDefaultLibCheck: true,
-    skipLibCheck: true,
-    sourceMap: false,
-    types: ['node'],
-};
-const tsCreateProgram = timerify(ts.createProgram);
+const parseOptions = { sourceType: 'unambiguous', experimentalRawTransfer: rawTransferSupported() };
+const _requireSpecs = [];
+const _requireVisitor = new Visitor({
+    CallExpression(node) {
+        if (node.callee?.type === 'Identifier' && node.callee.name === 'require') {
+            const arg = node.arguments?.[0];
+            if (isStringLiteral(arg))
+                _requireSpecs.push(getStringValue(arg));
+        }
+        if (node.callee?.type === 'MemberExpression' &&
+            !node.callee.computed &&
+            node.callee.object?.type === 'Identifier' &&
+            node.callee.object.name === 'require' &&
+            node.callee.property?.name === 'resolve') {
+            const arg = node.arguments?.[0];
+            if (isStringLiteral(arg))
+                _requireSpecs.push(getStringValue(arg));
+        }
+    },
+    TSImportEqualsDeclaration(node) {
+        if (node.moduleReference?.type === 'TSExternalModuleReference') {
+            const expr = node.moduleReference.expression;
+            if (isStringLiteral(expr))
+                _requireSpecs.push(getStringValue(expr));
+        }
+    },
+});
+const _jsDocImportRe = /import\(\s*['"]([^'"]+)['"]\s*\)/g;
 export class ProjectPrincipal {
     entryPaths = new Set();
     projectPaths = new Set();
     programPaths = new Set();
     skipExportsAnalysis = new Set();
-    visitors = { dynamicImport: [], script: [] };
-    cwd;
-    compilerOptions;
-    extensions;
-    syncCompilers;
-    asyncCompilers;
-    isWatch;
+    pluginCtx = {
+        filePath: '',
+        sourceText: '',
+        addScript: () => { },
+        addImport: () => { },
+    };
+    pluginVisitorObjects = [];
+    _visitor;
+    syncCompilers = new Map();
+    asyncCompilers = new Map();
+    paths = {};
+    extensions = new Set(DEFAULT_EXTENSIONS);
     cache;
     toSourceFilePath;
-    backend;
-    findReferences;
-    getImplementationAtPosition;
-    constructor(options, { compilerOptions, compilers, pkgName, toSourceFilePath }) {
-        this.compilerOptions = {
-            ...compilerOptions,
-            ...baseCompilerOptions,
-            types: compact([...(compilerOptions.types ?? []), ...(baseCompilerOptions.types ?? [])]),
-            allowNonTsExtensions: true,
-        };
-        const [syncCompilers, asyncCompilers] = compilers;
-        this.extensions = new Set([...DEFAULT_EXTENSIONS, ...getCompilerExtensions(compilers)]);
-        this.syncCompilers = syncCompilers;
-        this.asyncCompilers = asyncCompilers;
-        this.cwd = options.cwd;
-        this.isWatch = options.isWatch || options.isSession;
-        this.cache = new CacheConsultant(pkgName || ANONYMOUS, options);
+    fileManager;
+    resolver;
+    resolvedFiles = new Set();
+    deletedFiles = new Set();
+    constructor(options, toSourceFilePath) {
+        this.cache = new CacheConsultant('root', options);
         this.toSourceFilePath = toSourceFilePath;
-        this.backend = {
-            fileManager: new SourceFileManager({ compilers, isSkipLibs: options.isSkipLibs }),
-        };
-    }
-    init() {
-        const { compilerHost, resolveModuleNames, languageServiceHost } = createHosts({
-            cwd: this.cwd,
-            compilerOptions: this.compilerOptions,
-            entryPaths: this.entryPaths,
+        this.pluginVisitorObjects.push(createBunShellVisitor(this.pluginCtx));
+        this.fileManager = new SourceFileManager({
             compilers: [this.syncCompilers, this.asyncCompilers],
-            toSourceFilePath: this.toSourceFilePath,
-            useResolverCache: !this.isWatch,
-            fileManager: this.backend.fileManager,
+            isSkipLibs: options.isSkipLibs,
         });
-        this.backend.compilerHost = compilerHost;
-        this.backend.resolveModuleNames = resolveModuleNames;
-        this.backend.languageServiceHost = languageServiceHost;
+    }
+    addCompilers(compilers) {
+        for (const [ext, compiler] of compilers[0]) {
+            if (!this.syncCompilers.has(ext)) {
+                this.syncCompilers.set(ext, compiler);
+                this.extensions.add(ext);
+            }
+        }
+        for (const [ext, compiler] of compilers[1]) {
+            if (!this.asyncCompilers.has(ext)) {
+                this.asyncCompilers.set(ext, compiler);
+                this.extensions.add(ext);
+            }
+        }
     }
     addPaths(paths, basePath) {
         if (!paths)
             return;
-        this.compilerOptions.paths ??= {};
         for (const key in paths) {
             const prefixes = paths[key].map(prefix => toAbsolute(prefix, basePath));
-            if (key in this.compilerOptions.paths) {
-                this.compilerOptions.paths[key] = compact([...this.compilerOptions.paths[key], ...prefixes]);
+            if (key in this.paths) {
+                this.paths[key] = compact([...this.paths[key], ...prefixes]);
             }
             else {
-                this.compilerOptions.paths[key] = prefixes;
+                this.paths[key] = prefixes;
             }
         }
     }
-    addCompilers(compilers) {
-        this.syncCompilers = new Map([...this.syncCompilers, ...compilers[0]]);
-        this.asyncCompilers = new Map([...this.asyncCompilers, ...compilers[1]]);
-        this.extensions = new Set([...this.extensions, ...getCompilerExtensions(compilers)]);
+    init() {
+        this.extensions = new Set([
+            ...DEFAULT_EXTENSIONS,
+            ...getCompilerExtensions([this.syncCompilers, this.asyncCompilers]),
+        ]);
+        const customCompilerExtensions = getCompilerExtensions([this.syncCompilers, this.asyncCompilers]);
+        const pathsOrUndefined = Object.keys(this.paths).length > 0 ? this.paths : undefined;
+        this.resolver = createCustomModuleResolver({ paths: pathsOrUndefined }, customCompilerExtensions, this.toSourceFilePath);
     }
-    createProgram() {
-        this.backend.program = tsCreateProgram([...this.entryPaths, ...this.programPaths], this.compilerOptions, this.backend.compilerHost, this.backend.program);
-        const typeChecker = timerify(this.backend.program.getTypeChecker);
-        this.backend.typeChecker = typeChecker();
+    readFile(filePath) {
+        return this.fileManager.readFile(filePath);
     }
     hasAcceptedExtension(filePath) {
         return this.extensions.has(extname(filePath));
@@ -126,7 +136,6 @@ export class ProjectPrincipal {
             this.deletedFiles.delete(filePath);
         }
     }
-    deletedFiles = new Set();
     removeProjectPath(filePath) {
         this.entryPaths.delete(filePath);
         this.projectPaths.delete(filePath);
@@ -134,99 +143,193 @@ export class ProjectPrincipal {
         this.deletedFiles.add(filePath);
     }
     async runAsyncCompilers() {
-        const add = timerify(this.backend.fileManager.compileAndAddSourceFile.bind(this.backend.fileManager));
+        const add = timerify(this.fileManager.compileAndAddSourceFile.bind(this.fileManager));
         const extensions = Array.from(this.asyncCompilers.keys());
         const files = Array.from(this.projectPaths).filter(filePath => extensions.includes(extname(filePath)));
         for (const filePath of files) {
             await add(filePath);
         }
     }
+    walkAndAnalyze(analyzeFile) {
+        this.resolvedFiles.clear();
+        const queue = [...this.entryPaths, ...this.programPaths];
+        const visited = new Set();
+        let lastEntrySize = this.entryPaths.size;
+        let lastProgramSize = this.programPaths.size;
+        for (let i = 0; i < queue.length; i++) {
+            const filePath = queue[i];
+            if (visited.has(filePath))
+                continue;
+            visited.add(filePath);
+            const sourceText = this.fileManager.readFile(filePath);
+            if (!sourceText) {
+                if (this.projectPaths.has(filePath))
+                    analyzeFile(filePath, undefined, '');
+                continue;
+            }
+            try {
+                const ext = extname(filePath);
+                const parseFileName = DEFAULT_EXTENSIONS.has(ext) ? filePath : `${filePath}.ts`;
+                const result = parseSync(parseFileName, sourceText, parseOptions);
+                this.fileManager.sourceTextCache.delete(filePath);
+                if (this.projectPaths.has(filePath)) {
+                    const internalPaths = analyzeFile(filePath, result, sourceText);
+                    if (internalPaths) {
+                        for (const p of internalPaths) {
+                            if (!visited.has(p))
+                                queue.push(p);
+                        }
+                    }
+                }
+                else {
+                    this.followImportsLightweight(result, sourceText, filePath, visited, queue);
+                }
+                if (this.entryPaths.size > lastEntrySize || this.programPaths.size > lastProgramSize) {
+                    for (const p of this.entryPaths) {
+                        if (!visited.has(p))
+                            queue.push(p);
+                    }
+                    for (const p of this.programPaths) {
+                        if (!visited.has(p))
+                            queue.push(p);
+                    }
+                    lastEntrySize = this.entryPaths.size;
+                    lastProgramSize = this.programPaths.size;
+                }
+            }
+            catch {
+            }
+        }
+        this.resolvedFiles = visited;
+    }
+    followImportsLightweight(result, sourceText, filePath, visited, queue) {
+        const mod = result.module;
+        for (const si of mod.staticImports) {
+            const resolved = this.resolveSpecifier(si.moduleRequest.value, filePath);
+            if (resolved && !isInNodeModules(resolved)) {
+                if (!visited.has(resolved))
+                    queue.push(resolved);
+            }
+        }
+        for (const se of mod.staticExports) {
+            for (const entry of se.entries) {
+                if (entry.moduleRequest) {
+                    const resolved = this.resolveSpecifier(entry.moduleRequest.value, filePath);
+                    if (resolved && !isInNodeModules(resolved)) {
+                        if (!visited.has(resolved))
+                            queue.push(resolved);
+                    }
+                }
+            }
+        }
+        for (const di of mod.dynamicImports) {
+            const cleaned = stripQuotes(sourceText.slice(di.moduleRequest.start, di.moduleRequest.end));
+            if (cleaned && !cleaned.includes('$') && !cleaned.includes('+')) {
+                const resolved = this.resolveSpecifier(cleaned, filePath);
+                if (resolved && !isInNodeModules(resolved)) {
+                    if (!visited.has(resolved))
+                        queue.push(resolved);
+                }
+            }
+        }
+        if (!isInNodeModules(filePath)) {
+            _requireSpecs.length = 0;
+            _requireVisitor.visit(result.program);
+            for (const spec of _requireSpecs) {
+                const resolved = this.resolveSpecifier(spec, filePath);
+                if (resolved && !isInNodeModules(resolved)) {
+                    if (!visited.has(resolved))
+                        queue.push(resolved);
+                }
+            }
+        }
+        for (const comment of result.comments) {
+            if (comment.type !== 'Block')
+                continue;
+            let m;
+            _jsDocImportRe.lastIndex = 0;
+            while ((m = _jsDocImportRe.exec(comment.value)) !== null) {
+                const resolved = this.resolveSpecifier(m[1], filePath);
+                if (resolved && !isInNodeModules(resolved)) {
+                    if (!visited.has(resolved))
+                        queue.push(resolved);
+                }
+            }
+        }
+    }
     getUsedResolvedFiles() {
-        this.createProgram();
-        const sourceFiles = this.getProgramSourceFiles();
-        return Array.from(this.projectPaths).filter(filePath => sourceFiles.has(filePath));
+        this.resolvedFiles.clear();
+        const queue = [...this.entryPaths, ...this.programPaths];
+        const visited = new Set();
+        for (let i = 0; i < queue.length; i++) {
+            const filePath = queue[i];
+            if (visited.has(filePath))
+                continue;
+            visited.add(filePath);
+            const sourceText = this.fileManager.readFile(filePath);
+            if (!sourceText)
+                continue;
+            try {
+                const ext = extname(filePath);
+                const parseFileName = DEFAULT_EXTENSIONS.has(ext) ? filePath : `${filePath}.ts`;
+                const result = parseSync(parseFileName, sourceText, parseOptions);
+                this.followImportsLightweight(result, sourceText, filePath, visited, queue);
+            }
+            catch {
+            }
+        }
+        this.resolvedFiles = visited;
+        return Array.from(this.projectPaths).filter(filePath => visited.has(filePath));
     }
-    getProgramSourceFiles() {
-        const programSourceFiles = this.backend.program?.getSourceFiles().map(sourceFile => sourceFile.fileName);
-        return new Set(programSourceFiles);
+    resolveSpecifier(specifier, containingFile) {
+        return this.resolver.resolveFileName(specifier, containingFile);
     }
     getUnreferencedFiles() {
-        const sourceFiles = this.getProgramSourceFiles();
-        return Array.from(this.projectPaths).filter(filePath => !sourceFiles.has(filePath));
+        return Array.from(this.projectPaths).filter(filePath => !this.resolvedFiles.has(filePath));
     }
-    analyzeSourceFile(filePath, options, ignoreExportsUsedInFile) {
+    analyzeSourceFile(filePath, options, ignoreExportsUsedInFile, parseResult, sourceText) {
         const fd = this.cache.getFileDescriptor(filePath);
         if (!fd.changed && fd.meta?.data)
             return fd.meta.data;
-        const typeChecker = this.backend.typeChecker;
-        if (!typeChecker)
-            throw new Error('TypeChecker must be initialized before source file analysis');
-        const sourceFile = this.backend.fileManager.getSourceFile(filePath);
-        if (!sourceFile)
-            throw new Error(`Unable to find ${filePath}`);
+        sourceText ??= this.fileManager.readFile(filePath);
         const skipExports = this.skipExportsAnalysis.has(filePath);
         if (options.isFixExports || options.isFixTypes) {
             const ext = extname(filePath);
-            if (!DEFAULT_EXTENSIONS.includes(ext) && (this.syncCompilers.has(ext) || this.asyncCompilers.has(ext))) {
+            if (!DEFAULT_EXTENSIONS.has(ext) && (this.syncCompilers.has(ext) || this.asyncCompilers.has(ext))) {
                 options = { ...options, isFixExports: false, isFixTypes: false };
             }
         }
-        const resolve = (specifier) => this.backend.resolveModuleNames([specifier], sourceFile.fileName)[0];
-        return _getImportsAndExports(sourceFile, resolve, typeChecker, options, ignoreExportsUsedInFile, skipExports, this.visitors);
+        const resolveModule = this.resolver.resolveModuleName;
+        if (!this._visitor)
+            this._visitor = this.buildVisitor();
+        return _getImportsAndExports(filePath, sourceText, resolveModule, options, ignoreExportsUsedInFile, skipExports, this._visitor, this.pluginVisitorObjects.length > 0 ? this.pluginCtx : undefined, parseResult);
     }
-    invalidateFile(filePath) {
-        this.backend.fileManager.invalidate(filePath);
-    }
-    findUnusedMembers(filePath, members) {
-        if (!this.findReferences || !this.getImplementationAtPosition) {
-            const languageService = ts.createLanguageService(this.backend.languageServiceHost, ts.createDocumentRegistry());
-            this.findReferences = timerify(languageService.findReferences);
-            this.getImplementationAtPosition = timerify(languageService.getImplementationAtPosition);
-        }
-        return members.filter(member => {
-            if (member.jsDocTags.has(PUBLIC_TAG))
-                return false;
-            const implementations = this.getImplementationAtPosition(filePath, member.pos)?.filter(impl => impl.fileName !== filePath || impl.textSpan.start !== member.pos) ?? [];
-            const referencedSymbols = this.findReferences(filePath, member.pos) ?? [];
-            if (referencedSymbols.length > 1 && referencedSymbols.some(sym => isInNodeModules(sym.definition.fileName))) {
-                return false;
-            }
-            const refs = referencedSymbols
-                .filter(sym => !implementations.some(impl => impl.fileName === sym.definition.fileName &&
-                impl.textSpan.start === sym.definition.textSpan.start &&
-                impl.textSpan.length === sym.definition.textSpan.length))
-                .flatMap(refs => refs.references)
-                .filter(ref => !ref.isDefinition);
-            if (refs.length === 0)
-                return true;
-            if (member.flags & MEMBER_FLAGS.SETTER)
-                return false;
-            return !refs.some(ref => !ref.isWriteAccess);
-        });
+    buildVisitor() {
+        if (this.pluginVisitorObjects.length === 0)
+            return new Visitor(coreVisitorObject);
+        const merged = { ...coreVisitorObject };
+        for (const obj of this.pluginVisitorObjects) {
+            const handlers = obj;
+            for (const key in handlers) {
+                const existing = merged[key];
+                const pluginFn = handlers[key];
+                if (!pluginFn)
+                    continue;
+                if (existing) {
+                    merged[key] = (node) => {
+                        existing(node);
+                        pluginFn(node);
+                    };
+                }
+                else {
+                    merged[key] = pluginFn;
+                }
+            }
+        }
+        return new Visitor(merged);
     }
-    hasExternalReferences(filePath, exportedItem) {
-        if (exportedItem.jsDocTags.has(PUBLIC_TAG))
-            return false;
-        if (!this.findReferences) {
-            const languageService = ts.createLanguageService(this.backend.languageServiceHost, ts.createDocumentRegistry());
-            this.findReferences = timerify(languageService.findReferences);
-        }
-        const referencedSymbols = this.findReferences(filePath, exportedItem.pos);
-        if (!referencedSymbols?.length)
-            return false;
-        const externalRefs = referencedSymbols
-            .flatMap(refs => refs.references)
-            .filter(ref => !ref.isDefinition && ref.fileName !== filePath)
-            .filter(ref => {
-            const sourceFile = this.backend.program?.getSourceFile(ref.fileName);
-            if (!sourceFile)
-                return true;
-            const node = ts.getTokenAtPosition(sourceFile, ref.textSpan.start);
-            if (!node?.parent?.parent?.parent)
-                return true;
-            return !(ts.isExportSpecifier(node.parent) && node.parent.parent.parent.moduleSpecifier);
-        });
-        return externalRefs.length > 0;
+    invalidateFile(filePath) {
+        this.fileManager.invalidate(filePath);
     }
     reconcileCache(graph) {
         for (const [filePath, file] of graph) {