knip 5.62.0 → 5.63.1

package/dist/util/create-options.js

@@ -0,0 +1,112 @@
+import { partitionCompilers } from '../compilers/index.js';
+import { KNIP_CONFIG_LOCATIONS } from '../constants.js';
+import { knipConfigurationSchema } from '../schema/configuration.js';
+import { ConfigurationError } from './errors.js';
+import { findFile, loadJSON } from './fs.js';
+import { getIncludedIssueTypes, shorthandDeps, shorthandFiles, shorthandTypes } from './get-included-issue-types.js';
+import { defaultRules } from './issue-initializers.js';
+import { loadResolvedConfigFile } from './load-config.js';
+import { _load } from './loader.js';
+import { getKeysByValue } from './object.js';
+import { isAbsolute, join, normalize, toAbsolute, toPosix } from './path.js';
+import { splitTags } from './tag.js';
+const pcwd = process.cwd();
+export const createOptions = async (options) => {
+    const { parsedCLIArgs = {}, ...rest } = options;
+    const cwd = normalize(toPosix(toAbsolute(options.cwd ?? parsedCLIArgs.directory ?? pcwd, pcwd)));
+    const manifestPath = findFile(cwd, 'package.json');
+    const manifest = manifestPath && (await loadJSON(manifestPath));
+    if (!(manifestPath && manifest)) {
+        throw new ConfigurationError('Unable to find package.json');
+    }
+    let configFilePath;
+    for (const configPath of parsedCLIArgs.config ? [parsedCLIArgs.config] : KNIP_CONFIG_LOCATIONS) {
+        const resolvedConfigFilePath = isAbsolute(configPath) ? configPath : findFile(cwd, configPath);
+        if (resolvedConfigFilePath) {
+            configFilePath = resolvedConfigFilePath;
+            break;
+        }
+    }
+    if (parsedCLIArgs.config && !configFilePath && !manifest.knip) {
+        throw new ConfigurationError(`Unable to find ${parsedCLIArgs.config} or package.json#knip`);
+    }
+    const loadedConfig = Object.assign({}, manifest.knip, configFilePath ? await loadResolvedConfigFile(configFilePath) : {});
+    const parsedConfig = knipConfigurationSchema.parse(partitionCompilers(loadedConfig));
+    if (!configFilePath && manifest.knip)
+        configFilePath = manifestPath;
+    const pnpmWorkspacesPath = findFile(cwd, 'pnpm-workspace.yaml');
+    const pnpmWorkspaces = pnpmWorkspacesPath && (await _load(pnpmWorkspacesPath));
+    const workspaces = pnpmWorkspaces?.packages ??
+        (manifest.workspaces
+            ? Array.isArray(manifest.workspaces)
+                ? manifest.workspaces
+                : (manifest.workspaces.packages ?? [])
+            : []);
+    const isStrict = rest.isStrict ?? parsedCLIArgs.strict ?? false;
+    const isProduction = rest.isProduction ?? parsedCLIArgs.production ?? isStrict;
+    const rules = { ...defaultRules, ...parsedConfig.rules };
+    const excludesFromRules = getKeysByValue(rules, 'off');
+    const includedIssueTypes = getIncludedIssueTypes({
+        isProduction,
+        exclude: [...excludesFromRules, ...(parsedConfig.exclude ?? [])],
+        include: parsedConfig.include ?? [],
+        excludeOverrides: rest.excludedIssueTypes ?? parsedCLIArgs.exclude ?? [],
+        includeOverrides: [
+            ...(rest.includedIssueTypes ?? parsedCLIArgs.include ?? []),
+            ...(parsedCLIArgs.dependencies ? shorthandDeps : []),
+            ...(parsedCLIArgs.exports ? shorthandTypes : []),
+            ...(parsedCLIArgs.files ? shorthandFiles : []),
+        ],
+    });
+    const fixTypes = rest.fixTypes ?? parsedCLIArgs['fix-type'] ?? [];
+    const isFixFiles = parsedCLIArgs['allow-remove-files'] && (fixTypes.length === 0 || fixTypes.includes('files'));
+    const isIncludeLibs = parsedCLIArgs['include-libs'] ?? rest.isIncludeLibs ?? false;
+    const isReportClassMembers = includedIssueTypes.classMembers;
+    const tags = splitTags(parsedCLIArgs.tags ?? rest.tags ?? parsedConfig.tags ?? parsedCLIArgs['experimental-tags'] ?? []);
+    return {
+        cacheLocation: parsedCLIArgs['cache-location'] ?? join(cwd, 'node_modules', '.cache', 'knip'),
+        config: parsedCLIArgs.config,
+        configFilePath,
+        cwd,
+        dependencies: parsedCLIArgs.dependencies ?? false,
+        experimentalTags: tags,
+        exports: parsedCLIArgs.exports ?? false,
+        files: parsedCLIArgs.files ?? false,
+        fixTypes,
+        gitignore: parsedCLIArgs['no-gitignore'] ? false : (rest.gitignore ?? true),
+        includedIssueTypes,
+        isCache: parsedCLIArgs.cache ?? false,
+        isDebug: parsedCLIArgs.debug ?? false,
+        isDisableConfigHints: parsedCLIArgs['no-config-hints'] || isProduction || Boolean(parsedCLIArgs.workspace),
+        isFix: parsedCLIArgs.fix ?? rest.isFix ?? false,
+        isFixDependencies: fixTypes.length === 0 || fixTypes.includes('dependencies'),
+        isFixFiles,
+        isFixUnusedExports: fixTypes.length === 0 || fixTypes.includes('exports'),
+        isFixUnusedTypes: fixTypes.length === 0 || fixTypes.includes('types'),
+        isFormat: parsedCLIArgs.format ?? rest.isFormat ?? false,
+        isIncludeEntryExports: parsedCLIArgs['include-entry-exports'] ?? rest.isIncludeEntryExports ?? false,
+        isIsolateWorkspaces: rest.isIsolateWorkspaces ?? parsedCLIArgs['isolate-workspaces'] ?? false,
+        isProduction,
+        isReportClassMembers,
+        isReportDependencies: includedIssueTypes.dependencies ||
+            includedIssueTypes.unlisted ||
+            includedIssueTypes.unresolved ||
+            includedIssueTypes.binaries,
+        isReportTypes: includedIssueTypes.types || includedIssueTypes.nsTypes || includedIssueTypes.enumMembers,
+        isReportValues: includedIssueTypes.exports || includedIssueTypes.nsExports || isReportClassMembers,
+        isShowProgress: parsedCLIArgs['no-progress'] === false && process.stdout.isTTY && typeof process.stdout.cursorTo === 'function',
+        isSkipLibs: !(isIncludeLibs || includedIssueTypes.classMembers),
+        isStrict,
+        isTrace: parsedCLIArgs.trace ?? false,
+        isTreatConfigHintsAsErrors: parsedCLIArgs['treat-config-hints-as-errors'] ?? parsedConfig.treatConfigHintsAsErrors ?? false,
+        isWatch: parsedCLIArgs.watch ?? rest.isWatch ?? false,
+        parsedConfig,
+        rules,
+        tags,
+        traceExport: parsedCLIArgs['trace-export'],
+        traceFile: parsedCLIArgs['trace-file'],
+        tsConfigFile: parsedCLIArgs.tsConfig,
+        workspace: rest.workspace ?? parsedCLIArgs.workspace,
+        workspaces,
+    };
+};

