knip 0.0.0-angular.0

package/dist/typescript/ast-helpers.js

@@ -0,0 +1,101 @@
+import ts from 'typescript';
+export function isValidImportTypeNode(node) {
+    return ts.isImportTypeNode(node);
+}
+export function isPrivateMember(node) {
+    return node.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.PrivateKeyword) ?? false;
+}
+export function isDefaultImport(node) {
+    return node.kind === ts.SyntaxKind.ImportDeclaration && !!node.importClause && !!node.importClause.name;
+}
+export function isAccessExpression(node) {
+    return ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node);
+}
+export function isImportCall(node) {
+    return (node.kind === ts.SyntaxKind.CallExpression &&
+        node.expression.kind === ts.SyntaxKind.ImportKeyword);
+}
+export function isRequireCall(callExpression) {
+    if (callExpression.kind !== ts.SyntaxKind.CallExpression) {
+        return false;
+    }
+    const { expression, arguments: args } = callExpression;
+    if (expression.kind !== ts.SyntaxKind.Identifier || expression.escapedText !== 'require') {
+        return false;
+    }
+    return args.length === 1;
+}
+export function isRequireResolveCall(node) {
+    return (ts.isCallExpression(node) &&
+        ts.isPropertyAccessExpression(node.expression) &&
+        node.expression.getText() === 'require.resolve');
+}
+export function getAccessExpressionName(node) {
+    return 'argumentExpression' in node ? stripQuotes(node.argumentExpression.getText()) : node.name.getText();
+}
+export function isModuleExportsAccessExpression(node) {
+    return ((ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node)) &&
+        ts.isIdentifier(node.expression) &&
+        node.expression.escapedText === 'module' &&
+        getAccessExpressionName(node) === 'exports');
+}
+export function stripQuotes(name) {
+    const length = name.length;
+    if (length >= 2 && name.charCodeAt(0) === name.charCodeAt(length - 1) && isQuoteOrBacktick(name.charCodeAt(0))) {
+        return name.substring(1, length - 1);
+    }
+    return name;
+}
+var CharacterCodes;
+(function (CharacterCodes) {
+    CharacterCodes[CharacterCodes["backtick"] = 96] = "backtick";
+    CharacterCodes[CharacterCodes["doubleQuote"] = 34] = "doubleQuote";
+    CharacterCodes[CharacterCodes["singleQuote"] = 39] = "singleQuote";
+})(CharacterCodes || (CharacterCodes = {}));
+function isQuoteOrBacktick(charCode) {
+    return (charCode === CharacterCodes.singleQuote ||
+        charCode === CharacterCodes.doubleQuote ||
+        charCode === CharacterCodes.backtick);
+}
+export function findAncestor(node, callback) {
+    node = node?.parent;
+    while (node) {
+        const result = callback(node);
+        if (result === 'STOP') {
+            return undefined;
+        }
+        else if (result) {
+            return node;
+        }
+        node = node.parent;
+    }
+    return undefined;
+}
+export function findDescendants(node, callback) {
+    const results = [];
+    if (!node)
+        return results;
+    function visit(node) {
+        const result = callback(node);
+        if (result === 'STOP') {
+            return;
+        }
+        else if (result) {
+            results.push(node);
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(node);
+    return results;
+}
+export const isDeclarationFileExtension = (extension) => extension === '.d.ts' || extension === '.d.mts' || extension === '.d.cts';
+export const isInModuleBlock = (node) => {
+    node = node?.parent;
+    while (node) {
+        if (ts.isModuleBlock(node))
+            return true;
+        node = node.parent;
+    }
+    return false;
+};
+export const getJSDocTags = (node) => ts.getJSDocTags(node).map(node => node.getText().match(/@\S+/)[0]);

package/dist/typescript/createHosts.d.ts

@@ -0,0 +1,15 @@
+import ts from 'typescript';
+import { SourceFileManager } from './SourceFileManager.js';
+import type { SyncCompilers, AsyncCompilers } from '../types/compilers.js';
+type CreateHostsOptions = {
+    cwd: string;
+    compilerOptions: ts.CompilerOptions;
+    entryPaths: Set<string>;
+    compilers: [SyncCompilers, AsyncCompilers];
+};
+export declare const createHosts: ({ cwd, compilerOptions, entryPaths, compilers }: CreateHostsOptions) => {
+    fileManager: SourceFileManager;
+    languageServiceHost: ts.LanguageServiceHost;
+    compilerHost: ts.CompilerHost;
+};
+export {};

package/dist/typescript/createHosts.js

@@ -0,0 +1,39 @@
+import { EOL } from 'node:os';
+import path from 'node:path';
+import ts from 'typescript';
+import { createCustomModuleResolver } from './resolveModuleNames.js';
+import { SourceFileManager } from './SourceFileManager.js';
+import { createCustomSys } from './sys.js';
+const libLocation = path.dirname(ts.getDefaultLibFilePath({}));
+const fileManager = new SourceFileManager();
+export const createHosts = ({ cwd, compilerOptions, entryPaths, compilers }) => {
+    fileManager.installCompilers(compilers);
+    const virtualFileExtensions = [...compilers[0].keys(), ...compilers[1].keys()];
+    const sys = createCustomSys(cwd, virtualFileExtensions);
+    const resolveModuleNames = createCustomModuleResolver(sys, compilerOptions, virtualFileExtensions);
+    const languageServiceHost = {
+        getCompilationSettings: () => compilerOptions,
+        getScriptFileNames: () => Array.from(entryPaths),
+        getScriptVersion: () => '0',
+        getScriptSnapshot: (fileName) => fileManager.getSnapshot(fileName),
+        getCurrentDirectory: sys.getCurrentDirectory,
+        getDefaultLibFileName: ts.getDefaultLibFilePath,
+        readFile: sys.readFile,
+        fileExists: sys.fileExists,
+        resolveModuleNames,
+    };
+    const compilerHost = {
+        writeFile: () => undefined,
+        getDefaultLibLocation: () => libLocation,
+        getDefaultLibFileName: languageServiceHost.getDefaultLibFileName,
+        getSourceFile: (fileName) => fileManager.getSourceFile(fileName),
+        getCurrentDirectory: languageServiceHost.getCurrentDirectory,
+        getCanonicalFileName: (fileName) => fileName,
+        useCaseSensitiveFileNames: () => true,
+        getNewLine: () => EOL,
+        readFile: languageServiceHost.readFile,
+        fileExists: languageServiceHost.fileExists,
+        resolveModuleNames: languageServiceHost.resolveModuleNames,
+    };
+    return { fileManager, languageServiceHost, compilerHost };
+};

package/dist/typescript/getImportsAndExports.d.ts

@@ -0,0 +1,29 @@
+import ts from 'typescript';
+import type { BoundSourceFile } from './SourceFile.js';
+import type { ExportItems as Exports, ExportItem } from '../types/exports.js';
+import type { Imports } from '../types/imports.js';
+export type GetImportsAndExportsOptions = {
+    skipTypeOnly: boolean;
+    skipExports: boolean;
+};
+export type AddImportOptions = {
+    specifier: string;
+    symbol?: ts.Symbol;
+    identifier?: string;
+    isReExport?: boolean;
+};
+export type AddExportOptions = ExportItem & {
+    identifier: string;
+};
+export declare const getImportsAndExports: (sourceFile: BoundSourceFile, options: GetImportsAndExportsOptions) => {
+    imports: {
+        internal: Imports;
+        external: Set<string>;
+        unresolved: Set<string>;
+    };
+    exports: {
+        exported: Exports;
+        duplicate: string[][];
+    };
+    scripts: Set<string>;
+};

package/dist/typescript/getImportsAndExports.js

@@ -0,0 +1,159 @@
+import { isBuiltin } from 'node:module';
+import ts from 'typescript';
+import { getOrSet } from '../util/map.js';
+import { isMaybePackageName } from '../util/modules.js';
+import { isInNodeModules } from '../util/path.js';
+import { isDeclarationFileExtension, isAccessExpression, getAccessExpressionName, getJSDocTags, } from './ast-helpers.js';
+import getExportVisitors from './visitors/exports/index.js';
+import { getJSXImplicitImportBase } from './visitors/helpers.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 jsxImport = getJSXImplicitImportBase(sourceFile);
+    if (jsxImport)
+        externalImports.add(jsxImport);
+    const visitors = getVisitors(sourceFile);
+    const addInternalImport = (options) => {
+        const { identifier, specifier, symbol, filePath, isReExport } = options;
+        const isStar = identifier === '*';
+        const internalImport = getOrSet(internalImports, filePath, {
+            specifier,
+            isStar,
+            isReExport,
+            isReExportedBy: new Set(),
+            symbols: new Set(),
+        });
+        if (isReExport) {
+            internalImport.isReExport = isReExport;
+            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 = (options) => {
+        const { specifier, symbol, identifier = '__anonymous', isReExport = false } = options;
+        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, isReExport });
+                    }
+                    if (!isMaybePackageName(specifier))
+                        return;
+                    if (isDeclarationFileExtension(module.resolvedModule.extension)) {
+                        externalImports.add(specifier);
+                    }
+                    else {
+                        externalImports.add(module.resolvedModule.packageId?.name ?? specifier);
+                    }
+                }
+                else {
+                    addInternalImport({ identifier, specifier, symbol, filePath, isReExport });
+                }
+            }
+        }
+        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;
+        const jsDocTags = getJSDocTags(node);
+        if (exports.has(identifier)) {
+            const item = exports.get(identifier);
+            const crew = [...item.members, ...members];
+            const tags = [...item.jsDocTags, ...jsDocTags];
+            exports.set(identifier, { ...item, node, type, pos, members: crew, jsDocTags: tags });
+        }
+        else {
+            exports.set(identifier, { node, type, pos, members, jsDocTags });
+        }
+        if (!jsDocTags.includes('@alias')) {
+            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);
+            }
+        }
+        for (const visitor of visitors.export) {
+            if (visitor) {
+                const results = visitor(node, options);
+                if (results)
+                    [results].flat().forEach(addExport);
+            }
+        }
+        for (const visitor of visitors.script) {
+            if (visitor) {
+                const results = visitor(node, options);
+                if (results)
+                    [results].flat().forEach(script => scripts.add(script));
+            }
+        }
+        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/resolveModuleNames.d.ts

