knip 0.0.0-angular.0

package/dist/ProjectPrincipal.d.ts

@@ -0,0 +1,64 @@
+import { isGitIgnoredSync } from 'globby';
+import ts from 'typescript';
+import { SourceFileManager } from './typescript/SourceFileManager.js';
+import type { SyncCompilers, AsyncCompilers } from './types/compilers.js';
+import type { ExportItem, ExportItemMember } from './types/exports.js';
+type ProjectPrincipalOptions = {
+    compilerOptions: ts.CompilerOptions;
+    cwd: string;
+    compilers: [SyncCompilers, AsyncCompilers];
+};
+export declare class ProjectPrincipal {
+    entryPaths: Set<string>;
+    projectPaths: Set<string>;
+    skipExportsAnalysis: Set<string>;
+    isGitIgnored: ReturnType<typeof isGitIgnoredSync>;
+    cwd: string;
+    compilerOptions: ts.CompilerOptions;
+    extensions: Set<string>;
+    syncCompilers: SyncCompilers;
+    asyncCompilers: AsyncCompilers;
+    backend: {
+        fileManager: SourceFileManager;
+        compilerHost: ts.CompilerHost;
+        languageServiceHost: ts.LanguageServiceHost;
+        lsFindReferences: ts.LanguageService['findReferences'];
+        program?: ts.Program;
+    };
+    constructor({ compilerOptions, cwd, compilers }: ProjectPrincipalOptions);
+    private createProgram;
+    private hasAcceptedExtension;
+    addEntryPath(filePath: string, options?: {
+        skipExportsAnalysis: boolean;
+    }): void;
+    addEntryPaths(filePaths: Set<string> | string[], options?: {
+        skipExportsAnalysis: boolean;
+    }): void;
+    addProjectPath(filePath: string): void;
+    runAsyncCompilers(): Promise<void>;
+    getUsedResolvedFiles(): string[];
+    private getProgramSourceFiles;
+    getUnreferencedFiles(): string[];
+    analyzeSourceFile(filePath: string, { skipTypeOnly }: {
+        skipTypeOnly: boolean;
+    }): {
+        imports: {
+            internal: import("./types/imports.js").Imports;
+            unresolved: Set<string>;
+            external: Set<string>;
+        };
+        exports: {
+            exported: import("./types/exports.js").ExportItems;
+            duplicate: string[][];
+        };
+        scripts: Set<string>;
+    };
+    private resolveModule;
+    getHasReferences(filePath: string, exportedItem: ExportItem): {
+        external: boolean;
+        internal: boolean;
+    };
+    findUnusedMembers(filePath: string, members: ExportItemMember[]): string[];
+    private findReferences;
+}
+export {};

package/dist/ProjectPrincipal.js

