knip 0.0.0-angular.0

package/dist/reporters/compact.js

@@ -0,0 +1,36 @@
+import { getTitle, logTitle, logIssueLine, logIssueSet } from './util.js';
+const logIssueRecord = (issues) => {
+    const sortedByFilePath = issues.sort((a, b) => (a.filePath > b.filePath ? 1 : -1));
+    sortedByFilePath.forEach(logIssueLine);
+};
+export default ({ report, issues, isShowProgress }) => {
+    const reportMultipleGroups = Object.values(report).filter(Boolean).length > 1;
+    let totalIssues = 0;
+    for (const [reportType, isReportType] of Object.entries(report)) {
+        if (isReportType) {
+            const title = reportMultipleGroups && getTitle(reportType);
+            const isSet = issues[reportType] instanceof Set;
+            const issuesForType = isSet
+                ? Array.from(issues[reportType])
+                : reportType === 'duplicates'
+                    ? Object.values(issues[reportType]).map(Object.values).flat()
+                    : Object.values(issues[reportType]).map(issues => {
+                        const items = Object.values(issues);
+                        return { ...items[0], symbols: items.map(issue => issue.symbol) };
+                    });
+            if (issuesForType.length > 0) {
+                title && logTitle(title, issuesForType.length);
+                if (isSet) {
+                    logIssueSet(Array.from(issues[reportType]));
+                }
+                else {
+                    logIssueRecord(issuesForType);
+                }
+            }
+            totalIssues = totalIssues + issuesForType.length;
+        }
+    }
+    if (totalIssues === 0 && isShowProgress) {
+        console.log('✂️  Excellent, Knip found no issues.');
+    }
+};

package/dist/reporters/index.d.ts

@@ -0,0 +1,7 @@
+declare const _default: {
+    symbols: ({ report, issues, configurationHints, noConfigHints, isShowProgress }: import("../index.js").ReporterOptions) => void;
+    compact: ({ report, issues, isShowProgress }: import("../index.js").ReporterOptions) => void;
+    codeowners: ({ report, issues, isShowProgress, options }: import("../index.js").ReporterOptions) => void;
+    json: ({ report, issues, options }: import("../index.js").ReporterOptions) => Promise<void>;
+};
+export default _default;

package/dist/reporters/index.js

@@ -0,0 +1,10 @@
+import codeowners from './codeowners.js';
+import compact from './compact.js';
+import json from './json.js';
+import symbols from './symbols.js';
+export default {
+    symbols,
+    compact,
+    codeowners,
+    json,
+};

package/dist/reporters/json.d.ts

@@ -0,0 +1,3 @@
+import type { ReporterOptions } from '../types/issues.js';
+declare const _default: ({ report, issues, options }: ReporterOptions) => Promise<void>;
+export default _default;

package/dist/reporters/json.js

@@ -0,0 +1,67 @@
+import { OwnershipEngine } from '@snyk/github-codeowners/dist/lib/ownership/index.js';
+import { isFile } from '../util/fs.js';
+import { relative, resolve } from '../util/path.js';
+const mergeTypes = (type) => type === 'exports' || type === 'nsExports' ? 'exports' : type === 'types' || type === 'nsTypes' ? 'types' : type;
+export default async ({ report, issues, options }) => {
+    let opts = {};
+    try {
+        opts = options ? JSON.parse(options) : opts;
+    }
+    catch (error) {
+        console.error(error);
+    }
+    const json = {};
+    const codeownersFilePath = resolve(opts.codeowners ?? '.github/CODEOWNERS');
+    const codeownersEngine = isFile(codeownersFilePath) && OwnershipEngine.FromCodeownersFile(codeownersFilePath);
+    const flatten = (issues) => Object.values(issues).map(Object.values).flat();
+    const initRow = (filePath) => {
+        const file = relative(filePath);
+        const row = {
+            file,
+            ...(codeownersEngine && { owners: codeownersEngine.calcFileOwnership(file) }),
+            ...(report.files && { files: false }),
+            ...(report.dependencies && { dependencies: [] }),
+            ...(report.devDependencies && { devDependencies: [] }),
+            ...(report.optionalPeerDependencies && { optionalPeerDependencies: [] }),
+            ...(report.unlisted && { unlisted: [] }),
+            ...(report.unresolved && { unresolved: [] }),
+            ...((report.exports || report.nsExports) && { exports: [] }),
+            ...((report.types || report.nsTypes) && { types: [] }),
+            ...(report.enumMembers && { enumMembers: {} }),
+            ...(report.classMembers && { classMembers: {} }),
+            ...(report.duplicates && { duplicates: [] }),
+        };
+        return row;
+    };
+    for (const [reportType, isReportType] of Object.entries(report)) {
+        if (isReportType) {
+            if (reportType === 'files') {
+                Array.from(issues[reportType]).forEach(filePath => {
+                    json[filePath] = json[filePath] ?? initRow(filePath);
+                    json[filePath][reportType] = true;
+                });
+            }
+            else {
+                const type = mergeTypes(reportType);
+                flatten(issues[reportType]).forEach(issue => {
+                    const { filePath, symbol, symbols, parentSymbol } = issue;
+                    json[filePath] = json[filePath] ?? initRow(filePath);
+                    if (type === 'duplicates') {
+                        symbols && json[filePath][type]?.push(symbols);
+                    }
+                    else if (type === 'enumMembers' || type === 'classMembers') {
+                        const item = json[filePath][type];
+                        if (parentSymbol && item) {
+                            item[parentSymbol] = item[parentSymbol] ?? [];
+                            item[parentSymbol].push(symbol);
+                        }
+                    }
+                    else {
+                        json[filePath][type]?.push(symbol);
+                    }
+                });
+            }
+        }
+    }
+    console.log(JSON.stringify(Object.values(json)));
+};

