knip 2.1.3 → 2.2.1

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

@@ -0,0 +1,46 @@
+import ts from 'typescript';
+import { isRequireCall, findAncestor, findDescendants } from '../../ast-helpers.js';
+import { isJS } from '../helpers.js';
+import { importVisitor as visit } from '../index.js';
+export default visit(isJS, node => {
+    if (isRequireCall(node)) {
+        if (ts.isStringLiteralLike(node.arguments[0])) {
+            const specifier = node.arguments[0].text;
+            if (specifier) {
+                const propertyAccessExpression = findAncestor(node, _node => {
+                    if (ts.isExpressionStatement(_node) || ts.isCallExpression(_node))
+                        return 'STOP';
+                    return ts.isPropertyAccessExpression(_node);
+                });
+                if (propertyAccessExpression) {
+                    const identifier = String(propertyAccessExpression.name.escapedText);
+                    return { identifier, specifier };
+                }
+                else {
+                    const variableDeclaration = node.parent;
+                    if (ts.isVariableDeclaration(variableDeclaration) &&
+                        ts.isVariableDeclarationList(variableDeclaration.parent)) {
+                        if (ts.isIdentifier(variableDeclaration.name)) {
+                            return { identifier: 'default', specifier };
+                        }
+                        else {
+                            const bindings = findDescendants(variableDeclaration, ts.isBindingElement);
+                            if (bindings.length > 0) {
+                                return bindings.map(element => {
+                                    const identifier = (element.propertyName ?? element.name).getText();
+                                    return { identifier, specifier };
+                                });
+                            }
+                            else {
+                                return { identifier: 'default', specifier };
+                            }
+                        }
+                    }
+                    else {
+                        return { identifier: 'default', specifier };
+                    }
+                }
+            }
+        }
+    }
+});

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

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

package/dist/typescript/visitors/imports/requireResolveCall.js

@@ -0,0 +1,14 @@
+import ts from 'typescript';
+import { isRequireResolveCall } from '../../ast-helpers.js';
+import { isJS } from '../helpers.js';
+import { importVisitor as visit } from '../index.js';
+export default visit(isJS, node => {
+    if (isRequireResolveCall(node)) {
+        if (node.arguments[0] && ts.isStringLiteralLike(node.arguments[0])) {
+            const specifier = node.arguments[0].text;
+            if (specifier) {
+                return { specifier };
+            }
+        }
+    }
+});

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

@@ -0,0 +1,10 @@
+import ts from 'typescript';
+import type { GetImportsAndExportsOptions, AddExportOptions, AddImportOptions } from '../getImportsAndExports.js';
+type FileCondition = (sourceFile: ts.SourceFile) => boolean;
+type VisitorFactory<T> = (fileCondition: FileCondition, fn: Visitor<T>) => VisitorCondition<T>;
+type VisitorCondition<T> = (sourceFile: ts.SourceFile) => undefined | Visitor<T>;
+type Visitor<T> = (node: ts.Node, options: GetImportsAndExportsOptions) => undefined | T | T[];
+export declare const importVisitor: VisitorFactory<AddImportOptions>;
+export declare const exportVisitor: VisitorFactory<AddExportOptions>;
+export declare const scriptVisitor: VisitorFactory<string>;
+export {};

package/dist/typescript/visitors/index.js

@@ -0,0 +1,15 @@
+export const importVisitor = (fileCondition, visitorFn) => sourceFile => {
+    if (fileCondition(sourceFile)) {
+        return (node, options) => visitorFn(node, options);
+    }
+};
+export const exportVisitor = (fileCondition, visitorFn) => sourceFile => {
+    if (fileCondition(sourceFile)) {
+        return (node, options) => visitorFn(node, options);
+    }
+};
+export const scriptVisitor = (fileCondition, visitorFn) => sourceFile => {
+    if (fileCondition(sourceFile)) {
+        return (node, options) => visitorFn(node, options);
+    }
+};

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

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

package/dist/typescript/visitors/scripts/index.js

@@ -0,0 +1,3 @@
+import zx from './zx.js';
+const visitors = [zx];
+export default (sourceFile) => visitors.map(v => v(sourceFile)).filter(v => v);

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

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

package/dist/typescript/visitors/scripts/zx.js