@@ -0,0 +1,197 @@
+import { isGitIgnoredSync } from 'globby';
+import ts from 'typescript';
+import { DEFAULT_EXTENSIONS } from './constants.js';
+import { IGNORED_FILE_EXTENSIONS } from './constants.js';
+import { getJSDocTags, isInModuleBlock } from './typescript/ast-helpers.js';
+import { createHosts } from './typescript/createHosts.js';
+import { getImportsAndExports } from './typescript/getImportsAndExports.js';
+import { SourceFileManager } from './typescript/SourceFileManager.js';
+import { isMaybePackageName } from './util/modules.js';
+import { dirname, extname, isInNodeModules, join } from './util/path.js';
+import { timerify } from './util/Performance.js';
+const baseCompilerOptions = {
+    allowJs: true,
+    jsx: ts.JsxEmit.Preserve,
+    jsxImportSource: undefined,
+    allowSyntheticDefaultImports: true,
+    esModuleInterop: true,
+    skipDefaultLibCheck: true,
+    skipLibCheck: true,
+    lib: [],
+    target: ts.ScriptTarget.Latest,
+    module: ts.ModuleKind.CommonJS,
+    moduleResolution: ts.ModuleResolutionKind.NodeNext,
+};
+const tsCreateProgram = timerify(ts.createProgram);
+export class ProjectPrincipal {
+    entryPaths = new Set();
+    projectPaths = new Set();
+    skipExportsAnalysis = new Set();
+    isGitIgnored;
+    cwd;
+    compilerOptions;
+    extensions;
+    syncCompilers;
+    asyncCompilers;
+    backend;
+    constructor({ compilerOptions, cwd, compilers }) {
+        this.cwd = cwd;
+        this.isGitIgnored = isGitIgnoredSync({ cwd });
+        this.compilerOptions = {
+            ...compilerOptions,
+            ...baseCompilerOptions,
+            allowNonTsExtensions: [...compilers].flat().length > 0,
+        };
+        const [syncCompilers, asyncCompilers] = compilers;
+        this.extensions = new Set([...DEFAULT_EXTENSIONS, ...syncCompilers.keys(), ...asyncCompilers.keys()]);
+        this.syncCompilers = syncCompilers;
+        this.asyncCompilers = asyncCompilers;
+        const { fileManager, compilerHost, languageServiceHost } = createHosts({
+            cwd: this.cwd,
+            compilerOptions: this.compilerOptions,
+            entryPaths: this.entryPaths,
+            compilers: [this.syncCompilers, this.asyncCompilers],
+        });
+        const languageService = ts.createLanguageService(languageServiceHost, ts.createDocumentRegistry());
+        const lsFindReferences = timerify(languageService?.findReferences);
+        this.backend = {
+            fileManager,
+            compilerHost,
+            languageServiceHost,
+            lsFindReferences,
+        };
+    }
+    createProgram() {
+        this.backend.program = tsCreateProgram(Array.from(this.entryPaths), this.compilerOptions, this.backend.compilerHost, this.backend.program);
+        const typeChecker = timerify(this.backend.program.getTypeChecker);
+        typeChecker();
+    }
+    hasAcceptedExtension(filePath) {
+        return this.extensions.has(extname(filePath));
+    }
+    addEntryPath(filePath, options) {
+        if (!isInNodeModules(filePath) && this.hasAcceptedExtension(filePath)) {
+            this.entryPaths.add(filePath);
+            this.projectPaths.add(filePath);
+            if (options?.skipExportsAnalysis)
+                this.skipExportsAnalysis.add(filePath);
+        }
+    }
+    addEntryPaths(filePaths, options) {
+        filePaths.forEach(filePath => this.addEntryPath(filePath, options));
+    }
+    addProjectPath(filePath) {
+        if (!isInNodeModules(filePath) && this.hasAcceptedExtension(filePath)) {
+            this.projectPaths.add(filePath);
+        }
+    }
+    async runAsyncCompilers() {
+        const add = timerify(this.backend.fileManager.compileAndAddSourceFile.bind(this.backend.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);
+        }
+    }
+    getUsedResolvedFiles() {
+        this.createProgram();
+        const sourceFiles = this.getProgramSourceFiles();
+        return Array.from(this.projectPaths).filter(filePath => sourceFiles.has(filePath));
+    }
+    getProgramSourceFiles() {
+        const programSourceFiles = this.backend.program?.getSourceFiles().map(sourceFile => sourceFile.fileName);
+        return new Set(programSourceFiles);
+    }
+    getUnreferencedFiles() {
+        const sourceFiles = this.getProgramSourceFiles();
+        return Array.from(this.projectPaths).filter(filePath => !sourceFiles.has(filePath));
+    }
+    analyzeSourceFile(filePath, { skipTypeOnly }) {
+        const sourceFile = this.backend.program?.getSourceFile(filePath);
+        if (!sourceFile)
+            throw new Error(`Unable to find ${filePath}`);
+        const skipExports = this.skipExportsAnalysis.has(filePath);
+        const { imports, exports, scripts } = getImportsAndExports(sourceFile, { skipTypeOnly, skipExports });
+        const { internal, unresolved, external } = imports;
+        const unresolvedImports = new Set();
+        unresolved.forEach(specifier => {
+            if (specifier.startsWith('http')) {
+                return;
+            }
+            const resolvedModule = this.resolveModule(specifier, filePath);
+            if (resolvedModule) {
+                if (resolvedModule.isExternalLibraryImport) {
+                    external.add(specifier);
+                }
+                else {
+                    this.addEntryPath(resolvedModule.resolvedFileName, { skipExportsAnalysis: true });
+                }
+            }
+            else {
+                const sanitizedSpecifier = specifier.replace(/^([?!|-]+)?([^!?]+).*/, '$2');
+                if (isMaybePackageName(sanitizedSpecifier)) {
+                    external.add(sanitizedSpecifier);
+                }
+                else {
+                    const isIgnored = this.isGitIgnored(join(dirname(filePath), sanitizedSpecifier));
+                    if (!isIgnored) {
+                        const ext = extname(sanitizedSpecifier);
+                        if (!ext || (ext !== '.json' && !IGNORED_FILE_EXTENSIONS.includes(ext))) {
+                            unresolvedImports.add(specifier);
+                        }
+                    }
+                }
+            }
+        });
+        return {
+            imports: {
+                internal,
+                unresolved: unresolvedImports,
+                external,
+            },
+            exports,
+            scripts,
+        };
+    }
+    resolveModule(specifier, filePath = specifier) {
+        const module = ts.resolveModuleName(specifier, filePath, this.compilerOptions, this.backend.languageServiceHost);
+        return module?.resolvedModule;
+    }
+    getHasReferences(filePath, exportedItem) {
+        const hasReferences = { external: false, internal: false };
+        const symbolReferences = this.findReferences(filePath, exportedItem.pos).flatMap(f => f.references);
+        for (const reference of symbolReferences) {
+            if (reference.fileName === filePath) {
+                if (!reference.isDefinition) {
+                    hasReferences.internal = true;
+                }
+            }
+            else {
+                hasReferences.external = true;
+            }
+        }
+        if (!hasReferences.external && hasReferences.internal) {
+            hasReferences.external = isInModuleBlock(exportedItem.node);
+        }
+        return hasReferences;
+    }
+    findUnusedMembers(filePath, members) {
+        return members
+            .filter(member => {
+            if (getJSDocTags(member.node).includes('@public'))
+                return false;
+            const referencedSymbols = this.findReferences(filePath, member.pos);
+            const files = referencedSymbols
+                .flatMap(refs => refs.references)
+                .filter(ref => !ref.isDefinition)
+                .map(ref => ref.fileName);
+            const internalRefs = files.filter(f => f === filePath);
+            const externalRefs = files.filter(f => f !== filePath);
+            return externalRefs.length === 0 && internalRefs.length === 0;
+        })
+            .map(member => member.identifier);
+    }
+    findReferences(filePath, pos) {
+        return this.backend.lsFindReferences(filePath, pos) ?? [];
+    }
+}

