knip 2.1.2 → 2.2.0

package/dist/typescript/getImportsAndExports.js

@@ -0,0 +1,157 @@
+import { isBuiltin } from 'node:module';
+import ts from 'typescript';
+import { isInNodeModules } from '../util/path.js';
+import { isDeclarationFileExtension, isAccessExpression, getAccessExpressionName } from './ast-helpers.js';
+import getExportVisitors from './visitors/exports/index.js';
+import getImportVisitors from './visitors/imports/index.js';
+import getScriptVisitors from './visitors/scripts/index.js';
+const getVisitors = (sourceFile) => ({
+    export: getExportVisitors(sourceFile),
+    import: getImportVisitors(sourceFile),
+    script: getScriptVisitors(sourceFile),
+});
+export const getImportsAndExports = (sourceFile, options) => {
+    const internalImports = new Map();
+    const externalImports = new Set();
+    const unresolvedImports = new Set();
+    const exports = new Map();
+    const aliasedExports = {};
+    const scripts = new Set();
+    const importedInternalSymbols = new Map();
+    const visitors = getVisitors(sourceFile);
+    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 (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 });
+        }
+        if (ts.isExportAssignment(node))
+            maybeAddAliasedExport(node.expression, 'default');
+        if (ts.isVariableDeclaration(node))
+            maybeAddAliasedExport(node.initializer, identifier);
+    };
+    const maybeAddAliasedExport = (node, alias) => {
+        const identifier = node?.getText();
+        if (identifier && sourceFile.symbol?.exports?.has(identifier)) {
+            aliasedExports[identifier] = aliasedExports[identifier] ?? [identifier];
+            aliasedExports[identifier].push(alias);
+        }
+    };
+    const visit = (node) => {
+        for (const visitor of visitors.import) {
+            if (visitor) {
+                const results = visitor(node, options);
+                if (results) {
+                    [results].flat().forEach(addImport);
+                    return;
+                }
+            }
+        }
+        for (const visitor of visitors.export) {
+            if (visitor) {
+                const results = visitor(node, options);
+                if (results) {
+                    [results].flat().forEach(addExport);
+                    return;
+                }
+            }
+        }
+        for (const visitor of visitors.script) {
+            if (visitor) {
+                const results = visitor(node, options);
+                if (results) {
+                    [results].flat().forEach(script => scripts.add(script));
+                    return;
+                }
+            }
+        }
+        if (isAccessExpression(node)) {
+            maybeAddNamespaceAccessAsImport({
+                namespace: node.expression.getText(),
+                member: getAccessExpressionName(node),
+            });
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return {
+        imports: {
+            internal: internalImports,
+            external: externalImports,
+            unresolved: unresolvedImports,
+        },
+        exports: {
+            exported: exports,
+            duplicate: Object.values(aliasedExports),
+        },
+        scripts,
+    };
+};

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("../../getImportsAndExports.js").GetImportsAndExportsOptions) => import("../../getImportsAndExports.js").AddExportOptions | import("../../getImportsAndExports.js").AddExportOptions[] | undefined) | undefined;
+export default _default;

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

@@ -0,0 +1,8 @@
+import ts from 'typescript';
+import { SymbolType } from '../../../types/issues.js';
+import { exportVisitor as visit } from '../index.js';
+export default visit(() => true, node => {
+    if (ts.isExportAssignment(node)) {
+        return { node, identifier: 'default', type: SymbolType.UNKNOWN, pos: node.expression.getStart() };
+    }
+});

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("../../getImportsAndExports.js").GetImportsAndExportsOptions) => import("../../getImportsAndExports.js").AddExportOptions | import("../../getImportsAndExports.js").AddExportOptions[] | undefined) | undefined;
+export default _default;

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

@@ -0,0 +1,13 @@
+import ts from 'typescript';
+import { SymbolType } from '../../../types/issues.js';
+import { exportVisitor as visit } from '../index.js';
+export default visit(() => true, node => {
+    if (ts.isExportDeclaration(node)) {
+        if (node.exportClause && ts.isNamedExports(node.exportClause)) {
+            const type = node.isTypeOnly ? SymbolType.TYPE : SymbolType.UNKNOWN;
+            return node.exportClause.elements.map(element => {
+                return { node: element, identifier: element.name.getText(), type, pos: element.name.pos };
+            });
+        }
+    }
+});

