knip 5.50.0 → 5.50.1

package/dist/CacheConsultant.d.ts

@@ -0,0 +1,14 @@
+import { type FileDescriptor } from './util/file-entry-cache.js';
+type CacheOptions = {
+    name: string;
+    isEnabled: boolean;
+    cacheLocation: string;
+};
+export declare class CacheConsultant<T> {
+    private isEnabled;
+    private cache;
+    constructor(options: CacheOptions);
+    getFileDescriptor(file: string): FileDescriptor<T>;
+    reconcile(): void;
+}
+export {};

package/dist/ConfigurationChief.d.ts

@@ -0,0 +1,182 @@
+import type { Configuration, IgnorePatterns, WorkspaceConfiguration } from './types/config.js';
+import type { PackageJson, WorkspacePackage } from './types/package-json.js';
+import { type WorkspaceGraph } from './util/create-workspace-graph.js';
+import { type CLIArguments } from './util/get-included-issue-types.js';
+type ConfigurationManagerOptions = {
+    cwd: string;
+    isProduction: boolean;
+    isStrict: boolean;
+    isIncludeEntryExports: boolean;
+    workspace: string | undefined;
+};
+export type Workspace = {
+    name: string;
+    pkgName: string;
+    dir: string;
+    ancestors: string[];
+    config: WorkspaceConfiguration;
+    manifestPath: string;
+    manifestStr: string;
+    ignoreMembers: IgnorePatterns;
+    srcDir?: string;
+    outDir?: string;
+};
+export declare class ConfigurationChief {
+    cwd: string;
+    isProduction: boolean;
+    isStrict: boolean;
+    isIncludeEntryExports: boolean;
+    config: Configuration;
+    workspace: string | undefined;
+    manifestPath?: string;
+    manifest?: PackageJson;
+    ignoredWorkspacePatterns: string[];
+    workspacePackages: Map<string, WorkspacePackage>;
+    workspacesByPkgName: Map<string, Workspace>;
+    workspacesByName: Map<string, Workspace>;
+    additionalWorkspaceNames: Set<string>;
+    availableWorkspaceNames: string[];
+    availableWorkspacePkgNames: Set<string>;
+    availableWorkspaceDirs: string[];
+    workspaceGraph: WorkspaceGraph;
+    includedWorkspaces: Workspace[];
+    resolvedConfigFilePath?: string;
+    rawConfig?: any;
+    constructor({ cwd, isProduction, isStrict, isIncludeEntryExports, workspace }: ConfigurationManagerOptions);
+    init(): Promise<void>;
+    private loadResolvedConfigurationFile;
+    getRules(): import("./types/issues.js").Rules;
+    getFilters(): {
+        dir: string;
+    } | {
+        dir?: undefined;
+    };
+    private normalize;
+    private setWorkspaces;
+    private getListedWorkspaces;
+    private getIgnoredWorkspacePatterns;
+    private getConfiguredWorkspaceKeys;
+    private getAdditionalWorkspaceNames;
+    private getAvailableWorkspaceNames;
+    private getIncludedWorkspaces;
+    getManifestForWorkspace(name: string): PackageJson | undefined;
+    getWorkspaces(): Workspace[];
+    private getDescendentWorkspaces;
+    getIgnoredWorkspacesFor(name: string): string[];
+    getNegatedWorkspacePatterns(name: string): string[];
+    private getConfigKeyForWorkspace;
+    getWorkspaceConfig(workspaceName: string): any;
+    getIgnores(workspaceName: string): {
+        ignoreBinaries: any[];
+        ignoreDependencies: any[];
+        ignoreUnresolved: any[];
+    };
+    getConfigForWorkspace(workspaceName: string, extensions?: string[]): {
+        node?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        angular?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        astro?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        ava?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        babel?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        c8?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        capacitor?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        changesets?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        commitizen?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        commitlint?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "create-typescript-app"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        cspell?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        cucumber?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        cypress?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "dependency-cruiser"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        dotenv?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        drizzle?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        eleventy?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        eslint?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        expo?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        gatsby?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "github-action"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "github-actions"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        glob?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "graphql-codegen"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        husky?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        jest?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        karma?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        ladle?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        lefthook?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "lint-staged"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        linthtml?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "lockfile-lint"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "lost-pixel"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        markdownlint?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        metro?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        mocha?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        moonrepo?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        msw?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        nest?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        netlify?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        next?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        nodemon?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "npm-package-json-lint"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        nuxt?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        nx?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        nyc?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        oclif?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        playwright?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "playwright-ct"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "playwright-test"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        plop?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        postcss?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        preconstruct?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        prettier?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "react-cosmos"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "react-router"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "release-it"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        remark?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        remix?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        rollup?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        rsbuild?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        rspack?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "semantic-release"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        sentry?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "simple-git-hooks"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "size-limit"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        sst?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        starlight?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        storybook?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        stryker?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        stylelint?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        svelte?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        syncpack?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        tailwind?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "tanstack-router"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        travis?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "ts-node"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        tsup?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        tsx?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        typedoc?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        typescript?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        unbuild?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        unocss?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "vercel-og"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        vike?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        vite?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        vitest?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        vue?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "webdriver-io"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        webpack?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        wireit?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        wrangler?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        xo?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        yarn?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        yorkie?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        entry: string[];
+        project: string[];
+        paths: any;
+        ignore: string[];
+        isIncludeEntryExports: any;
+    };
+    getIncludedIssueTypes(cliArgs: CLIArguments): import("./types/issues.js").Report;
+    findWorkspaceByFilePath(filePath: string): Workspace | undefined;
+    getUnusedIgnoredWorkspaces(): string[];
+    getTags(): import("./types/cli.js").Tags;
+}
+export {};