package/dist/WorkspaceWorker.d.ts

@@ -0,0 +1,56 @@
+import type { Configuration, PluginName, WorkspaceConfiguration } from './types/config.js';
+import type { PackageJsonWithPlugins } from './types/plugins.js';
+import type { InstalledBinaries, PeerDependencies } from './types/workspace.js';
+type WorkspaceManagerOptions = {
+    name: string;
+    dir: string;
+    cwd: string;
+    config: WorkspaceConfiguration;
+    manifest: PackageJsonWithPlugins;
+    rootIgnore: Configuration['ignore'];
+    negatedWorkspacePatterns: string[];
+    enabledPluginsInAncestors: string[];
+    isProduction: boolean;
+    isStrict: boolean;
+};
+type ReferencedDependencies = Set<[string, string]>;
+export declare class WorkspaceWorker {
+    name: string;
+    dir: string;
+    cwd: string;
+    config: WorkspaceConfiguration;
+    manifest: PackageJsonWithPlugins;
+    isProduction: boolean;
+    isStrict: boolean;
+    rootIgnore: Configuration['ignore'];
+    negatedWorkspacePatterns: string[];
+    enabledPluginsInAncestors: string[];
+    enabled: Record<PluginName, boolean>;
+    enabledPlugins: PluginName[];
+    referencedDependencies: ReferencedDependencies;
+    peerDependencies: PeerDependencies;
+    installedBinaries: InstalledBinaries;
+    constructor({ name, dir, cwd, config, manifest, isProduction, isStrict, rootIgnore, negatedWorkspacePatterns, enabledPluginsInAncestors, }: WorkspaceManagerOptions);
+    init(): Promise<void>;
+    private setEnabledPlugins;
+    private initReferencedDependencies;
+    private getConfigForPlugin;
+    getEntryFilePatterns(): string[];
+    getProjectFilePatterns(): string[];
+    getPluginEntryFilePatterns(isIncludeProductionEntryFiles?: boolean): string[];
+    getPluginProjectFilePatterns(): string[];
+    getPluginConfigPatterns(): string[];
+    getProductionEntryFilePatterns(): string[];
+    getProductionProjectFilePatterns(): string[];
+    getProductionPluginEntryFilePatterns(): string[];
+    private getConfigurationFilePatterns;
+    getIgnorePatterns(): string[];
+    private findDependenciesByPlugins;
+    findAllDependencies(): Promise<{
+        peerDependencies: PeerDependencies;
+        installedBinaries: InstalledBinaries;
+        referencedDependencies: ReferencedDependencies;
+        enabledPlugins: ("angular" | "ava" | "babel" | "capacitor" | "changesets" | "commitizen" | "commitlint" | "cspell" | "cypress" | "eslint" | "gatsby" | "husky" | "jest" | "lefthook" | "markdownlint" | "mocha" | "next" | "nx" | "nyc" | "playwright" | "postcss" | "prettier" | "remark" | "remix" | "rollup" | "sentry" | "storybook" | "stryker" | "stylelint" | "tailwind" | "typedoc" | "typescript" | "vite" | "vitest" | "webpack" | "githubActions" | "lintStaged" | "npmPackageJsonLint" | "releaseIt" | "semanticRelease" | "svelte")[];
+    }>;
+}
+export {};