@@ -0,0 +1,2 @@
+import ts from 'typescript';
+export declare function createCustomModuleResolver(customSys: typeof ts.sys, compilerOptions: ts.CompilerOptions, virtualFileExtensions: string[]): (moduleNames: string[], containingFile: string) => Array<ts.ResolvedModule | undefined>;

package/dist/typescript/resolveModuleNames.js

@@ -0,0 +1,27 @@
+import ts from 'typescript';
+import { ensureRealFilePath, isVirtualFilePath } from './utils.js';
+export function createCustomModuleResolver(customSys, compilerOptions, virtualFileExtensions) {
+    function resolveModuleNames(moduleNames, containingFile) {
+        return moduleNames.map(moduleName => resolveModuleName(moduleName, containingFile));
+    }
+    function resolveModuleName(name, containingFile) {
+        const tsResolvedModule = ts.resolveModuleName(name, containingFile, compilerOptions, ts.sys).resolvedModule;
+        if (virtualFileExtensions.length === 0)
+            return tsResolvedModule;
+        if (tsResolvedModule && !isVirtualFilePath(tsResolvedModule.resolvedFileName, virtualFileExtensions)) {
+            return tsResolvedModule;
+        }
+        const customResolvedModule = ts.resolveModuleName(name, containingFile, compilerOptions, customSys).resolvedModule;
+        if (!customResolvedModule || !isVirtualFilePath(customResolvedModule.resolvedFileName, virtualFileExtensions)) {
+            return customResolvedModule;
+        }
+        const resolvedFileName = ensureRealFilePath(customResolvedModule.resolvedFileName, virtualFileExtensions);
+        const resolvedModule = {
+            extension: ts.Extension.Js,
+            resolvedFileName,
+            isExternalLibraryImport: customResolvedModule.isExternalLibraryImport,
+        };
+        return resolvedModule;
+    }
+    return resolveModuleNames;
+}