package/dist/util/debug.js

@@ -1,8 +1,7 @@
-import util from 'node:util';
+import util, { parseArgs } from 'node:util';
 import picocolors from 'picocolors';
-import parsedArgValues from './cli-arguments.js';
-const { debug } = parsedArgValues;
-const IS_DEBUG_ENABLED = debug ?? false;
+const { values } = parseArgs({ strict: false, options: { debug: { type: 'boolean' } } });
+const IS_DEBUG_ENABLED = values.debug ?? false;
 const IS_COLORS = !process.env.NO_COLOR;
 const noop = () => { };
 const inspectOptions = { maxArrayLength: null, depth: null, colors: IS_COLORS };

package/dist/util/errors.d.ts

@@ -6,7 +6,7 @@ export declare class ConfigurationError extends Error {
 }
 export declare class LoaderError extends Error {
 }
-export declare const isKnownError: (error: Error) => error is ConfigurationError | LoaderError | ZodError<any>;
+export declare const isKnownError: (error: Error) => error is ZodError<any> | ConfigurationError | LoaderError;
 export declare const isDisplayReason: (error: Error) => error is ErrorWithCause;
 export declare const isConfigurationError: (error: Error) => error is ConfigurationError;
 export declare const getKnownError: (error: Error) => Error;

package/dist/util/file-entry-cache.js