package/dist/WorkspaceWorker.js

@@ -0,0 +1,244 @@
+import { TEST_FILE_PATTERNS } from './constants.js';
+import * as npm from './manifest/index.js';
+import * as plugins from './plugins/index.js';
+import { debugLogArray, debugLogObject } from './util/debug.js';
+import { _pureGlob, negate, hasProductionSuffix, hasNoProductionSuffix, prependDirToPattern } from './util/glob.js';
+import { getKeysByValue } from './util/object.js';
+import { join, toPosix } from './util/path.js';
+const negatedTestFilePatterns = TEST_FILE_PATTERNS.map(negate);
+export class WorkspaceWorker {
+    name;
+    dir;
+    cwd;
+    config;
+    manifest;
+    isProduction;
+    isStrict;
+    rootIgnore;
+    negatedWorkspacePatterns = [];
+    enabledPluginsInAncestors;
+    enabled;
+    enabledPlugins = [];
+    referencedDependencies = new Set();
+    peerDependencies = new Map();
+    installedBinaries = new Map();
+    constructor({ name, dir, cwd, config, manifest, isProduction, isStrict, rootIgnore, negatedWorkspacePatterns, enabledPluginsInAncestors, }) {
+        this.name = name;
+        this.dir = dir;
+        this.cwd = cwd;
+        this.config = config;
+        this.manifest = manifest;
+        this.isProduction = isProduction;
+        this.isStrict = isStrict;
+        this.rootIgnore = rootIgnore;
+        this.negatedWorkspacePatterns = negatedWorkspacePatterns;
+        this.enabledPluginsInAncestors = enabledPluginsInAncestors;
+        this.enabled = Object.keys(plugins).reduce((enabled, pluginName) => ({ ...enabled, [pluginName]: false }), {});
+    }
+    async init() {
+        await this.setEnabledPlugins();
+        await this.initReferencedDependencies();
+    }
+    async setEnabledPlugins() {
+        const manifest = this.manifest;
+        const deps = Object.keys(manifest.dependencies ?? {});
+        const devDeps = Object.keys(manifest.devDependencies ?? {});
+        const dependencies = new Set([...deps, ...devDeps]);
+        const pluginEntries = Object.entries(plugins);
+        for (const [pluginName, plugin] of pluginEntries) {
+            if (this.config[pluginName] === false)
+                continue;
+            const isEnabledInAncestor = this.enabledPluginsInAncestors.includes(pluginName);
+            if (isEnabledInAncestor ||
+                (await plugin.isEnabled({ cwd: this.dir, manifest, dependencies, config: this.config }))) {
+                this.enabled[pluginName] = true;
+            }
+        }
+        this.enabledPlugins = getKeysByValue(this.enabled, true);
+        const enabledPluginNames = this.enabledPlugins.map(name => plugins[name].NAME);
+        debugLogObject(`Enabled plugins (${this.name})`, enabledPluginNames);
+    }
+    async initReferencedDependencies() {
+        const { dependencies, peerDependencies, installedBinaries } = await npm.findDependencies({
+            manifest: this.manifest,
+            isProduction: this.isProduction,
+            isStrict: this.isStrict,
+            dir: this.dir,
+            cwd: this.cwd,
+        });
+        const filePath = join(this.dir, 'package.json');
+        dependencies.forEach(dependency => this.referencedDependencies.add([filePath, dependency]));
+        this.peerDependencies = peerDependencies;
+        this.installedBinaries = installedBinaries;
+    }
+    getConfigForPlugin(pluginName) {
+        return this.config[pluginName] ?? { config: null, entry: null, project: null };
+    }
+    getEntryFilePatterns() {
+        const { entry } = this.config;
+        if (entry.length === 0)
+            return [];
+        return [entry, TEST_FILE_PATTERNS, this.negatedWorkspacePatterns].flat();
+    }
+    getProjectFilePatterns() {
+        const { project } = this.config;
+        if (project.length === 0)
+            return [];
+        const negatedPluginConfigPatterns = this.getPluginConfigPatterns().map(negate);
+        const negatedPluginEntryFilePatterns = this.getPluginEntryFilePatterns(false).map(negate);
+        const negatedPluginProjectFilePatterns = this.getPluginProjectFilePatterns().map(negate);
+        return [
+            project,
+            negatedPluginConfigPatterns,
+            negatedPluginEntryFilePatterns,
+            negatedPluginProjectFilePatterns,
+            TEST_FILE_PATTERNS,
+            this.negatedWorkspacePatterns,
+        ].flat();
+    }
+    getPluginEntryFilePatterns(isIncludeProductionEntryFiles = true) {
+        const patterns = [];
+        for (const [pluginName, plugin] of Object.entries(plugins)) {
+            const pluginConfig = this.getConfigForPlugin(pluginName);
+            if (this.enabled[pluginName] && pluginConfig) {
+                const { entry } = pluginConfig;
+                const defaultEntryFiles = 'ENTRY_FILE_PATTERNS' in plugin ? plugin.ENTRY_FILE_PATTERNS : [];
+                patterns.push(...(entry ?? defaultEntryFiles));
+                if (isIncludeProductionEntryFiles) {
+                    const entry = 'PRODUCTION_ENTRY_FILE_PATTERNS' in plugin ? plugin.PRODUCTION_ENTRY_FILE_PATTERNS : [];
+                    patterns.push(...entry);
+                }
+            }
+        }
+        return [patterns, this.negatedWorkspacePatterns].flat();
+    }
+    getPluginProjectFilePatterns() {
+        const patterns = [];
+        for (const [pluginName, plugin] of Object.entries(plugins)) {
+            const pluginConfig = this.getConfigForPlugin(pluginName);
+            if (this.enabled[pluginName] && pluginConfig) {
+                const { entry, project } = pluginConfig;
+                patterns.push(...(project ??
+                    entry ??
+                    ('PROJECT_FILE_PATTERNS' in plugin
+                        ? plugin.PROJECT_FILE_PATTERNS
+                        : 'ENTRY_FILE_PATTERNS' in plugin
+                            ? plugin.ENTRY_FILE_PATTERNS
+                            : [])));
+            }
+        }
+        return [patterns, this.negatedWorkspacePatterns].flat();
+    }
+    getPluginConfigPatterns() {
+        const patterns = [];
+        for (const [pluginName, plugin] of Object.entries(plugins)) {
+            const pluginConfig = this.getConfigForPlugin(pluginName);
+            if (this.enabled[pluginName] && pluginConfig) {
+                const { config } = pluginConfig;
+                const defaultConfigFiles = 'CONFIG_FILE_PATTERNS' in plugin ? plugin.CONFIG_FILE_PATTERNS : [];
+                patterns.push(...(config ?? defaultConfigFiles));
+            }
+        }
+        return patterns;
+    }
+    getProductionEntryFilePatterns() {
+        const entry = this.config.entry.filter(hasProductionSuffix);
+        if (entry.length === 0)
+            return [];
+        const negatedEntryFiles = this.config.entry.filter(hasNoProductionSuffix).map(negate);
+        return [entry, negatedEntryFiles, negatedTestFilePatterns, this.negatedWorkspacePatterns].flat();
+    }
+    getProductionProjectFilePatterns() {
+        const project = this.config.project;
+        if (project.length === 0)
+            return this.getProductionEntryFilePatterns();
+        const _project = this.config.project.map(pattern => {
+            if (!pattern.endsWith('!') && !pattern.startsWith('!'))
+                return negate(pattern);
+            return pattern;
+        });
+        const negatedEntryFiles = this.config.entry.filter(hasNoProductionSuffix).map(negate);
+        const negatedPluginConfigPatterns = this.getPluginConfigPatterns().map(negate);
+        const negatedPluginEntryFilePatterns = this.getPluginEntryFilePatterns(false).map(negate);
+        const negatedPluginProjectFilePatterns = this.getPluginProjectFilePatterns().map(negate);
+        return [
+            _project,
+            negatedEntryFiles,
+            negatedPluginConfigPatterns,
+            negatedPluginEntryFilePatterns,
+            negatedPluginProjectFilePatterns,
+            negatedTestFilePatterns,
+            this.negatedWorkspacePatterns,
+        ].flat();
+    }
+    getProductionPluginEntryFilePatterns() {
+        const patterns = [];
+        for (const [pluginName, plugin] of Object.entries(plugins)) {
+            const pluginConfig = this.getConfigForPlugin(pluginName);
+            if (this.enabled[pluginName] && pluginConfig) {
+                if ('PRODUCTION_ENTRY_FILE_PATTERNS' in plugin) {
+                    patterns.push(...(pluginConfig.entry ?? plugin.PRODUCTION_ENTRY_FILE_PATTERNS));
+                }
+            }
+        }
+        if (patterns.length === 0)
+            return [];
+        return [patterns.flat(), negatedTestFilePatterns].flat();
+    }
+    getConfigurationFilePatterns(pluginName) {
+        const plugin = plugins[pluginName];
+        const pluginConfig = this.getConfigForPlugin(pluginName);
+        if (pluginConfig) {
+            const defaultConfig = 'CONFIG_FILE_PATTERNS' in plugin ? plugin.CONFIG_FILE_PATTERNS : [];
+            return pluginConfig.config ?? defaultConfig;
+        }
+        return [];
+    }
+    getIgnorePatterns() {
+        return [...this.rootIgnore, ...this.config.ignore.map(pattern => prependDirToPattern(this.name, pattern))];
+    }
+    async findDependenciesByPlugins() {
+        const cwd = this.dir;
+        const ignore = this.getIgnorePatterns();
+        for (const [pluginName, plugin] of Object.entries(plugins)) {
+            const isIncludePlugin = this.isProduction ? `PRODUCTION_ENTRY_FILE_PATTERNS` in plugin : true;
+            if (this.enabled[pluginName] && isIncludePlugin) {
+                const hasDependencyFinder = 'findDependencies' in plugin && typeof plugin.findDependencies === 'function';
+                if (hasDependencyFinder) {
+                    const pluginConfig = this.getConfigForPlugin(pluginName);
+                    if (!pluginConfig)
+                        continue;
+                    const patterns = this.getConfigurationFilePatterns(pluginName);
+                    const configFilePaths = await _pureGlob({ patterns, cwd, ignore, gitignore: false });
+                    debugLogArray(`Found ${plugin.NAME} config file paths`, configFilePaths);
+                    if (configFilePaths.length === 0)
+                        continue;
+                    const pluginDependencies = new Set();
+                    for (const configFilePath of configFilePaths) {
+                        const dependencies = await plugin.findDependencies(configFilePath, {
+                            cwd,
+                            manifest: this.manifest,
+                            config: pluginConfig,
+                            isProduction: this.isProduction,
+                        });
+                        dependencies.map(toPosix).forEach(specifier => {
+                            pluginDependencies.add(specifier);
+                            this.referencedDependencies.add([configFilePath, specifier]);
+                        });
+                        dependencies.forEach(dependency => pluginDependencies.add(dependency));
+                    }
+                    debugLogArray(`Dependencies referenced in ${plugin.NAME}`, pluginDependencies);
+                }
+            }
+        }
+    }
+    async findAllDependencies() {
+        await this.findDependenciesByPlugins();
+        return {
+            peerDependencies: this.peerDependencies,
+            installedBinaries: this.installedBinaries,
+            referencedDependencies: this.referencedDependencies,
+            enabledPlugins: this.enabledPlugins,
+        };
+    }
+}

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

