knip 5.70.2 → 5.71.0

package/dist/graph-explorer/walk-down.js

@@ -0,0 +1,119 @@
+import { STOP } from './constants.js';
+import { hasNamespaceMemberReference } from './utils.js';
+import { getAliasReExportMap, getPassThroughReExportSources, getStarReExportSources } from './visitors.js';
+export const walkDown = (graph, filePath, identifier, visitor, entryPaths, visited = new Set()) => {
+    const key = `${filePath}:${identifier}`;
+    if (visited.has(key))
+        return false;
+    visited.add(key);
+    const file = graph.get(filePath);
+    if (!file?.imported)
+        return false;
+    const restIds = identifier.split('.');
+    const id = restIds.shift();
+    if (!id)
+        return false;
+    const imported = file.imported;
+    const importedByFiles = imported.imported.get(id);
+    if (importedByFiles) {
+        for (const importingFile of importedByFiles) {
+            const isEntry = entryPaths.has(importingFile);
+            if (visitor(filePath, id, importingFile, id, isEntry, false) === STOP)
+                return true;
+        }
+    }
+    const importedAsAliases = imported.importedAs.get(id);
+    if (importedAsAliases) {
+        for (const [alias, byFilePaths] of importedAsAliases) {
+            for (const importingFile of byFilePaths) {
+                const isEntry = entryPaths.has(importingFile);
+                if (visitor(filePath, id, importingFile, alias, isEntry, false) === STOP)
+                    return true;
+            }
+        }
+    }
+    for (const [namespace, byFilePaths] of imported.importedNs) {
+        for (const importingFile of byFilePaths) {
+            if (hasNamespaceMemberReference(graph, importingFile, filePath, namespace, identifier) === false)
+                continue;
+            const isEntry = entryPaths.has(importingFile);
+            if (visitor(filePath, identifier, importingFile, `${namespace}.${identifier}`, isEntry, false) === STOP) {
+                return true;
+            }
+        }
+    }
+    let done = false;
+    if (!done) {
+        const passThroughSources = getPassThroughReExportSources(imported, id);
+        if (passThroughSources) {
+            for (const reExportingFile of passThroughSources) {
+                const isEntry = entryPaths.has(reExportingFile);
+                if (visitor(filePath, id, reExportingFile, id, isEntry, true) === STOP) {
+                    done = true;
+                    break;
+                }
+                if (!isEntry && walkDown(graph, reExportingFile, identifier, visitor, entryPaths, visited)) {
+                    done = true;
+                    break;
+                }
+            }
+        }
+    }
+    if (!done) {
+        const aliasReExportMap = getAliasReExportMap(imported, id);
+        if (aliasReExportMap) {
+            for (const [alias, sources] of aliasReExportMap) {
+                for (const reExportingFile of sources) {
+                    const isEntry = entryPaths.has(reExportingFile);
+                    if (visitor(filePath, id, reExportingFile, alias, isEntry, true) === STOP) {
+                        done = true;
+                        break;
+                    }
+                    if (!isEntry) {
+                        const ref = [alias, ...restIds].join('.');
+                        if (walkDown(graph, reExportingFile, ref, visitor, entryPaths, visited)) {
+                            done = true;
+                            break;
+                        }
+                    }
+                }
+                if (done)
+                    break;
+            }
+        }
+    }
+    if (!done) {
+        for (const [namespace, sources] of imported.reExportedNs) {
+            for (const reExportingFile of sources) {
+                const isEntry = entryPaths.has(reExportingFile);
+                if (visitor(filePath, identifier, reExportingFile, `${namespace}.${identifier}`, isEntry, true) === STOP) {
+                    done = true;
+                    break;
+                }
+                if (!isEntry && walkDown(graph, reExportingFile, `${namespace}.${identifier}`, visitor, entryPaths, visited)) {
+                    done = true;
+                    break;
+                }
+            }
+            if (done)
+                break;
+        }
+    }
+    if (!done) {
+        const starSources = getStarReExportSources(imported);
+        if (starSources) {
+            for (const reExportingFile of starSources) {
+                const isEntry = entryPaths.has(reExportingFile);
+                if (visitor(filePath, id, reExportingFile, id, isEntry, true) === STOP) {
+                    done = true;
+                    break;
+                }
+                if (!isEntry && walkDown(graph, reExportingFile, identifier, visitor, entryPaths, visited)) {
+                    done = true;
+                    break;
+                }
+            }
+        }
+    }
+    return done;
+};