@@ -4,7 +4,7 @@ import { deserialize, serialize } from 'node:v8';
 import { timerify } from './Performance.js';
 import { debugLog } from './debug.js';
 import { isDirectory, isFile } from './fs.js';
-import { cwd, dirname, isAbsolute, resolve } from './path.js';
+import { dirname, isAbsolute, resolve } from './path.js';
 const createCache = (filePath) => {
     try {
         return deserialize(fs.readFileSync(filePath));
@@ -19,7 +19,7 @@ export class FileEntryCache {
     cache = new Map();
     normalizedEntries = new Map();
     constructor(cacheId, _path) {
-        this.filePath = isAbsolute(_path) ? path.resolve(_path, cacheId) : path.resolve(cwd, _path, cacheId);
+        this.filePath = path.resolve(_path, cacheId);
         if (isFile(this.filePath))
             this.cache = create(this.filePath);
         this.removeNotFoundFiles();
@@ -72,7 +72,7 @@ export class FileEntryCache {
     }
     removeEntry(entryName) {
         if (!isAbsolute(entryName))
-            entryName = resolve(cwd, entryName);
+            entryName = resolve(entryName);
         this.normalizedEntries.delete(entryName);
         this.cache.delete(entryName);
     }

package/dist/util/fs.d.ts

@@ -4,6 +4,6 @@ export declare const findFile: (workingDir: string, fileName: string) => string
 export declare const loadFile: (filePath: string) => Promise<string>;
 export declare const loadJSON: (filePath: string) => Promise<any>;
 export declare const loadYAML: (filePath: string) => Promise<unknown>;
-export declare const loadTOML: (filePath: string) => Promise<Record<string, import("smol-toml").TomlPrimitive>>;
+export declare const loadTOML: (filePath: string) => Promise<import("smol-toml").TomlTable>;
 export declare const parseJSON: (filePath: string, contents: string) => Promise<any>;
 export declare const parseYAML: (contents: string) => unknown;

package/dist/util/get-included-issue-types.d.ts

@@ -1,18 +1,14 @@
 import type { Report } from '../types/issues.js';
-export type CLIArguments = {
-    includedIssueTypes: string[];
-    excludedIssueTypes: string[];
-    isDependenciesShorthand: boolean;
-    isExportsShorthand: boolean;
-    isFilesShorthand: boolean;
-};
-type Options = {
+type GetIncludedIssueTypesOptions = {
     isProduction?: boolean;
-    include?: string[];
-    exclude?: string[];
-    dependencies?: boolean;
-    exports?: boolean;
+    include: string[];
+    exclude: string[];
+    includeOverrides?: string[];
+    excludeOverrides?: string[];
 };
 export declare const defaultExcludedIssueTypes: string[];
-export declare const getIncludedIssueTypes: (cliArgs: CLIArguments, { include, exclude, isProduction }?: Options) => Report;
+export declare const shorthandDeps: string[];
+export declare const shorthandTypes: string[];
+export declare const shorthandFiles: string[];
+export declare const getIncludedIssueTypes: (options: GetIncludedIssueTypesOptions) => Report;
 export {};

package/dist/util/get-included-issue-types.js

@@ -3,27 +3,21 @@ import { ConfigurationError } from './errors.js';
 export const defaultExcludedIssueTypes = ['classMembers', 'nsExports', 'nsTypes'];
 const defaultIssueTypes = ISSUE_TYPES.filter(type => !defaultExcludedIssueTypes.includes(type));
 const normalize = (values) => values.flatMap(value => value.split(','));
-export const getIncludedIssueTypes = (cliArgs, { include = [], exclude = [], isProduction = false } = {}) => {
-    let incl = normalize(cliArgs.includedIssueTypes);
-    const excl = normalize(cliArgs.excludedIssueTypes);
-    for (const type of [...incl, ...excl, ...include, ...exclude]) {
+export const shorthandDeps = ['dependencies', 'optionalPeerDependencies', 'unlisted', 'binaries', 'unresolved'];
+export const shorthandTypes = ['types', 'nsTypes', 'enumMembers', 'duplicates'];
+export const shorthandFiles = ['files'];
+export const getIncludedIssueTypes = (options) => {
+    const incl = normalize(options.includeOverrides ?? []);
+    const excl = normalize(options.excludeOverrides ?? []);
+    for (const type of [...incl, ...excl, ...options.include, ...options.exclude]) {
         if (!ISSUE_TYPES.includes(type))
             throw new ConfigurationError(`Invalid issue type: ${type}`);
     }
-    const excludes = exclude.filter(exclude => !incl.includes(exclude));
-    const includes = include.filter(include => !excl.includes(include));
-    if (cliArgs.isDependenciesShorthand) {
-        incl = [...incl, 'dependencies', 'optionalPeerDependencies', 'unlisted', 'binaries', 'unresolved'];
-    }
-    if (cliArgs.isExportsShorthand) {
-        incl = [...incl, 'exports', 'types', 'enumMembers', 'duplicates'];
-    }
-    if (cliArgs.isFilesShorthand) {
-        incl = [...incl, 'files'];
-    }
+    const excludes = options.exclude.filter(exclude => !incl.includes(exclude));
+    const includes = options.include.filter(include => !excl.includes(include));
     const _include = [...incl, ...includes];
     const _exclude = [...excl, ...excludes];
-    if (isProduction) {
+    if (options.isProduction) {
         _exclude.push('devDependencies');
     }
     else {

package/dist/util/get-referenced-inputs.js

@@ -83,7 +83,7 @@ export const getReferencedInputsHandler = (collector, deputy, chief, isGitIgnore
             });
         }
         else {
-            debugLog(workspace.name, `Unable to resolve ${toDebugString(input)}`);
+            debugLog(workspace.name, `Unable to resolve ${toDebugString(input, chief.cwd)}`);
         }
     }
 };

package/dist/util/glob-core.d.ts

@@ -14,6 +14,6 @@ export declare const findAndParseGitignores: (cwd: string) => Promise<{
     ignores: Set<string>;
     unignores: string[];
 }>;
-export declare function glob(patterns: string | string[], options: GlobOptions): Promise<string[]>;
+export declare function glob(_patterns: string[], options: GlobOptions): Promise<string[]>;
 export declare function getGitIgnoredHandler(options: Options): Promise<(path: string) => boolean>;
 export {};

package/dist/util/glob-core.js

@@ -5,7 +5,7 @@ import fg, {} from 'fast-glob';
 import picomatch from 'picomatch';
 import { GLOBAL_IGNORE_PATTERNS, ROOT_WORKSPACE_NAME } from '../constants.js';
 import { timerify } from './Performance.js';
-import { compact } from './array.js';
+import { compact, partition } from './array.js';
 import { debugLogObject } from './debug.js';
 import { isDirectory, isFile } from './fs.js';
 import { parseAndConvertGitignorePatterns } from './parse-and-convert-gitignores.js';
@@ -126,13 +126,14 @@ export const findAndParseGitignores = async (cwd) => {
     return { gitignoreFiles, ignores, unignores };
 };
 const _parseFindGitignores = timerify(findAndParseGitignores);
-export async function glob(patterns, options) {
-    if (Array.isArray(patterns) && patterns.length === 0)
+export async function glob(_patterns, options) {
+    if (Array.isArray(_patterns) && _patterns.length === 0)
         return [];
     const hasCache = cachedGlobIgnores.has(options.dir);
     const willCache = !hasCache && options.gitignore && options.label;
     const cachedIgnores = options.gitignore ? cachedGlobIgnores.get(options.dir) : undefined;
-    const _ignore = options.gitignore && Array.isArray(options.ignore) ? [...options.ignore] : [];
+    const _ignore = [];
+    const [negatedPatterns, patterns] = partition(_patterns, pattern => pattern.startsWith('!'));
     if (options.gitignore) {
         if (willCache) {
             let dir = options.dir;
@@ -151,16 +152,16 @@ export async function glob(patterns, options) {
     else {
         _ignore.push(...GLOBAL_IGNORE_PATTERNS);
     }
-    const ignore = cachedIgnores || compact(_ignore);
     if (willCache)
         cachedGlobIgnores.set(options.dir, compact(_ignore));
-    const { dir, label, ...fgOptions } = { ...options, ignore };
+    const ignorePatterns = (cachedIgnores || _ignore).concat(negatedPatterns);
+    const { dir, label, ...fgOptions } = { ...options, ignore: ignorePatterns };
     const paths = await fg.glob(patterns, fgOptions);
     const name = relative(options.cwd, dir) || ROOT_WORKSPACE_NAME;
     debugLogObject(name, label ? `Finding ${label}` : 'Finding paths', () => ({
         patterns,
         ...fgOptions,
-        ignore: hasCache ? `// using cache from ${name}` : ignore,
+        ignore: hasCache ? `// using cache from ${name}` : ignorePatterns,
         paths,
     }));
     return paths;

package/dist/util/glob.d.ts

@@ -6,6 +6,7 @@ interface GlobOptions {
     name?: boolean;
     label?: string;
 }
+export declare const removeProductionSuffix: (pattern: string) => string;
 export declare const prependDirToPattern: (dir: string, pattern: string) => string;
 export declare const negate: (pattern: string) => string;
 export declare const hasProductionSuffix: (pattern: string) => boolean;

package/dist/util/glob.js

@@ -9,7 +9,7 @@ const prependDirToPatterns = (cwd, dir, patterns) => {
     const relativePath = relative(cwd, dir);
     return compact([patterns].flat().map(p => removeProductionSuffix(prepend(p, relativePath)))).sort(negatedLast);
 };
-const removeProductionSuffix = (pattern) => pattern.replace(/!$/, '');
+export const removeProductionSuffix = (pattern) => pattern.replace(/!$/, '');
 const negatedLast = (pattern) => (pattern.startsWith('!') ? 1 : -1);
 export const prependDirToPattern = (dir, pattern) => {
     if (pattern.startsWith('!'))

package/dist/util/input.d.ts

@@ -54,5 +54,5 @@ export declare const toAlias: (specifier: string, prefix: string | string[], opt
 export declare const isAlias: (input: Input) => input is AliasInput;
 export declare const toIgnore: (specifier: string, issueType: IssueType) => IgnoreInput;
 export declare const isIgnore: (input: Input) => input is IgnoreInput;
-export declare const toDebugString: (input: Input) => string;
+export declare const toDebugString: (input: Input, cwd: string) => string;
 export {};

package/dist/util/input.js

@@ -67,4 +67,4 @@ export const toIgnore = (specifier, issueType) => ({
     issueType,
 });
 export const isIgnore = (input) => input.type === 'ignore';
-export const toDebugString = (input) => `${input.type}:${isAbsolute(input.specifier) ? toRelative(input.specifier) : input.specifier}${input.containingFilePath ? ` (${toRelative(input.containingFilePath)})` : ''}`;
+export const toDebugString = (input, cwd) => `${input.type}:${isAbsolute(input.specifier) ? toRelative(input.specifier, cwd) : input.specifier}${input.containingFilePath ? ` (${toRelative(input.containingFilePath, cwd)})` : ''}`;

package/dist/util/is-identifier-referenced.d.ts

@@ -5,5 +5,5 @@ type Result = {
     reExportingEntryFile: undefined | string;
     traceNode: TraceNode;
 };
-export declare const getIsIdentifierReferencedHandler: (graph: ModuleGraph, entryPaths: Set<string>) => (filePath: string, id: string, isIncludeEntryExports?: boolean, traceNode?: TraceNode, seen?: Set<string>) => Result;
+export declare const getIsIdentifierReferencedHandler: (graph: ModuleGraph, entryPaths: Set<string>, isTrace: boolean) => (filePath: string, id: string, isIncludeEntryExports?: boolean, traceNode?: TraceNode, seen?: Set<string>) => Result;
 export {};

package/dist/util/is-identifier-referenced.js

@@ -1,6 +1,6 @@
 import { IMPORT_STAR } from '../constants.js';
-import { addNodes, createNode, isTrace } from './trace.js';
-export const getIsIdentifierReferencedHandler = (graph, entryPaths) => {
+import { addNodes, createNode } from './trace.js';
+export const getIsIdentifierReferencedHandler = (graph, entryPaths, isTrace) => {
     const isIdentifierReferenced = (filePath, id, isIncludeEntryExports = false, traceNode = createNode(filePath), seen = new Set()) => {
         let isReferenced = false;
         let reExportingEntryFile = entryPaths.has(filePath) ? filePath : undefined;
@@ -86,23 +86,6 @@ export const getIsIdentifierReferencedHandler = (graph, entryPaths) => {
                 }
             }
         }
-        const reExported = file.reExported.get(identifier) ?? file.reExported.get(IMPORT_STAR);
-        if (reExported) {
-            for (const byFilePath of reExported) {
-                if (!seen.has(byFilePath)) {
-                    const child = createNode(byFilePath);
-                    traceNode.children.add(child);
-                    const result = isIdentifierReferenced(byFilePath, id, isIncludeEntryExports, child, seen);
-                    if (result.reExportingEntryFile)
-                        reExportingEntryFile = result.reExportingEntryFile;
-                    if (result.isReferenced) {
-                        isReferenced = true;
-                        if (!isTrace)
-                            return { isReferenced, reExportingEntryFile, traceNode };
-                    }
-                }
-            }
-        }
         const reExportedAs = file.reExportedAs.get(identifier);
         if (reExportedAs) {
             for (const [alias, byFilePaths] of reExportedAs) {
@@ -123,6 +106,23 @@ export const getIsIdentifierReferencedHandler = (graph, entryPaths) => {
                 }
             }
         }
+        const reExported = file.reExported.get(identifier) ?? file.reExported.get(IMPORT_STAR);
+        if (reExported) {
+            for (const byFilePath of reExported) {
+                if (!seen.has(byFilePath)) {
+                    const child = createNode(byFilePath);
+                    traceNode.children.add(child);
+                    const result = isIdentifierReferenced(byFilePath, id, isIncludeEntryExports, child, seen);
+                    if (result.reExportingEntryFile)
+                        reExportingEntryFile = result.reExportingEntryFile;
+                    if (result.isReferenced) {
+                        isReferenced = true;
+                        if (!isTrace)
+                            return { isReferenced, reExportingEntryFile, traceNode };
+                    }
+                }
+            }
+        }
         for (const [namespace, byFilePaths] of file.reExportedNs.entries()) {
             for (const byFilePath of byFilePaths) {
                 if (!seen.has(byFilePath)) {

package/dist/util/load-config.d.ts

@@ -0,0 +1 @@
+export declare function loadResolvedConfigFile(configPath: string): Promise<any>;

package/dist/util/load-config.js

@@ -0,0 +1,24 @@
+import { debugLogObject } from './debug.js';
+import { ConfigurationError } from './errors.js';
+import { _load } from './loader.js';
+const unwrapFunction = async (maybeFunction) => {
+    if (typeof maybeFunction === 'function') {
+        try {
+            return await maybeFunction();
+        }
+        catch (error) {
+            debugLogObject('*', 'Error executing function:', error);
+            throw error;
+        }
+    }
+    return maybeFunction;
+};
+export async function loadResolvedConfigFile(configPath) {
+    const loadedValue = await _load(configPath);
+    try {
+        return await unwrapFunction(loadedValue);
+    }
+    catch (_error) {
+        throw new ConfigurationError(`Error running the function from ${configPath}`);
+    }
+}

package/dist/util/package-json.d.ts

@@ -7,5 +7,6 @@ interface ExtendedPackageJson extends PackageJson {
 }
 export declare const load: (filePath: string) => Promise<ExtendedPackageJson>;
 export declare const save: (filePath: string, content: ExtendedPackageJson) => Promise<void>;
-export declare const getEntryPathsFromManifest: (manifest: PackageJson) => Set<string>;
+export declare const getEntrySpecifiersFromManifest: (manifest: PackageJson) => Set<string>;
+export declare const getManifestImportDependencies: (manifest: PackageJson) => Set<string>;
 export {};

package/dist/util/package-json.js

@@ -45,7 +45,7 @@ export const save = async (filePath, content) => {
     const fileContent = `${JSON.stringify(content, null, space)}\n`.replace(/\n/g, EOL);
     await writeFile(filePath, fileContent);
 };
-export const getEntryPathsFromManifest = (manifest) => {
+export const getEntrySpecifiersFromManifest = (manifest) => {
     const { main, module, browser, bin, exports, types, typings } = manifest;
     const entryPaths = new Set();
     if (typeof main === 'string')
@@ -54,13 +54,15 @@ export const getEntryPathsFromManifest = (manifest) => {
         entryPaths.add(module);
     if (typeof browser === 'string')
         entryPaths.add(browser);
-    if (bin) {
-        if (typeof bin === 'string')
-            entryPaths.add(bin);
-        if (typeof bin === 'object')
-            for (const id of Object.values(bin))
-                entryPaths.add(id);
-    }
+    if (typeof bin === 'string')
+        entryPaths.add(bin);
+    if (bin && typeof bin === 'object')
+        for (const id of Object.values(bin))
+            entryPaths.add(id);
+    if (typeof types === 'string')
+        entryPaths.add(types);
+    if (typeof typings === 'string')
+        entryPaths.add(typings);
     if (exports) {
         for (const item of getEntriesFromExports(exports)) {
             if (item === './*')
@@ -72,9 +74,19 @@ export const getEntryPathsFromManifest = (manifest) => {
             entryPaths.add(expanded);
         }
     }
-    if (typeof types === 'string')
-        entryPaths.add(types);
-    if (typeof typings === 'string')
-        entryPaths.add(typings);
     return entryPaths;
 };
+export const getManifestImportDependencies = (manifest) => {
+    const dependencies = new Set();
+    if (!manifest.imports)
+        return dependencies;
+    for (const [entry, exportValue] of Object.entries(manifest.imports)) {
+        if (!entry.startsWith('#'))
+            continue;
+        for (const item of getEntriesFromExports(exportValue)) {
+            if (!item.startsWith('.') && !item.startsWith('!'))
+                dependencies.add(item);
+        }
+    }
+    return dependencies;
+};

package/dist/util/parse-and-convert-gitignores.js

@@ -7,6 +7,8 @@ export const convertGitignoreToPicomatchIgnorePatterns = (pattern) => {
         pattern = pattern.slice(0, -1);
     if (pattern.startsWith('*/**/'))
         pattern = pattern.slice(5);
+    if (pattern === '*' || pattern === '**')
+        return { negated, patterns: [pattern, pattern] };
     if (pattern.startsWith('/'))
         pattern = pattern.slice(1);
     else if (!pattern.startsWith('**/'))

package/dist/util/path.d.ts

@@ -4,10 +4,10 @@ export declare const extname: (path: string) => string;
 export declare const basename: (path: string, suffix?: string) => string;
 export declare const join: (...paths: string[]) => string;
 export declare const toPosix: (value: string) => string;
-export declare const cwd: string;
 export declare const resolve: (...paths: string[]) => string;
-export declare const relative: (from: string, to?: string) => string;
+export declare const relative: (from: string, to: string) => string;
 export declare const isInNodeModules: (filePath: string) => boolean;
-export declare const toAbsolute: (id: string, base?: string) => string;
-export declare const toRelative: (id: string) => string;
+export declare const toAbsolute: (id: string, base: string) => string;
+export declare const toRelative: (id: string, base: string) => string;
 export declare const isInternal: (id: string) => boolean;
+export declare const normalize: (path: string) => string;

package/dist/util/path.js

@@ -1,16 +1,14 @@
 import path from 'node:path';
-import parsedArgValues from './cli-arguments.js';
-const { directory } = parsedArgValues;
 export const isAbsolute = path.isAbsolute;
 export const dirname = path.posix.dirname;
 export const extname = path.posix.extname;
 export const basename = path.posix.basename;
 export const join = path.posix.join;
 export const toPosix = (value) => value.split(path.sep).join(path.posix.sep);
-export const cwd = directory ? path.posix.resolve(directory) : toPosix(process.cwd());
-export const resolve = (...paths) => paths.length === 1 ? path.posix.join(cwd, paths[0]) : path.posix.resolve(...paths);
-export const relative = (from, to) => toPosix(path.relative(to ? from : cwd, to ?? from));
+export const resolve = path.posix.resolve;
+export const relative = (from, to) => toPosix(path.relative(from, to));
 export const isInNodeModules = (filePath) => filePath.includes('node_modules');
-export const toAbsolute = (id, base = cwd) => (isAbsolute(id) ? id : join(base, id));
-export const toRelative = (id) => (isAbsolute(id) ? relative(id) : id);
+export const toAbsolute = (id, base) => (isAbsolute(id) ? id : join(base, id));
+export const toRelative = (id, base) => (isAbsolute(id) ? relative(base, id) : id);
 export const isInternal = (id) => (id.startsWith('.') || isAbsolute(id)) && !isInNodeModules(id);
+export const normalize = path.posix.normalize;

package/dist/util/reporter.js

@@ -1,8 +1,8 @@
 import internalReporters from '../reporters/index.js';
 import { _load } from './loader.js';
-import { isInternal, resolve } from './path.js';
+import { isAbsolute, isInternal, resolve } from './path.js';
 export const runPreprocessors = async (processors, data) => {
-    const preprocessors = await Promise.all(processors.map(proc => _load(isInternal(proc) ? resolve(proc) : proc)));
+    const preprocessors = await Promise.all(processors.map(proc => _load(isInternal(proc) && !isAbsolute(proc) ? resolve(proc) : proc)));
     return preprocessors.length === 0
         ? Promise.resolve(data)
         : runPreprocessors(preprocessors.slice(1), preprocessors[0](data));
@@ -11,7 +11,7 @@ export const runReporters = async (reporter, options) => {
     const reporters = await Promise.all(reporter.map(async (reporter) => {
         return reporter in internalReporters
             ? internalReporters[reporter]
-            : await _load(isInternal(reporter) ? resolve(reporter) : reporter);
+            : await _load(isInternal(reporter) && !isAbsolute(reporter) ? resolve(reporter) : reporter);
     }));
     for (const reporter of reporters)
         await reporter(options);

package/dist/util/require.js

@@ -1,5 +1,4 @@
 import { createRequire } from 'node:module';
 import { timerify } from './Performance.js';
-import { cwd } from './path.js';
-const require = createRequire(cwd);
+const require = createRequire(process.cwd());
 export const _require = timerify(require);

package/dist/util/table.js

@@ -55,9 +55,7 @@ export class Table {
             this.rows.unshift(headerRow);
         }
         const columnWidths = columns.reduce((acc, col) => {
-            acc[col] = Math.max(...this.rows.map(row => row[col]?.formatted
-                ? stripVTControlCharacters(row[col].formatted).length
-                : String(row[col]?.value || '').length));
+            acc[col] = Math.max(...this.rows.map(row => stripVTControlCharacters(row[col]?.formatted ?? String(row[col].value || '')).length));
             return acc;
         }, {});
         const separatorWidth = (columns.length - 1) * COLUMN_SEPARATOR.length;

package/dist/util/tag.d.ts

@@ -1,4 +1,4 @@
-import type { Tags } from '../types/cli.js';
+import type { Tags } from '../types/options.js';
 export declare const splitTags: (rawTags: string[]) => Tags;
 export declare const shouldIgnore: (jsDocTags: Set<string>, tags: Tags) => boolean;
 export declare const getShouldIgnoreHandler: (isProduction: boolean) => (jsDocTags: Set<string>) => boolean;

package/dist/util/to-source-path.d.ts

@@ -2,5 +2,5 @@ import type { CompilerOptions } from 'typescript';
 import type { ConfigurationChief, Workspace } from '../ConfigurationChief.js';
 export declare const augmentWorkspace: (workspace: Workspace, dir: string, compilerOptions: CompilerOptions) => void;
 export declare const getToSourcePathHandler: (chief: ConfigurationChief) => (filePath: string) => string | undefined;
-export declare const getToSourcePathsHandler: (chief: ConfigurationChief) => (specifiers: Set<string>, cwd: string, extensions?: string) => Promise<string[]>;
+export declare const getToSourcePathsHandler: (chief: ConfigurationChief) => (specifiers: Set<string>, dir: string, extensions?: string) => Promise<string[]>;
 export type ToSourceFilePath = ReturnType<typeof getToSourcePathHandler>;