package/dist/reporters/symbols.d.ts

@@ -0,0 +1,3 @@
+import type { ReporterOptions } from '../types/issues.js';
+declare const _default: ({ report, issues, configurationHints, noConfigHints, isShowProgress }: ReporterOptions) => void;
+export default _default;

package/dist/reporters/symbols.js

@@ -0,0 +1,54 @@
+import chalk from 'chalk';
+import EasyTable from 'easy-table';
+import { ROOT_WORKSPACE_NAME } from '../constants.js';
+import { relative } from '../util/path.js';
+import { getTitle, logTitle, logIssueSet, identity } from './util.js';
+const TRUNCATE_WIDTH = 40;
+const truncate = (text) => (text.length > TRUNCATE_WIDTH ? text.slice(0, TRUNCATE_WIDTH - 3) + '...' : text);
+const logIssueRecord = (issues) => {
+    const table = new EasyTable();
+    issues.forEach(issue => {
+        const print = issue.severity === 'warn' ? chalk.grey : identity;
+        table.cell('symbol', print(issue.symbols ? truncate(issue.symbols.join(', ')) : issue.symbol));
+        issue.parentSymbol && table.cell('parentSymbol', print(issue.parentSymbol));
+        issue.symbolType && table.cell('symbolType', print(issue.symbolType));
+        table.cell('filePath', print(relative(issue.filePath)));
+        table.newRow();
+    });
+    console.log(table.sort(['filePath', 'parentSymbol', 'symbol']).print().trim());
+};
+export default ({ report, issues, configurationHints, noConfigHints, isShowProgress }) => {
+    const reportMultipleGroups = Object.values(report).filter(Boolean).length > 1;
+    let totalIssues = 0;
+    for (const [reportType, isReportType] of Object.entries(report)) {
+        if (isReportType) {
+            const title = reportMultipleGroups && getTitle(reportType);
+            const isSet = issues[reportType] instanceof Set;
+            const issuesForType = isSet
+                ? Array.from(issues[reportType])
+                : Object.values(issues[reportType]).map(Object.values).flat();
+            if (issuesForType.length > 0) {
+                title && logTitle(title, issuesForType.length);
+                if (isSet) {
+                    logIssueSet(issuesForType);
+                }
+                else {
+                    logIssueRecord(issuesForType);
+                }
+            }
+            totalIssues = totalIssues + issuesForType.length;
+        }
+    }
+    if (!noConfigHints && configurationHints.size > 0) {
+        logTitle('Configuration issues', configurationHints.size);
+        configurationHints.forEach(hint => {
+            const { type, workspaceName, identifier } = hint;
+            const message = `Unused item in ${type}`;
+            const workspace = workspaceName && workspaceName !== ROOT_WORKSPACE_NAME ? ` (workspace: ${workspaceName})` : ``;
+            console.warn(chalk.grey(`${message}${workspace}:`), identifier);
+        });
+    }
+    if (totalIssues === 0 && isShowProgress) {
+        console.log('✂️  Excellent, Knip found no issues.');
+    }
+};

package/dist/reporters/util.d.ts