package/dist/ConsoleStreamer.d.ts

@@ -0,0 +1,12 @@
+export declare class ConsoleStreamer {
+    isEnabled: boolean;
+    private lines;
+    constructor({ isEnabled }: {
+        isEnabled?: boolean | undefined;
+    });
+    private clearLines;
+    private resetLines;
+    private update;
+    cast(message: string | string[]): void;
+    clear(): void;
+}

package/dist/DependencyDeputy.d.ts

@@ -0,0 +1,78 @@
+import type { Workspace } from './ConfigurationChief.js';
+import type { ConfigurationHints, Counters, Issue, Issues, SymbolIssueType } from './types/issues.js';
+import type { PackageJson } from './types/package-json.js';
+import type { DependencyArray, DependencySet, HostDependencies, InstalledBinaries, WorkspaceManifests } from './types/workspace.js';
+type Options = {
+    isProduction: boolean;
+    isStrict: boolean;
+};
+export declare class DependencyDeputy {
+    isProduction: boolean;
+    isStrict: boolean;
+    _manifests: WorkspaceManifests;
+    referencedDependencies: Map<string, Set<string>>;
+    referencedBinaries: Map<string, Set<string>>;
+    hostDependencies: Map<string, HostDependencies>;
+    installedBinaries: Map<string, InstalledBinaries>;
+    hasTypesIncluded: Map<string, Set<string>>;
+    constructor({ isProduction, isStrict }: Options);
+    addWorkspace({ name, cwd, dir, manifestPath, manifestStr, manifest, ignoreDependencies, ignoreBinaries, ignoreUnresolved, }: {
+        name: string;
+        cwd: string;
+        dir: string;
+        manifestPath: string;
+        manifestStr: string;
+        manifest: PackageJson;
+        ignoreDependencies: (string | RegExp)[];
+        ignoreBinaries: (string | RegExp)[];
+        ignoreUnresolved: (string | RegExp)[];
+    }): void;
+    getWorkspaceManifest(workspaceName: string): {
+        workspaceDir: string;
+        manifestPath: string;
+        manifestStr: string;
+        dependencies: DependencyArray;
+        devDependencies: DependencyArray;
+        peerDependencies: DependencySet;
+        optionalPeerDependencies: DependencyArray;
+        allDependencies: DependencySet;
+        ignoreDependencies: (string | RegExp)[];
+        ignoreBinaries: (string | RegExp)[];
+        ignoreUnresolved: (string | RegExp)[];
+        usedIgnoreDependencies: Set<string | RegExp>;
+        usedIgnoreBinaries: Set<string | RegExp>;
+        usedIgnoreUnresolved: Set<string | RegExp>;
+    } | undefined;
+    getProductionDependencies(workspaceName: string): DependencyArray;
+    getDevDependencies(workspaceName: string): DependencyArray;
+    getDependencies(workspaceName: string): DependencySet;
+    setInstalledBinaries(workspaceName: string, installedBinaries: Map<string, Set<string>>): void;
+    getInstalledBinaries(workspaceName: string): InstalledBinaries | undefined;
+    setHasTypesIncluded(workspaceName: string, hasTypesIncluded: Set<string>): void;
+    getHasTypesIncluded(workspaceName: string): Set<string> | undefined;
+    addReferencedDependency(workspaceName: string, packageName: string): void;
+    addReferencedBinary(workspaceName: string, binaryName: string): void;
+    setHostDependencies(workspaceName: string, hostDependencies: HostDependencies): void;
+    getHostDependenciesFor(workspaceName: string, dependency: string): {
+        name: string;
+        isPeerOptional: boolean;
+    }[];
+    getOptionalPeerDependencies(workspaceName: string): DependencyArray;
+    maybeAddReferencedExternalDependency(workspace: Workspace, packageName: string): boolean;
+    maybeAddReferencedBinary(workspace: Workspace, binaryName: string): boolean;
+    private isInDependencies;
+    settleDependencyIssues(): {
+        dependencyIssues: Issue[];
+        devDependencyIssues: Issue[];
+        optionalPeerDependencyIssues: Issue[];
+    };
+    handleIgnoredDependencies(issues: Issues, counters: Counters, type: SymbolIssueType): void;
+    handleIgnoredBinaries(issues: Issues, counters: Counters, type: SymbolIssueType): void;
+    handleIgnoredUnresolved(issues: Issues, counters: Counters): void;
+    removeIgnoredIssues({ issues, counters }: {
+        issues: Issues;
+        counters: Counters;
+    }): void;
+    getConfigurationHints(): ConfigurationHints;
+}
+export {};