@@ -0,0 +1,6 @@
+import type { PackageJson } from '@npmcli/package-json';
+export declare const getBinariesFromScript: (script: string, { cwd, manifest, knownGlobalsOnly }: {
+    cwd: string;
+    manifest: PackageJson;
+    knownGlobalsOnly?: boolean | undefined;
+}) => string[];

package/dist/binaries/bash-parser.js

@@ -0,0 +1,58 @@
+import parse from '@ericcornelissen/bash-parser';
+import { debugLogObject } from '../util/debug.js';
+import * as FallbackResolver from './resolvers/fallback.js';
+import * as KnownResolvers from './resolvers/index.js';
+import { stripBinaryPath } from './util.js';
+export const getBinariesFromScript = (script, { cwd, manifest, knownGlobalsOnly = false }) => {
+    if (!script)
+        return [];
+    const fromArgs = (args) => getBinariesFromScript(args.filter(arg => arg !== '--').join(' '), { cwd, manifest });
+    const getBinariesFromNodes = (nodes) => nodes.flatMap(node => {
+        switch (node.type) {
+            case 'Command': {
+                const binary = node.name?.text ? stripBinaryPath(node.name.text) : node.name?.text;
+                const commandExpansions = node.prefix?.flatMap(prefix => prefix.expansion?.filter(expansion => expansion.type === 'CommandExpansion') ?? []) ?? [];
+                if (commandExpansions.length > 0) {
+                    return commandExpansions.flatMap(expansion => getBinariesFromNodes(expansion.commandAST.commands)) ?? [];
+                }
+                if (!binary || binary === '.' || binary === 'source' || binary === '[')
+                    return [];
+                if (binary.startsWith('-') || binary.startsWith('"') || binary.startsWith('..'))
+                    return [];
+                if (['bun', 'deno'].includes(binary))
+                    return [];
+                const args = node.suffix?.map(arg => arg.text) ?? [];
+                if (['!', 'test'].includes(binary))
+                    return fromArgs(args);
+                if (binary in KnownResolvers) {
+                    return KnownResolvers[binary].resolve(binary, args, { cwd, manifest, fromArgs });
+                }
+                if (knownGlobalsOnly)
+                    return [];
+                return FallbackResolver.resolve(binary, args, { cwd, manifest, fromArgs });
+            }
+            case 'LogicalExpression':
+                return getBinariesFromNodes([node.left, node.right]);
+            case 'If':
+                return getBinariesFromNodes([node.clause, node.then, ...(node.else ? [node.else] : [])]);
+            case 'For':
+                return getBinariesFromNodes(node.do.commands);
+            case 'CompoundList':
+                return getBinariesFromNodes(node.commands);
+            case 'Pipeline':
+                return getBinariesFromNodes(node.commands);
+            case 'Function':
+                return getBinariesFromNodes(node.body.commands);
+            default:
+                return [];
+        }
+    });
+    try {
+        const parsed = parse(script);
+        return parsed?.commands ? getBinariesFromNodes(parsed.commands) : [];
+    }
+    catch (error) {
+        debugLogObject('Bash parser error', error);
+        return [];
+    }
+};