@@ -0,0 +1,15 @@
+import { ISSUE_TYPE_TITLE } from '../constants.js';
+import type { IssueSeverity } from '../types/issues.js';
+export declare const identity: (text: string) => string;
+export declare const getTitle: (reportType: keyof typeof ISSUE_TYPE_TITLE) => string;
+export declare const logTitle: (title: string, count: number) => void;
+type LogIssueLine = {
+    owner?: string;
+    filePath: string;
+    symbols?: string[];
+    parentSymbol?: string;
+    severity?: IssueSeverity;
+};
+export declare const logIssueLine: ({ owner, filePath, symbols, parentSymbol, severity }: LogIssueLine) => void;
+export declare const logIssueSet: (issues: string[]) => void;
+export {};

package/dist/reporters/util.js

@@ -0,0 +1,17 @@
+import chalk from 'chalk';
+import { ISSUE_TYPE_TITLE } from '../constants.js';
+import { toRelative, relative } from '../util/path.js';
+export const identity = (text) => text;
+export const getTitle = (reportType) => {
+    return ISSUE_TYPE_TITLE[reportType];
+};
+export const logTitle = (title, count) => console.log(`${chalk.bold.yellow.underline(title)} (${count})`);
+export const logIssueLine = ({ owner, filePath, symbols, parentSymbol, severity }) => {
+    const symbol = symbols ? `: ${symbols.join(', ')}` : '';
+    const parent = parentSymbol ? ` (${parentSymbol})` : '';
+    const print = severity === 'warn' ? chalk.grey : identity;
+    console.log(`${owner ? `${chalk.cyan(owner)} ` : ''}${print(`${relative(filePath)}${symbol}${parent}`)}`);
+};
+export const logIssueSet = (issues) => {
+    issues.sort().forEach(value => console.log(toRelative(value)));
+};

package/dist/types/cli.d.ts

@@ -0,0 +1,10 @@
+export interface CommandLineOptions {
+    cwd: string;
+    tsConfigFile?: string;
+    gitignore: boolean;
+    isStrict: boolean;
+    isProduction: boolean;
+    isIgnoreInternal: boolean;
+    isShowProgress: boolean;
+    isIncludeEntryExports: boolean;
+}

package/dist/types/cli.js

@@ -0,0 +1 @@
+export {};

package/dist/types/compilers.d.ts

@@ -0,0 +1,6 @@
+type FileExtension = string;
+export type SyncCompilerFn = (source: string, path: string) => string;
+export type AsyncCompilerFn = (source: string, path: string) => Promise<string>;
+export type SyncCompilers = Map<FileExtension, SyncCompilerFn>;
+export type AsyncCompilers = Map<FileExtension, AsyncCompilerFn>;
+export {};

package/dist/types/compilers.js

@@ -0,0 +1 @@
+export {};

package/dist/types/config.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import { ConfigurationValidator } from '../ConfigurationValidator.js';
+import * as Plugins from '../plugins/index.js';
+import type { Rules } from './issues.js';
+import type { SyncCompilers, AsyncCompilers } from '../types/compilers.js';
+export type RawConfiguration = z.infer<typeof ConfigurationValidator>;
+type NormalizedGlob = string[];
+export type PluginName = keyof typeof Plugins;
+export type PluginConfiguration = {
+    config: NormalizedGlob | null;
+    entry: NormalizedGlob | null;
+    project: NormalizedGlob | null;
+} | false;
+type PluginsConfiguration = Record<PluginName, PluginConfiguration>;
+interface BaseWorkspaceConfiguration {
+    entry: NormalizedGlob;
+    project: NormalizedGlob;
+    paths: Record<string, string[]>;
+    ignore: NormalizedGlob;
+    ignoreBinaries: string[];
+    ignoreDependencies: string[];
+}
+export interface WorkspaceConfiguration extends BaseWorkspaceConfiguration, Partial<PluginsConfiguration> {
+}
+type IgnorableExport = 'class' | 'enum' | 'function' | 'interface' | 'member' | 'type';
+export interface Configuration {
+    rules: Rules;
+    include: string[];
+    exclude: string[];
+    ignore: NormalizedGlob;
+    ignoreBinaries: string[];
+    ignoreDependencies: string[];
+    ignoreExportsUsedInFile: boolean | Partial<Record<IgnorableExport, boolean>>;
+    ignoreWorkspaces: string[];
+    workspaces: Record<string, WorkspaceConfiguration>;
+    syncCompilers: SyncCompilers;
+    asyncCompilers: AsyncCompilers;
+}
+export {};

package/dist/types/config.js

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+import { ConfigurationValidator } from '../ConfigurationValidator.js';
+import * as Plugins from '../plugins/index.js';

package/dist/types/exports.d.ts