package/dist/typescript/visitors/exports/exportKeyword.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").AddExportOptions | import("../../getImportsAndExports.js").AddExportOptions[] | undefined) | undefined;
+export default _default;

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

@@ -0,0 +1,77 @@
+import ts from 'typescript';
+import { SymbolType } from '../../../types/issues.js';
+import { compact } from '../../../util/array.js';
+import { isPrivateMember, stripQuotes } from '../../ast-helpers.js';
+import { exportVisitor as visit } from '../index.js';
+export default visit(() => true, node => {
+    const modifierKinds = node.modifiers?.map(modifier => modifier.kind) ?? [];
+    if (modifierKinds.includes(ts.SyntaxKind.ExportKeyword)) {
+        if (ts.isVariableStatement(node)) {
+            return node.declarationList.declarations.flatMap(declaration => {
+                if (ts.isObjectBindingPattern(declaration.name)) {
+                    return compact(declaration.name.elements.map(element => {
+                        if (ts.isIdentifier(element.name)) {
+                            return {
+                                node: element,
+                                identifier: element.name.escapedText.toString(),
+                                type: SymbolType.UNKNOWN,
+                                pos: element.name.getStart(),
+                            };
+                        }
+                    }));
+                }
+                else if (ts.isArrayBindingPattern(declaration.name)) {
+                    return compact(declaration.name.elements.map(element => {
+                        if (ts.isBindingElement(element)) {
+                            return {
+                                node: element,
+                                identifier: element.getText(),
+                                type: SymbolType.UNKNOWN,
+                                pos: element.getStart(),
+                            };
+                        }
+                    }));
+                }
+                else {
+                    const identifier = declaration.name.getText();
+                    return { node: declaration, identifier, type: SymbolType.UNKNOWN, pos: declaration.name.getStart() };
+                }
+            });
+        }
+        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();
+            return { 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)) && !isPrivateMember(member))
+                .map(member => ({
+                node: member,
+                identifier: member.name.getText(),
+                pos: member.name.getStart(),
+                type: SymbolType.MEMBER,
+            }));
+            return { node, identifier, type: SymbolType.CLASS, pos, members };
+        }
+        if (ts.isTypeAliasDeclaration(node)) {
+            return { node, identifier: node.name.getText(), type: SymbolType.TYPE, pos: node.name.getStart() };
+        }
+        if (ts.isInterfaceDeclaration(node)) {
+            return { 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: stripQuotes(member.name.getText()),
+                pos: member.name.getStart(),
+                type: SymbolType.MEMBER,
+            }));
+            return { node, identifier, type: SymbolType.ENUM, pos, members };
+        }
+    }
+});

package/dist/typescript/visitors/exports/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) => import("../../getImportsAndExports.js").AddExportOptions | import("../../getImportsAndExports.js").AddExportOptions[] | undefined) | undefined)[];
+export default _default;

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

@@ -0,0 +1,6 @@
+import exportAssignment from './exportAssignment.js';
+import exportDeclaration from './exportDeclaration.js';
+import exportKeyword from './exportKeyword.js';
+import moduleExportsAccessExpression from './moduleExportsAccessExpression.js';
+const visitors = [exportAssignment, exportDeclaration, exportKeyword, moduleExportsAccessExpression];
+export default (sourceFile) => visitors.map(v => v(sourceFile)).filter(v => v);

package/dist/typescript/visitors/exports/moduleExportsAccessExpression.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").AddExportOptions | import("../../getImportsAndExports.js").AddExportOptions[] | undefined) | undefined;
+export default _default;

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