@@ -0,0 +1,8 @@
+import ts from 'typescript';
+import { stripQuotes } from '../../ast-helpers.js';
+import { scriptVisitor as visit } from '../index.js';
+export default visit(sourceFile => ts.getShebang(sourceFile.text) === '#!/usr/bin/env zx', node => {
+    if (ts.isTaggedTemplateExpression(node) && node.tag.getText() === '$') {
+        return stripQuotes(node.template.getText());
+    }
+});

package/dist/util/array.d.ts

@@ -1,3 +1,2 @@
 export declare const compact: <T>(collection: (T | undefined)[]) => T[];
 export declare const arrayify: (value?: string[] | string) => string[];
-export declare const partition: <T>(values: Set<T> | T[], predicate: (value: T) => boolean) => [T[], T[]];

package/dist/util/array.js

@@ -1,9 +1,2 @@
 export const compact = (collection) => Array.from(new Set(collection)).filter((value) => Boolean(value));
 export const arrayify = (value) => Array.isArray(value) ? value : typeof value === 'string' ? [value] : [];
-export const partition = (values, predicate) => {
-    const results = [[], []];
-    values.forEach(value => {
-        results[predicate(value) ? 0 : 1].push(value);
-    });
-    return results;
-};

package/dist/util/compilers.d.ts

@@ -1,7 +1,8 @@
+import { AsyncCompilerFn, SyncCompilerFn } from '../types/compilers.js';
 import { RawConfiguration } from '../types/config.js';
 export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
-    exclude?: string[] | undefined;
-    include?: string[] | undefined;
+    syncCompilers: Record<string, SyncCompilerFn>;
+    asyncCompilers: Record<string, AsyncCompilerFn>;
     entry?: string | string[] | undefined;
     project?: string | string[] | undefined;
     paths?: Record<string, string[]> | undefined;
@@ -10,8 +11,8 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
     ignoreDependencies?: string[] | undefined;
     ignoreWorkspaces?: string[] | undefined;
     compilers?: Record<string, ((args_0: string, ...args_1: unknown[]) => string) | ((args_0: string, ...args_1: unknown[]) => Promise<string>)> | undefined;
-    syncCompilers?: Record<string, (args_0: string, ...args_1: unknown[]) => string> | undefined;
-    asyncCompilers?: Record<string, (args_0: string, ...args_1: unknown[]) => Promise<string>> | undefined;
+    include?: string[] | undefined;
+    exclude?: string[] | undefined;
     workspaces?: Record<string, {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;

package/dist/util/compilers.js

@@ -16,7 +16,5 @@ export const partitionCompilers = (rawLocalConfig) => {
         const ext = normalizeExt(extension);
         asyncCompilers[ext] = rawLocalConfig.asyncCompilers[extension];
     }
-    rawLocalConfig.syncCompilers = syncCompilers;
-    rawLocalConfig.asyncCompilers = asyncCompilers;
-    return rawLocalConfig;
+    return { ...rawLocalConfig, syncCompilers, asyncCompilers };
 };

package/dist/util/glob.js

@@ -4,7 +4,7 @@ import { ROOT_WORKSPACE_NAME } from '../constants.js';
 import { compact } from './array.js';
 import { debugLogObject } from './debug.js';
 import { join, relative } from './path.js';