package/dist/index.js

@@ -1,98 +1,2 @@
-import { watch } from 'node:fs';
-import { formatly } from 'formatly';
-import { CatalogCounselor } from './CatalogCounselor.js';
-import { ConfigurationChief } from './ConfigurationChief.js';
-import { ConsoleStreamer } from './ConsoleStreamer.js';
-import { DependencyDeputy } from './DependencyDeputy.js';
-import { analyze } from './graph/analyze.js';
-import { build } from './graph/build.js';
-import { IssueCollector } from './IssueCollector.js';
-import { IssueFixer } from './IssueFixer.js';
-import { PrincipalFactory } from './PrincipalFactory.js';
-import watchReporter from './reporters/watch.js';
-import { debugLogArray, debugLogObject } from './util/debug.js';
-import { getGitIgnoredHandler } from './util/glob-core.js';
-import { getWatchHandler } from './util/watch.js';
-export const main = async (options) => {
-    debugLogObject('*', 'Unresolved configuration', options);
-    debugLogObject('*', 'Included issue types', options.includedIssueTypes);
-    const chief = new ConfigurationChief(options);
-    const deputy = new DependencyDeputy(options);
-    const factory = new PrincipalFactory();
-    const streamer = new ConsoleStreamer(options);
-    const fixer = new IssueFixer(options);
-    const collector = new IssueCollector(options);
-    const counselor = new CatalogCounselor(options);
-    streamer.cast('Reading workspace configuration');
-    const workspaces = await chief.getWorkspaces();
-    const isGitIgnored = await getGitIgnoredHandler(options);
-    collector.setIgnoreIssues(chief.config.ignoreIssues);
-    debugLogObject('*', 'Included workspaces', () => workspaces.map(w => w.pkgName));
-    debugLogObject('*', 'Included workspace configs', () => workspaces.map(w => ({ pkgName: w.pkgName, name: w.name, config: w.config, ancestors: w.ancestors })));
-    const { graph, entryPaths, analyzedFiles, unreferencedFiles, analyzeSourceFile } = await build({
-        chief,
-        collector,
-        counselor,
-        deputy,
-        factory,
-        isGitIgnored,
-        streamer,
-        workspaces,
-        options,
-    });
-    const reAnalyze = await analyze({
-        analyzedFiles,
-        counselor,
-        chief,
-        collector,
-        deputy,
-        entryPaths,
-        factory,
-        fixer,
-        graph,
-        streamer,
-        unreferencedFiles,
-        options,
-    });
-    if (options.isWatch) {
-        const isIgnored = (filePath) => filePath.startsWith(options.cacheLocation) || filePath.includes('/.git/') || isGitIgnored(filePath);
-        const onUpdate = options.isWatch
-            ? ({ issues, duration }) => watchReporter(options, { issues, streamer, size: analyzedFiles.size, duration })
-            : () => { };
-        const watchHandler = await getWatchHandler(options, {
-            analyzedFiles,
-            analyzeSourceFile,
-            chief,
-            collector,
-            analyze: reAnalyze,
-            factory,
-            graph,
-            isIgnored,
-            onUpdate,
-            unreferencedFiles,
-        });
-        watch('.', { recursive: true }, watchHandler);
-    }
-    const { issues, counters, tagHints, configurationHints } = collector.getIssues();
-    if (options.isFix) {
-        const touchedFiles = await fixer.fixIssues(issues);
-        if (options.isFormat) {
-            const report = await formatly(Array.from(touchedFiles));
-            if (report.ran && report.result && (report.result.runner === 'virtual' || report.result.code === 0)) {
-                debugLogArray('*', `Formatted files using ${report.formatter.name} (${report.formatter.runner})`, touchedFiles);
-            }
-            else {
-                debugLogObject('*', 'Formatting files failed', report);
-            }
-        }
-    }
-    if (!options.isWatch)
-        streamer.clear();
-    return {
-        issues,
-        counters,
-        tagHints,
-        configurationHints,
-        includedWorkspaceDirs: chief.includedWorkspaces.map(w => w.dir),
-    };
-};
+import { run } from './run.js';
+export const main = async (options) => (await run(options)).results;

