knip 5.33.2 → 5.34.0

package/dist/plugins.js

@@ -1,17 +1,24 @@
-import * as originalPlugins from './plugins/index.js';
+import { Plugins } from './plugins/index.js';
 import { timerify } from './util/Performance.js';
 import parsedArgValues from './util/cli-arguments.js';
+const PMap = Plugins;
 const { performance: isEnabled = false } = parsedArgValues;
-const plugins = (isEnabled ? {} : originalPlugins);
-const methods = ['resolve', 'resolveConfig', 'resolveEntryPaths'];
+const timerifyMethods = ['resolve', 'resolveConfig', 'resolveEntryPaths'];
+const PluginEntries = Object.entries(PMap);
 if (isEnabled) {
-    for (const [name, plugin] of Object.entries(originalPlugins)) {
-        plugins[name] = plugin;
-        for (const method of methods) {
-            if (method in plugin) {
-                plugins[name][method] = timerify(plugin[method], `${method} (${plugin.title})`);
-            }
+    for (const [, plugin] of PluginEntries) {
+        for (const method of timerifyMethods) {
+            if (method in plugin)
+                plugin[method] = timerify(plugin[method], `${method} (${plugin.title})`);
         }
     }
 }
-export { plugins };
+const pluginArgsMap = new Map(PluginEntries.flatMap(([pluginName, plugin]) => {
+    if (!plugin.args)
+        return [];
+    const item = [pluginName, plugin.args];
+    if (Array.isArray(plugin.args?.binaries))
+        return plugin.args.binaries.map(bin => [bin, item]);
+    return [[pluginName, item]];
+}));
+export { PMap as Plugins, PluginEntries, pluginArgsMap };

package/dist/reporters/symbols.js

@@ -56,7 +56,7 @@ export default ({ report, issues, tagHints, configurationHints, noConfigHints, i
     }
     if (!noConfigHints) {
         if (configurationHints.size > 0) {
-            logTitle('Configuration issues', configurationHints.size);
+            logTitle('Configuration hints', configurationHints.size);
             for (const hint of configurationHints) {
                 const { type, workspaceName, identifier } = hint;
                 const message = `Unused item in ${type}`;

package/dist/types/PluginNames.d.ts

@@ -0,0 +1,2 @@
+export type PluginName = 'angular' | 'astro' | 'ava' | 'babel' | 'c8' | 'capacitor' | 'changesets' | 'commitizen' | 'commitlint' | 'cspell' | 'cucumber' | 'cypress' | 'dotenv' | 'drizzle' | 'eleventy' | 'eslint' | 'gatsby' | 'github-actions' | 'graphql-codegen' | 'husky' | 'jest' | 'ladle' | 'lefthook' | 'lint-staged' | 'linthtml' | 'lockfile-lint' | 'lost-pixel' | 'markdownlint' | 'mocha' | 'moonrepo' | 'msw' | 'nest' | 'netlify' | 'next' | 'node' | 'node-test-runner' | 'nodemon' | 'npm-package-json-lint' | 'nuxt' | 'nx' | 'nyc' | 'oclif' | 'playwright' | 'playwright-ct' | 'playwright-test' | 'postcss' | 'preconstruct' | 'prettier' | 'react-cosmos' | 'release-it' | 'remark' | 'remix' | 'rollup' | 'rsbuild' | 'rspack' | 'semantic-release' | 'sentry' | 'simple-git-hooks' | 'size-limit' | 'storybook' | 'stryker' | 'stylelint' | 'svelte' | 'syncpack' | 'tailwind' | 'travis' | 'ts-node' | 'tsup' | 'tsx' | 'typedoc' | 'typescript' | 'unbuild' | 'unocss' | 'vercel-og' | 'vike' | 'vite' | 'vitest' | 'vue' | 'webdriver-io' | 'webpack' | 'wireit' | 'wrangler' | 'xo' | 'yorkie';
+export declare const pluginNames: readonly ["angular", "astro", "ava", "babel", "c8", "capacitor", "changesets", "commitizen", "commitlint", "cspell", "cucumber", "cypress", "dotenv", "drizzle", "eleventy", "eslint", "gatsby", "github-actions", "graphql-codegen", "husky", "jest", "ladle", "lefthook", "lint-staged", "linthtml", "lockfile-lint", "lost-pixel", "markdownlint", "mocha", "moonrepo", "msw", "nest", "netlify", "next", "node", "node-test-runner", "nodemon", "npm-package-json-lint", "nuxt", "nx", "nyc", "oclif", "playwright", "playwright-ct", "playwright-test", "postcss", "preconstruct", "prettier", "react-cosmos", "release-it", "remark", "remix", "rollup", "rsbuild", "rspack", "semantic-release", "sentry", "simple-git-hooks", "size-limit", "storybook", "stryker", "stylelint", "svelte", "syncpack", "tailwind", "travis", "ts-node", "tsup", "tsx", "typedoc", "typescript", "unbuild", "unocss", "vercel-og", "vike", "vite", "vitest", "vue", "webdriver-io", "webpack", "wireit", "wrangler", "xo", "yorkie"];

package/dist/types/PluginNames.js

@@ -0,0 +1,86 @@
+export const pluginNames = [
+    'angular',
+    'astro',
+    'ava',
+    'babel',
+    'c8',
+    'capacitor',
+    'changesets',
+    'commitizen',
+    'commitlint',
+    'cspell',
+    'cucumber',
+    'cypress',
+    'dotenv',
+    'drizzle',
+    'eleventy',
+    'eslint',
+    'gatsby',
+    'github-actions',
+    'graphql-codegen',
+    'husky',
+    'jest',
+    'ladle',
+    'lefthook',
+    'lint-staged',
+    'linthtml',
+    'lockfile-lint',
+    'lost-pixel',
+    'markdownlint',
+    'mocha',
+    'moonrepo',
+    'msw',
+    'nest',
+    'netlify',
+    'next',
+    'node',
+    'node-test-runner',
+    'nodemon',
+    'npm-package-json-lint',
+    'nuxt',
+    'nx',
+    'nyc',
+    'oclif',
+    'playwright',
+    'playwright-ct',
+    'playwright-test',
+    'postcss',
+    'preconstruct',
+    'prettier',
+    'react-cosmos',
+    'release-it',
+    'remark',
+    'remix',
+    'rollup',
+    'rsbuild',
+    'rspack',
+    'semantic-release',
+    'sentry',
+    'simple-git-hooks',
+    'size-limit',
+    'storybook',
+    'stryker',
+    'stylelint',
+    'svelte',
+    'syncpack',
+    'tailwind',
+    'travis',
+    'ts-node',
+    'tsup',
+    'tsx',
+    'typedoc',
+    'typescript',
+    'unbuild',
+    'unocss',
+    'vercel-og',
+    'vike',
+    'vite',
+    'vitest',
+    'vue',
+    'webdriver-io',
+    'webpack',
+    'wireit',
+    'wrangler',
+    'xo',
+    'yorkie',
+];

package/dist/types/args.d.ts

@@ -0,0 +1,14 @@
+import type { ParsedArgs } from 'minimist';
+export type ConfigArg = boolean | (string | [string, (id: string) => string])[];
+export type Args = {
+    binaries?: string[];
+    positional?: boolean;
+    string?: string[];
+    boolean?: string[];
+    alias?: Record<string, string[]>;
+    resolve?: string[];
+    nodeImportArgs?: boolean;
+    config?: ConfigArg;
+    args?: (args: string[]) => string[];
+    fromArgs?: string[] | ((parsed: ParsedArgs, args: string[]) => string[]);
+};

package/dist/types/config.d.ts

@@ -1,33 +1,37 @@
 import type { z } from 'zod';
 import type { ConfigurationValidator, pluginSchema } from '../ConfigurationValidator.js';
 import type { AsyncCompilers, SyncCompilers } from '../compilers/types.js';
-import type * as Plugins from '../plugins/index.js';
+import type { Input } from '../util/input.js';
+import type { PluginName } from './PluginNames.js';
+import type { Args } from './args.js';
+import type { Tags } from './cli.js';
 import type { IssueType, Rules } from './issues.js';
+import type { PackageJson } from './package-json.js';
+export interface GetInputsFromScriptsOptions extends BaseOptions {
+    knownBinsOnly?: boolean;
+    containingFilePath: string;
+}
+export type GetInputsFromScripts<T = GetInputsFromScriptsOptions> = (npmScripts: string | string[] | Set<string>, options: T) => Input[];
+export type GetInputsFromScriptsPartial = (npmScripts: string | string[] | Set<string>, options?: Partial<GetInputsFromScriptsOptions>) => Input[];
+type FromArgs = (args: string[]) => Input[];
+interface BinaryResolverOptions extends GetInputsFromScriptsOptions {
+    fromArgs: FromArgs;
+}
+export type BinaryResolver = (binary: string, args: string[], options: BinaryResolverOptions) => Input[];
 export type RawConfiguration = z.infer<typeof ConfigurationValidator>;
 export type RawPluginConfiguration = z.infer<typeof pluginSchema>;
-type NormalizedGlob = string[];
 export type IgnorePatterns = (string | RegExp)[];
-export type EnablerPatterns = IgnorePatterns;
-export type PluginName = keyof typeof Plugins;
-export type PluginMap = typeof Plugins;
-export type EnsuredPluginConfiguration = {
-    config: NormalizedGlob | null;
-    entry: NormalizedGlob | null;
-    project: NormalizedGlob | null;
-};
-type PluginConfiguration = EnsuredPluginConfiguration | boolean;
-export type PluginsConfiguration = Record<PluginName, PluginConfiguration>;
-interface BaseWorkspaceConfiguration {
-    entry: NormalizedGlob;
-    project: NormalizedGlob;
-    paths: Record<string, string[]>;
-    ignore: NormalizedGlob;
-    isIncludeEntryExports: boolean;
-}
-export interface WorkspaceConfiguration extends BaseWorkspaceConfiguration, Partial<PluginsConfiguration> {
-}
 type IgnorableExport = 'class' | 'enum' | 'function' | 'interface' | 'member' | 'type';
 export type IgnoreExportsUsedInFile = boolean | Partial<Record<IgnorableExport, boolean>>;
+export type GetImportsAndExportsOptions = {
+    skipTypeOnly: boolean;
+    skipExports: boolean;
+    isFixExports: boolean;
+    isFixTypes: boolean;
+    isReportClassMembers: boolean;
+    ignoreExportsUsedInFile: IgnoreExportsUsedInFile;
+    tags: Tags;
+};
 export interface Configuration {
     rules: Rules;
     include: IssueType[];
@@ -43,4 +47,63 @@ export interface Configuration {
     asyncCompilers: AsyncCompilers;
     rootPluginConfigs: Partial<PluginsConfiguration>;
 }
+export type NormalizedGlob = string[];
+export type EnsuredPluginConfiguration = {
+    config: NormalizedGlob | null;
+    entry: NormalizedGlob | null;
+    project: NormalizedGlob | null;
+};
+interface BaseWorkspaceConfiguration {
+    entry: NormalizedGlob;
+    project: NormalizedGlob;
+    paths: Record<string, string[]>;
+    ignore: NormalizedGlob;
+    isIncludeEntryExports: boolean;
+}
+type PluginConfiguration = EnsuredPluginConfiguration | boolean;
+export type PluginsConfiguration = Record<PluginName, PluginConfiguration>;
+export interface WorkspaceConfiguration extends BaseWorkspaceConfiguration, Partial<PluginsConfiguration> {
+}
+interface BaseOptions {
+    rootCwd: string;
+    cwd: string;
+    manifestScriptNames: Set<string>;
+}
+type IsPluginEnabledOptions = {
+    cwd: string;
+    manifest: PackageJson;
+    dependencies: Set<string>;
+    config: WorkspaceConfiguration;
+};
+export type IsPluginEnabled = (options: IsPluginEnabledOptions) => boolean | Promise<boolean>;
+export interface PluginOptions extends BaseOptions {
+    manifest: PackageJson;
+    config: EnsuredPluginConfiguration;
+    configFileDir: string;
+    configFileName: string;
+    configFilePath: string;
+    isProduction: boolean;
+    enabledPlugins: string[];
+    getInputsFromScripts: GetInputsFromScriptsPartial;
+}
+export type ResolveEntryPaths<T = any> = (config: T, options: PluginOptions) => Promise<Input[]> | Input[];
+export type ResolveConfig<T = any> = (config: T, options: PluginOptions) => Promise<Input[]> | Input[];
+export type Resolve = (options: PluginOptions) => Promise<Input[]> | Input[];
+export interface Plugin {
+    title: string;
+    note?: string;
+    args?: Args;
+    packageJsonPath?: string | ((manifest: PackageJson) => string);
+    enablers?: IgnorePatterns | string;
+    isEnabled?: IsPluginEnabled;
+    config?: string[];
+    entry?: string[];
+    production?: string[];
+    project?: string[];
+    resolveEntryPaths?: ResolveEntryPaths;
+    resolveConfig?: ResolveConfig;
+    resolve?: Resolve;
+}
+export type PluginMap = Record<PluginName, Plugin>;
+export type Entries = [PluginName, Plugin][];
 export {};

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

@@ -37,5 +37,15 @@ export type PackageJson = {
     peerDependenciesMeta?: Record<string, {
         optional: true;
     }>;
+    module?: string;
+    browser?: string;
+    types?: string;
+    typings?: string;
 } & Plugins;
+export type Package = {
+    dir: string;
+    name: string;
+    pkgName: string | undefined;
+    manifest: PackageJson;
+};
 export {};

package/dist/types/project.d.ts

@@ -0,0 +1,18 @@
+import type ts from 'typescript';
+import type { AsyncCompilers, SyncCompilers } from '../compilers/types.js';
+import type { ToSourceFilePath } from '../util/to-source-path.js';
+export type Paths = ts.CompilerOptions['paths'];
+export type PrincipalOptions = {
+    cwd: string;
+    isFile: boolean;
+    compilerOptions: ts.CompilerOptions;
+    paths: Paths;
+    compilers: [SyncCompilers, AsyncCompilers];
+    pkgName: string;
+    isIsolateWorkspaces: boolean;
+    isSkipLibs: boolean;
+    isWatch: boolean;
+    toSourceFilePath: ToSourceFilePath;
+    isCache: boolean;
+    cacheLocation: string;
+};

package/dist/typescript/ast-helpers.d.ts

@@ -24,7 +24,7 @@ export declare const isObjectEnumerationCallExpressionArgument: (node: ts.Identi
 export declare const isTopLevel: (node: ts.Node) => boolean;
 export declare const getTypeName: (node: ts.Identifier) => ts.QualifiedName | undefined;
 export declare const isImportSpecifier: (node: ts.Node) => boolean;
-export declare const isReferencedInExportedType: (node: ts.Node) => boolean;
+export declare const isReferencedInExport: (node: ts.Node) => boolean;
 export declare const getExportKeywordNode: (node: ts.Node) => ts.ExportKeyword | undefined;
 export declare const getDefaultKeywordNode: (node: ts.Node) => ts.DefaultKeyword | undefined;
 export declare const hasRequireCall: (node: ts.Node) => boolean;

package/dist/typescript/ast-helpers.js

@@ -172,7 +172,11 @@ const getAncestorTypeDeclaration = (node) => {
         node = node.parent;
     }
 };
-export const isReferencedInExportedType = (node) => {
+export const isReferencedInExport = (node) => {
+    if (ts.isTypeQueryNode(node.parent) && isExported(node.parent.parent))
+        return true;
+    if (ts.isTypeReferenceNode(node.parent) && isExported(node.parent.parent))
+        return true;
     const typeNode = getAncestorTypeDeclaration(node);
     return Boolean(typeNode && isExported(typeNode));
 };

package/dist/typescript/find-internal-references.d.ts

@@ -1,4 +1,4 @@
 import ts from 'typescript';
 import type { Export, ExportMember } from '../types/dependency-graph.js';
 export declare const isType: (item: Export | ExportMember) => boolean;
-export declare const findInternalReferences: (item: Export | ExportMember, sourceFile: ts.SourceFile, typeChecker: ts.TypeChecker, referencedSymbolsInExportedTypes: Set<ts.Symbol>) => [number, boolean];
+export declare const findInternalReferences: (item: Export | ExportMember, sourceFile: ts.SourceFile, typeChecker: ts.TypeChecker, referencedSymbolsInExport: Set<ts.Symbol>, isBindingElement?: boolean) => [number, boolean];

package/dist/typescript/find-internal-references.js

@@ -1,7 +1,7 @@
 import ts from 'typescript';
 import { isIdChar } from '../util/regex.js';
 export const isType = (item) => item.type === 'type' || item.type === 'interface' || item.type === 'enum';
-export const findInternalReferences = (item, sourceFile, typeChecker, referencedSymbolsInExportedTypes) => {
+export const findInternalReferences = (item, sourceFile, typeChecker, referencedSymbolsInExport, isBindingElement) => {
     if (!item.symbol)
         return [0, false];
     if (item.identifier === '')
@@ -12,7 +12,7 @@ export const findInternalReferences = (item, sourceFile, typeChecker, referenced
     const id = item.identifier;
     const symbols = new Set();
     let refCount = 0;
-    let isSymbolInExportedType = false;
+    let isSymbolInExport = false;
     let index = 0;
     while (index < text.length && (index = text.indexOf(id, index)) !== -1) {
         if (!isIdChar(text.charAt(index - 1)) && !isIdChar(text.charAt(index + id.length))) {
@@ -20,21 +20,23 @@ export const findInternalReferences = (item, sourceFile, typeChecker, referenced
             if (!isExportDeclaration) {
                 const symbol = typeChecker.getSymbolAtLocation(ts.getTokenAtPosition(sourceFile, index));
                 if (symbol) {
-                    const isInExportedType = referencedSymbolsInExportedTypes.has(symbol);
-                    if (isInExportedType)
-                        isSymbolInExportedType = true;
+                    const isInExport = referencedSymbolsInExport.has(symbol);
+                    if (isInExport)
+                        isSymbolInExport = true;
                     if (item.symbol === symbol) {
                         refCount++;
-                        if (isInExportedType || isType(item))
-                            return [refCount, isSymbolInExportedType];
+                        if (isInExport || isType(item))
+                            return [refCount, isSymbolInExport];
+                        if (isBindingElement)
+                            return [refCount, true];
                     }
                     const declaration = symbol.declarations?.[0];
                     if (declaration) {
                         if (item.symbol === declaration.name?.flowNode?.node?.symbol) {
-                            return [++refCount, isSymbolInExportedType];
+                            return [++refCount, isSymbolInExport];
                         }
                         if (ts.isImportSpecifier(declaration) && symbols.has(symbol)) {
-                            return [++refCount, isSymbolInExportedType];
+                            return [++refCount, isSymbolInExport];
                         }
                     }
                     symbols.add(symbol);
@@ -43,5 +45,5 @@ export const findInternalReferences = (item, sourceFile, typeChecker, referenced
         }
         index += id.length;
     }
-    return [refCount, isSymbolInExportedType];
+    return [refCount, isSymbolInExport];
 };

package/dist/typescript/get-imports-and-exports.d.ts

@@ -1,18 +1,8 @@
 import ts from 'typescript';
-import type { Tags } from '../types/cli.js';
-import type { IgnoreExportsUsedInFile } from '../types/config.js';
+import type { GetImportsAndExportsOptions } from '../types/config.js';
 import type { ExportMap, ImportMap, UnresolvedImport } from '../types/dependency-graph.js';
 import type { IssueSymbol } from '../types/issues.js';
 import type { BoundSourceFile } from './SourceFile.js';
-export type GetImportsAndExportsOptions = {
-    skipTypeOnly: boolean;
-    skipExports: boolean;
-    isFixExports: boolean;
-    isFixTypes: boolean;
-    isReportClassMembers: boolean;
-    ignoreExportsUsedInFile: IgnoreExportsUsedInFile;
-    tags: Tags;
-};
 export declare const _getImportsAndExports: (sourceFile: BoundSourceFile, resolveModule: (specifier: string) => ts.ResolvedModuleFull | undefined, typeChecker: ts.TypeChecker, options: GetImportsAndExportsOptions) => {
     imports: {
         internal: ImportMap;

package/dist/typescript/get-imports-and-exports.js

@@ -1,12 +1,12 @@
 import { isBuiltin } from 'node:module';
 import ts from 'typescript';
-import { ALIAS_TAG, ANONYMOUS, DEFAULT_EXTENSIONS, IMPORT_STAR } from '../constants.js';
+import { ALIAS_TAG, ANONYMOUS, DEFAULT_EXTENSIONS, IMPORT_STAR, PROTOCOL_VIRTUAL } from '../constants.js';
 import { timerify } from '../util/Performance.js';
 import { addNsValue, addValue, createImports } from '../util/dependency-graph.js';
 import { getPackageNameFromFilePath, isStartsLikePackageName, sanitizeSpecifier } from '../util/modules.js';
 import { extname, isInNodeModules } from '../util/path.js';
 import { shouldIgnore } from '../util/tag.js';
-import { getAccessMembers, getDestructuredIds, getJSDocTags, getLineAndCharacterOfPosition, getTypeName, isAccessExpression, isConsiderReferencedNS, isDestructuring, isImportSpecifier, isObjectEnumerationCallExpressionArgument, isReferencedInExportedType, } from './ast-helpers.js';
+import { getAccessMembers, getDestructuredIds, getJSDocTags, getLineAndCharacterOfPosition, getTypeName, isAccessExpression, isConsiderReferencedNS, isDestructuring, isImportSpecifier, isObjectEnumerationCallExpressionArgument, isReferencedInExport, } from './ast-helpers.js';
 import { findInternalReferences, isType } from './find-internal-references.js';
 import getDynamicImportVisitors from './visitors/dynamic-imports/index.js';
 import getExportVisitors from './visitors/exports/index.js';
@@ -45,7 +45,7 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options) =
     const scripts = new Set();
     const traceRefs = new Set();
     const importedInternalSymbols = new Map();
-    const referencedSymbolsInExportedTypes = new Set();
+    const referencedSymbolsInExport = new Set();
     const visitors = getVisitors(sourceFile);
     const addNsMemberRefs = (internalImport, namespace, member) => {
         if (typeof member === 'string') {
@@ -144,6 +144,8 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options) =
                 return;
             if (shouldIgnore(getJSDocTags(node), tags))
                 return;
+            if (specifier.startsWith(PROTOCOL_VIRTUAL))
+                return;
             if (typeof pos === 'number') {
                 const { line, character } = sourceFile.getLineAndCharacterOfPosition(pos);
                 unresolvedImports.add({ specifier, pos, line: line + 1, col: character + 1 });
@@ -280,10 +282,8 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options) =
                         }
                     }
                 }
-                if (!isTopLevel && symbol.exportSymbol) {
-                    if (ts.isTypeQueryNode(node.parent) || isReferencedInExportedType(node)) {
-                        referencedSymbolsInExportedTypes.add(symbol.exportSymbol);
-                    }
+                if (!isTopLevel && symbol.exportSymbol && isReferencedInExport(node)) {
+                    referencedSymbolsInExport.add(symbol.exportSymbol);
                 }
             }
         }
@@ -308,17 +308,22 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options) =
         for (const node of pragmaImports)
             addImport(node, sourceFile);
     for (const item of exports.values()) {
-        const isType_ = isType(item);
-        if (item.symbol && referencedSymbolsInExportedTypes.has(item.symbol)) {
+        if (item.symbol && referencedSymbolsInExport.has(item.symbol)) {
             item.refs = [1, true];
         }
-        else if (ignoreExportsUsedInFile === true ||
-            (typeof ignoreExportsUsedInFile === 'object' && item.type !== 'unknown' && ignoreExportsUsedInFile[item.type]) ||
-            isType_) {
-            item.refs = findInternalReferences(item, sourceFile, typeChecker, referencedSymbolsInExportedTypes);
+        else {
+            const isBindingElement = item.symbol?.valueDeclaration && ts.isBindingElement(item.symbol.valueDeclaration);
+            if (ignoreExportsUsedInFile === true ||
+                (typeof ignoreExportsUsedInFile === 'object' &&
+                    item.type !== 'unknown' &&
+                    ignoreExportsUsedInFile[item.type]) ||
+                isType(item) ||
+                isBindingElement) {
+                item.refs = findInternalReferences(item, sourceFile, typeChecker, referencedSymbolsInExport, isBindingElement);
+            }
         }
         for (const member of item.members) {
-            member.refs = findInternalReferences(member, sourceFile, typeChecker, referencedSymbolsInExportedTypes);
+            member.refs = findInternalReferences(member, sourceFile, typeChecker, referencedSymbolsInExport);
             member.symbol = undefined;
         }
         item.symbol = undefined;

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("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[] | undefined;
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../../types/config.js").GetImportsAndExportsOptions) => import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[] | undefined;
 export default _default;

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("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[] | undefined;
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../../types/config.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("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[] | undefined)[];
+declare const _default: (sourceFile: ts.SourceFile) => ((node: ts.Node, options: import("../../../types/config.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("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => ImportNode | ImportNode[] | undefined;
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../../types/config.js").GetImportsAndExportsOptions) => ImportNode | 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("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[] | undefined;
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../../types/config.js").GetImportsAndExportsOptions) => import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[] | undefined;
 export default _default;

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

@@ -1,3 +1,3 @@
 import ts from 'typescript';
-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;
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../../types/config.js").GetImportsAndExportsOptions) => import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[] | undefined;
 export default _default;

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("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[] | undefined;
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../../types/config.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("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[] | undefined;
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../../types/config.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("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[] | undefined;
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../../types/config.js").GetImportsAndExportsOptions) => import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[] | undefined;
 export default _default;

package/dist/typescript/visitors/exports/exportKeyword.js

@@ -19,6 +19,7 @@ export default visit(() => true, (node, { isFixExports, isFixTypes, isReportClas
                                 : undefined;
                             return {
                                 node: element,
+                                symbol: element.symbol,
                                 identifier: element.name.escapedText.toString(),
                                 type: SymbolType.UNKNOWN,
                                 pos: element.name.getStart(),
@@ -33,6 +34,7 @@ export default visit(() => true, (node, { isFixExports, isFixTypes, isReportClas
                             const fix = isFixExports ? [element.getStart(), element.getEnd(), FIX_FLAGS.NONE] : undefined;
                             return {
                                 node: element,
+                                symbol: element.symbol,
                                 identifier: element.getText(),
                                 type: SymbolType.UNKNOWN,
                                 pos: element.getStart(),

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("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[] | undefined;
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../../types/config.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("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[] | undefined)[];
+declare const _default: (sourceFile: ts.SourceFile) => ((node: ts.Node, options: import("../../../types/config.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("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[] | undefined;
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../../types/config.js").GetImportsAndExportsOptions) => import("../../../types/exports.js").ExportNode | import("../../../types/exports.js").ExportNode[] | undefined;
 export default _default;

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("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[] | undefined;
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../../types/config.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("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[] | undefined;
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../../types/config.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("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[] | undefined)[];
+declare const _default: (sourceFile: ts.SourceFile) => ((node: ts.Node, options: import("../../../types/config.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("../../get-imports-and-exports.js").GetImportsAndExportsOptions) => import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[] | undefined;
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../../types/config.js").GetImportsAndExportsOptions) => import("../../../types/imports.js").ImportNode | import("../../../types/imports.js").ImportNode[] | undefined;
 export default _default;