package/dist/typescript/sys.d.ts

@@ -0,0 +1,35 @@
+import ts from 'typescript';
+export declare function createCustomSys(cwd: string, virtualFileExtensions: string[]): {
+    getCurrentDirectory: () => string;
+    args: string[];
+    newLine: string;
+    useCaseSensitiveFileNames: boolean;
+    write(s: string): void;
+    writeOutputIsTTY?(): boolean;
+    getWidthOfTerminal?(): number;
+    readFile(path: string, encoding?: string | undefined): string | undefined;
+    getFileSize?(path: string): number;
+    writeFile(path: string, data: string, writeByteOrderMark?: boolean | undefined): void;
+    watchFile?(path: string, callback: ts.FileWatcherCallback, pollingInterval?: number | undefined, options?: ts.WatchOptions | undefined): ts.FileWatcher;
+    watchDirectory?(path: string, callback: ts.DirectoryWatcherCallback, recursive?: boolean | undefined, options?: ts.WatchOptions | undefined): ts.FileWatcher;
+    resolvePath(path: string): string;
+    fileExists(path: string): boolean;
+    directoryExists(path: string): boolean;
+    createDirectory(path: string): void;
+    getExecutingFilePath(): string;
+    getDirectories(path: string): string[];
+    readDirectory(path: string, extensions?: readonly string[] | undefined, exclude?: readonly string[] | undefined, include?: readonly string[] | undefined, depth?: number | undefined): string[];
+    getModifiedTime?(path: string): Date | undefined;
+    setModifiedTime?(path: string, time: Date): void;
+    deleteFile?(path: string): void;
+    createHash?(data: string): string;
+    createSHA256Hash?(data: string): string;
+    getMemoryUsage?(): number;
+    exit(exitCode?: number | undefined): void;
+    realpath?(path: string): string;
+    setTimeout?(callback: (...args: any[]) => void, ms: number, ...args: any[]): any;
+    clearTimeout?(timeoutId: any): void;
+    clearScreen?(): void;
+    base64decode?(input: string): string;
+    base64encode?(input: string): string;
+};