package/dist/binaries/index.d.ts

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

package/dist/binaries/index.js

@@ -0,0 +1,18 @@
+import { compact } from '../util/array.js';
+import { getPackageNameFromModuleSpecifier } from '../util/modules.js';
+import { isInternal } from '../util/path.js';
+import { timerify } from '../util/Performance.js';
+import { getBinariesFromScript } from './bash-parser.js';
+import { isBinary } from './util.js';
+const defaultCwd = process.cwd();
+const getDependenciesFromScripts = (npmScripts, options = {}) => {
+    const { cwd = defaultCwd, manifest = {}, knownGlobalsOnly = false } = options;
+    const scripts = typeof npmScripts === 'string' ? [npmScripts] : [...npmScripts];
+    const results = scripts.flatMap(script => getBinariesFromScript(script, { cwd, manifest, knownGlobalsOnly }));
+    return compact(results.map(identifier => {
+        if (isBinary(identifier) || isInternal(identifier))
+            return identifier;
+        return getPackageNameFromModuleSpecifier(identifier);
+    }));
+};
+export const _getDependenciesFromScripts = timerify(getDependenciesFromScripts);

package/dist/binaries/resolvers/c8.d.ts

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

package/dist/binaries/resolvers/c8.js

@@ -0,0 +1,10 @@
+import parseArgs from 'minimist';
+import { toBinary, argsFrom } from '../util.js';
+export const resolve = (binary, args, { fromArgs }) => {
+    const parsed = parseArgs(args, {
+        boolean: ['all', 'check-coverage', 'clean', 'exclude-after-remap', 'per-file', 'skip-full'],
+    });
+    parsed._ = parsed._.filter(a => a !== 'check-coverage');
+    const rest = argsFrom(args, parsed._[0]);
+    return [toBinary(binary), ...fromArgs(rest)];
+};

package/dist/binaries/resolvers/dotenv.d.ts

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