@@ -0,0 +1,31 @@
+import ts from 'typescript';
+import { SymbolType } from '../../../types/issues.js';
+import { isModuleExportsAccessExpression, stripQuotes } from '../../ast-helpers.js';
+import { isJS } from '../helpers.js';
+import { exportVisitor as visit } from '../index.js';
+export default visit(isJS, node => {
+    if (isModuleExportsAccessExpression(node)) {
+        const parent = node.parent;
+        if (ts.isPropertyAccessExpression(parent)) {
+            const identifier = parent.name.getText();
+            const pos = parent.name.getStart();
+            return { node, identifier, type: SymbolType.UNKNOWN, pos };
+        }
+        else if (ts.isElementAccessExpression(parent)) {
+            const identifier = stripQuotes(parent.argumentExpression.getText());
+            const pos = parent.argumentExpression.getStart();
+            return { node, identifier, type: SymbolType.UNKNOWN, pos };
+        }
+        else if (ts.isBinaryExpression(parent)) {
+            const expr = parent.right;
+            if (ts.isObjectLiteralExpression(expr) && expr.properties.every(ts.isShorthandPropertyAssignment)) {
+                return expr.properties.map(node => {
+                    return { node, identifier: node.getText(), type: SymbolType.UNKNOWN, pos: node.pos };
+                });
+            }
+            else {
+                return { node, identifier: 'default', type: SymbolType.UNKNOWN, pos: node.getStart() };
+            }
+        }
+    }
+});

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

@@ -0,0 +1,3 @@
+import { BoundSourceFile } from '../SourceFile.js';
+export declare const isNotJS: (sourceFile: BoundSourceFile) => boolean;
+export declare const isJS: (sourceFile: BoundSourceFile) => boolean;

package/dist/typescript/visitors/helpers.js

@@ -0,0 +1,3 @@
+import ts from 'typescript';
+export const isNotJS = (sourceFile) => sourceFile.scriptKind !== ts.ScriptKind.JS && sourceFile.scriptKind !== ts.ScriptKind.JSX;
+export const isJS = (sourceFile) => sourceFile.scriptKind === ts.ScriptKind.JS || sourceFile.scriptKind === ts.ScriptKind.JSX;

package/dist/typescript/visitors/imports/importCall.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/importCall.js

@@ -0,0 +1,38 @@
+import ts from 'typescript';
+import { isImportCall, isAccessExpression, getAccessExpressionName, isVariableDeclarationList, findDescendants, } from '../../ast-helpers.js';
+import { importVisitor as visit } from '../index.js';
+export default visit(() => true, node => {
+    if (isImportCall(node)) {
+        if (node.arguments[0] && ts.isStringLiteralLike(node.arguments[0])) {
+            const specifier = node.arguments[0].text;
+            let _node = node.parent;
+            while (_node) {
+                if (_node.parent && ts.isCallExpression(_node.parent)) {
+                    return { specifier, identifier: 'default' };
+                }
+                if (isAccessExpression(_node)) {
+                    const identifier = getAccessExpressionName(_node);
+                    const isPromiseLike = identifier === 'then';
+                    const symbol = isPromiseLike ? 'default' : identifier;
+                    return { identifier: symbol, specifier };
+                }
+                if (isVariableDeclarationList(_node)) {
+                    return findDescendants(_node, ts.isVariableDeclaration).flatMap(variableDeclaration => {
+                        if (ts.isIdentifier(variableDeclaration.name)) {
+                            return { identifier: 'default', specifier };
+                        }
+                        else {
+                            const binds = findDescendants(variableDeclaration, _node => ts.isBindingElement(_node));
+                            return binds.flatMap(element => {
+                                const symbol = element.propertyName?.getText() || element.name.getText();
+                                return { identifier: symbol, specifier };
+                            });
+                        }
+                    });
+                }
+                _node = _node.parent;
+            }
+            return { specifier };
+        }
+    }
+});

package/dist/typescript/visitors/imports/importDeclaration.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/importDeclaration.js

