knip 5.50.0 → 5.50.1

package/dist/types/PluginNames.d.ts

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

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

package/dist/types/config.d.ts

@@ -0,0 +1,119 @@
+import type ts from 'typescript';
+import type { z } from 'zod';
+import type { AsyncCompilers, SyncCompilers } from '../compilers/types.js';
+import type { knipConfigurationSchema } from '../schema/configuration.js';
+import type { pluginSchema } from '../schema/plugins.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, SymbolType } 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[];
+export type FromArgs = (args: string[], options?: Partial<GetInputsFromScriptsOptions>) => Input[];
+export interface BinaryResolverOptions extends GetInputsFromScriptsOptions {
+    fromArgs: FromArgs;
+}
+export type BinaryResolver = (binary: string, args: string[], options: BinaryResolverOptions) => Input[];
+export type RawConfiguration = z.infer<typeof knipConfigurationSchema>;
+export type RawPluginConfiguration = z.infer<typeof pluginSchema>;
+export type IgnorePatterns = (string | RegExp)[];
+type IgnorableExport = Exclude<SymbolType, SymbolType.UNKNOWN>;
+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[];
+    exclude: IssueType[];
+    ignore: NormalizedGlob;
+    ignoreBinaries: IgnorePatterns;
+    ignoreDependencies: IgnorePatterns;
+    ignoreExportsUsedInFile: IgnoreExportsUsedInFile;
+    ignoreMembers: IgnorePatterns;
+    ignoreWorkspaces: string[];
+    isIncludeEntryExports: boolean;
+    syncCompilers: SyncCompilers;
+    asyncCompilers: AsyncCompilers;
+    rootPluginConfigs: Partial<PluginsConfiguration>;
+    tags: string[];
+}
+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 type GetSourceFile = (filePath: string) => ts.SourceFile | undefined;
+export type GetReferencedInternalFilePath = (input: Input) => string | undefined;
+export type ResolveFromAST = (sourceFile: ts.SourceFile, options: PluginOptions & {
+    getSourceFile: GetSourceFile;
+    getReferencedInternalFilePath: GetReferencedInternalFilePath;
+}) => Input[];
+export interface Plugin {
+    title: string;
+    args?: Args;
+    packageJsonPath?: string | ((manifest: PackageJson) => unknown);
+    enablers?: IgnorePatterns | string;
+    isEnabled?: IsPluginEnabled;
+    isRootOnly?: boolean;
+    config?: string[];
+    entry?: string[];
+    production?: string[];
+    project?: string[];
+    resolveEntryPaths?: ResolveEntryPaths;
+    resolveConfig?: ResolveConfig;
+    resolve?: Resolve;
+    resolveFromAST?: ResolveFromAST;
+}
+export type PluginMap = Record<PluginName, Plugin>;
+export type Entries = [PluginName, Plugin][];
+export {};

package/dist/types/exports.d.ts

@@ -0,0 +1,24 @@
+import type ts from 'typescript';
+import type { SymbolType } from './issues.js';
+type Identifier = string;
+type ExportPosTuple = [number, number, number];
+export type Fix = ExportPosTuple | undefined;
+export type Fixes = Array<ExportPosTuple>;
+export type ExportNode = {
+    node: ts.Node;
+    symbol?: ts.Symbol;
+    identifier: Identifier;
+    pos: number;
+    type: SymbolType;
+    members?: ExportNodeMember[];
+    jsDocTags?: Set<string>;
+    fix: Fix;
+};
+export type ExportNodeMember = {
+    node: ts.Node;
+    identifier: Identifier;
+    pos: number;
+    type: SymbolType;
+    fix: Fix;
+};
+export {};

package/dist/types/imports.d.ts

@@ -0,0 +1,12 @@
+import type ts from 'typescript';
+export interface ImportNode {
+    specifier: string;
+    identifier: string | undefined;
+    alias?: string | undefined;
+    namespace?: string | undefined;
+    pos: number | undefined;
+    symbol?: ts.Symbol;
+    isTypeOnly?: boolean;
+    isReExport?: boolean;
+    resolve?: boolean;
+}

package/dist/types/issues.d.ts