@@ -0,0 +1,20 @@
+import ts from 'typescript';
+import type { SymbolType } from './issues.js';
+type FilePath = string;
+type Identifier = string;
+export type ExportItem = {
+    node: ts.Node;
+    pos: number;
+    type: SymbolType;
+    members?: ExportItemMember[];
+    jsDocTags?: string[];
+};
+export type ExportItemMember = {
+    node: ts.Node;
+    identifier: Identifier;
+    pos: number;
+    type: SymbolType;
+};
+export type ExportItems = Map<string, Required<ExportItem>>;
+export type Exports = Map<FilePath, ExportItems>;
+export {};

package/dist/types/exports.js

@@ -0,0 +1 @@
+import ts from 'typescript';

package/dist/types/imports.d.ts

@@ -0,0 +1,13 @@
+type FilePath = string;
+type Specifier = string;
+type Identifier = string;
+type ImportItems = Set<Identifier>;
+export type ImportedModule = {
+    specifier: Specifier;
+    symbols: ImportItems;
+    isStar: boolean;
+    isReExport: boolean;
+    isReExportedBy: Set<string>;
+};
+export type Imports = Map<FilePath, ImportedModule>;
+export {};

package/dist/types/imports.js

@@ -0,0 +1 @@
+export {};

package/dist/types/issues.d.ts

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

package/dist/types/issues.js

@@ -0,0 +1,10 @@
+export var SymbolType;
+(function (SymbolType) {
+    SymbolType["TYPE"] = "type";
+    SymbolType["INTERFACE"] = "interface";
+    SymbolType["ENUM"] = "enum";
+    SymbolType["FUNCTION"] = "function";
+    SymbolType["CLASS"] = "class";
+    SymbolType["MEMBER"] = "member";
+    SymbolType["UNKNOWN"] = "unknown";
+})(SymbolType || (SymbolType = {}));

package/dist/types/plugins.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="npmcli__package-json" />
+import type { PluginConfiguration, WorkspaceConfiguration } from './config.js';
+import type { PackageJson } from '@npmcli/package-json';
+export type PackageJsonWithPlugins = PackageJson & Record<string, unknown>;
+type IsPluginEnabledCallbackOptions = {
+    cwd: string;
+    manifest: PackageJson;
+    dependencies: Set<string>;
+    config: WorkspaceConfiguration;
+};
+export type IsPluginEnabledCallback = (options: IsPluginEnabledCallbackOptions) => boolean | Promise<boolean>;
+type GenericPluginCallbackOptions = {
+    cwd: string;
+    manifest: PackageJsonWithPlugins;
+    config: PluginConfiguration;
+    isProduction: boolean;
+};
+export type GenericPluginCallback = (configFilePath: string, options: GenericPluginCallbackOptions) => Promise<string[]> | string[];
+export {};

package/dist/types/plugins.js

@@ -0,0 +1 @@
+export {};

package/dist/types/workspace.d.ts

@@ -0,0 +1,17 @@
+type WorkspaceManifest = {
+    workspaceDir: string;
+    manifestPath: string;
+    scripts: string[];
+    dependencies: string[];
+    peerDependencies: string[];
+    optionalPeerDependencies: string[];
+    optionalDependencies: string[];
+    devDependencies: string[];
+    allDependencies: string[];
+    ignoreDependencies: string[];
+    ignoreBinaries: string[];
+};
+export type WorkspaceManifests = Map<string, WorkspaceManifest>;
+export type PeerDependencies = Map<string, Set<string>>;
+export type InstalledBinaries = Map<string, Set<string>>;
+export {};

package/dist/types/workspace.js

@@ -0,0 +1 @@
+export {};

package/dist/typescript/SourceFile.d.ts

@@ -0,0 +1,18 @@
+import ts from 'typescript';
+type SymbolTable = Map<string, ts.Symbol>;
+type SymbolWithExports = ts.Symbol & {
+    exports?: SymbolTable;
+};
+type PragmaMap = {
+    arguments: {
+        factory: string;
+    };
+};
+export interface BoundSourceFile extends ts.SourceFile {
+    symbol?: SymbolWithExports;
+    resolvedModules?: ts.ModeAwareCache<ts.ResolvedModuleWithFailedLookupLocations>;
+    locals?: SymbolTable;
+    scriptKind?: ts.ScriptKind;
+    pragmas?: Map<string, PragmaMap | PragmaMap[]>;
+}
+export {};

package/dist/typescript/SourceFile.js

@@ -0,0 +1 @@
+import ts from 'typescript';

