knip 0.11.2 → 0.12.0

package/dist/runner.js

@@ -1,29 +1,22 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.findIssues = void 0;
-const node_path_1 = __importDefault(require("node:path"));
-const ts_morph_1 = require("ts-morph");
-const ts_morph_helpers_1 = require("ts-morph-helpers");
-const project_1 = require("./util/project");
-const type_1 = require("./util/type");
-const dependencies_1 = require("./util/dependencies");
-const debug_1 = require("./util/debug");
-const progress_1 = require("./progress");
-async function findIssues(configuration) {
-    const { workingDir, report, isDev, jsDocOptions, debug } = configuration;
+import path from 'node:path';
+import { ts } from 'ts-morph';
+import { partitionSourceFiles, _findDuplicateExportedNames, _hasReferencingDefaultImport, _findReferencingNamespaceNodes, _getExportedDeclarations, _findReferences, } from './util/project.js';
+import { getType } from './util/type.js';
+import { getDependencyAnalyzer } from './util/dependencies.js';
+import { debugLogSourceFiles } from './util/debug.js';
+import { getCountersUpdater, getMessageUpdater } from './progress.js';
+export async function findIssues(configuration) {
+    const { workingDir, report, jsDocOptions, debug } = configuration;
     const { entryFiles, productionFiles, projectFiles, isIncludeEntryFiles } = configuration;
     const { manifestPath } = configuration;
-    const updateMessage = (0, progress_1.getMessageUpdater)(configuration);
-    const { getUnresolvedDependencies, getUnusedDependencies, getUnusedDevDependencies } = (0, dependencies_1.getDependencyAnalyzer)(configuration);
-    const [usedProductionFiles, unreferencedProductionFiles] = (0, project_1.partitionSourceFiles)(projectFiles, productionFiles);
-    const [usedEntryFiles, usedNonEntryFiles] = (0, project_1.partitionSourceFiles)(usedProductionFiles, entryFiles);
-    (0, debug_1.debugLogSourceFiles)(debug, 1, 'Used production files', usedProductionFiles);
-    (0, debug_1.debugLogSourceFiles)(debug, 1, 'Unreferenced production files', unreferencedProductionFiles);
-    (0, debug_1.debugLogSourceFiles)(debug, 1, 'Used entry files', usedEntryFiles);
-    (0, debug_1.debugLogSourceFiles)(debug, 1, 'Used non-entry files', usedNonEntryFiles);
+    const updateMessage = getMessageUpdater(configuration);
+    const { _findUnresolvedDependencies, getUnusedDependencies, getUnusedDevDependencies } = getDependencyAnalyzer(configuration);
+    const [usedProductionFiles, unreferencedProductionFiles] = partitionSourceFiles(projectFiles, productionFiles);
+    const [usedEntryFiles, usedNonEntryFiles] = partitionSourceFiles(usedProductionFiles, entryFiles);
+    debugLogSourceFiles(debug, 1, 'Used production files', usedProductionFiles);
+    debugLogSourceFiles(debug, 1, 'Unreferenced production files', unreferencedProductionFiles);
+    debugLogSourceFiles(debug, 1, 'Used entry files', usedEntryFiles);
+    debugLogSourceFiles(debug, 1, 'Used non-entry files', usedNonEntryFiles);
     const issues = {
         files: new Set(unreferencedProductionFiles.map(file => file.getFilePath())),
         dependencies: {},
@@ -48,10 +41,10 @@ async function findIssues(configuration) {
         processed: issues.files.size,
         total: projectFiles.length,
     };
-    const updateCounters = (0, progress_1.getCountersUpdater)(configuration, counters);
+    const updateCounters = getCountersUpdater(configuration, counters);
     const addSymbolIssue = (issueType, issue) => {
         const { filePath, symbol } = issue;
-        const key = node_path_1.default.relative(workingDir, filePath).replace(/\\/g, '/');
+        const key = path.relative(workingDir, filePath).replace(/\\/g, '/');
         issues[issueType][key] = issues[issueType][key] ?? {};
         issues[issueType][key][symbol] = issue;
         counters[issueType]++;
@@ -69,12 +62,11 @@ async function findIssues(configuration) {
             counters.processed++;
             const filePath = sourceFile.getFilePath();
             if (report.dependencies || report.unlisted) {
-                const unresolvedDependencies = getUnresolvedDependencies(sourceFile);
+                const unresolvedDependencies = _findUnresolvedDependencies(sourceFile);
                 unresolvedDependencies.forEach(issue => addSymbolIssue('unlisted', issue));
             }
-            const exportDeclarations = sourceFile.getExportedDeclarations();
             if (report.duplicates) {
-                const duplicateExports = (0, ts_morph_helpers_1.findDuplicateExportedNames)(sourceFile);
+                const duplicateExports = _findDuplicateExportedNames(sourceFile);
                 duplicateExports.forEach(symbols => {
                     const symbol = symbols.join('|');
                     addSymbolIssue('duplicates', { filePath, symbol, symbols });
@@ -83,6 +75,7 @@ async function findIssues(configuration) {
             if (!isIncludeEntryFiles && usedEntryFiles.includes(sourceFile))
                 return;
             if (report.exports || report.types || report.nsExports || report.nsTypes) {
+                const exportDeclarations = _getExportedDeclarations(sourceFile);
                 if (!isIncludeEntryFiles) {
                     const uniqueExportedSymbols = new Set([...exportDeclarations.values()].flat());
                     if (uniqueExportedSymbols.size === 1)
@@ -90,41 +83,41 @@ async function findIssues(configuration) {
                 }
                 exportDeclarations.forEach(declarations => {
                     declarations.forEach(declaration => {
-                        const type = (0, type_1.getType)(declaration);
+                        const type = getType(declaration);
                         if (!report.nsExports && !report.nsTypes) {
                             if (!report.types && type)
                                 return;
                             if (!report.exports && !type)
                                 return;
                         }
-                        if (jsDocOptions.isReadPublicTag && ts_morph_1.ts.getJSDocPublicTag(declaration.compilerNode))
+                        if (jsDocOptions.isReadPublicTag && ts.getJSDocPublicTag(declaration.compilerNode))
                             return;
                         let identifier;
                         let fakeIdentifier;
-                        if (declaration.isKind(ts_morph_1.ts.SyntaxKind.Identifier)) {
+                        if (declaration.isKind(ts.SyntaxKind.Identifier)) {
                             identifier = declaration;
                         }
-                        else if (declaration.isKind(ts_morph_1.ts.SyntaxKind.ArrowFunction) ||
-                            declaration.isKind(ts_morph_1.ts.SyntaxKind.ObjectLiteralExpression) ||
-                            declaration.isKind(ts_morph_1.ts.SyntaxKind.ArrayLiteralExpression) ||
-                            declaration.isKind(ts_morph_1.ts.SyntaxKind.StringLiteral) ||
-                            declaration.isKind(ts_morph_1.ts.SyntaxKind.NumericLiteral)) {
-                            if (!(0, ts_morph_helpers_1.hasReferencingDefaultImport)(sourceFile)) {
+                        else if (declaration.isKind(ts.SyntaxKind.ArrowFunction) ||
+                            declaration.isKind(ts.SyntaxKind.ObjectLiteralExpression) ||
+                            declaration.isKind(ts.SyntaxKind.ArrayLiteralExpression) ||
+                            declaration.isKind(ts.SyntaxKind.StringLiteral) ||
+                            declaration.isKind(ts.SyntaxKind.NumericLiteral)) {
+                            if (!_hasReferencingDefaultImport(sourceFile)) {
                                 fakeIdentifier = 'default';
                             }
                         }
-                        else if (declaration.isKind(ts_morph_1.ts.SyntaxKind.FunctionDeclaration) ||
-                            declaration.isKind(ts_morph_1.ts.SyntaxKind.ClassDeclaration) ||
-                            declaration.isKind(ts_morph_1.ts.SyntaxKind.TypeAliasDeclaration) ||
-                            declaration.isKind(ts_morph_1.ts.SyntaxKind.InterfaceDeclaration) ||
-                            declaration.isKind(ts_morph_1.ts.SyntaxKind.EnumDeclaration)) {
-                            identifier = declaration.getFirstChildByKindOrThrow(ts_morph_1.ts.SyntaxKind.Identifier);
+                        else if (declaration.isKind(ts.SyntaxKind.FunctionDeclaration) ||
+                            declaration.isKind(ts.SyntaxKind.ClassDeclaration) ||
+                            declaration.isKind(ts.SyntaxKind.TypeAliasDeclaration) ||
+                            declaration.isKind(ts.SyntaxKind.InterfaceDeclaration) ||
+                            declaration.isKind(ts.SyntaxKind.EnumDeclaration)) {
+                            identifier = declaration.getFirstChildByKindOrThrow(ts.SyntaxKind.Identifier);
                         }
-                        else if (declaration.isKind(ts_morph_1.ts.SyntaxKind.PropertyAccessExpression)) {
-                            identifier = declaration.getLastChildByKindOrThrow(ts_morph_1.ts.SyntaxKind.Identifier);
+                        else if (declaration.isKind(ts.SyntaxKind.PropertyAccessExpression)) {
+                            identifier = declaration.getLastChildByKindOrThrow(ts.SyntaxKind.Identifier);
                         }
                         else {
-                            identifier = declaration.getFirstDescendantByKind(ts_morph_1.ts.SyntaxKind.Identifier);
+                            identifier = declaration.getFirstDescendantByKind(ts.SyntaxKind.Identifier);
                         }
                         if (identifier || fakeIdentifier) {
                             const identifierText = fakeIdentifier ?? identifier?.getText() ?? '*';
@@ -136,7 +129,7 @@ async function findIssues(configuration) {
                                 return;
                             if (report.nsTypes && issues.nsTypes[filePath]?.[identifierText])
                                 return;
-                            const refs = identifier?.findReferences() ?? [];
+                            const refs = _findReferences(identifier);
                             if (refs.length === 0) {
                                 addSymbolIssue('exports', { filePath, symbol: identifierText });
                             }
@@ -145,7 +138,7 @@ async function findIssues(configuration) {
                                 const isReferencedOnlyBySelf = refFiles.size === 1 && [...refFiles][0] === filePath;
                                 if (!isReferencedOnlyBySelf)
                                     return;
-                                if ((0, ts_morph_helpers_1.findReferencingNamespaceNodes)(sourceFile).length > 0) {
+                                if (_findReferencingNamespaceNodes(sourceFile).length > 0) {
                                     if (type) {
                                         addSymbolIssue('nsTypes', { filePath, symbol: identifierText, symbolType: type });
                                     }
@@ -169,12 +162,11 @@ async function findIssues(configuration) {
     if (report.dependencies) {
         const unusedDependencies = getUnusedDependencies();
         unusedDependencies.forEach(symbol => addSymbolIssue('dependencies', { filePath: manifestPath, symbol }));
-        if (isDev) {
-            const unusedDevDependencies = getUnusedDevDependencies();
-            unusedDevDependencies.forEach(symbol => addSymbolIssue('devDependencies', { filePath: manifestPath, symbol }));
-        }
+    }
+    if (report.devDependencies) {
+        const unusedDevDependencies = getUnusedDevDependencies();
+        unusedDevDependencies.forEach(symbol => addSymbolIssue('devDependencies', { filePath: manifestPath, symbol }));
     }
     updateCounters();
     return { issues, counters };
 }
-exports.findIssues = findIssues;

package/dist/types.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/dist/util/config.d.ts

@@ -1,4 +1,4 @@
-import type { ImportedConfiguration, LocalConfiguration, Report } from '../types';
+import type { ImportedConfiguration, LocalConfiguration, Report } from '../types.js';
 export declare const resolveConfig: (importedConfiguration: ImportedConfiguration, options?: {
     workingDir?: string;
     isDev?: boolean;

package/dist/util/config.js

@@ -1,18 +1,12 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveIncludedIssueTypes = exports.resolveConfig = void 0;
-const micromatch_1 = __importDefault(require("micromatch"));
-const resolveConfig = (importedConfiguration, options) => {
+import micromatch from 'micromatch';
+export const resolveConfig = (importedConfiguration, options) => {
     if (!importedConfiguration)
         return;
     let resolvedConfig = importedConfiguration;
     const { workingDir, isDev } = options ?? {};
     const configKeys = Object.keys(importedConfiguration);
     if (workingDir && !('projectFiles' in importedConfiguration)) {
-        const importedConfigKey = configKeys.find(pattern => micromatch_1.default.isMatch(workingDir.replace(/\/$/, ''), pattern));
+        const importedConfigKey = configKeys.find(pattern => micromatch.isMatch(workingDir.replace(/\/$/, ''), pattern));
         if (importedConfigKey) {
             resolvedConfig = importedConfiguration[importedConfigKey];
         }
@@ -27,17 +21,26 @@ const resolveConfig = (importedConfiguration, options) => {
     resolvedConfig.dev = Boolean(typeof resolvedConfig.dev === 'boolean' ? resolvedConfig.dev : isDev);
     return resolvedConfig;
 };
-exports.resolveConfig = resolveConfig;
-const resolveIncludedIssueTypes = (includeArg, excludeArg, resolvedConfig) => {
-    const deps = resolvedConfig?.dev ? ['dependencies', 'devDependencies'] : ['dependencies'];
-    const groups = ['files', ...deps, 'unlisted', 'exports', 'types', 'nsExports', 'nsTypes', 'duplicates'];
+const ISSUE_TYPES = [
+    'files',
+    'dependencies',
+    'devDependencies',
+    'unlisted',
+    'exports',
+    'types',
+    'nsExports',
+    'nsTypes',
+    'duplicates',
+];
+export const resolveIncludedIssueTypes = (includeArg, excludeArg, resolvedConfig) => {
     const normalizedIncludesArg = includeArg.map(value => value.split(',')).flat();
     const normalizedExcludesArg = excludeArg.map(value => value.split(',')).flat();
     const excludes = (resolvedConfig?.exclude ?? []).filter(exclude => !normalizedIncludesArg.includes(exclude));
     const includes = (resolvedConfig?.include ?? []).filter(include => !normalizedExcludesArg.includes(include));
     const include = [normalizedIncludesArg, includes].flat();
     const exclude = [normalizedExcludesArg, excludes].flat();
-    const included = (include.length > 0 ? include : groups).filter(group => !exclude.includes(group));
-    return groups.reduce((types, group) => ((types[group] = included.includes(group)), types), {});
+    include.includes('dependencies') && include.push('devDependencies');
+    !resolvedConfig?.dev && exclude.push('devDependencies');
+    const included = (include.length > 0 ? include : ISSUE_TYPES).filter(group => !exclude.includes(group));
+    return ISSUE_TYPES.reduce((types, group) => ((types[group] = included.includes(group)), types), {});
 };
-exports.resolveIncludedIssueTypes = resolveIncludedIssueTypes;

package/dist/util/debug.js

@@ -1,19 +1,12 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.debugLogSourceFiles = exports.debugLogFiles = exports.debugLogObject = void 0;
-const node_util_1 = __importDefault(require("node:util"));
-const logArray = (collection) => console.log(node_util_1.default.inspect(collection, { maxArrayLength: null }));
-const debugLogObject = (debug, minimumLevel, name, obj) => {
+import util from 'node:util';
+const logArray = (collection) => console.log(util.inspect(collection, { maxArrayLength: null }));
+export const debugLogObject = (debug, minimumLevel, name, obj) => {
     if (minimumLevel > debug.level)
         return;
     console.log(`[knip] ${name}:`);
-    console.log(node_util_1.default.inspect(obj, { depth: null, colors: true }));
+    console.log(util.inspect(obj, { depth: null, colors: true }));
 };
-exports.debugLogObject = debugLogObject;
-const debugLogFiles = (debug, minimumLevel, name, filePaths) => {
+export const debugLogFiles = (debug, minimumLevel, name, filePaths) => {
     if (minimumLevel > debug.level)
         return;
     console.debug(`[knip] ${name} (${filePaths.length}):`);
@@ -21,8 +14,7 @@ const debugLogFiles = (debug, minimumLevel, name, filePaths) => {
         logArray(filePaths);
     }
 };
-exports.debugLogFiles = debugLogFiles;
-const debugLogSourceFiles = (debug, minimumLevel, name, sourceFiles) => {
+export const debugLogSourceFiles = (debug, minimumLevel, name, sourceFiles) => {
     if (minimumLevel > debug.level)
         return;
     console.debug(`[knip] ${name} (${sourceFiles.length})`);
@@ -31,7 +23,6 @@ const debugLogSourceFiles = (debug, minimumLevel, name, sourceFiles) => {
         logArray(files);
     }
 };
-exports.debugLogSourceFiles = debugLogSourceFiles;
 const debugLogDiff = (debug, minimumLevel, name, arrA, arrB) => {
     if (minimumLevel > debug.level)
         return;

package/dist/util/dependencies.d.ts

@@ -1,7 +1,7 @@
 import type { SourceFile } from 'ts-morph';
-import type { Configuration, Issue } from '../types';
+import type { Configuration, Issue } from '../types.js';
 export declare const getDependencyAnalyzer: (configuration: Configuration) => {
-    getUnresolvedDependencies: (sourceFile: SourceFile) => Set<Issue>;
+    _findUnresolvedDependencies: (sourceFile: SourceFile) => Set<Issue>;
     getUnusedDependencies: () => string[];
     getUnusedDevDependencies: () => string[];
 };

package/dist/util/dependencies.js

@@ -1,21 +1,16 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDependencyAnalyzer = void 0;
-const ts_morph_1 = require("ts-morph");
-const is_builtin_module_1 = __importDefault(require("is-builtin-module"));
-const micromatch_1 = __importDefault(require("micromatch"));
-const ts_morph_helpers_1 = require("ts-morph-helpers");
+import { isBuiltin } from 'node:module';
+import { ts } from 'ts-morph';
+import micromatch from 'micromatch';
+import { findCallExpressionsByName } from 'ts-morph-helpers';
+import { timerify } from './performance.js';
 const compact = (collection) => Array.from(new Set(collection)).filter((value) => Boolean(value));
-const findRequireModuleSpecifiers = (sourceFile) => (0, ts_morph_helpers_1.findCallExpressionsByName)(sourceFile, 'require').map(expression => expression.getFirstDescendantByKind(ts_morph_1.ts.SyntaxKind.StringLiteral));
+const findRequireModuleSpecifiers = (sourceFile) => findCallExpressionsByName(sourceFile, 'require').map(expression => expression.getFirstDescendantByKind(ts.SyntaxKind.StringLiteral));
 const isExternalDependency = (moduleSpecifier, tsConfigPathGlobs) => {
     if (moduleSpecifier.startsWith('.'))
         return false;
-    if ((0, is_builtin_module_1.default)(moduleSpecifier))
+    if (isBuiltin(moduleSpecifier))
         return false;
-    if (tsConfigPathGlobs.length > 0 && micromatch_1.default.isMatch(moduleSpecifier, tsConfigPathGlobs))
+    if (tsConfigPathGlobs.length > 0 && micromatch.isMatch(moduleSpecifier, tsConfigPathGlobs))
         return false;
     return true;
 };
@@ -23,11 +18,11 @@ const resolvePackageName = (moduleSpecifier) => {
     const parts = moduleSpecifier.split('/').slice(0, 2);
     return moduleSpecifier.startsWith('@') ? parts.join('/') : parts[0];
 };
-const getDependencyAnalyzer = (configuration) => {
+export const getDependencyAnalyzer = (configuration) => {
     const { dependencies, devDependencies, peerDependencies, optionalDependencies, tsConfigPathGlobs } = configuration;
     const productionDependencies = [...dependencies, ...peerDependencies, ...optionalDependencies];
     const referencedDependencies = new Set();
-    const getUnresolvedDependencies = (sourceFile) => {
+    const findUnresolvedDependencies = (sourceFile) => {
         const unresolvedDependencies = new Set();
         const importLiterals = sourceFile.getImportStringLiterals();
         const requireCallExpressions = findRequireModuleSpecifiers(sourceFile);
@@ -47,6 +42,9 @@ const getDependencyAnalyzer = (configuration) => {
     };
     const getUnusedDependencies = () => productionDependencies.filter(dependency => !referencedDependencies.has(dependency));
     const getUnusedDevDependencies = () => devDependencies.filter(dependency => !referencedDependencies.has(dependency));
-    return { getUnresolvedDependencies, getUnusedDependencies, getUnusedDevDependencies };
+    return {
+        _findUnresolvedDependencies: timerify(findUnresolvedDependencies),
+        getUnusedDependencies,
+        getUnusedDevDependencies,
+    };
 };
-exports.getDependencyAnalyzer = getDependencyAnalyzer;

package/dist/util/errors.js

@@ -1,6 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfigurationError = void 0;
-class ConfigurationError extends Error {
+export class ConfigurationError extends Error {
 }
-exports.ConfigurationError = ConfigurationError;

package/dist/util/fs.d.ts

@@ -1,2 +1,3 @@
 export declare const isFile: (filePath: string) => Promise<boolean>;
 export declare const findFile: (cwd: string, workingDir: string, fileName: string) => Promise<string | undefined>;
+export declare const loadJSON: (filePath: string) => any;

package/dist/util/fs.js

@@ -1,31 +1,26 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.findFile = exports.isFile = void 0;
-const promises_1 = __importDefault(require("node:fs/promises"));
-const node_path_1 = __importDefault(require("node:path"));
-const isFile = async (filePath) => {
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+const require = createRequire(process.cwd());
+export const isFile = async (filePath) => {
     try {
-        const stats = await promises_1.default.stat(filePath);
+        const stats = await fs.stat(filePath);
         return stats.isFile();
     }
     catch {
         return false;
     }
 };
-exports.isFile = isFile;
-const findFile = async (cwd, workingDir, fileName) => {
-    const filePath = node_path_1.default.join(workingDir, fileName);
-    if (await (0, exports.isFile)(filePath)) {
+export const findFile = async (cwd, workingDir, fileName) => {
+    const filePath = path.join(workingDir, fileName);
+    if (await isFile(filePath)) {
         return filePath;
     }
     else {
         if (cwd === workingDir)
             return;
-        const parentDir = node_path_1.default.resolve(workingDir, '..');
-        return (0, exports.findFile)(cwd, parentDir, fileName);
+        const parentDir = path.resolve(workingDir, '..');
+        return findFile(cwd, parentDir, fileName);
     }
 };
-exports.findFile = findFile;
+export const loadJSON = (filePath) => require(filePath);

package/dist/util/glob.d.ts

@@ -1,4 +1,4 @@
-export declare const glob: ({ cwd, workingDir, patterns, ignore, gitignore, }: {
+export declare const _glob: ({ cwd, workingDir, patterns, ignore, gitignore, }: {
     cwd: string;
     workingDir: string;
     patterns: string[];

package/dist/util/glob.js

@@ -1,32 +1,20 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.glob = void 0;
-const node_path_1 = __importDefault(require("node:path"));
-let _globby;
-const globProxy = async function (patterns, options) {
-    if (!_globby) {
-        const { globby } = await eval('import("globby")');
-        _globby = globby;
-    }
-    return _globby(patterns, options);
-};
-const ensurePosixPath = (value) => value.split(node_path_1.default.sep).join(node_path_1.default.posix.sep);
+import path from 'node:path';
+import { globby } from 'globby';
+import { timerify } from './performance.js';
+const ensurePosixPath = (value) => value.split(path.sep).join(path.posix.sep);
 const prependDirToPattern = (workingDir, pattern) => {
     if (pattern.startsWith('!'))
-        return '!' + node_path_1.default.posix.join(workingDir, pattern.slice(1));
-    return node_path_1.default.posix.join(workingDir, pattern);
+        return '!' + path.posix.join(workingDir, pattern.slice(1));
+    return path.posix.join(workingDir, pattern);
 };
 const glob = async ({ cwd, workingDir, patterns, ignore, gitignore, }) => {
     const cwdPosix = ensurePosixPath(cwd);
     const workingDirPosix = ensurePosixPath(workingDir);
-    return globProxy(patterns.map(pattern => prependDirToPattern(node_path_1.default.posix.relative(cwdPosix, workingDirPosix), pattern)), {
+    return globby(patterns.map(pattern => prependDirToPattern(path.posix.relative(cwdPosix, workingDirPosix), pattern)), {
         cwd,
         ignore: [...ignore, '**/node_modules/**'],
         gitignore,
         absolute: true,
     });
 };
-exports.glob = glob;
+export const _glob = timerify(glob);

package/dist/util/parseArgs.d.ts

@@ -0,0 +1,24 @@
+declare const _default: {
+    values: {
+        help: boolean | undefined;
+        config: string | undefined;
+        tsConfig: string | undefined;
+        dir: string | undefined;
+        include: string[] | undefined;
+        exclude: string[] | undefined;
+        ignore: string[] | undefined;
+        'no-gitignore': boolean | undefined;
+        dev: boolean | undefined;
+        'include-entry-files': boolean | undefined;
+        'no-progress': boolean | undefined;
+        'max-issues': string | undefined;
+        reporter: string | undefined;
+        'reporter-options': string | undefined;
+        jsdoc: string[] | undefined;
+        debug: boolean | undefined;
+        'debug-level': string | undefined;
+        performance: boolean | undefined;
+    };
+    positionals: [];
+};
+export default _default;

package/dist/util/parseArgs.js

@@ -0,0 +1,23 @@
+import { parseArgs } from 'node:util';
+export default parseArgs({
+    options: {
+        help: { type: 'boolean' },
+        config: { type: 'string', short: 'c' },
+        tsConfig: { type: 'string', short: 't' },
+        dir: { type: 'string' },
+        include: { type: 'string', multiple: true },
+        exclude: { type: 'string', multiple: true },
+        ignore: { type: 'string', multiple: true },
+        'no-gitignore': { type: 'boolean' },
+        dev: { type: 'boolean' },
+        'include-entry-files': { type: 'boolean' },
+        'no-progress': { type: 'boolean' },
+        'max-issues': { type: 'string' },
+        reporter: { type: 'string' },
+        'reporter-options': { type: 'string' },
+        jsdoc: { type: 'string', multiple: true },
+        debug: { type: 'boolean' },
+        'debug-level': { type: 'string' },
+        performance: { type: 'boolean' },
+    },
+});

package/dist/util/path.js

@@ -1,10 +1,3 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.relative = void 0;
-const node_path_1 = __importDefault(require("node:path"));
+import path from 'node:path';
 const cwd = process.cwd();
-const relative = (to) => node_path_1.default.relative(cwd, to);
-exports.relative = relative;
+export const relative = (to) => path.relative(cwd, to);

package/dist/util/performance.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" resolution-mode="require"/>
+import { PerformanceObserver, PerformanceEntry } from 'node:perf_hooks';
+import EasyTable from 'easy-table';
+import type { TimerifyOptions } from 'node:perf_hooks';
+declare type Timerify = <T extends (...params: any[]) => any>(fn: T, options?: TimerifyOptions) => T;
+export declare const timerify: Timerify;
+declare class Performance {
+    enabled: boolean;
+    entries: PerformanceEntry[];
+    instanceId?: number;
+    observer?: PerformanceObserver;
+    constructor(enabled: boolean);
+    start(name: string): void;
+    end(name: string): void;
+    getEntriesByName(): Record<string, number[]>;
+    getTable(sort?: string[]): EasyTable;
+    flush(): Promise<void>;
+    print(): Promise<void>;
+    reset(): void;
+}
+export declare const measure: Performance;
+export {};

package/dist/util/performance.js

@@ -0,0 +1,81 @@
+import { performance, PerformanceObserver } from 'node:perf_hooks';
+import Summary from 'summary';
+import EasyTable from 'easy-table';
+import parsedArgs from './parseArgs.js';
+const { values } = parsedArgs;
+const { performance: isEnabled = false } = values;
+export const timerify = fn => (isEnabled ? performance.timerify(fn) : fn);
+class Performance {
+    enabled;
+    entries = [];
+    instanceId;
+    observer;
+    constructor(enabled) {
+        if (enabled) {
+            this.instanceId = Math.floor(performance.now() * 100);
+            this.observer = new PerformanceObserver(items => {
+                items.getEntries().forEach(entry => {
+                    this.entries.push(entry);
+                });
+            });
+            this.observer.observe({ entryTypes: ['measure', 'function'] });
+        }
+        this.enabled = enabled;
+    }
+    start(name) {
+        if (!this.enabled)
+            return;
+        const id = `${this.instanceId}:${name}`;
+        performance.mark(`${id}:start`);
+    }
+    end(name) {
+        if (!this.enabled)
+            return;
+        const id = `${this.instanceId}:${name}`;
+        performance.mark(`${id}:end`);
+        performance.measure(id, `${id}:start`, `${id}:end`);
+        performance.clearMarks(`${id}:start`);
+        performance.clearMarks(`${id}:end`);
+    }
+    getEntriesByName() {
+        return this.entries.reduce((entries, entry) => {
+            const name = entry.name.replace(`${this.instanceId}:`, '');
+            entries[name] = entries[name] ?? [];
+            entries[name].push(entry.duration);
+            return entries;
+        }, {});
+    }
+    getTable(sort = ['sum|des']) {
+        const entriesByName = this.getEntriesByName();
+        const table = new EasyTable();
+        Object.entries(entriesByName).map(([name, values]) => {
+            const stats = new Summary(values);
+            table.cell('Name', name);
+            table.cell('size', stats.size(), EasyTable.number(0));
+            table.cell('min', stats.min(), EasyTable.number(2));
+            table.cell('max', stats.max(), EasyTable.number(2));
+            table.cell('median', stats.median(), EasyTable.number(2));
+            table.cell('sum', stats.sum(), EasyTable.number(2));
+            table.newRow();
+        });
+        table.total('sum', { printer: EasyTable.number(2) });
+        table.sort(sort);
+        return table;
+    }
+    async flush() {
+        this.start('_flush');
+        await new Promise(resolve => setTimeout(resolve, 1));
+        this.end('_flush');
+    }
+    async print() {
+        if (!this.enabled)
+            return;
+        await this.flush();
+        console.log('\n' + this.getTable().toString().trim());
+    }
+    reset() {
+        this.entries = [];
+        this.observer?.disconnect();
+    }
+}
+export const measure = new Performance(isEnabled);