package/dist/IssueCollector.d.ts

@@ -0,0 +1,39 @@
+import type { ConfigurationHint, Issue, Rules, TagHint } from './types/issues.js';
+type Filters = Partial<{
+    dir: string;
+}>;
+type IssueCollectorOptions = {
+    cwd: string;
+    rules: Rules;
+    filters: Filters;
+};
+export declare class IssueCollector {
+    private cwd;
+    private rules;
+    private filters;
+    private issues;
+    private counters;
+    private referencedFiles;
+    private configurationHints;
+    private tagHints;
+    private ignorePatterns;
+    private isMatch;
+    constructor({ cwd, rules, filters }: IssueCollectorOptions);
+    addIgnorePatterns(patterns: string[]): void;
+    addFileCounts({ processed, unused }: {
+        processed: number;
+        unused: number;
+    }): void;
+    addFilesIssues(filePaths: string[]): void;
+    addIssue(issue: Issue): Issue | undefined;
+    addConfigurationHint(issue: ConfigurationHint): void;
+    addTagHint(issue: TagHint): void;
+    purge(): import("./types/issues.js").IssueSet;
+    getIssues(): {
+        issues: import("./types/issues.js").Issues;
+        counters: import("./types/issues.js").Counters;
+        tagHints: Set<TagHint>;
+        configurationHints: Set<ConfigurationHint>;
+    };
+}
+export {};

package/dist/IssueFixer.d.ts

@@ -0,0 +1,27 @@
+import type { Fix, Fixes } from './types/exports.js';
+import type { Issues } from './types/issues.js';
+interface Fixer {
+    isEnabled: boolean;
+    cwd: string;
+    fixTypes: string[];
+    isRemoveFiles: boolean;
+}
+export declare class IssueFixer {
+    isEnabled: boolean;
+    cwd: string;
+    isFixFiles: boolean;
+    isFixDependencies: boolean;
+    isFixUnusedTypes: boolean;
+    isFixUnusedExports: boolean;
+    unusedTypeNodes: Map<string, Set<Fix>>;
+    unusedExportNodes: Map<string, Set<Fix>>;
+    constructor({ isEnabled, cwd, fixTypes, isRemoveFiles }: Fixer);
+    addUnusedTypeNode(filePath: string, fixes: Fixes | undefined): void;
+    addUnusedExportNode(filePath: string, fixes: Fixes | undefined): void;
+    fixIssues(issues: Issues): Promise<void>;
+    private markExportFixed;
+    private removeUnusedFiles;
+    private removeUnusedExports;
+    private removeUnusedDependencies;
+}
+export {};