@@ -0,0 +1,88 @@
+export declare enum SymbolType {
+    VARIABLE = "variable",
+    TYPE = "type",
+    INTERFACE = "interface",
+    ENUM = "enum",
+    FUNCTION = "function",
+    CLASS = "class",
+    MEMBER = "member",
+    UNKNOWN = "unknown"
+}
+export type IssueSymbol = {
+    symbol: string;
+    pos?: number;
+    line?: number;
+    col?: number;
+};
+export type Issue = {
+    type: SymbolIssueType;
+    filePath: string;
+    workspace: string;
+    symbol: string;
+    symbols?: IssueSymbol[];
+    symbolType?: SymbolType;
+    parentSymbol?: string;
+    specifier?: string;
+    severity?: IssueSeverity;
+    pos?: number;
+    line?: number;
+    col?: number;
+    isFixed?: boolean;
+};
+export type IssueSet = Set<string>;
+export type IssueRecords = Record<string, Record<string, Issue>>;
+export type Issues = {
+    files: IssueSet;
+    _files: IssueRecords;
+    dependencies: IssueRecords;
+    devDependencies: IssueRecords;
+    optionalPeerDependencies: IssueRecords;
+    unlisted: IssueRecords;
+    binaries: IssueRecords;
+    unresolved: IssueRecords;
+    exports: IssueRecords;
+    types: IssueRecords;
+    nsExports: IssueRecords;
+    nsTypes: IssueRecords;
+    duplicates: IssueRecords;
+    enumMembers: IssueRecords;
+    classMembers: IssueRecords;
+};
+export type IssueType = keyof Issues;
+export type SymbolIssueType = Exclude<IssueType, 'files'>;
+export type Report = {
+    [key in keyof Issues]: boolean;
+};
+export type Counters = Record<IssueType | 'processed' | 'total', number>;
+export type ReporterOptions = {
+    report: Report;
+    issues: Issues;
+    counters: Counters;
+    tagHints: TagHints;
+    configurationHints: ConfigurationHints;
+    isDisableConfigHints: boolean;
+    isTreatConfigHintsAsErrors: boolean;
+    cwd: string;
+    isProduction: boolean;
+    isShowProgress: boolean;
+    options: string;
+    preprocessorOptions: string;
+};
+export type Reporter = (options: ReporterOptions) => void;
+export type Preprocessor = (options: ReporterOptions) => ReporterOptions;
+export type IssueSeverity = 'error' | 'warn' | 'off';
+export type Rules = Record<IssueType, IssueSeverity>;
+export type ConfigurationHints = Set<ConfigurationHint>;
+export type ConfigurationHint = {
+    type: 'ignoreBinaries' | 'ignoreDependencies' | 'ignoreUnresolved' | 'ignoreWorkspaces';
+    identifier: string | RegExp;
+    workspaceName?: string;
+};
+type TagHints = Set<TagHint>;
+export type TagHint = {
+    type: 'tag';
+    filePath: string;
+    identifier: string;
+    tagName: string;
+};
+export {};

package/dist/types/module-graph.d.ts

@@ -0,0 +1,67 @@
+import type ts from 'typescript';
+import type { Fix, Fixes } from './exports.js';
+import type { IssueSymbol, SymbolType } from './issues.js';
+type Identifier = string;
+type FilePath = string;
+type NamespaceOrAlias = string;
+type Reference = string;
+type References = Set<Reference>;
+type Tags = Set<string>;
+export type IdToFileMap = Map<Identifier, Set<FilePath>>;
+export type IdToNsToFileMap = Map<Identifier, Map<NamespaceOrAlias, Set<FilePath>>>;
+export type ImportDetails = {
+    refs: References;
+    imported: IdToFileMap;
+    importedAs: IdToNsToFileMap;
+    importedNs: IdToFileMap;
+    reExported: IdToFileMap;
+    reExportedAs: IdToNsToFileMap;
+    reExportedNs: IdToFileMap;
+};
+export type ImportMap = Map<FilePath, ImportDetails>;
+export type UnresolvedImport = {
+    specifier: string;
+    pos?: number;
+    line?: number;
+    col?: number;
+};
+export interface Export {
+    identifier: Identifier;
+    pos: number;
+    line: number;
+    col: number;
+    type: SymbolType;
+    members: ExportMember[];
+    jsDocTags: Tags;
+    refs: [number, boolean];
+    fixes: Fixes;
+    symbol?: ts.Symbol;
+    isReExport: boolean;
+}
+export type ExportMember = {
+    identifier: Identifier;
+    pos: number;
+    line: number;
+    col: number;
+    type: SymbolType;
+    refs: [number, boolean];
+    fix: Fix;
+    symbol?: ts.Symbol;
+    jsDocTags: Tags;
+};
+export type ExportMap = Map<Identifier, Export>;
+export type FileNode = {
+    imports: {
+        internal: ImportMap;
+        external: Set<string>;
+        unresolved: Set<UnresolvedImport>;
+    };
+    exports: ExportMap;
+    duplicates: Iterable<Array<IssueSymbol>>;
+    scripts: Set<string>;
+    imported?: ImportDetails;
+    internalImportCache?: ImportMap;
+    traceRefs: References;
+};
+export type ModuleGraph = Map<FilePath, FileNode>;
+export {};

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