@@ -0,0 +1,32 @@
+import ts from 'typescript';
+import { isDefaultImport } from '../../ast-helpers.js';
+import { importVisitor as visit } from '../index.js';
+export default visit(() => true, (node, options) => {
+    if (ts.isImportDeclaration(node) && ts.isStringLiteralLike(node.moduleSpecifier)) {
+        const specifier = node.moduleSpecifier.text;
+        if (!node.importClause) {
+            return { specifier };
+        }
+        else {
+            if (node.importClause.isTypeOnly && options.skipTypeOnly)
+                return;
+            const imports = [];
+            if (isDefaultImport(node)) {
+                imports.push({ specifier, identifier: 'default' });
+            }
+            if (node.importClause?.namedBindings) {
+                if (ts.isNamespaceImport(node.importClause.namedBindings)) {
+                    const symbol = node.importClause.namedBindings.symbol;
+                    imports.push({ symbol, specifier, identifier: '*' });
+                }
+                if (ts.isNamedImports(node.importClause.namedBindings)) {
+                    node.importClause.namedBindings.elements.forEach(element => {
+                        const identifier = (element.propertyName ?? element.name).getText();
+                        imports.push({ symbol: element.symbol, specifier, identifier });
+                    });
+                }
+            }
+            return imports;
+        }
+    }
+});

package/dist/typescript/visitors/imports/importEqualsDeclaration.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/importEqualsDeclaration.js

@@ -0,0 +1,11 @@
+import ts from 'typescript';
+import { isNotJS } from '../helpers.js';
+import { importVisitor as visit } from '../index.js';
+export default visit(isNotJS, node => {
+    if (ts.isImportEqualsDeclaration(node) &&
+        ts.isExternalModuleReference(node.moduleReference) &&
+        ts.isStringLiteralLike(node.moduleReference.expression)) {
+        const specifier = node.moduleReference.expression.text;
+        return { specifier, identifier: 'default' };
+    }
+});

package/dist/typescript/visitors/imports/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) => import("../../getImportsAndExports.js").AddImportOptions | import("../../getImportsAndExports.js").AddImportOptions[] | undefined) | undefined)[];
+export default _default;

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

@@ -0,0 +1,17 @@
+import importCall from './importCall.js';
+import importDeclaration from './importDeclaration.js';
+import importEqualsDeclaration from './importEqualsDeclaration.js';
+import jsDocType from './jsDocType.js';
+import reExportDeclaration from './reExportDeclaration.js';
+import requireCall from './requireCall.js';
+import requireResolveCall from './requireResolveCall.js';
+const visitors = [
+    importCall,
+    importDeclaration,
+    importEqualsDeclaration,
+    jsDocType,
+    reExportDeclaration,
+    requireCall,
+    requireResolveCall,
+];
+export default (sourceFile) => visitors.map(v => v(sourceFile)).filter(v => v);

package/dist/typescript/visitors/imports/jsDocType.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/jsDocType.js

@@ -0,0 +1,11 @@
+import ts from 'typescript';
+import { isValidImportTypeNode } from '../../ast-helpers.js';
+import { importVisitor as visit } from '../index.js';
+export default visit(() => true, node => {
+    if ('jsDoc' in node) {
+        const type = ts.getJSDocType(node);
+        if (type && isValidImportTypeNode(type)) {
+            return { specifier: type.argument.literal.text };
+        }
+    }
+});

package/dist/typescript/visitors/imports/reExportDeclaration.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/reExportDeclaration.js

@@ -0,0 +1,21 @@
+import ts from 'typescript';
+import { importVisitor as visit } from '../index.js';
+export default visit(() => true, node => {
+    if (ts.isExportDeclaration(node)) {
+        if (node.moduleSpecifier && ts.isStringLiteralLike(node.moduleSpecifier)) {
+            if (!node.exportClause) {
+                return { identifier: '*', specifier: node.moduleSpecifier.text };
+            }
+            else if (node.exportClause.kind === ts.SyntaxKind.NamespaceExport) {
+                return { identifier: '*', specifier: node.moduleSpecifier.text };
+            }
+            else {
+                const specifier = node.moduleSpecifier;
+                return node.exportClause.elements.map(element => {
+                    const identifier = (element.propertyName ?? element.name).getText();
+                    return { identifier, specifier: specifier.text };
+                });
+            }
+        }
+    }
+});

package/dist/typescript/visitors/imports/requireCall.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/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[]];