package/dist/typescript/SourceFileManager.d.ts

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

package/dist/typescript/SourceFileManager.js

@@ -0,0 +1,57 @@
+import ts from 'typescript';
+import { debugLog } from '../util/debug.js';
+import { extname, isInternal } from '../util/path.js';
+export class SourceFileManager {
+    sourceFileCache = new Map();
+    snapshotCache = new Map();
+    syncCompilers;
+    asyncCompilers;
+    installCompilers(compilers) {
+        this.syncCompilers = compilers[0];
+        this.asyncCompilers = compilers[1];
+    }
+    createSourceFile(filePath, contents) {
+        const setParentNodes = isInternal(filePath);
+        const sourceFile = ts.createSourceFile(filePath, contents, ts.ScriptTarget.Latest, setParentNodes);
+        this.sourceFileCache.set(filePath, sourceFile);
+        return sourceFile;
+    }
+    getSourceFile(filePath) {
+        if (this.sourceFileCache.has(filePath))
+            return this.sourceFileCache.get(filePath);
+        const contents = ts.sys.readFile(filePath);
+        if (typeof contents !== 'string') {
+            if (isInternal(filePath))
+                throw new Error(`Unable to read ${filePath}`);
+            return this.createSourceFile(filePath, '');
+        }
+        const ext = extname(filePath);
+        const compiler = this.syncCompilers?.get(ext);
+        const compiled = compiler ? compiler(contents, filePath) : contents;
+        if (compiler)
+            debugLog(`Compiled ${filePath}`);
+        return this.createSourceFile(filePath, compiled);
+    }
+    getSnapshot(filePath) {
+        if (this.snapshotCache.has(filePath))
+            return this.snapshotCache.get(filePath);
+        const sourceFile = this.getSourceFile(filePath);
+        if (!sourceFile)
+            return undefined;
+        const snapshot = ts.ScriptSnapshot.fromString(sourceFile.text);
+        this.snapshotCache.set(filePath, snapshot);
+        return snapshot;
+    }
+    async compileAndAddSourceFile(filePath) {
+        const contents = ts.sys.readFile(filePath);
+        if (typeof contents !== 'string')
+            throw new Error(`Unable to read ${filePath}`);
+        const ext = extname(filePath);
+        const compiler = this.asyncCompilers?.get(ext);
+        if (compiler) {
+            const compiled = await compiler(contents, filePath);
+            debugLog(`Compiled ${filePath}`);
+            this.createSourceFile(filePath, compiled);
+        }
+    }
+}

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

@@ -0,0 +1,27 @@
+import ts from 'typescript';
+interface ValidImportTypeNode extends ts.ImportTypeNode {
+    argument: ts.LiteralTypeNode & {
+        literal: ts.StringLiteral;
+    };
+}
+export declare function isValidImportTypeNode(node: ts.Node): node is ValidImportTypeNode;
+export declare function isPrivateMember(node: ts.MethodDeclaration | ts.PropertyDeclaration): boolean;
+export declare function isDefaultImport(node: ts.ImportDeclaration | ts.ImportEqualsDeclaration | ts.ExportDeclaration): boolean;
+export declare function isAccessExpression(node: ts.Node): node is ts.PropertyAccessExpression | ts.ElementAccessExpression;
+export declare function isImportCall(node: ts.Node): node is ts.ImportCall;
+export declare function isRequireCall(callExpression: ts.Node): callExpression is ts.CallExpression;
+export declare function isRequireResolveCall(node: ts.Node): node is ts.CallExpression;
+export declare function getAccessExpressionName(node: ts.PropertyAccessExpression | ts.ElementAccessExpression): string;
+type LiteralLikeElementAccessExpression = ts.ElementAccessExpression & ts.Declaration & {
+    readonly argumentExpression: ts.StringLiteralLike | ts.NumericLiteral;
+};
+export declare function isModuleExportsAccessExpression(node: ts.Node): node is LiteralLikeElementAccessExpression & {
+    expression: ts.Identifier;
+};
+export declare function stripQuotes(name: string): string;
+export declare function findAncestor<T>(node: ts.Node | undefined, callback: (element: ts.Node) => boolean | 'STOP'): T | undefined;
+export declare function findDescendants<T>(node: ts.Node | undefined, callback: (element: ts.Node) => boolean | 'STOP'): T[];
+export declare const isDeclarationFileExtension: (extension: string) => boolean;
+export declare const isInModuleBlock: (node: ts.Node) => boolean;
+export declare const getJSDocTags: (node: ts.Node) => string[];
+export {};