package/dist/PackageJsonPeeker.d.ts

@@ -0,0 +1,13 @@
+export declare class PackageJsonPeeker {
+    private manifestStr;
+    private lines;
+    private sections;
+    private ready;
+    constructor(manifestStr: string);
+    private init;
+    getLocation(type: 'dependencies' | 'devDependencies' | 'optionalPeerDependencies', packageName: string): {
+        line: number;
+        col: number;
+        pos: number;
+    } | undefined;
+}

package/dist/PrincipalFactory.d.ts

@@ -0,0 +1,20 @@
+import { ProjectPrincipal } from './ProjectPrincipal.js';
+import type { PrincipalOptions } from './types/project.js';
+type Principal = {
+    principal: ProjectPrincipal;
+    wsDirs: Set<string>;
+    pathKeys: Set<string>;
+    pkgNames: Set<string>;
+};
+type Principals = Set<Principal>;
+export declare class PrincipalFactory {
+    principals: Principals;
+    createPrincipal(options: PrincipalOptions): ProjectPrincipal;
+    private findReusablePrincipal;
+    private linkPrincipal;
+    private addNewPrincipal;
+    getPrincipals(): ProjectPrincipal[];
+    getPrincipalByPackageName(packageName: string): ProjectPrincipal | undefined;
+    deletePrincipal(principal: ProjectPrincipal): void;
+}
+export {};

package/dist/ProjectPrincipal.d.ts

@@ -0,0 +1,58 @@
+import ts from 'typescript';
+import { CacheConsultant } from './CacheConsultant.js';
+import type { AsyncCompilers, SyncCompilers } from './compilers/types.js';
+import type { GetImportsAndExportsOptions } from './types/config.js';
+import type { Export, ExportMember, FileNode, ModuleGraph } from './types/module-graph.js';
+import type { PrincipalOptions } from './types/project.js';
+import { SourceFileManager } from './typescript/SourceFileManager.js';
+import type { ResolveModuleNames } from './typescript/resolve-module-names.js';
+import type { ToSourceFilePath } from './util/to-source-path.js';
+export declare class ProjectPrincipal {
+    entryPaths: Set<string>;
+    projectPaths: Set<string>;
+    nonEntryPaths: Set<string>;
+    skipExportsAnalysis: Set<string>;
+    cwd: string;
+    compilerOptions: ts.CompilerOptions;
+    extensions: Set<string>;
+    syncCompilers: SyncCompilers;
+    asyncCompilers: AsyncCompilers;
+    isSkipLibs: boolean;
+    isWatch: boolean;
+    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'];
+    constructor({ compilerOptions, cwd, compilers, isSkipLibs, isWatch, pkgName, toSourceFilePath, isCache, cacheLocation, }: PrincipalOptions);
+    init(): void;
+    addPaths(paths: ts.CompilerOptions['paths']): void;
+    addCompilers(compilers: [SyncCompilers, AsyncCompilers]): void;
+    private createProgram;
+    private hasAcceptedExtension;
+    addEntryPath(filePath: string, options?: {
+        skipExportsAnalysis: boolean;
+    }): void;
+    addEntryPaths(filePaths: Set<string> | string[], options?: {
+        skipExportsAnalysis: boolean;
+    }): void;
+    addNonEntryPath(filePath: string): void;
+    addProjectPath(filePath: string): void;
+    deletedFiles: Set<unknown>;
+    removeProjectPath(filePath: string): void;
+    runAsyncCompilers(): Promise<void>;
+    getUsedResolvedFiles(): string[];
+    private getProgramSourceFiles;
+    getUnreferencedFiles(): string[];
+    analyzeSourceFile(filePath: string, options: Omit<GetImportsAndExportsOptions, 'skipExports'>, isGitIgnored: (filePath: string) => boolean, isInternalWorkspace: (packageName: string) => boolean, getPrincipalByFilePath: (filePath: string) => undefined | ProjectPrincipal): FileNode;
+    invalidateFile(filePath: string): void;
+    findUnusedMembers(filePath: string, members: ExportMember[]): ExportMember[];
+    hasExternalReferences(filePath: string, exportedItem: Export): boolean;
+    reconcileCache(graph: ModuleGraph): void;
+}