@@ -0,0 +1,53 @@
+import type { PluginMap } from './config.js';
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+type LiteralUnion<LiteralType, BaseType extends Primitive> = LiteralType | (BaseType & Record<never, never>);
+type Dependencies = Record<string, string>;
+type C = 'import' | 'require' | 'node' | 'node-addons' | 'deno' | 'browser' | 'electron' | 'react-native' | 'default';
+type ExportCondition = LiteralUnion<C, string>;
+type Exports = null | string | string[] | {
+    [key in ExportCondition]: Exports;
+} | {
+    [key: string]: Exports;
+};
+type PackageJsonPath<T> = T extends {
+    packageJsonPath: infer P;
+} ? (P extends string ? P : never) : never;
+type WithPackageJsonPathAsKey<T> = {
+    [K in keyof T]: PackageJsonPath<T[K]> extends never ? K : PackageJsonPath<T[K]>;
+};
+type PluginConfig<P> = {
+    [K in keyof P as WithPackageJsonPathAsKey<P>[K]]: unknown;
+};
+type Plugins = PluginConfig<PluginMap>;
+export type Scripts = Record<string, string>;
+export type PackageJson = {
+    name?: string;
+    main?: string;
+    bin?: string | Record<string, string>;
+    version?: string;
+    workspaces?: string[] | {
+        packages?: string[];
+    };
+    exports?: Exports;
+    scripts?: Scripts;
+    dependencies?: Dependencies;
+    devDependencies?: Dependencies;
+    peerDependencies?: Dependencies;
+    optionalDependencies?: Dependencies;
+    peerDependenciesMeta?: Record<string, {
+        optional: true;
+    }>;
+    module?: string;
+    browser?: string;
+    types?: string;
+    typings?: string;
+} & Plugins;
+export type WorkspacePackage = {
+    dir: string;
+    name: string;
+    pkgName: string | undefined;
+    manifest: PackageJson;
+    manifestPath: string;
+    manifestStr: string;
+};
+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/types/workspace.d.ts

@@ -0,0 +1,27 @@
+export type DependencySet = Set<string>;
+export type DependencyArray = Array<string>;
+type WorkspaceManifest = {
+    workspaceDir: string;
+    manifestPath: string;
+    manifestStr: string;
+    dependencies: DependencyArray;
+    devDependencies: DependencyArray;
+    peerDependencies: DependencySet;
+    optionalPeerDependencies: DependencyArray;
+    allDependencies: DependencySet;
+    ignoreDependencies: (string | RegExp)[];
+    ignoreBinaries: (string | RegExp)[];
+    ignoreUnresolved: (string | RegExp)[];
+    usedIgnoreDependencies: Set<string | RegExp>;
+    usedIgnoreBinaries: Set<string | RegExp>;
+    usedIgnoreUnresolved: Set<string | RegExp>;
+};
+export type WorkspaceManifests = Map<string, WorkspaceManifest>;
+export type HostDependencies = Map<string, Array<{
+    name: string;
+    isPeerOptional: boolean;
+}>>;
+type PackageName = string;
+type BinaryName = string;
+export type InstalledBinaries = Map<PackageName, Set<BinaryName>>;
+export {};

package/dist/typescript/SourceFile.d.ts