package/dist/typescript/sys.js

@@ -0,0 +1,16 @@
+import ts from 'typescript';
+import { ensureRealFilePath } from './utils.js';
+export function createCustomSys(cwd, virtualFileExtensions) {
+    const sys = {
+        ...ts.sys,
+        getCurrentDirectory: () => cwd,
+    };
+    if (virtualFileExtensions.length === 0)
+        return sys;
+    return {
+        ...sys,
+        fileExists(path) {
+            return ts.sys.fileExists(ensureRealFilePath(path, virtualFileExtensions));
+        },
+    };
+}

package/dist/typescript/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function isVirtualFilePath(filePath: string, extensions: string[]): boolean;
+export declare function ensureRealFilePath(filePath: string, extensions: string[]): string;

package/dist/typescript/utils.js

@@ -0,0 +1,9 @@
+function toRealFilePath(filePath) {
+    return filePath.slice(0, -'.ts'.length);
+}
+export function isVirtualFilePath(filePath, extensions) {
+    return extensions.some(extension => filePath.endsWith(`${extension}.ts`));
+}
+export function ensureRealFilePath(filePath, extensions) {
+    return isVirtualFilePath(filePath, extensions) ? toRealFilePath(filePath) : filePath;
+}

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,9 @@
+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)) {
+        const pos = node.getChildAt(1).getStart();
+        return { node, identifier: 'default', type: SymbolType.UNKNOWN, pos };
+    }
+});

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

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,4 @@
+import type { BoundSourceFile } from '../SourceFile.js';
+export declare const isNotJS: (sourceFile: BoundSourceFile) => boolean;
+export declare const isJS: (sourceFile: BoundSourceFile) => boolean;
+export declare function getJSXImplicitImportBase(sourceFile: BoundSourceFile): string | undefined;

package/dist/typescript/visitors/helpers.js

@@ -0,0 +1,10 @@
+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;
+export function getJSXImplicitImportBase(sourceFile) {
+    const jsxImportSourcePragmas = sourceFile.pragmas?.get('jsximportsource');
+    const jsxImportSourcePragma = Array.isArray(jsxImportSourcePragmas)
+        ? jsxImportSourcePragmas[jsxImportSourcePragmas.length - 1]
+        : jsxImportSourcePragmas;
+    return jsxImportSourcePragma?.arguments.factory;
+}

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,11 @@
+import ts from 'typescript';
+import { isImportCall } 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;
+            return { specifier, identifier: 'default' };
+        }
+    }
+});

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;