package/dist/WorkspaceWorker.d.ts

@@ -0,0 +1,69 @@
+import { CacheConsultant } from './CacheConsultant.js';
+import type { Workspace } from './ConfigurationChief.js';
+import type { PluginName } from './types/PluginNames.js';
+import type { Configuration, GetReferencedInternalFilePath, GetSourceFile, WorkspaceConfiguration } from './types/config.js';
+import type { PackageJson } from './types/package-json.js';
+import type { DependencySet } from './types/workspace.js';
+import { type Input } from './util/input.js';
+type WorkspaceManagerOptions = {
+    name: string;
+    dir: string;
+    cwd: string;
+    config: WorkspaceConfiguration;
+    manifest: PackageJson;
+    dependencies: DependencySet;
+    getReferencedInternalFilePath: GetReferencedInternalFilePath;
+    findWorkspaceByFilePath: (filePath: string) => Workspace | undefined;
+    getSourceFile: GetSourceFile;
+    rootIgnore: Configuration['ignore'];
+    negatedWorkspacePatterns: string[];
+    ignoredWorkspacePatterns: string[];
+    enabledPluginsInAncestors: string[];
+    isProduction: boolean;
+    isStrict: boolean;
+    isCache: boolean;
+    cacheLocation: string;
+    configFilesMap: Map<string, Map<PluginName, Set<string>>>;
+};
+type CacheItem = {
+    resolveEntryPaths?: Input[];
+    resolveConfig?: Input[];
+    resolveFromAST?: Input[];
+};
+export declare class WorkspaceWorker {
+    name: string;
+    dir: string;
+    cwd: string;
+    config: WorkspaceConfiguration;
+    manifest: PackageJson;
+    dependencies: DependencySet;
+    getReferencedInternalFilePath: GetReferencedInternalFilePath;
+    findWorkspaceByFilePath: (filePath: string) => Workspace | undefined;
+    getSourceFile: GetSourceFile;
+    isProduction: boolean;
+    isStrict: boolean;
+    rootIgnore: Configuration['ignore'];
+    negatedWorkspacePatterns: string[];
+    ignoredWorkspacePatterns: string[];
+    enabledPluginsMap: Record<PluginName, boolean>;
+    enabledPlugins: PluginName[];
+    enabledPluginsInAncestors: string[];
+    cache: CacheConsultant<CacheItem>;
+    configFilesMap: Map<string, Map<PluginName, Set<string>>>;
+    constructor({ name, dir, cwd, config, manifest, dependencies, isProduction, isStrict, rootIgnore, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, getReferencedInternalFilePath, findWorkspaceByFilePath, getSourceFile, isCache, cacheLocation, configFilesMap, }: WorkspaceManagerOptions);
+    init(): Promise<void>;
+    private determineEnabledPlugins;
+    private getConfigForPlugin;
+    getEntryFilePatterns(): string[];
+    getProjectFilePatterns(projectFilePatterns: string[]): string[];
+    getPluginProjectFilePatterns(patterns?: string[]): string[];
+    getPluginConfigPatterns(): string[];
+    getPluginEntryFilePatterns(patterns: string[]): string[];
+    getProductionEntryFilePatterns(negatedTestFilePatterns: string[]): string[];
+    getProductionProjectFilePatterns(negatedTestFilePatterns: string[]): string[];
+    private getConfigurationFilePatterns;
+    getIgnorePatterns(): string[];
+    runPlugins(): Promise<Input[]>;
+    onDispose(): void;
+}
+export {};