@@ -0,0 +1,35 @@
+import type ts from 'typescript';
+type SymbolTable = Map<string, SymbolWithExportSymbol>;
+type SymbolWithExports = ts.Symbol & {
+    exports?: SymbolTable;
+};
+interface SymbolWithExportSymbol extends ts.Symbol {
+    exportSymbol?: ts.Symbol;
+}
+type PragmaMap = {
+    arguments: {
+        factory?: string;
+        path?: {
+            value?: string;
+            pos?: number;
+        };
+        types?: {
+            value?: string;
+            pos?: number;
+        };
+    };
+    range?: {
+        kind?: number;
+        pos?: number;
+        end?: number;
+        hasTrailingNewLine?: boolean;
+    };
+};
+export interface BoundSourceFile extends ts.SourceFile {
+    symbol?: SymbolWithExports;
+    locals?: SymbolTable;
+    getNamedDeclarations?(): Map<string, readonly ts.Declaration[]>;
+    scriptKind?: ts.ScriptKind;
+    pragmas?: Map<string, PragmaMap | PragmaMap[]>;
+}
+export {};

package/dist/typescript/SourceFileManager.d.ts

@@ -0,0 +1,19 @@
+import ts from 'typescript';
+import type { AsyncCompilers, SyncCompilers } from '../compilers/types.js';
+interface SourceFileManagerOptions {
+    isSkipLibs: boolean;
+    compilers: [SyncCompilers, AsyncCompilers];
+}
+export declare class SourceFileManager {
+    isSkipLibs: boolean;
+    sourceFileCache: Map<string, ts.SourceFile | undefined>;
+    snapshotCache: Map<string, ts.IScriptSnapshot | undefined>;
+    syncCompilers: SyncCompilers;
+    asyncCompilers: AsyncCompilers;
+    constructor({ compilers, isSkipLibs }: SourceFileManagerOptions);
+    createSourceFile(filePath: string, contents: string): ts.SourceFile;
+    getSourceFile(filePath: string): ts.SourceFile | undefined;
+    getSnapshot(filePath: string): ts.IScriptSnapshot | undefined;
+    compileAndAddSourceFile(filePath: string): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,38 @@
+import ts from 'typescript';
+import { SymbolType } from '../types/issues.js';
+export declare function isGetOrSetAccessorDeclaration(node: ts.Node): node is ts.AccessorDeclaration;
+export declare function isPrivateMember(node: ts.MethodDeclaration | ts.PropertyDeclaration | ts.SetAccessorDeclaration | ts.GetAccessorDeclaration): boolean;
+export declare function isDefaultImport(node: ts.ImportDeclaration | ts.ImportEqualsDeclaration | ts.ExportDeclaration): boolean;
+export declare function isAccessExpression(node: ts.Node): node is ts.AccessExpression;
+export declare function isImportCall(node: ts.Node): node is ts.ImportCall;
+export declare function isRequireCall(callExpression: ts.Node): callExpression is ts.CallExpression;
+export declare function isPropertyAccessCall(node: ts.Node, identifier: string): node is ts.CallExpression;
+export declare const getNodeType: (node: ts.Node) => SymbolType;
+export declare function stripQuotes(name: string): string;
+export declare function findAncestor<T>(node: ts.Node | undefined, callback: (element: ts.Node) => boolean | 'STOP'): T | undefined;
+export declare function findDescendants<T>(node: ts.Node | undefined, callback: (element: ts.Node) => boolean | 'STOP'): T[];
+export declare const isDeclarationFileExtension: (extension: string) => extension is ".d.ts" | ".d.mts" | ".d.cts";
+export declare const getJSDocTags: (node: ts.Node) => Set<string>;
+export declare const getLineAndCharacterOfPosition: (node: ts.Node, pos: number) => {
+    line: number;
+    col: number;
+    pos: number;
+};
+export declare const getAccessMembers: (typeChecker: ts.TypeChecker, node: ts.Identifier) => string[];
+export declare const isDestructuring: (node: ts.Node) => boolean;
+export declare const getDestructuredIds: (name: ts.ObjectBindingPattern) => string[];
+export declare const isConsiderReferencedNS: (node: ts.Identifier) => boolean;
+export declare const isObjectEnumerationCallExpressionArgument: (node: ts.Identifier) => boolean;
+export declare const isInForIteration: (node: ts.Node) => boolean;
+export declare const isTopLevel: (node: ts.Node) => boolean;
+export declare const getTypeRef: (node: ts.Identifier) => ts.TypeReferenceNode | undefined;
+export declare const isImportSpecifier: (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;
+export declare const isModuleExportsAccess: (node: ts.PropertyAccessExpression) => boolean;
+export declare const getImportMap: (sourceFile: ts.SourceFile) => Map<string, string>;
+export declare const getDefaultImportName: (importMap: ReturnType<typeof getImportMap>, specifier: string) => string | undefined;
+export declare const getPropertyValues: (node: ts.ObjectLiteralExpression, propertyName: string) => Set<string>;
+export declare const getPropertyValueEntries: (node: ts.ObjectLiteralExpression, propertyNames: Set<string>) => [string, string][];

package/dist/typescript/create-hosts.d.ts

@@ -0,0 +1,21 @@
+import ts from 'typescript';
+import type { AsyncCompilers, SyncCompilers } from '../compilers/types.js';
+import type { ToSourceFilePath } from '../util/to-source-path.js';
+import type { SourceFileManager } from './SourceFileManager.js';
+type CreateHostsOptions = {
+    cwd: string;
+    compilerOptions: ts.CompilerOptions;
+    entryPaths: Set<string>;
+    compilers: [SyncCompilers, AsyncCompilers];
+    isSkipLibs: boolean;
+    toSourceFilePath: ToSourceFilePath;
+    useResolverCache: boolean;
+    fileManager: SourceFileManager;
+};
+export declare const createHosts: ({ cwd, compilerOptions, fileManager, entryPaths, compilers, isSkipLibs, toSourceFilePath, useResolverCache, }: CreateHostsOptions) => {
+    fileManager: SourceFileManager;
+    compilerHost: ts.CompilerHost;
+    resolveModuleNames: (moduleNames: string[], containingFile: string) => Array<ts.ResolvedModuleFull | undefined>;
+    languageServiceHost: ts.LanguageServiceHost;
+};
+export {};

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

@@ -0,0 +1,4 @@
+import ts from 'typescript';
+import type { Export, ExportMember } from '../types/module-graph.js';
+export declare const isType: (item: Export | ExportMember) => 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/get-imports-and-exports.d.ts

@@ -0,0 +1,18 @@
+import ts from 'typescript';
+import type { GetImportsAndExportsOptions } from '../types/config.js';
+import type { IssueSymbol } from '../types/issues.js';
+import type { ExportMap, ImportMap, UnresolvedImport } from '../types/module-graph.js';
+import type { BoundSourceFile } from './SourceFile.js';
+export declare const _getImportsAndExports: (sourceFile: BoundSourceFile, resolveModule: (specifier: string) => ts.ResolvedModuleFull | undefined, typeChecker: ts.TypeChecker, options: GetImportsAndExportsOptions) => {
+    imports: {
+        internal: ImportMap;
+        external: Set<string>;
+        resolved: Set<string>;
+        specifiers: Set<[string, string]>;
+        unresolved: Set<UnresolvedImport>;
+    };
+    exports: ExportMap;
+    duplicates: IssueSymbol[][];
+    scripts: Set<string>;
+    traceRefs: Set<string>;
+};

package/dist/typescript/resolve-module-names.d.ts

@@ -0,0 +1,4 @@
+import ts from 'typescript';
+import type { ToSourceFilePath } from '../util/to-source-path.js';
+export type ResolveModuleNames = ReturnType<typeof createCustomModuleResolver>;
+export declare function createCustomModuleResolver(compilerOptions: ts.CompilerOptions, customCompilerExtensions: string[], toSourceFilePath: ToSourceFilePath, useCache?: boolean, isSkipLibs?: boolean): (moduleNames: string[], containingFile: string) => Array<ts.ResolvedModuleFull | undefined>;

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

@@ -0,0 +1,3 @@
+import ts from 'typescript';
+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

@@ -0,0 +1,3 @@
+import ts from 'typescript';
+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

@@ -0,0 +1,3 @@
+import type ts from 'typescript';
+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

@@ -0,0 +1,4 @@
+import ts from 'typescript';
+import type { ImportNode } from '../../../types/imports.js';
+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

@@ -0,0 +1,3 @@
+import ts from 'typescript';
+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

@@ -0,0 +1,3 @@
+import ts from 'typescript';
+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

@@ -0,0 +1,3 @@
+import ts from 'typescript';
+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

@@ -0,0 +1,3 @@
+import ts from 'typescript';
+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;