knip 5.26.0 → 5.27.1

package/dist/plugins/react-cosmos/index.js

@@ -0,0 +1,33 @@
+import { hasDependency, resolveEntry } from '#p/util/plugin.js';
+import { join } from '../../util/path.js';
+import { toEntryPattern } from '../../util/protocols.js';
+const title = 'React Cosmos';
+const enablers = ['react-cosmos'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['cosmos.config.json'];
+const ext = '{js,jsx,ts,tsx,md,mdx}';
+const fixtureEntry = [`**/*.fixture.${ext}`, `__fixtures__/**/*.${ext}`, `**/fixture.${ext}`];
+const decoratorEntry = ['**/cosmos.decorator.{jsx,tsx}'];
+const entry = [...fixtureEntry, ...decoratorEntry];
+const resolveEntryPaths = async (localConfig) => {
+    const { fixturesDir, fixtureFileSuffix } = localConfig;
+    const entries = [
+        join(fixturesDir ?? '__fixtures__', `**/*.${ext}`),
+        join(fixturesDir ?? '', `**/*.${fixtureFileSuffix ?? 'fixture'}.${ext}`),
+        join(fixturesDir ?? '', `**/${fixtureFileSuffix ?? 'fixture'}.${ext}`),
+    ];
+    return [...entries, ...decoratorEntry].map(toEntryPattern);
+};
+const resolveConfig = async (localConfig, options) => {
+    const dependencies = (localConfig?.plugins ?? []).map(specifier => resolveEntry(options, specifier));
+    return [...dependencies];
+};
+export default {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    entry,
+    resolveConfig,
+    resolveEntryPaths,
+};

package/dist/plugins/react-cosmos/types.d.ts

@@ -0,0 +1,5 @@
+export type ReactCosmosConfig = {
+    plugins?: string[];
+    fixtureFileSuffix?: string;
+    fixturesDir?: string;
+};

package/dist/plugins/react-cosmos/types.js

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

package/dist/plugins/rsbuild/index.d.ts

@@ -0,0 +1,10 @@
+import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
+import type { RsbuildConfig } from './types.js';
+declare const _default: {
+    title: string;
+    enablers: import("#p/types/config.js").IgnorePatterns;
+    isEnabled: IsPluginEnabled;
+    config: string[];
+    resolveConfig: ResolveConfig<RsbuildConfig>;
+};
+export default _default;

package/dist/plugins/rsbuild/index.js

@@ -0,0 +1,15 @@
+import { hasDependency } from '#p/util/plugin.js';
+const title = 'Rsbuild';
+const enablers = ['@rsbuild/core'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['rsbuild*.config.{mjs,ts,js,cjs,mts,cts}'];
+const resolveConfig = async () => {
+    return [];
+};
+export default {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    resolveConfig,
+};

package/dist/plugins/rsbuild/types.d.ts

@@ -0,0 +1,3 @@
+export type RsbuildConfig = {
+    plugins?: unknown[];
+};

package/dist/plugins/rsbuild/types.js

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

package/dist/plugins/rspack/index.d.ts

@@ -0,0 +1,10 @@
+import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
+import type { WebpackConfig } from '../webpack/types.js';
+declare const _default: {
+    title: string;
+    enablers: import("#p/types/config.js").IgnorePatterns;
+    isEnabled: IsPluginEnabled;
+    config: string[];
+    resolveConfig: ResolveConfig<WebpackConfig>;
+};
+export default _default;

package/dist/plugins/rspack/index.js

@@ -0,0 +1,22 @@
+import { hasDependency } from '#p/util/plugin.js';
+import { compact } from '../../util/array.js';
+import { findWebpackDependenciesFromConfig } from '../webpack/index.js';
+const title = 'Rspack';
+const enablers = ['@rspack/core'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['rspack.config*.{js,ts,mjs,cjs}'];
+const resolveConfig = async (localConfig, options) => {
+    const { cwd, isProduction } = options;
+    const { entryPatterns, dependencies } = await findWebpackDependenciesFromConfig({ config: localConfig, cwd });
+    const deps = Array.from(dependencies).filter(dependency => !dependency.startsWith('builtin:'));
+    if (isProduction)
+        return [...entryPatterns];
+    return compact([...entryPatterns, ...deps]);
+};
+export default {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    resolveConfig,
+};

package/dist/plugins/vitest/index.js

@@ -47,7 +47,7 @@ const getConfigs = async (localConfig) => {
     return configs;
 };
 export const resolveEntryPaths = async (localConfig, options) => {
-    const dependencies = new Set();
+    const dependencies = new Set(['src/vite-env.d.ts']);
     const configs = await getConfigs(localConfig);
     for (const cfg of configs) {
         const rootDir = cfg.test?.root ?? '.';

package/dist/types/cli.d.ts

@@ -1,20 +1,27 @@
 export interface CommandLineOptions {
+    cacheLocation: string;
     cwd: string;
-    tsConfigFile?: string;
+    excludedIssueTypes: string[];
+    fixTypes: string[];
     gitignore: boolean;
+    includedIssueTypes: string[];
+    isCache: boolean;
     isDebug: boolean;
-    isStrict: boolean;
-    isProduction: boolean;
-    isShowProgress: boolean;
+    isDependenciesShorthand: boolean;
+    isExportsShorthand: boolean;
+    isFilesShorthand: boolean;
+    isFix: boolean;
+    isHideConfigHints: boolean;
     isIncludeEntryExports: boolean;
     isIncludeLibs: boolean;
     isIsolateWorkspaces: boolean;
+    isProduction: boolean;
+    isRemoveFiles: boolean;
+    isShowProgress: boolean;
+    isStrict: boolean;
     isWatch: boolean;
-    isCache?: boolean;
-    cacheLocation?: string;
     tags: Tags;
-    isFix: boolean;
-    fixTypes: string[];
-    isRemoveFiles: boolean;
+    tsConfigFile: string | undefined;
+    workspace: string | undefined;
 }
 export type Tags = [string[], string[]];

package/dist/typescript/{createHosts.js → create-hosts.js}

@@ -3,7 +3,7 @@ import path from 'node:path';
 import ts from 'typescript';
 import { getCompilerExtensions } from '../compilers/index.js';
 import { SourceFileManager } from './SourceFileManager.js';
-import { createCustomModuleResolver } from './resolveModuleNames.js';
+import { createCustomModuleResolver } from './resolve-module-names.js';
 const libLocation = path.dirname(ts.getDefaultLibFilePath({}));
 export const createHosts = ({ cwd, compilerOptions, entryPaths, compilers, isSkipLibs, toSourceFilePath, useResolverCache, }) => {
     const fileManager = new SourceFileManager({ compilers, isSkipLibs });

package/dist/typescript/{resolveModuleNames.js → resolve-module-names.js}

@@ -5,7 +5,7 @@ import { DEFAULT_EXTENSIONS } from '../constants.js';
 import { timerify } from '../util/Performance.js';
 import { sanitizeSpecifier } from '../util/modules.js';
 import { dirname, extname, isAbsolute, isInNodeModules, join } from '../util/path.js';
-import { resolveSync } from '../util/resolve.js';
+import { _resolveSync, createSyncResolver } from '../util/resolve.js';
 import { isDeclarationFileExtension } from './ast-helpers.js';
 const resolutionCache = new Map();
 const fileExists = (name, containingFile) => {
@@ -22,6 +22,7 @@ const fileExists = (name, containingFile) => {
 export function createCustomModuleResolver(compilerOptions, customCompilerExtensions, toSourceFilePath, useCache = true) {
     const customCompilerExtensionsSet = new Set(customCompilerExtensions);
     const extensions = [...DEFAULT_EXTENSIONS, ...customCompilerExtensions];
+    const resolveSync = customCompilerExtensionsSet.size === 0 ? _resolveSync : createSyncResolver(extensions);
     const virtualDeclarationFiles = new Map();
     const tsSys = {
         ...ts.sys,
@@ -56,7 +57,7 @@ export function createCustomModuleResolver(compilerOptions, customCompilerExtens
         const sanitizedSpecifier = sanitizeSpecifier(name);
         if (isBuiltin(sanitizedSpecifier) || isInNodeModules(name))
             return undefined;
-        const resolvedFileName = resolveSync(sanitizedSpecifier, containingFile, extensions);
+        const resolvedFileName = resolveSync(sanitizedSpecifier, dirname(containingFile));
         if (resolvedFileName) {
             const ext = extname(resolvedFileName);
             if (!customCompilerExtensionsSet.has(ext)) {

package/dist/typescript/visitors/dynamic-imports/importCall.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[];
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[] | undefined;
 export default _default;

package/dist/typescript/visitors/dynamic-imports/importCall.js

@@ -2,6 +2,7 @@ import ts from 'typescript';
 import { ANONYMOUS } from '../../../constants.js';
 import { findAncestor, findDescendants, isAccessExpression, isImportCall, isTopLevel, stripQuotes, } from '../../ast-helpers.js';
 import { importVisitor as visit } from '../index.js';
+const getSymbol = (node, isTopLevel) => (isTopLevel ? node.symbol : undefined);
 export default visit(() => true, node => {
     if (isImportCall(node)) {
         if (node.arguments[0] && ts.isStringLiteralLike(node.arguments[0])) {
@@ -34,12 +35,7 @@ export default visit(() => true, node => {
                                     return arg.name.elements.map(element => {
                                         const identifier = (element.propertyName ?? element.name).getText();
                                         const alias = element.propertyName ? element.name.getText() : undefined;
-                                        return {
-                                            identifier,
-                                            alias,
-                                            specifier,
-                                            pos: element.pos,
-                                        };
+                                        return { identifier, alias, specifier, pos: element.pos };
                                     });
                                 }
                             }
@@ -51,9 +47,9 @@ export default visit(() => true, node => {
                             return ts.isVariableDeclaration(_node);
                         });
                         if (variableDeclaration) {
-                            const isTLA = isTopLevel(variableDeclaration.parent);
                             const alias = String(variableDeclaration.name.escapedText);
-                            return { identifier, alias, symbol: isTLA ? variableDeclaration.symbol : undefined, specifier, pos };
+                            const symbol = getSymbol(variableDeclaration, isTopLevel(variableDeclaration.parent));
+                            return { identifier, alias, symbol, specifier, pos };
                         }
                         return { identifier, specifier, pos };
                     }
@@ -71,20 +67,17 @@ export default visit(() => true, node => {
                         ts.isVariableDeclarationList(variableDeclaration.parent)) {
                         const isTLA = isTopLevel(variableDeclaration.parent);
                         if (ts.isIdentifier(variableDeclaration.name)) {
-                            return {
-                                identifier: 'default',
-                                alias: String(variableDeclaration.name.escapedText),
-                                symbol: isTLA ? variableDeclaration.symbol : undefined,
-                                specifier,
-                                pos: node.arguments[0].pos,
-                            };
+                            const alias = String(variableDeclaration.name.escapedText);
+                            const symbol = getSymbol(variableDeclaration, isTLA);
+                            return { identifier: 'default', alias, symbol, specifier, pos: node.arguments[0].pos };
                         }
                         const bindings = findDescendants(variableDeclaration, ts.isBindingElement);
                         if (bindings.length > 0) {
                             return bindings.map(element => {
                                 const identifier = (element.propertyName ?? element.name).getText();
                                 const alias = element.propertyName ? element.name.getText() : undefined;
-                                return { identifier, alias, symbol: isTLA ? element.symbol : undefined, specifier, pos: element.pos };
+                                const symbol = getSymbol(element, isTLA);
+                                return { identifier, alias, symbol, specifier, pos: element.pos };
                             });
                         }
                         return { identifier: ANONYMOUS, specifier, pos: node.arguments[0].pos };
@@ -98,22 +91,23 @@ export default visit(() => true, node => {
                         ts.isArrayBindingPattern(variableDeclarationParent.name)) {
                         const index = arrayLiteralExpression.elements.indexOf(node);
                         const element = variableDeclarationParent.name.elements[index];
-                        const isTLA = isTopLevel(variableDeclarationParent.parent);
-                        if (ts.isBindingElement(element) && ts.isObjectBindingPattern(element.name) && element.name.elements) {
-                            return element.name.elements.map(element => {
-                                const identifier = (element.propertyName ?? element.name).getText();
-                                const alias = element.propertyName ? element.name.getText() : undefined;
-                                return { identifier, alias, symbol: isTLA ? element.symbol : undefined, specifier, pos: element.pos };
-                            });
+                        if (element) {
+                            const isTL = isTopLevel(variableDeclarationParent.parent);
+                            if (ts.isBindingElement(element) && ts.isObjectBindingPattern(element.name) && element.name.elements) {
+                                return element.name.elements.map(element => {
+                                    const identifier = (element.propertyName ?? element.name).getText();
+                                    const alias = element.propertyName ? element.name.getText() : undefined;
+                                    const symbol = getSymbol(element, isTL);
+                                    return { identifier, alias, symbol, specifier, pos: element.pos };
+                                });
+                            }
+                            if (!ts.isOmittedExpression(element) && ts.isIdentifier(element.name)) {
+                                const alias = String(element.name.escapedText);
+                                const symbol = getSymbol(element, isTL);
+                                return { identifier: 'default', symbol, alias, specifier, pos: element.pos };
+                            }
+                            return { identifier: 'default', specifier, pos: element.pos };
                         }
-                        const alias = element.name.escapedText;
-                        return {
-                            identifier: 'default',
-                            symbol: isTLA ? element.symbol : undefined,
-                            alias,
-                            specifier,
-                            pos: element.pos,
-                        };
                     }
                     return { identifier: 'default', specifier, pos: node.arguments[0].pos };
                 }

package/dist/typescript/visitors/dynamic-imports/importType.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[];
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[] | undefined;
 export default _default;

package/dist/typescript/visitors/dynamic-imports/index.d.ts

@@ -1,3 +1,3 @@
 import type ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => ((node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[])[];
+declare const _default: (sourceFile: ts.SourceFile) => ((node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[] | undefined)[];
 export default _default;

package/dist/typescript/visitors/dynamic-imports/jsDocType.d.ts

@@ -1,4 +1,4 @@
 import ts from 'typescript';
 import type { ImportNode } from '../../../types/imports.js';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | ImportNode | ImportNode[];
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => ImportNode | ImportNode[] | undefined;
 export default _default;

package/dist/typescript/visitors/dynamic-imports/propertyAccessCall.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[];
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[] | undefined;
 export default _default;

package/dist/typescript/visitors/dynamic-imports/requireCall.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[];
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[] | undefined;
 export default _default;

package/dist/typescript/visitors/dynamic-imports/requireCall.js

@@ -1,5 +1,6 @@
 import ts from 'typescript';
 import { findAncestor, findDescendants, isRequireCall, isTopLevel } from '../../ast-helpers.js';
+import { isNotJS } from '../helpers.js';
 import { importVisitor as visit } from '../index.js';
 export default visit(() => true, node => {
     if (isRequireCall(node)) {
@@ -11,9 +12,10 @@ export default visit(() => true, node => {
                         return 'STOP';
                     return ts.isPropertyAccessExpression(_node);
                 });
+                const resolve = isNotJS(node.getSourceFile());
                 if (propertyAccessExpression) {
                     const identifier = String(propertyAccessExpression.name.escapedText);
-                    return { identifier, specifier, pos: propertyAccessExpression.name.pos };
+                    return { identifier, specifier, pos: propertyAccessExpression.name.pos, resolve };
                 }
                 const variableDeclaration = node.parent;
                 if (ts.isVariableDeclaration(variableDeclaration) &&
@@ -27,6 +29,7 @@ export default visit(() => true, node => {
                             symbol: isTLA ? variableDeclaration.symbol : undefined,
                             specifier,
                             pos: node.arguments[0].pos,
+                            resolve,
                         };
                     }
                     const bindings = findDescendants(variableDeclaration, ts.isBindingElement);
@@ -34,12 +37,13 @@ export default visit(() => true, node => {
                         return bindings.map(element => {
                             const identifier = (element.propertyName ?? element.name).getText();
                             const alias = element.propertyName ? element.name.getText() : undefined;
-                            return { identifier, specifier, alias, symbol: isTLA ? element.symbol : undefined, pos: element.pos };
+                            const symbol = isTLA ? element.symbol : undefined;
+                            return { identifier, specifier, alias, symbol, pos: element.pos, resolve };
                         });
                     }
-                    return { identifier: 'default', specifier, pos: node.arguments[0].pos };
+                    return { identifier: 'default', specifier, pos: node.arguments[0].pos, resolve };
                 }
-                return { identifier: 'default', specifier, pos: node.arguments[0].pos };
+                return { identifier: 'default', specifier, pos: node.arguments[0].pos, resolve };
             }
         }
     }

package/dist/typescript/visitors/exports/exportAssignment.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[];
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[] | undefined;
 export default _default;

package/dist/typescript/visitors/exports/exportDeclaration.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[];
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[] | undefined;
 export default _default;

package/dist/typescript/visitors/exports/exportKeyword.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[];
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[] | undefined;
 export default _default;

package/dist/typescript/visitors/exports/exportsAccessExpression.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[];
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[] | undefined;
 export default _default;

package/dist/typescript/visitors/exports/index.d.ts

@@ -1,3 +1,3 @@
 import type ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => ((node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[])[];
+declare const _default: (sourceFile: ts.SourceFile) => ((node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[] | undefined)[];
 export default _default;

package/dist/typescript/visitors/exports/moduleExportsAccessExpression.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[];
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[] | undefined;
 export default _default;

package/dist/typescript/visitors/helpers.js

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-export const isNotJS = (sourceFile) => sourceFile.scriptKind !== ts.ScriptKind.JS && sourceFile.scriptKind !== ts.ScriptKind.JSX;
+export const isNotJS = (sourceFile) => !isJS(sourceFile);
 export const isJS = (sourceFile) => sourceFile.scriptKind === ts.ScriptKind.JS || sourceFile.scriptKind === ts.ScriptKind.JSX;
 export function getImportsFromPragmas(sourceFile) {
     const importNodes = [];

package/dist/typescript/visitors/imports/importDeclaration.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[];
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[] | undefined;
 export default _default;

package/dist/typescript/visitors/imports/importEqualsDeclaration.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[];
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[] | undefined;
 export default _default;

package/dist/typescript/visitors/imports/index.d.ts

@@ -1,3 +1,3 @@
 import type ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => ((node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[])[];
+declare const _default: (sourceFile: ts.SourceFile) => ((node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[] | undefined)[];
 export default _default;

package/dist/typescript/visitors/imports/reExportDeclaration.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[];
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[] | undefined;
 export default _default;

package/dist/typescript/visitors/index.d.ts

@@ -1,7 +1,7 @@
 import type ts from 'typescript';
 import type { ExportNode } from '../../types/exports.js';
 import type { ImportNode } from '../../types/imports.js';
-import type { GetImportsAndExportsOptions } from '../getImportsAndExports.js';
+import type { GetImportsAndExportsOptions } from '../get-imports-and-exports.js';
 type FileCondition = (sourceFile: ts.SourceFile) => boolean;
 type VisitorFactory<T> = (fileCondition: FileCondition, fn: Visitor<T>) => VisitorCondition<T>;
 type VisitorCondition<T> = (sourceFile: ts.SourceFile) => Visitor<T>;

package/dist/typescript/visitors/scripts/bun.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | string | string[];
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => string | string[] | undefined;
 export default _default;

package/dist/typescript/visitors/scripts/execa.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | string | string[];
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => string | string[] | undefined;
 export default _default;

package/dist/typescript/visitors/scripts/index.d.ts

@@ -1,3 +1,3 @@
 import type ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => ((node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | string | string[])[];
+declare const _default: (sourceFile: ts.SourceFile) => ((node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => string | string[] | undefined)[];
 export default _default;

package/dist/typescript/visitors/scripts/zx.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => undefined | string | string[];
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => string | string[] | undefined;
 export default _default;

package/dist/util/create-workspace-graph.d.ts

@@ -0,0 +1,8 @@
+import type { PackageJson } from '../types/package-json.js';
+interface Package {
+    manifest: PackageJson;
+    dir: string;
+}
+export type WorkspaceGraph = Record<string, Set<string>>;
+export declare function createWorkspaceGraph(cwd: string, wsNames: string[], wsPkgNames: Set<string>, byPkgName: Map<string, Package>, byName: Map<string, Package>): WorkspaceGraph;
+export {};

package/dist/util/{pkgs-graph.js → create-workspace-graph.js}

@@ -1,8 +1,8 @@
 import { join } from './path.js';
 const types = ['peerDependencies', 'devDependencies', 'optionalDependencies', 'dependencies'];
-export function createPkgGraph(cwd, wsNames, wsPkgNames, byPkgName, byName) {
+export function createWorkspaceGraph(cwd, wsNames, wsPkgNames, byPkgName, byName) {
     const graph = {};
-    const getPkgDirs = (pkg) => {
+    const getWorkspaceDirs = (pkg) => {
         const dirs = new Set();
         for (const type of types) {
             if (pkg.manifest[type]) {
@@ -20,7 +20,7 @@ export function createPkgGraph(cwd, wsNames, wsPkgNames, byPkgName, byName) {
     for (const name of wsNames) {
         const pkg = byName.get(name);
         if (pkg)
-            graph[join(cwd, name)] = getPkgDirs(pkg);
+            graph[join(cwd, name)] = getWorkspaceDirs(pkg);
     }
     return graph;
 }

package/dist/util/dependency-graph.d.ts

@@ -1,7 +1,6 @@
-import type { FileNode, IdToFileMap, IdToNsToFileMap, ImportDetails } from '../types/dependency-graph.js';
-export declare const createFileNode: () => FileNode;
+import type { DependencyGraph, FileNode, IdToFileMap, IdToNsToFileMap, ImportDetails, ImportMap } from '../types/dependency-graph.js';
+export declare const getOrCreateFileNode: (graph: DependencyGraph, filePath: string) => FileNode;
+export declare const updateImportMap: (file: FileNode, importMap: ImportMap, graph: DependencyGraph) => void;
 export declare const createImports: () => ImportDetails;
 export declare const addValue: (map: IdToFileMap, id: string, value: string) => void;
 export declare const addNsValue: (map: IdToNsToFileMap, id: string, ns: string, value: string) => void;
-export declare const addValues: (map: IdToFileMap, id: string, values: Set<string>) => void;
-export declare const addNsValues: (map: IdToNsToFileMap, id: string, value: IdToFileMap) => void;

package/dist/util/dependency-graph.js

@@ -1,4 +1,36 @@
-export const createFileNode = () => ({
+export const getOrCreateFileNode = (graph, filePath) => graph.get(filePath) ?? createFileNode();
+const updateImportDetails = (importedModule, importItems) => {
+    for (const id of importItems.refs)
+        importedModule.refs.add(id);
+    for (const [id, v] of importItems.imported.entries())
+        addValues(importedModule.imported, id, v);
+    for (const [id, v] of importItems.importedAs.entries())
+        addNsValues(importedModule.importedAs, id, v);
+    for (const [id, v] of importItems.importedNs.entries())
+        addValues(importedModule.importedNs, id, v);
+    for (const [id, v] of importItems.reExported.entries())
+        addValues(importedModule.reExported, id, v);
+    for (const [id, v] of importItems.reExportedAs.entries())
+        addNsValues(importedModule.reExportedAs, id, v);
+    for (const [id, v] of importItems.reExportedNs.entries())
+        addValues(importedModule.reExportedNs, id, v);
+};
+export const updateImportMap = (file, importMap, graph) => {
+    for (const [importedFilePath, importDetails] of importMap.entries()) {
+        const importedFileImports = file.imports.internal.get(importedFilePath);
+        if (!importedFileImports)
+            file.imports.internal.set(importedFilePath, importDetails);
+        else
+            updateImportDetails(importedFileImports, importDetails);
+        const importedFile = getOrCreateFileNode(graph, importedFilePath);
+        if (!importedFile.imported)
+            importedFile.imported = importDetails;
+        else
+            updateImportDetails(importedFile.imported, importDetails);
+        graph.set(importedFilePath, importedFile);
+    }
+};
+const createFileNode = () => ({
     imports: {
         internal: new Map(),
         external: new Set(),
@@ -37,14 +69,14 @@ export const addNsValue = (map, id, ns, value) => {
         map.set(id, new Map([[ns, new Set([value])]]));
     }
 };
-export const addValues = (map, id, values) => {
+const addValues = (map, id, values) => {
     if (map.has(id))
         for (const v of values)
             map.get(id)?.add(v);
     else
         map.set(id, values);
 };
-export const addNsValues = (map, id, value) => {
+const addNsValues = (map, id, value) => {
     if (map.has(id))
         for (const [ns, v] of value)
             addValues(map.get(id), ns, v);

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

@@ -1,10 +1,10 @@
 import type { Report } from '../types/issues.js';
-type CLIArguments = {
-    include: string[];
-    exclude: string[];
-    dependencies: boolean;
-    exports: boolean;
-    files: boolean;
+export type CLIArguments = {
+    includedIssueTypes: string[];
+    excludedIssueTypes: string[];
+    isDependenciesShorthand: boolean;
+    isExportsShorthand: boolean;
+    isFilesShorthand: boolean;
 };
 type Options = {
     isProduction?: boolean;