package/dist/binaries/bash-parser.d.ts

@@ -0,0 +1,3 @@
+import type { GetInputsFromScriptsOptions } from '../types/config.js';
+import { type Input } from '../util/input.js';
+export declare const getDependenciesFromScript: (script: string, options: GetInputsFromScriptsOptions) => Input[];

package/dist/binaries/fallback.d.ts

@@ -0,0 +1,2 @@
+import type { BinaryResolver } from '../types/config.js';
+export declare const resolve: BinaryResolver;

package/dist/binaries/index.d.ts

@@ -0,0 +1,2 @@
+import type { GetInputsFromScripts } from '../types/config.js';
+export declare const _getInputsFromScripts: GetInputsFromScripts;

package/dist/binaries/package-manager/bun.d.ts

@@ -0,0 +1,2 @@
+import type { BinaryResolver } from '../../types/config.js';
+export declare const resolve: BinaryResolver;

package/dist/binaries/package-manager/bunx.d.ts

@@ -0,0 +1,3 @@
+import type { BinaryResolver, BinaryResolverOptions } from '../../types/config.js';
+export declare const resolveX: (args: string[], options: BinaryResolverOptions) => import("../../util/input.js").Input[];
+export declare const resolve: BinaryResolver;

package/dist/binaries/package-manager/index.d.ts

@@ -0,0 +1,10 @@
+declare const _default: {
+    bun: import("../../types/config.js").BinaryResolver;
+    bunx: import("../../types/config.js").BinaryResolver;
+    npm: import("../../types/config.js").BinaryResolver;
+    npx: import("../../types/config.js").BinaryResolver;
+    pnpm: import("../../types/config.js").BinaryResolver;
+    pnpx: import("../../types/config.js").BinaryResolver;
+    yarn: import("../../types/config.js").BinaryResolver;
+};
+export default _default;

package/dist/binaries/package-manager/npm.d.ts

@@ -0,0 +1,2 @@
+import type { BinaryResolver } from '../../types/config.js';
+export declare const resolve: BinaryResolver;

package/dist/binaries/package-manager/npx.d.ts

@@ -0,0 +1,2 @@
+import type { BinaryResolver } from '../../types/config.js';
+export declare const resolve: BinaryResolver;

package/dist/binaries/package-manager/pnpm.d.ts

@@ -0,0 +1,2 @@
+import type { BinaryResolver } from '../../types/config.js';
+export declare const resolve: BinaryResolver;

package/dist/binaries/package-manager/pnpx.d.ts

@@ -0,0 +1,3 @@
+import type { BinaryResolver, BinaryResolverOptions } from '../../types/config.js';
+export declare const resolveDlx: (args: string[], options: BinaryResolverOptions) => import("../../util/input.js").Input[];
+export declare const resolve: BinaryResolver;

package/dist/binaries/package-manager/yarn.d.ts

@@ -0,0 +1,2 @@
+import type { BinaryResolver } from '../../types/config.js';
+export declare const resolve: BinaryResolver;

package/dist/binaries/plugins.d.ts

@@ -0,0 +1,2 @@
+import type { BinaryResolver } from '../types/config.js';
+export declare const resolve: BinaryResolver;

package/dist/binaries/util.d.ts

@@ -0,0 +1,3 @@
+import parseArgs from 'minimist';
+export declare const argsFrom: (args: string[], from: string) => string[];
+export declare const parseNodeArgs: (args: string[]) => parseArgs.ParsedArgs;

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/compilers/astro.d.ts

@@ -0,0 +1,6 @@
+import type { HasDependency } from './types.js';
+declare const _default: {
+    condition: (hasDependency: HasDependency) => boolean;
+    compiler: (text: string) => string;
+};
+export default _default;

package/dist/compilers/compilers.d.ts

@@ -0,0 +1,5 @@
+import type { SyncCompilerFn } from './types.js';
+export declare const fencedCodeBlockMatcher: RegExp;
+export declare const importMatcher: RegExp;
+export declare const importsWithinScripts: SyncCompilerFn;
+export declare const scriptBodies: SyncCompilerFn;