-import { timerify } from './performance.js';
+import { timerify } from './Performance.js';
 export const prependDirToPattern = (workingDir, pattern) => {
     if (pattern.startsWith('!'))
         return '!' + join(workingDir, pattern.slice(1));

package/dist/util/loader.js

@@ -2,7 +2,7 @@ import { pathToFileURL } from 'node:url';
 import { LoaderError } from './errors.js';
 import { loadJSON, loadYAML, loadFile, parseJSON, parseYAML } from './fs.js';
 import { extname } from './path.js';
-import { timerify } from './performance.js';
+import { timerify } from './Performance.js';
 import { jiti } from './register.js';
 const load = async (filePath) => {
     try {

package/dist/util/plugin.js

@@ -1,5 +1,5 @@
 import { _load } from './loader.js';
-import { timerify } from './performance.js';
+import { timerify } from './Performance.js';
 export const toCamelCase = (name) => name.toLowerCase().replace(/(-[a-z])/g, group => group.toUpperCase().replace('-', ''));
 export const hasDependency = (dependencies, values) => values.some(value => {
     if (typeof value === 'string') {

package/dist/util/require.js

@@ -3,7 +3,7 @@ import { pathToFileURL } from 'node:url';
 import { debugLog } from './debug.js';
 import { getPackageNameFromModuleSpecifier } from './modules.js';
 import { cwd, toPosix, join } from './path.js';
-import { timerify } from './performance.js';
+import { timerify } from './Performance.js';
 const createRequire = (path) => nodeCreateRequire(pathToFileURL(path ?? cwd));
 const require = createRequire();
 const resolve = (specifier) => toPosix(require.resolve(specifier));

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "2.1.3";
+export declare const version = "2.2.1";

package/dist/version.js

@@ -1 +1 @@
-export const version = '2.1.3';
+export const version = '2.2.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "2.1.3",
+  "version": "2.2.1",
   "description": "Find unused files, dependencies and exports in your TypeScript and JavaScript projects",
   "homepage": "https://github.com/webpro/knip",
   "repository": "github:webpro/knip",

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

@@ -1,16 +0,0 @@
-import type { BoundSourceFile } from './SourceFile.js';
-import type { Imports, ExportItems } from '../types/ast.js';
-type Options = {
-    skipTypeOnly: boolean;
-    skipExports: boolean;
-};
-export declare const getImportsAndExports: (sourceFile: BoundSourceFile, options: Options) => {
-    imports: {
-        internal: Imports;
-        external: Set<string>;
-        unresolved: Set<string>;
-    };
-    exports: ExportItems;
-    duplicateExports: string[][];
-};
-export {};

package/dist/typescript/ast-walker.js

@@ -1,364 +0,0 @@
-import { isBuiltin } from 'node:module';
-import ts from 'typescript';
-import { SymbolType } from '../types/issues.js';
-import { isInNodeModules } from '../util/path.js';
-import * as ast from './ast-helpers.js';
-export const getImportsAndExports = (sourceFile, options) => {
-    const internalImports = new Map();
-    const externalImports = new Set();
-    const unresolvedImports = new Set();
-    const exports = new Map();
-    const aliasedExports = {};
-    const importedInternalSymbols = new Map();
-    const addInternalImport = ({ identifier = '__anonymous', specifier, symbol, filePath, }) => {
-        const isStar = identifier === '*';
-        const isReExported = Boolean(isStar && !symbol);
-        if (!internalImports.has(filePath)) {
-            internalImports.set(filePath, {
-                specifier,
-                isStar,
-                isReExported,
-                isReExportedBy: new Set(),
-                symbols: new Set(),
-            });
-        }
-        const internalImport = internalImports.get(filePath);
-        if (isReExported) {
-            internalImport.isReExported = isReExported;
-            internalImport.isReExportedBy.add(sourceFile.fileName);
-        }
-        if (isStar) {
-            internalImport.isStar = isStar;
-        }
-        if (!isStar) {
-            internalImport.symbols.add(identifier);
-        }
-        if (isStar && symbol) {
-            importedInternalSymbols.set(symbol, filePath);
-        }
-    };
-    const addImport = ({ specifier, symbol, identifier = '__anonymous' }) => {
-        if (isBuiltin(specifier))
-            return;
-        const module = sourceFile.resolvedModules?.get(specifier, undefined);
-        if (module?.resolvedModule) {
-            const filePath = module.resolvedModule.resolvedFileName;
-            if (filePath) {
-                if (module.resolvedModule.isExternalLibraryImport) {
-                    if (!isInNodeModules(filePath)) {
-                        addInternalImport({ identifier, specifier, symbol, filePath });
-                    }
-                    else if (ast.isDeclarationFileExtension(module.resolvedModule.extension)) {
-                        externalImports.add(specifier);
-                    }
-                    else {
-                        externalImports.add(module.resolvedModule.packageId?.name ?? specifier);
-                    }
-                }
-                else {
-                    addInternalImport({ identifier, specifier, symbol, filePath });
-                }
-            }
-        }
-        else {
-            unresolvedImports.add(specifier);
-        }
-    };
-    const maybeAddNamespaceAccessAsImport = ({ namespace, member }) => {
-        const symbol = sourceFile.locals?.get(namespace);
-        if (symbol) {
-            const importedSymbolFilePath = importedInternalSymbols.get(symbol);
-            if (importedSymbolFilePath) {
-                const internalImport = internalImports.get(importedSymbolFilePath);
-                internalImport?.symbols.add(member);
-            }
-        }
-    };
-    const addExport = ({ node, identifier, type, pos, members }) => {
-        if (options.skipExports)
-            return;
-        if (exports.has(identifier)) {
-            const item = exports.get(identifier);
-            exports.set(identifier, { ...item, node, type, pos, members });
-        }
-        else {
-            exports.set(identifier, { node, type, pos, members });
-        }
-    };
-    const addAliasedExport = (symbol, alias) => {
-        aliasedExports[symbol] = aliasedExports[symbol] ?? [symbol];
-        aliasedExports[symbol].push(alias);
-    };
-    const maybeAddAliasedExport = (node, alias) => {
-        if (node && ts.isIdentifier(node) && sourceFile.symbol?.exports?.has(node.getText())) {
-            addAliasedExport(node.getText(), alias);
-        }
-    };
-    const visit = (node) => {
-        if (ts.isImportDeclaration(node) && ts.isStringLiteralLike(node.moduleSpecifier)) {
-            const specifier = node.moduleSpecifier.text;
-            if (!node.importClause) {
-                addImport({ specifier });
-            }
-            else {
-                if (node.importClause.isTypeOnly && options.skipTypeOnly)
-                    return;
-                if (ast.isDefaultImport(node)) {
-                    addImport({ specifier, identifier: 'default' });
-                }
-                if (node.importClause?.namedBindings) {
-                    if (ts.isNamespaceImport(node.importClause.namedBindings)) {
-                        const symbol = node.importClause.namedBindings.symbol;
-                        addImport({ symbol, specifier, identifier: '*' });
-                    }
-                    if (ts.isNamedImports(node.importClause.namedBindings)) {
-                        node.importClause.namedBindings.elements.forEach(element => {
-                            const identifier = (element.propertyName ?? element.name).getText();
-                            addImport({ symbol: element.symbol, specifier, identifier });
-                        });
-                    }
-                }
-            }
-        }
-        if (ast.isImportCall(node)) {
-            if (node.arguments[0] && ts.isStringLiteralLike(node.arguments[0])) {
-                const specifier = node.arguments[0].text;
-                let _node = node.parent;
-                while (_node) {
-                    if (ts.isExpressionStatement(_node)) {
-                        addImport({ specifier });
-                        break;
-                    }
-                    if (_node.parent && ts.isCallExpression(_node.parent)) {
-                        addImport({ specifier, identifier: 'default' });
-                        break;
-                    }
-                    if (ast.isAccessExpression(_node)) {
-                        const identifier = ast.getAccessExpressionName(_node);
-                        const isPromiseLike = identifier === 'then';
-                        const symbol = isPromiseLike ? 'default' : identifier;
-                        addImport({ identifier: symbol, specifier });
-                        break;
-                    }
-                    if (ast.isVariableDeclarationList(_node)) {
-                        const variableDeclarations = ast.findDescendants(_node, _node => ts.isVariableDeclaration(_node));
-                        variableDeclarations.forEach(variableDeclaration => {
-                            if (ts.isIdentifier(variableDeclaration.name)) {
-                                addImport({ identifier: 'default', specifier });
-                            }
-                            else {
-                                const binds = ast.findDescendants(variableDeclaration, _node => ts.isBindingElement(_node));
-                                binds.forEach(element => {
-                                    const symbol = element.propertyName?.getText() || element.name.getText();
-                                    addImport({ identifier: symbol, specifier });
-                                });
-                            }
-                        });
-                        break;
-                    }
-                    _node = _node.parent;
-                }
-            }
-        }
-        if (ts.isImportEqualsDeclaration(node) &&
-            ts.isExternalModuleReference(node.moduleReference) &&
-            ts.isStringLiteralLike(node.moduleReference.expression)) {
-            const specifier = node.moduleReference.expression.text;
-            addImport({ specifier, identifier: 'default' });
-        }
-        if (ast.isRequireCall(node)) {
-            if (ts.isStringLiteralLike(node.arguments[0])) {
-                const specifier = node.arguments[0].text;
-                if (specifier) {
-                    const propertyAccessExpression = ast.findAncestor(node, _node => {
-                        if (ts.isExpressionStatement(_node) || ts.isCallExpression(_node))
-                            return 'STOP';
-                        return ts.isPropertyAccessExpression(_node);
-                    });
-                    if (propertyAccessExpression) {
-                        const identifier = String(propertyAccessExpression.name.escapedText);
-                        addImport({ identifier, specifier });
-                    }
-                    else {
-                        const variableDeclaration = node.parent;
-                        if (ts.isVariableDeclaration(variableDeclaration) &&
-                            ts.isVariableDeclarationList(variableDeclaration.parent)) {
-                            if (ts.isIdentifier(variableDeclaration.name)) {
-                                addImport({ identifier: 'default', specifier });
-                            }
-                            else {
-                                const bindings = ast.findDescendants(variableDeclaration, ts.isBindingElement);
-                                if (bindings.length > 0) {
-                                    bindings.forEach(element => {
-                                        const identifier = (element.propertyName ?? element.name).getText();
-                                        addImport({ identifier, specifier });
-                                    });
-                                }
-                                else {
-                                    addImport({ identifier: 'default', specifier });
-                                }
-                            }
-                        }
-                        else {
-                            addImport({ identifier: 'default', specifier });
-                        }
-                    }
-                }
-            }
-        }
-        if (ast.isRequireResolveCall(node)) {
-            if (node.arguments[0] && ts.isStringLiteralLike(node.arguments[0])) {
-                const specifier = node.arguments[0].text;
-                if (specifier) {
-                    addImport({ specifier });
-                }
-            }
-        }
-        const modifierKinds = node.modifiers?.map(modifier => modifier.kind) ?? [];
-        if (ts.isExportAssignment(node)) {
-            addExport({ node, identifier: 'default', type: SymbolType.UNKNOWN, pos: node.expression.getStart() });
-            maybeAddAliasedExport(node.expression, 'default');
-        }
-        if (modifierKinds.includes(ts.SyntaxKind.ExportKeyword)) {
-            if (ts.isVariableStatement(node)) {
-                node.declarationList.declarations.forEach(declaration => {
-                    if (ts.isObjectBindingPattern(declaration.name)) {
-                        declaration.name.elements.forEach(element => {
-                            if (ts.isIdentifier(element.name)) {
-                                addExport({
-                                    node: element,
-                                    identifier: element.name.escapedText.toString(),
-                                    type: SymbolType.UNKNOWN,
-                                    pos: element.name.getStart(),
-                                });
-                            }
-                        });
-                    }
-                    else if (ts.isArrayBindingPattern(declaration.name)) {
-                        declaration.name.elements.forEach(element => {
-                            if (ts.isBindingElement(element)) {
-                                addExport({
-                                    node: element,
-                                    identifier: element.getText(),
-                                    type: SymbolType.UNKNOWN,
-                                    pos: element.getStart(),
-                                });
-                            }
-                        });
-                    }
-                    else {
-                        const identifier = declaration.name.getText();
-                        addExport({ node: declaration, identifier, type: SymbolType.UNKNOWN, pos: declaration.name.getStart() });
-                        maybeAddAliasedExport(declaration.initializer, identifier);
-                    }
-                });
-            }
-            if (ts.isFunctionDeclaration(node) && node.name) {
-                const identifier = modifierKinds.includes(ts.SyntaxKind.DefaultKeyword) ? 'default' : node.name.getText();
-                const pos = (node.name ?? node.body ?? node).getStart();
-                addExport({ node, identifier, pos, type: SymbolType.FUNCTION });
-            }
-            if (ts.isClassDeclaration(node) && node.name) {
-                const identifier = modifierKinds.includes(ts.SyntaxKind.DefaultKeyword) ? 'default' : node.name.getText();
-                const pos = (node.name ?? node).getStart();
-                const members = node.members
-                    .filter((member) => (ts.isPropertyDeclaration(member) || ts.isMethodDeclaration(member)) && !ast.isPrivateMember(member))
-                    .map(member => ({
-                    node: member,
-                    identifier: member.name.getText(),
-                    pos: member.name.getStart(),
-                    type: SymbolType.MEMBER,
-                }));
-                addExport({ node, identifier, type: SymbolType.CLASS, pos, members });
-            }
-            if (ts.isTypeAliasDeclaration(node)) {
-                addExport({ node, identifier: node.name.getText(), type: SymbolType.TYPE, pos: node.name.getStart() });
-            }
-            if (ts.isInterfaceDeclaration(node)) {
-                addExport({ node, identifier: node.name.getText(), type: SymbolType.INTERFACE, pos: node.name.getStart() });
-            }
-            if (ts.isEnumDeclaration(node)) {
-                const identifier = modifierKinds.includes(ts.SyntaxKind.DefaultKeyword) ? 'default' : node.name.getText();
-                const pos = node.name.getStart();
-                const members = node.members.map(member => ({
-                    node: member,
-                    identifier: ast.stripQuotes(member.name.getText()),
-                    pos: member.name.getStart(),
-                    type: SymbolType.MEMBER,
-                }));
-                addExport({ node, identifier, type: SymbolType.ENUM, pos, members });
-            }
-        }
-        if (ts.isExportDeclaration(node)) {
-            if (node.moduleSpecifier && ts.isStringLiteralLike(node.moduleSpecifier)) {
-                if (!node.exportClause) {
-                    addImport({ identifier: '*', specifier: node.moduleSpecifier.text });
-                }
-                else if (node.exportClause.kind === ts.SyntaxKind.NamespaceExport) {
-                    addImport({ identifier: '*', specifier: node.moduleSpecifier.text });
-                }
-                else {
-                    const specifier = node.moduleSpecifier;
-                    node.exportClause.elements.forEach(element => {
-                        const identifier = (element.propertyName ?? element.name).getText();
-                        addImport({ identifier, specifier: specifier.text });
-                    });
-                }
-            }
-            else if (node.exportClause && ts.isNamedExports(node.exportClause)) {
-                const type = node.isTypeOnly ? SymbolType.TYPE : SymbolType.UNKNOWN;
-                node.exportClause.elements.forEach(element => {
-                    addExport({ node: element, identifier: element.name.getText(), type, pos: element.name.pos });
-                });
-            }
-        }
-        if (ast.isModuleExportsAccessExpression(node)) {
-            const parent = node.parent;
-            if (ts.isPropertyAccessExpression(parent)) {
-                const identifier = parent.name.getText();
-                const pos = parent.name.getStart();
-                addExport({ node, identifier, type: SymbolType.UNKNOWN, pos });
-            }
-            else if (ts.isElementAccessExpression(parent)) {
-                const identifier = ast.stripQuotes(parent.argumentExpression.getText());
-                const pos = parent.argumentExpression.getStart();
-                addExport({ node, identifier, type: SymbolType.UNKNOWN, pos });
-            }
-            else if (ts.isBinaryExpression(parent)) {
-                const expr = parent.right;
-                if (ts.isObjectLiteralExpression(expr) && expr.properties.every(ts.isShorthandPropertyAssignment)) {
-                    expr.properties.forEach(node => {
-                        addExport({ node, identifier: node.getText(), type: SymbolType.UNKNOWN, pos: node.pos });
-                    });
-                }
-                else {
-                    addExport({ node, identifier: 'default', type: SymbolType.UNKNOWN, pos: node.getStart() });
-                }
-            }
-        }
-        if ('jsDoc' in node) {
-            const type = ts.getJSDocType(node);
-            if (type && ast.isValidImportTypeNode(type)) {
-                addImport({ specifier: type.argument.literal.text });
-            }
-        }
-        if (ast.isAccessExpression(node)) {
-            maybeAddNamespaceAccessAsImport({
-                namespace: node.expression.getText(),
-                member: ast.getAccessExpressionName(node),
-            });
-        }
-        ts.forEachChild(node, visit);
-    };
-    visit(sourceFile);
-    const duplicateExports = Object.values(aliasedExports);
-    return {
-        imports: {
-            internal: internalImports,
-            external: externalImports,
-            unresolved: unresolvedImports,
-        },
-        exports,
-        duplicateExports,
-    };
-};