package/dist/plugins/angular/index.js

@@ -36,8 +36,8 @@ const resolveConfig = async (config, options) => {
                 }
                 return opts.isProduction ? toProductionEntry(normalizedPath) : toEntry(normalizedPath);
             };
-            for (const [configName, entriesByOption] of entriesByOptionByConfig.entries()) {
-                for (const [option, entries] of entriesByOption.entries()) {
+            for (const [configName, entriesByOption] of entriesByOptionByConfig) {
+                for (const [option, entries] of entriesByOption) {
                     for (const entry of entries) {
                         inputs.add(toInput(entry, {
                             isProduction: isBuildTarget && configName === PRODUCTION_CONFIG_NAME,
@@ -46,7 +46,7 @@ const resolveConfig = async (config, options) => {
                     }
                 }
             }
-            for (const [option, entries] of defaultEntriesByOption.entries()) {
+            for (const [option, entries] of defaultEntriesByOption) {
                 for (const entry of entries) {
                     inputs.add(toInput(entry, {
                         isProduction: isBuildTarget && !productionEntriesByOption.get(option)?.length,

package/dist/plugins/next/index.js

@@ -1,6 +1,6 @@
-import { toProductionEntry } from '../../util/input.js';
+import { toDependency, toProductionEntry } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
-import { getPageExtensions } from './resolveFromAST.js';
+import { getMdxPlugins, getPageExtensions } from './resolveFromAST.js';
 const title = 'Next.js';
 const enablers = ['next'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -26,7 +26,8 @@ const resolveFromAST = sourceFile => {
     const pageExtensions = getPageExtensions(sourceFile);
     const extensions = pageExtensions.length > 0 ? pageExtensions : defaultPageExtensions;
     const patterns = getEntryFilePatterns(extensions);
-    return patterns.map(id => toProductionEntry(id));
+    const mdxPlugins = getMdxPlugins(sourceFile);
+    return [...patterns.map(id => toProductionEntry(id)), ...Array.from(mdxPlugins).map(id => toDependency(id))];
 };
 const plugin = {
     title,

package/dist/plugins/next/resolveFromAST.d.ts

@@ -1,2 +1,3 @@
 import ts from 'typescript';
 export declare const getPageExtensions: (sourceFile: ts.SourceFile) => string[];
+export declare const getMdxPlugins: (sourceFile: ts.SourceFile) => Set<string>;

package/dist/plugins/next/resolveFromAST.js

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { getPropertyValues } from '../../typescript/ast-helpers.js';
+import { getDefaultImportName, getImportMap, getPropertyValues, stripQuotes } from '../../typescript/ast-helpers.js';
 export const getPageExtensions = (sourceFile) => {
     const pageExtensions = new Set();
     function visit(node) {
@@ -13,3 +13,44 @@ export const getPageExtensions = (sourceFile) => {
     visit(sourceFile);
     return Array.from(pageExtensions);
 };
+const isNamedProp = (prop, name) => ts.isPropertyAssignment(prop) && prop.name.getText() === name;
+export const getMdxPlugins = (sourceFile) => {
+    const plugins = new Set();
+    const importMap = getImportMap(sourceFile);
+    const mdxImportName = getDefaultImportName(importMap, '@next/mdx');
+    if (!mdxImportName)
+        return plugins;
+    function visit(node) {
+        if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === mdxImportName) {
+            if (node.arguments.length > 0 && ts.isObjectLiteralExpression(node.arguments[0])) {
+                const options = node.arguments[0]?.properties.find(prop => isNamedProp(prop, 'options'));
+                if (options && ts.isPropertyAssignment(options)) {
+                    if (ts.isObjectLiteralExpression(options.initializer)) {
+                        for (const pluginType of ['remarkPlugins', 'rehypePlugins', 'recmaPlugins']) {
+                            const props = options.initializer.properties.find(prop => isNamedProp(prop, pluginType));
+                            if (props && ts.isPropertyAssignment(props)) {
+                                if (ts.isArrayLiteralExpression(props.initializer)) {
+                                    for (const element of props.initializer.elements) {
+                                        if (ts.isStringLiteral(element)) {
+                                            plugins.add(stripQuotes(element.text));
+                                        }
+                                        else if (ts.isArrayLiteralExpression(element) && element.elements.length > 0) {
+                                            const firstElement = element.elements[0];
+                                            if (ts.isStringLiteral(firstElement)) {
+                                                plugins.add(stripQuotes(firstElement.text));
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            return true;
+        }
+        return ts.forEachChild(node, visit) ?? false;
+    }
+    visit(sourceFile);
+    return plugins;
+};

package/dist/plugins/vite/helpers.js

@@ -4,7 +4,7 @@ export const getReactBabelPlugins = (sourceFile) => {
     const babelPlugins = [];
     const importMap = getImportMap(sourceFile);
     const reactPluginNames = new Set();
-    for (const [importName, importPath] of importMap.entries()) {
+    for (const [importName, importPath] of importMap) {
         if (importPath.includes('@vitejs/plugin-react')) {
             reactPluginNames.add(importName);
         }

package/dist/reporters/codeclimate.js

@@ -1,7 +1,6 @@
 import { createHash } from 'node:crypto';
-import { ISSUE_TYPE_TITLE } from '../constants.js';
 import { toRelative } from '../util/path.js';
-import { getIssueTypeTitle } from './util/util.js';
+import { getIssuePrefix, getIssueTypeTitle } from './util/util.js';
 export default async ({ report, issues, cwd }) => {
     const entries = [];
     for (const [type, isReportType] of Object.entries(report)) {
@@ -52,15 +51,12 @@ function convertSeverity(severity) {
             return 'info';
     }
 }
-function getPrefix(type) {
-    return ISSUE_TYPE_TITLE[type].replace(/ies$/, 'y').replace(/s$/, '');
-}
 function getIssueDescription({ type, symbol, symbols, parentSymbol }) {
     const symbolDescription = symbols ? `${symbols.map(s => s.symbol).join(', ')}` : symbol;
-    return `${getPrefix(type)}: ${symbolDescription}${parentSymbol ? ` (${parentSymbol})` : ''}`;
+    return `${getIssuePrefix(type)}: ${symbolDescription}${parentSymbol ? ` (${parentSymbol})` : ''}`;
 }
 function getSymbolDescription({ type, symbol, parentSymbol, }) {
-    return `${getPrefix(type)}: ${symbol.symbol}${parentSymbol ? ` (${parentSymbol})` : ''}`;
+    return `${getIssuePrefix(type)}: ${symbol.symbol}${parentSymbol ? ` (${parentSymbol})` : ''}`;
 }
 function createLocation(filePath, cwd, line, col) {
     if (col !== undefined) {

package/dist/reporters/util/util.d.ts

@@ -1,5 +1,5 @@
 import { ISSUE_TYPE_TITLE } from '../../constants.js';
-import type { Issue, IssueSeverity, IssueSymbol } from '../../types/issues.js';
+import type { Issue, IssueSeverity, IssueSymbol, IssueType } from '../../types/issues.js';
 import { Table } from '../../util/table.js';
 export declare const dim: import("picocolors/types.js").Formatter;
 export declare const bright: import("picocolors/types.js").Formatter;
@@ -23,4 +23,5 @@ export declare const convert: (issue: Issue | IssueSymbol) => {
 export declare const getTableForType: (issues: Issue[], cwd: string, options?: {
     isUseColors?: boolean;
 }) => Table;
+export declare const getIssuePrefix: (type: IssueType) => string;
 export {};

package/dist/reporters/util/util.js

@@ -54,3 +54,4 @@ export const getTableForType = (issues, cwd, options = { isUseColors: true }) =>
     }
     return table;
 };
+export const getIssuePrefix = (type) => ISSUE_TYPE_TITLE[type].replace(/ies$/, 'y').replace(/s$/, '');

package/dist/reporters/watch.js

@@ -23,7 +23,7 @@ export default (options, { issues, streamer, duration, size }) => {
     }
     const mem = perfObserver.getCurrentMemUsageInMb();
     const ms = duration ?? perfObserver.getCurrentDurationInMs();
-    const summary = `${size} files in ${prettyMilliseconds(ms)} (${mem}MB)`;
+    const summary = `${size} files (${prettyMilliseconds(ms)} • ${mem}MB)`;
     const messages = totalIssues === 0
         ? ['✂️  Excellent, Knip found no issues.', '', picocolors.gray(summary)]
         : [...lines, '', picocolors.gray(summary)];

package/dist/run.d.ts

@@ -0,0 +1,25 @@
+import { ConsoleStreamer } from './ConsoleStreamer.js';
+import type { MainOptions } from './util/create-options.js';
+export declare const run: (options: MainOptions) => Promise<{
+    results: {
+        issues: import("./types/issues.js").Issues;
+        counters: import("./types/issues.js").Counters;
+        tagHints: Set<import("./types/issues.js").TagHint>;
+        configurationHints: Set<import("./types/issues.js").ConfigurationHint>;
+        includedWorkspaceDirs: string[];
+    };
+    watchHandler: {
+        listener: import("fs").WatchListener<string | Buffer<ArrayBufferLike>>;
+        handleFileChanges: (changes: {
+            type: "added" | "deleted" | "modified";
+            filePath: string;
+        }[]) => Promise<{
+            duration: number;
+            mem: number;
+        }>;
+        getEntryPaths: () => Set<string>;
+        getGraph: () => import("./types/module-graph.js").ModuleGraph;
+        getIssues: () => import("./types/issues.js").Issues;
+    } | undefined;
+    streamer: ConsoleStreamer;
+}>;

package/dist/run.js

@@ -0,0 +1,107 @@
+import { watch } from 'node:fs';
+import { formatly } from 'formatly';
+import { CatalogCounselor } from './CatalogCounselor.js';
+import { ConfigurationChief } from './ConfigurationChief.js';
+import { ConsoleStreamer } from './ConsoleStreamer.js';
+import { DependencyDeputy } from './DependencyDeputy.js';
+import { analyze } from './graph/analyze.js';
+import { build } from './graph/build.js';
+import { IssueCollector } from './IssueCollector.js';
+import { IssueFixer } from './IssueFixer.js';
+import { PrincipalFactory } from './PrincipalFactory.js';
+import watchReporter from './reporters/watch.js';
+import { debugLogArray, debugLogObject } from './util/debug.js';
+import { getGitIgnoredHandler } from './util/glob-core.js';
+import { getWatchHandler } from './util/watch.js';
+export const run = async (options) => {
+    debugLogObject('*', 'Unresolved configuration', options);
+    debugLogObject('*', 'Included issue types', options.includedIssueTypes);
+    const chief = new ConfigurationChief(options);
+    const deputy = new DependencyDeputy(options);
+    const factory = new PrincipalFactory();
+    const streamer = new ConsoleStreamer(options);
+    const fixer = new IssueFixer(options);
+    const collector = new IssueCollector(options);
+    const counselor = new CatalogCounselor(options);
+    streamer.cast('Reading workspace configuration');
+    const workspaces = await chief.getWorkspaces();
+    const isGitIgnored = await getGitIgnoredHandler(options);
+    collector.setIgnoreIssues(chief.config.ignoreIssues);
+    debugLogObject('*', 'Included workspaces', () => workspaces.map(w => w.pkgName));
+    debugLogObject('*', 'Included workspace configs', () => workspaces.map(w => ({ pkgName: w.pkgName, name: w.name, config: w.config, ancestors: w.ancestors })));
+    const { graph, entryPaths, analyzedFiles, unreferencedFiles, analyzeSourceFile } = await build({
+        chief,
+        collector,
+        counselor,
+        deputy,
+        factory,
+        isGitIgnored,
+        streamer,
+        workspaces,
+        options,
+    });
+    const reAnalyze = await analyze({
+        analyzedFiles,
+        counselor,
+        chief,
+        collector,
+        deputy,
+        entryPaths,
+        factory,
+        fixer,
+        graph,
+        streamer,
+        unreferencedFiles,
+        options,
+    });
+    let watchHandler;
+    if (options.isWatch) {
+        const isIgnored = (filePath) => (!!options.cacheLocation && filePath.startsWith(options.cacheLocation)) ||
+            filePath.includes('/.git/') ||
+            isGitIgnored(filePath);
+        const onFileChange = options.isWatch
+            ? ({ issues, duration }) => watchReporter(options, { issues, streamer, size: analyzedFiles.size, duration })
+            : undefined;
+        watchHandler = await getWatchHandler(options, {
+            analyzedFiles,
+            analyzeSourceFile,
+            chief,
+            collector,
+            analyze: reAnalyze,
+            factory,
+            graph,
+            isIgnored,
+            onFileChange,
+            unreferencedFiles,
+            entryPaths,
+        });
+        if (options.isWatch)
+            watch('.', { recursive: true }, watchHandler.listener);
+    }
+    const { issues, counters, tagHints, configurationHints } = collector.getIssues();
+    if (options.isFix) {
+        const touchedFiles = await fixer.fixIssues(issues);
+        if (options.isFormat) {
+            const report = await formatly(Array.from(touchedFiles));
+            if (report.ran && report.result && (report.result.runner === 'virtual' || report.result.code === 0)) {
+                debugLogArray('*', `Formatted files using ${report.formatter.name} (${report.formatter.runner})`, touchedFiles);
+            }
+            else {
+                debugLogObject('*', 'Formatting files failed', report);
+            }
+        }
+    }
+    if (!options.isWatch)
+        streamer.clear();
+    return {
+        results: {
+            issues,
+            counters,
+            tagHints,
+            configurationHints,
+            includedWorkspaceDirs: chief.includedWorkspaces.map(w => w.dir),
+        },
+        watchHandler,
+        streamer,
+    };
+};

package/dist/types/issues.d.ts

@@ -1,13 +1,13 @@
 import type { SYMBOL_TYPE } from '../constants.js';
 import type { Fixes } from './exports.js';
 export type SymbolType = (typeof SYMBOL_TYPE)[keyof typeof SYMBOL_TYPE];
-export type IssueSymbol = {
+export interface IssueSymbol {
     symbol: string;
     pos?: number;
     line?: number;
     col?: number;
-};
-export type Issue = {
+}
+export interface Issue {
     type: SymbolIssueType;
     filePath: string;
     workspace: string;
@@ -22,7 +22,7 @@ export type Issue = {
     col?: number;
     fixes: Fixes;
     isFixed?: boolean;
-};
+}
 export type IssueSet = Set<string>;
 export type IssueRecords = Record<string, Record<string, Issue>>;
 export type Issues = {

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

@@ -1,12 +1,17 @@
 import type ts from 'typescript';
 import type { Fix, Fixes } from './exports.js';
 import type { IssueSymbol, SymbolType } from './issues.js';
-type Identifier = string;
+export type Identifier = string;
 type FilePath = string;
 type NamespaceOrAlias = string;
 type Reference = string;
 type References = Set<Reference>;
 type Tags = Set<string>;
+interface SourceLocation {
+    pos: number;
+    line: number;
+    col: number;
+}
 export type IdToFileMap = Map<Identifier, Set<FilePath>>;
 export type IdToNsToFileMap = Map<Identifier, Map<NamespaceOrAlias, Set<FilePath>>>;
 export type ImportMaps = {
@@ -19,20 +24,14 @@ export type ImportMaps = {
     reExportedNs: IdToFileMap;
 };
 export type ImportMap = Map<FilePath, ImportMaps>;
-export type Import = {
+export interface Import extends SourceLocation {
     specifier: string;
     filePath: string | undefined;
     identifier: string | undefined;
-    pos?: number;
-    line?: number;
-    col?: number;
     isTypeOnly: boolean;
-};
-export interface Export {
+}
+export interface Export extends SourceLocation {
     identifier: Identifier;
-    pos: number;
-    line: number;
-    col: number;
     type: SymbolType;
     members: ExportMember[];
     jsDocTags: Tags;

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

@@ -58,6 +58,10 @@ export declare const isModuleExportsAccess: (node: ts.PropertyAccessExpression)
 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 function getThenBindings(callExpression: ts.CallExpression): {
+    identifier: string;
+    pos: number;
+}[] | undefined;
 export declare const getAccessedIdentifiers: (identifier: string, scope: ts.Node) => {
     identifier: string;
     pos: number;