knip 1.12.0 → 1.12.2

package/dist/cli.js

@@ -1,14 +1,15 @@
 #!/usr/bin/env node
 import './util/register.js';
 import path from 'node:path';
+import prettyMilliseconds from 'pretty-ms';
 import reporters from './reporters/index.js';
 import parsedArgs, { helpText } from './util/cli-arguments.js';
 import { ConfigurationError } from './util/errors.js';
 import { _load } from './util/loader.js';
-import { measure } from './util/performance.js';
+import { Performance } from './util/performance.js';
 import { version } from './version.js';
 import { main } from './index.js';
-const { values: { debug: isDebug = false, help: isHelp, 'include-entry-exports': isIncludeEntryExports = false, 'max-issues': maxIssues = '0', 'no-exit-code': noExitCode = false, 'no-gitignore': isNoGitIgnore = false, 'no-progress': isNoProgress = false, production: isProduction = false, reporter = 'symbols', 'reporter-options': reporterOptions = '', strict: isStrict = false, tsConfig, version: isVersion, }, } = parsedArgs;
+const { debug: isDebug = false, help: isHelp, 'include-entry-exports': isIncludeEntryExports = false, 'max-issues': maxIssues = '0', 'no-exit-code': noExitCode = false, 'no-gitignore': isNoGitIgnore = false, 'no-progress': isNoProgress = false, performance: isObservePerf = false, production: isProduction = false, reporter = 'symbols', 'reporter-options': reporterOptions = '', strict: isStrict = false, tsConfig, version: isVersion, } = parsedArgs.values;
 if (isHelp) {
     console.log(helpText);
     process.exit(0);
@@ -22,6 +23,7 @@ const isShowProgress = !isDebug && isNoProgress === false && process.stdout.isTT
 const printReport = reporter in reporters ? reporters[reporter] : await _load(path.join(cwd, reporter));
 const run = async () => {
     try {
+        const perfObserver = new Performance(isObservePerf);
         const { report, issues, counters } = await main({
             cwd,
             tsConfigFile: tsConfig,
@@ -35,7 +37,12 @@ const run = async () => {
         const totalErrorCount = Object.keys(report)
             .filter(reportGroup => report[reportGroup])
             .reduce((errorCount, reportGroup) => errorCount + counters[reportGroup], 0);
-        await measure.print();
+        if (isObservePerf) {
+            await perfObserver.finalize();
+            console.log('\n' + perfObserver.getTable());
+            console.log('\nTotal running time:', prettyMilliseconds(perfObserver.getTotalTime()));
+            perfObserver.reset();
+        }
         if (!noExitCode && totalErrorCount > Number(maxIssues)) {
             process.exit(totalErrorCount);
         }

package/dist/configuration-chief.js

@@ -8,12 +8,12 @@ import { arrayify } from './util/array.js';
 import parsedArgs from './util/cli-arguments.js';
 import { ConfigurationError } from './util/errors.js';
 import { findFile, loadJSON } from './util/fs.js';
-import { ensurePosixPath } from './util/glob.js';
 import { _load } from './util/loader.js';
+import { relativePosix } from './util/path.js';
 import { toCamelCase } from './util/plugin.js';
 import { resolveIncludedIssueTypes } from './util/resolve-included-issue-types.js';
 import { byPathDepth } from './util/workspace.js';
-const { values: { config: rawConfigArg, workspace: rawWorkspaceArg, include = [], exclude = [], dependencies = false, exports = false, }, } = parsedArgs;
+const { config: rawConfigArg, workspace: rawWorkspaceArg, include = [], exclude = [], dependencies = false, exports = false, } = parsedArgs.values;
 const defaultWorkspaceConfig = DEFAULT_WORKSPACE_CONFIG;
 const defaultConfig = {
     include: [],
@@ -135,9 +135,7 @@ export default class ConfigurationChief {
                 ignore: this.config.ignoreWorkspaces,
                 absolute: false,
             });
-            this.manifestWorkspaces = Array.from(workspaces.values())
-                .map(dir => path.relative(this.cwd, dir))
-                .map(ensurePosixPath);
+            this.manifestWorkspaces = Array.from(workspaces.values()).map(dir => relativePosix(this.cwd, dir));
             return this.manifestWorkspaces;
         }
         return [];

package/dist/index.js

@@ -9,7 +9,8 @@ import { compact } from './util/array.js';
 import { debugLogObject, debugLogFiles } from './util/debug.js';
 import { _findImportModuleSpecifiers } from './util/find-import-specifiers.js';
 import { findFile, loadJSON } from './util/fs.js';
-import { _glob, ensurePosixPath } from './util/glob.js';
+import { _glob } from './util/glob.js';
+import { toPosixPath } from './util/path.js';
 import { _findDuplicateExportedNames } from './util/project.js';
 import { loadTSConfig } from './util/tsconfig-loader.js';
 import { byPathDepth } from './util/workspace.js';
@@ -223,7 +224,7 @@ export const main = async (unresolvedConfiguration) => {
         const filePath = sourceFile.getFilePath();
         if (report.dependencies || report.unlisted) {
             const filePath = sourceFile.getFilePath();
-            const workspaceDir = workspaceDirs.find(workspaceDir => filePath.startsWith(ensurePosixPath(workspaceDir)));
+            const workspaceDir = workspaceDirs.find(workspaceDir => filePath.startsWith(toPosixPath(workspaceDir)));
             const workspace = workspaces.find(workspace => workspace.dir === workspaceDir);
             if (workspace) {
                 const [, externalModuleSpecifiers] = moduleSpecifierCache.get(sourceFile) ??

package/dist/issue-collector.js

@@ -1,9 +1,8 @@
-import path from 'node:path';
 import { ISSUE_TYPES } from './constants.js';
 import { initReport, initIssues, initCounters } from './issues/initializers.js';
 import { getTitle } from './reporters/util.js';
 import { getLine, LineRewriter } from './util/log.js';
-import { relative } from './util/path.js';
+import { relativePosix } from './util/path.js';
 export default class IssueCollector {
     report;
     issues;
@@ -40,8 +39,7 @@ export default class IssueCollector {
         });
     }
     addIssue(issue) {
-        issue.filePath = path.relative(this.cwd, issue.filePath);
-        const key = relative(issue.filePath);
+        const key = relativePosix(this.cwd, issue.filePath);
         this.issues[issue.type][key] = this.issues[issue.type][key] ?? {};
         if (!this.issues[issue.type][key][issue.symbol]) {
             this.issues[issue.type][key][issue.symbol] = issue;
@@ -68,7 +66,7 @@ export default class IssueCollector {
         }
         if (issue && processed < total) {
             messages.push('');
-            messages.push(`Processing: ${relative(issue.filePath)}`);
+            messages.push(`Processing: ${relativePosix(issue.filePath)}`);
         }
         this.lineRewriter.update(messages);
     }

package/dist/project-principal.js

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import { ts } from 'ts-morph';
 import { debugLogSourceFiles } from './util/debug.js';
-import { ensurePosixPath } from './util/glob.js';
+import { toPosixPath } from './util/path.js';
 import { _createProject, partitionSourceFiles, _resolveSourceFileDependencies, _removeExternalSourceFiles, } from './util/project.js';
 const baseCompilerOptions = {
     allowJs: true,
@@ -36,7 +36,7 @@ export default class ProjectPrincipal {
         this.projectPaths.add(filePath);
     }
     removeProjectPath(filePath) {
-        this.projectPaths.delete(ensurePosixPath(filePath));
+        this.projectPaths.delete(toPosixPath(filePath));
     }
     addTypeScriptPaths(workspaceDir, compilerOptions) {
         if (!compilerOptions || !compilerOptions.paths)

package/dist/reporters/codeowners.js

@@ -1,12 +1,12 @@
 import path from 'node:path';
 import { OwnershipEngine } from '@snyk/github-codeowners/dist/lib/ownership/index.js';
 import chalk from 'chalk';
-import { relative } from '../util/path.js';
+import { relativePosix } from '../util/path.js';
 import { getTitle, logTitle, logIssueLine } from './util.js';
 const logIssueSet = (issues) => {
     issues
         .sort((a, b) => (a.owner < b.owner ? -1 : 1))
-        .forEach(issue => console.log(chalk.cyan(issue.owner), issue.symbol.startsWith('/') ? relative(issue.symbol) : issue.symbol));
+        .forEach(issue => console.log(chalk.cyan(issue.owner), issue.symbol.startsWith('/') ? relativePosix(issue.symbol) : issue.symbol));
 };
 const logIssueRecord = (issues) => {
     const sortedByFilePath = issues.sort((a, b) => (a.owner < b.owner ? -1 : 1));
@@ -26,7 +26,7 @@ export default ({ report, issues, options }) => {
     const [dependenciesOwner = '[no-owner]'] = codeownersEngine.calcFileOwnership('package.json');
     const fallbackOwner = dependenciesOwner;
     let totalIssues = 0;
-    const calcFileOwnership = (filePath) => codeownersEngine.calcFileOwnership(relative(filePath))[0] ?? fallbackOwner;
+    const calcFileOwnership = (filePath) => codeownersEngine.calcFileOwnership(relativePosix(filePath))[0] ?? fallbackOwner;
     const addOwner = (issue) => ({ ...issue, owner: calcFileOwnership(issue.filePath) });
     for (const [reportType, isReportType] of Object.entries(report)) {
         if (isReportType) {

package/dist/reporters/json.js

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import { OwnershipEngine } from '@snyk/github-codeowners/dist/lib/ownership/index.js';
 import { isFile } from '../util/fs.js';
-import { relative } from '../util/path.js';
+import { relativePosix } 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 = {};
@@ -16,7 +16,7 @@ export default async ({ report, issues, options }) => {
     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 file = relativePosix(filePath);
         const row = {
             file,
             ...(codeownersEngine && { owners: codeownersEngine.calcFileOwnership(file) }),

package/dist/reporters/symbols.js

@@ -1,5 +1,5 @@
 import EasyTable from 'easy-table';
-import { relative } from '../util/path.js';
+import { relativePosix } from '../util/path.js';
 import { getTitle, logTitle, logIssueSet } from './util.js';
 const TRUNCATE_WIDTH = 40;
 const truncate = (text) => (text.length > TRUNCATE_WIDTH ? text.slice(0, TRUNCATE_WIDTH - 3) + '...' : text);
@@ -9,7 +9,7 @@ const logIssueRecord = (issues) => {
         table.cell('symbol', issue.symbols ? truncate(issue.symbols.join(', ')) : issue.symbol);
         issue.parentSymbol && table.cell('parentSymbol', issue.parentSymbol);
         issue.symbolType && table.cell('symbolType', issue.symbolType);
-        table.cell('filePath', relative(issue.filePath));
+        table.cell('filePath', relativePosix(issue.filePath));
         table.newRow();
     });
     console.log(table.sort(['filePath', 'parentSymbol', 'symbol']).print().trim());

package/dist/reporters/util.js

@@ -1,6 +1,6 @@
 import chalk from 'chalk';
 import { ISSUE_TYPE_TITLE } from '../constants.js';
-import { relative } from '../util/path.js';
+import { relativePosix } from '../util/path.js';
 export const getTitle = (reportType) => {
     return ISSUE_TYPE_TITLE[reportType];
 };
@@ -8,8 +8,8 @@ export const logTitle = (title, count) => console.log(`${chalk.bold.yellow.under
 export const logIssueLine = ({ owner, filePath, symbols, parentSymbol }) => {
     const symbol = symbols ? `: ${symbols.join(', ')}` : '';
     const parent = parentSymbol ? ` (${parentSymbol})` : '';
-    console.log(`${owner ? `${chalk.cyan(owner)} ` : ''}${relative(filePath)}${symbol}${parent}`);
+    console.log(`${owner ? `${chalk.cyan(owner)} ` : ''}${relativePosix(filePath)}${symbol}${parent}`);
 };
 export const logIssueSet = (issues) => {
-    issues.sort().forEach(value => console.log(value.startsWith('/') ? relative(value) : value));
+    issues.sort().forEach(value => console.log(value.startsWith('/') ? relativePosix(value) : value));
 };

package/dist/util/binaries/bash-parser.js

@@ -4,25 +4,24 @@ import * as FallbackResolver from './resolvers/fallback.js';
 import * as KnownResolvers from './resolvers/index.js';
 const spawningBinaries = ['cross-env', 'dotenv'];
 export const getBinariesFromScript = (script, { cwd, manifest, knownGlobalsOnly = false }) => {
-    const findByArgs = (args) => (args.length > 0 ? findBinaries(parse(args.join(' ')).commands) : []);
-    const findBinaries = (items) => items.flatMap(item => {
-        switch (item.type) {
+    if (!script)
+        return [];
+    const fromArgs = (args) => getBinariesFromScript(args.join(' '), { cwd, manifest });
+    const getBinariesFromNodes = (nodes) => nodes.flatMap(node => {
+        switch (node.type) {
             case 'Command': {
-                const binary = item.name?.text;
+                const binary = node.name?.text;
                 if (!binary || binary === '.' || binary === 'source')
                     return [];
                 if (binary.startsWith('-') || binary.startsWith('"') || binary.startsWith('..'))
                     return [];
                 if (['bun', 'deno'].includes(binary))
                     return [];
-                const args = item.suffix?.map(arg => arg.text) ?? [];
+                const args = node.suffix?.map(arg => arg.text) ?? [];
                 if (['!', 'test'].includes(binary))
-                    return findByArgs(args);
+                    return fromArgs(args);
                 if (binary in KnownResolvers) {
-                    return KnownResolvers[binary].resolve(binary, args, cwd, manifest, (args) => {
-                        const [binary, ...rest] = args;
-                        return FallbackResolver.resolve(binary, rest, cwd);
-                    });
+                    return KnownResolvers[binary].resolve(binary, args, { cwd, manifest, fromArgs });
                 }
                 if (knownGlobalsOnly)
                     return [];
@@ -31,24 +30,24 @@ export const getBinariesFromScript = (script, { cwd, manifest, knownGlobalsOnly
                     const [spawnedBinary] = parsedArgs._;
                     if (spawnedBinary) {
                         const restArgs = args.slice(args.indexOf(spawnedBinary));
-                        return [binary, ...findByArgs(restArgs)];
+                        return [binary, ...fromArgs(restArgs)];
                     }
                     else {
                         return [];
                     }
                 }
-                return FallbackResolver.resolve(binary, args, cwd);
+                return FallbackResolver.resolve(binary, args, { cwd, manifest, fromArgs });
             }
             case 'LogicalExpression':
-                return findBinaries([item.left, item.right]);
+                return getBinariesFromNodes([node.left, node.right]);
             case 'If':
-                return findBinaries([...item.clause.commands, ...item.then.commands]);
+                return getBinariesFromNodes([...node.clause.commands, ...node.then.commands]);
             case 'For':
-                return findBinaries(item.do.commands);
+                return getBinariesFromNodes(node.do.commands);
             default:
                 return [];
         }
     });
     const parsed = parse(script);
-    return parsed?.commands ? findBinaries(parsed.commands) : [];
+    return parsed?.commands ? getBinariesFromNodes(parsed.commands) : [];
 };

package/dist/util/binaries/index.d.ts

@@ -1,13 +1,2 @@
-import type { PackageJson } from 'type-fest';
-type Options = {
-    cwd?: string;
-    manifest?: PackageJson;
-    ignore?: string[];
-    knownGlobalsOnly?: boolean;
-};
-type GetBinariesFromScripts = (npmScripts: string | string[], options?: Options) => {
-    entryFiles: string[];
-    binaries: string[];
-};
+import type { GetBinariesFromScripts } from './types.js';
 export declare const _getReferencesFromScripts: GetBinariesFromScripts;
-export {};

package/dist/util/binaries/resolvers/fallback.d.ts

@@ -1 +1,2 @@
-export declare const resolve: (binary: string, args: string[], cwd: string) => string[];
+import type { Resolver } from '../types.js';
+export declare const resolve: Resolver;

package/dist/util/binaries/resolvers/fallback.js

@@ -1,28 +1,13 @@
-import path from 'node:path';
 import parseArgs from 'minimist';
-import { tryResolve } from '../../require.js';
-const resolveArguments = {
-    'ts-node': (parsed) => [parsed._[0], parsed.require].flat(),
-    tsx: (parsed) => parsed._.filter(p => p !== 'watch'),
-    default: (parsed) => [parsed.require].flat(),
+import { tryResolveFilePaths } from './node.js';
+const argResolvers = {
+    'ts-node': parsed => [parsed._[0], parsed.require].flat(),
+    tsx: parsed => parsed._.filter(p => p !== 'watch'),
+    default: parsed => [parsed.require].flat(),
 };
-export const resolve = (binary, args, cwd) => {
+export const resolve = (binary, args, { cwd }) => {
     const parsed = parseArgs(args, { string: ['r'], alias: { require: ['r', 'loader'] } });
-    const resolver = resolveArguments[binary] ?? resolveArguments.default;
+    const resolver = argResolvers[binary] ?? argResolvers.default;
     const resolve = resolver(parsed);
-    return [
-        binary,
-        ...resolve.flatMap(specifier => {
-            if (specifier) {
-                const filePath = path.join(cwd, specifier);
-                if (filePath.startsWith(cwd)) {
-                    const resolvedFilePath = tryResolve(filePath);
-                    if (resolvedFilePath)
-                        return [resolvedFilePath];
-                }
-                return [specifier];
-            }
-            return [];
-        }),
-    ];
+    return [binary, ...tryResolveFilePaths(cwd, resolve)];
 };

package/dist/util/binaries/resolvers/node.d.ts

@@ -1 +1,3 @@
-export declare const resolve: (binary: string, args: string[], cwd: string) => string[];
+import type { Resolver } from '../types.js';
+export declare const tryResolveFilePaths: (cwd: string, specifiers: string[]) => string[];
+export declare const resolve: Resolver;

package/dist/util/binaries/resolvers/node.js

@@ -1,19 +1,20 @@
 import path from 'node:path';
 import parseArgs from 'minimist';
 import { tryResolve } from '../../require.js';
-export const resolve = (binary, args, cwd) => {
-    const parsed = parseArgs(args, { string: ['r'], alias: { require: ['r', 'loader', 'experimental-loader'] } });
-    const resolve = [parsed._[0], parsed.require].flat();
-    return resolve.flatMap(specifier => {
-        if (specifier) {
-            const filePath = path.join(cwd, specifier);
-            if (filePath.startsWith(cwd)) {
-                const resolvedFilePath = tryResolve(filePath);
-                if (resolvedFilePath)
-                    return [resolvedFilePath];
-            }
-            return [specifier];
+const tryResolveFilePath = (cwd, specifier, fallback) => {
+    if (specifier) {
+        const filePath = path.join(cwd, specifier);
+        if (filePath.startsWith(cwd)) {
+            const resolvedFilePath = tryResolve(filePath);
+            if (resolvedFilePath)
+                return [resolvedFilePath];
         }
-        return [];
-    });
+        return fallback ? [fallback] : [];
+    }
+    return [];
+};
+export const tryResolveFilePaths = (cwd, specifiers) => specifiers.flatMap(specifier => tryResolveFilePath(cwd, specifier, specifier));
+export const resolve = (binary, args, { cwd }) => {
+    const parsed = parseArgs(args, { string: ['r'], alias: { require: ['r', 'loader', 'experimental-loader'] } });
+    return [...tryResolveFilePath(cwd, parsed._[0]), ...tryResolveFilePaths(cwd, [parsed.require].flat())];
 };

package/dist/util/binaries/resolvers/npx.d.ts

@@ -1,4 +1,2 @@
-import type { PackageJson } from 'type-fest';
-type FindByArgs = (args: string[]) => string[];
-export declare const resolve: (binary: string, args: string[], cwd: string, manifest: PackageJson, findByArgs: FindByArgs) => string[];
-export {};
+import type { Resolver } from '../types.js';
+export declare const resolve: Resolver;

package/dist/util/binaries/resolvers/npx.js

@@ -1,5 +1,5 @@
 import parseArgs from 'minimist';
-export const resolve = (binary, args, cwd, manifest, findByArgs) => {
+export const resolve = (binary, args, { fromArgs }) => {
     const parsed = parseArgs(args, { '--': true, stopEarly: true, boolean: ['yes', 'no'], alias: { yes: 'y', no: 'n' } });
-    return [...(parsed.yes ? [] : findByArgs(parsed._)), ...(parsed['--'] ? findByArgs(parsed['--']) : [])];
+    return [...(parsed.yes ? [] : fromArgs(parsed._)), ...(parsed['--'] ? fromArgs(parsed['--']) : [])];
 };

package/dist/util/binaries/resolvers/pnpm.d.ts

@@ -1,2 +1,2 @@
-import type { PackageJson } from 'type-fest';
-export declare const resolve: (binary: string, args: string[], cwd: string, manifest: PackageJson) => string[];
+import type { Resolver } from '../types.js';
+export declare const resolve: Resolver;

package/dist/util/binaries/resolvers/pnpm.js

@@ -1,6 +1,8 @@
 import parseArgs from 'minimist';
 const commands = [
     'add',
+    'dlx',
+    'run',
     'i',
     'install',
     'up',
@@ -31,15 +33,13 @@ const commands = [
     't',
     'tst',
 ];
-export const resolve = (binary, args, cwd, manifest) => {
+export const resolve = (binary, args, { manifest }) => {
     const scripts = manifest.scripts ? Object.keys(manifest.scripts) : [];
     const parsed = parseArgs(args, {});
     const [command, result] = parsed._;
     if (scripts.includes(command) || commands.includes(command))
         return [];
-    if (command === 'run' && scripts.includes(result))
-        return [];
-    if (command === 'exec' || command === 'run')
+    if (command === 'exec')
         return [result];
     return command ? [command] : [];
 };

package/dist/util/binaries/resolvers/yarn.d.ts

@@ -1,2 +1,2 @@
-import type { PackageJson } from 'type-fest';
-export declare const resolve: (binary: string, args: string[], cwd: string, manifest: PackageJson) => string[];
+import type { Resolver } from '../types.js';
+export declare const resolve: Resolver;

package/dist/util/binaries/resolvers/yarn.js

@@ -30,7 +30,7 @@ const commands = [
     'workspace',
     'workspaces',
 ];
-export const resolve = (binary, args, cwd, manifest) => {
+export const resolve = (binary, args, { manifest, fromArgs }) => {
     const scripts = manifest.scripts ? Object.keys(manifest.scripts) : [];
     const parsed = parseArgs(args, {});
     const [command, result] = parsed._;
@@ -40,5 +40,7 @@ export const resolve = (binary, args, cwd, manifest) => {
         return [];
     if (command === 'run' || command === 'exec')
         return [result];
+    if (command === 'node')
+        return fromArgs(parsed._);
     return command ? [command] : [];
 };

package/dist/util/binaries/types.d.ts

@@ -0,0 +1,18 @@
+import type { PackageJson } from 'type-fest';
+type Options = {
+    cwd?: string;
+    manifest?: PackageJson;
+    ignore?: string[];
+    knownGlobalsOnly?: boolean;
+};
+export type GetBinariesFromScripts = (npmScripts: string | string[], options?: Options) => {
+    entryFiles: string[];
+    binaries: string[];
+};
+type FromArgs = (args: string[]) => string[];
+export type Resolver = (binary: string, args: string[], options: {
+    cwd: string;
+    manifest: PackageJson;
+    fromArgs: FromArgs;
+}) => string[];
+export {};

package/dist/util/binaries/types.js

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

package/dist/util/glob.d.ts

@@ -1,6 +1,5 @@
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="nano-memoize" />
-export declare const ensurePosixPath: (value: string) => string;
 export declare const negate: (pattern: string) => string;
 export declare const hasProductionSuffix: (pattern: string) => boolean;
 export declare const hasNoProductionSuffix: (pattern: string) => boolean;

package/dist/util/glob.js

@@ -5,8 +5,8 @@ import memoize from 'nano-memoize';
 import { ROOT_WORKSPACE_NAME } from '../constants.js';
 import { compact } from './array.js';
 import { debugLogObject } from './debug.js';
+import { relativePosix } from './path.js';
 import { timerify } from './performance.js';
-export const ensurePosixPath = (value) => value.split(path.sep).join(path.posix.sep);
 const prependDirToPattern = (workingDir, pattern) => {
     if (pattern.startsWith('!'))
         return '!' + path.posix.join(workingDir, pattern.slice(1));
@@ -18,9 +18,7 @@ export const hasNoProductionSuffix = (pattern) => !pattern.endsWith('!');
 const removeProductionSuffix = (pattern) => pattern.replace(/!$/, '');
 const negatedLast = (pattern) => (pattern.startsWith('!') ? 1 : -1);
 const glob = async ({ cwd, workingDir = cwd, patterns, ignore = [], gitignore = true }) => {
-    const cwdPosix = ensurePosixPath(cwd);
-    const workingDirPosix = ensurePosixPath(workingDir);
-    const relativePath = path.posix.relative(cwdPosix, workingDirPosix);
+    const relativePath = relativePosix(cwd, workingDir);
     const prepend = (pattern) => prependDirToPattern(relativePath, pattern);
     const globPatterns = compact([patterns].flat().map(prepend).map(removeProductionSuffix)).sort(negatedLast);
     const ignorePatterns = compact([

package/dist/util/modules.js

@@ -1,10 +1,10 @@
-import { ensurePosixPath } from './glob.js';
+import { toPosixPath } from './path.js';
 export const getPackageNameFromModuleSpecifier = (moduleSpecifier) => {
     const parts = moduleSpecifier.split('/').slice(0, 2);
     return moduleSpecifier.startsWith('@') ? parts.join('/') : parts[0];
 };
 export const getPackageName = (value) => {
-    const match = ensurePosixPath(value).match(/(?<=node_modules\/)(@[^/]+\/[^/]+|[^/]+)/g);
+    const match = toPosixPath(value).match(/(?<=node_modules\/)(@[^/]+\/[^/]+|[^/]+)/g);
     if (match)
         return match[match.length - 1];
     if (value.startsWith('@')) {

package/dist/util/path.d.ts

@@ -1 +1,2 @@
-export declare const relative: (to: string) => string;
+export declare const toPosixPath: (value: string) => string;
+export declare const relativePosix: (from: string, to?: string) => string;

package/dist/util/path.js

@@ -1,4 +1,4 @@
 import path from 'node:path';
-import { ensurePosixPath } from './glob.js';
 const cwd = process.cwd();
-export const relative = (to) => ensurePosixPath(path.relative(cwd, to));
+export const toPosixPath = (value) => value.split(path.sep).join(path.posix.sep);
+export const relativePosix = (from, to) => toPosixPath(path.relative(to ? from : cwd, to ?? from));

package/dist/util/performance.d.ts

@@ -1,23 +1,23 @@
 /// <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';
 type Timerify = <T extends (...params: any[]) => any>(fn: T, options?: TimerifyOptions) => T;
 export declare const timerify: Timerify;
-declare class Performance {
-    enabled: boolean;
+export declare class Performance {
+    isEnabled: boolean;
     startTime: number;
+    endTime: number;
     entries: PerformanceEntry[];
     instanceId?: number;
     observer?: PerformanceObserver;
-    constructor(enabled: boolean);
-    start(name: string): void;
-    end(name: string): void;
-    getEntriesByName(): Record<string, number[]>;
-    getTable(): EasyTable;
-    flush(): Promise<void>;
-    print(): Promise<void>;
+    constructor(isEnabled: boolean);
+    private setMark;
+    private clearMark;
+    private flush;
+    private getEntriesByName;
+    getTable(): string;
+    getTotalTime(): number;
+    finalize(): Promise<void>;
     reset(): void;
 }
-export declare const measure: Performance;
 export {};

package/dist/util/performance.js

@@ -1,19 +1,18 @@
 import { performance, PerformanceObserver } from 'node:perf_hooks';
 import EasyTable from 'easy-table';
-import prettyMilliseconds from 'pretty-ms';
-import parsedArgs from './cli-arguments.js';
 import Summary from 'summary';
-const { values } = parsedArgs;
-const { performance: isEnabled = false } = values;
+import parsedArgs from './cli-arguments.js';
+const { performance: isEnabled = false } = parsedArgs.values;
 export const timerify = fn => (isEnabled ? performance.timerify(fn) : fn);
-class Performance {
-    enabled;
+export class Performance {
+    isEnabled;
     startTime = 0;
+    endTime = 0;
     entries = [];
     instanceId;
     observer;
-    constructor(enabled) {
-        if (enabled) {
+    constructor(isEnabled) {
+        if (isEnabled) {
             this.startTime = performance.now();
             this.instanceId = Math.floor(performance.now() * 100);
             this.observer = new PerformanceObserver(items => {
@@ -21,25 +20,26 @@ class Performance {
                     this.entries.push(entry);
                 });
             });
-            this.observer.observe({ entryTypes: ['measure', 'function'] });
+            this.observer.observe({ entryTypes: ['function'] });
         }
-        this.enabled = enabled;
+        this.isEnabled = isEnabled;
     }
-    start(name) {
-        if (!this.enabled)
-            return;
+    setMark(name) {
         const id = `${this.instanceId}:${name}`;
         performance.mark(`${id}:start`);
     }
-    end(name) {
-        if (!this.enabled)
-            return;
+    clearMark(name) {
         const id = `${this.instanceId}:${name}`;
         performance.mark(`${id}:end`);
         performance.measure(id, `${id}:start`, `${id}:end`);
         performance.clearMarks(`${id}:start`);
         performance.clearMarks(`${id}:end`);
     }
+    async flush() {
+        this.setMark('_flush');
+        await new Promise(resolve => setTimeout(resolve, 1));
+        this.clearMark('_flush');
+    }
     getEntriesByName() {
         return this.entries.reduce((entries, entry) => {
             const name = entry.name.replace(`${this.instanceId}:`, '');
@@ -62,23 +62,19 @@ class Performance {
             table.newRow();
         });
         table.sort(['sum|des']);
-        return table;
+        return table.toString().trim();
     }
-    async flush() {
-        this.start('_flush');
-        await new Promise(resolve => setTimeout(resolve, 1));
-        this.end('_flush');
+    getTotalTime() {
+        return this.endTime - this.startTime;
     }
-    async print() {
-        if (!this.enabled)
+    async finalize() {
+        if (!this.isEnabled)
             return;
+        this.endTime = performance.now();
         await this.flush();
-        console.log('\n' + this.getTable().toString().trim());
-        console.log('\nTotal running time:', prettyMilliseconds(performance.now() - this.startTime));
     }
     reset() {
         this.entries = [];
         this.observer?.disconnect();
     }
 }
-export const measure = new Performance(isEnabled);

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "1.12.0";
+export declare const version = "1.12.2";

package/dist/version.js

@@ -1 +1 @@
-export const version = '1.12.0';
+export const version = '1.12.2';

package/package.json

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