knip 6.4.1 → 6.6.1

package/dist/util/load-tsconfig.js

@@ -1,9 +1,7 @@
-import { readFileSync } from 'node:fs';
 import { parseTsconfig } from 'get-tsconfig';
-import stripJsonComments from 'strip-json-comments';
-import { isFile as _isFile } from "./fs.js";
-import { _syncGlob } from "./glob.js";
-import { dirname, isAbsolute, join, toAbsolute } from "./path.js";
+import { isFile } from './fs.js';
+import { _syncGlob } from './glob.js';
+import { dirname, isAbsolute, join, toAbsolute } from './path.js';
 const hasGlobChar = (p) => p.includes('*') || p.includes('?');
 const hasExtension = (p) => {
     const last = p.lastIndexOf('/');
@@ -47,56 +45,70 @@ const expandFileNames = (dir, compilerOptions, include, exclude, files) => {
     }
     return result;
 };
-const findRootDirsBase = (tsConfigFilePath) => {
-    try {
-        const raw = JSON.parse(stripJsonComments(readFileSync(tsConfigFilePath, 'utf8')));
-        if (raw.compilerOptions?.rootDirs)
-            return dirname(tsConfigFilePath);
-        if (raw.extends) {
-            const extPath = join(dirname(tsConfigFilePath), raw.extends);
-            return findRootDirsBase(extPath);
-        }
-    }
-    catch { }
-    return undefined;
+const resolveReference = (refPath, dir) => {
+    const abs = isAbsolute(refPath) ? refPath : join(dir, refPath);
+    if (isFile(abs))
+        return abs;
+    const withTsconfig = join(abs, 'tsconfig.json');
+    return isFile(withTsconfig) ? withTsconfig : undefined;
 };
-const resolveConfig = (tsConfigFilePath) => {
-    try {
-        return parseTsconfig(tsConfigFilePath);
-    }
-    catch {
-        try {
-            const raw = readFileSync(tsConfigFilePath, 'utf8');
-            return JSON.parse(stripJsonComments(raw));
-        }
-        catch {
-            return undefined;
-        }
+const fillFromReferences = (target, references, dir, visited) => {
+    if (!references?.length)
+        return;
+    for (const ref of references) {
+        if (target.outDir && target.rootDir)
+            return;
+        const refPath = resolveReference(ref.path, dir);
+        if (!refPath || visited.has(refPath))
+            continue;
+        visited.add(refPath);
+        const refConfig = parseTsconfig(refPath);
+        const refDir = dirname(refPath);
+        const refOpts = refConfig.compilerOptions;
+        if (refOpts?.outDir && !target.outDir)
+            target.outDir = toAbsolute(refOpts.outDir, refDir).replace(/\/+$/, '');
+        if (refOpts?.rootDir && !target.rootDir)
+            target.rootDir = toAbsolute(refOpts.rootDir, refDir).replace(/\/+$/, '');
+        if (!refOpts?.outDir || !refOpts?.rootDir)
+            fillFromReferences(target, refConfig.references, refDir, visited);
     }
 };
 export const loadTSConfig = async (tsConfigFilePath) => {
-    if (_isFile(tsConfigFilePath)) {
-        const config = resolveConfig(tsConfigFilePath);
-        if (!config)
-            return { isFile: true, compilerOptions: {}, fileNames: [] };
-        const dir = dirname(tsConfigFilePath);
-        const compilerOptions = (config.compilerOptions ?? {});
-        if (compilerOptions.outDir)
-            compilerOptions.outDir = toAbsolute(compilerOptions.outDir, dir).replace(/\/+$/, '');
-        if (compilerOptions.rootDir)
-            compilerOptions.rootDir = toAbsolute(compilerOptions.rootDir, dir).replace(/\/+$/, '');
-        if (compilerOptions.paths) {
-            compilerOptions.pathsBasePath ??= dir;
+    if (isFile(tsConfigFilePath)) {
+        try {
+            const config = parseTsconfig(tsConfigFilePath);
+            const dir = dirname(tsConfigFilePath);
+            const compilerOptions = (config.compilerOptions ?? {});
+            if (compilerOptions.outDir)
+                compilerOptions.outDir = toAbsolute(compilerOptions.outDir, dir).replace(/\/+$/, '');
+            if (compilerOptions.rootDir)
+                compilerOptions.rootDir = toAbsolute(compilerOptions.rootDir, dir).replace(/\/+$/, '');
+            if (compilerOptions.paths) {
+                compilerOptions.pathsBasePath ??= dir;
+            }
+            if (compilerOptions.rootDirs) {
+                compilerOptions.rootDirs = compilerOptions.rootDirs.map((d) => (isAbsolute(d) ? d : join(dir, d)));
+            }
+            if ((!compilerOptions.outDir || !compilerOptions.rootDir) && config.references?.length) {
+                fillFromReferences(compilerOptions, config.references, dir, new Set([tsConfigFilePath]));
+            }
+            const include = resolvePatterns(config.include, dir, true);
+            const exclude = resolvePatterns(config.exclude, dir, true);
+            const files = resolvePatterns(config.files, dir);
+            const fileNames = expandFileNames(dir, compilerOptions, include, exclude, files);
+            return { isFile: true, compilerOptions, fileNames };
         }
-        if (compilerOptions.rootDirs) {
-            const rootDirsBase = findRootDirsBase(tsConfigFilePath) ?? dir;
-            compilerOptions.rootDirs = compilerOptions.rootDirs.map((d) => isAbsolute(d) ? d : join(rootDirsBase, d));
+        catch {
+            return {
+                isFile: true,
+                compilerOptions: {},
+                fileNames: [],
+            };
         }
-        const include = resolvePatterns(config.include, dir, true);
-        const exclude = resolvePatterns(config.exclude, dir, true);
-        const files = resolvePatterns(config.files, dir);
-        const fileNames = expandFileNames(dir, compilerOptions, include, exclude, files);
-        return { isFile: true, compilerOptions, fileNames };
     }
-    return { isFile: false, compilerOptions: {}, fileNames: [] };
+    return {
+        isFile: false,
+        compilerOptions: {},
+        fileNames: [],
+    };
 };

package/dist/util/loader.js

@@ -6,11 +6,11 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
-import { LoaderError } from "./errors.js";
-import { loadFile, loadJSON, loadJSONC, loadTOML, loadYAML, parseJSONC, parseYAML } from "./fs.js";
-import { jiti } from "./jiti.js";
-import { timerify } from "./Performance.js";
-import { extname, isInternal } from "./path.js";
+import { LoaderError } from './errors.js';
+import { loadFile, loadJSON, loadJSONC, loadTOML, loadYAML, parseJSONC, parseYAML } from './fs.js';
+import { jiti } from './jiti.js';
+import { timerify } from './Performance.js';
+import { extname, isInternal } from './path.js';
 const load = async (filePath) => {
     try {
         const ext = extname(filePath);

package/dist/util/log.js

@@ -1,7 +1,7 @@
-import picocolors from 'picocolors';
+import st from './colors.js';
 export const logWarning = (prefix, message) => {
-    console.warn(`${picocolors.yellow(prefix)}: ${message}`);
+    console.warn(`${st.yellow(prefix)}: ${message}`);
 };
 export const logError = (prefix, message) => {
-    console.error(`${picocolors.red(prefix)}: ${message}`);
+    console.error(`${st.red(prefix)}: ${message}`);
 };

package/dist/util/map-workspaces.js

@@ -1,9 +1,9 @@
 import { readFile } from 'node:fs/promises';
-import fg from 'fast-glob';
-import { partition } from "./array.js";
-import { ConfigurationError } from "./errors.js";
-import { getPackageName } from "./package-name.js";
-import { join } from "./path.js";
+import { glob } from 'tinyglobby';
+import { partition } from './array.js';
+import { ConfigurationError } from './errors.js';
+import { getPackageName } from './package-name.js';
+import { join } from './path.js';
 export default async function mapWorkspaces(cwd, workspaces) {
     const [negatedPatterns, patterns] = partition(workspaces, p => p.match(/^!/));
     const packages = new Map();
@@ -11,7 +11,7 @@ export default async function mapWorkspaces(cwd, workspaces) {
     if (patterns.length === 0 && negatedPatterns.length === 0)
         return [packages, wsPkgNames];
     const manifestPatterns = patterns.map(p => join(p, 'package.json'));
-    const matches = await fg.glob(manifestPatterns, {
+    const matches = await glob(manifestPatterns, {
         cwd,
         ignore: ['**/node_modules/**', ...negatedPatterns.map(p => p.slice(1))],
     });

package/dist/util/modules.js

@@ -1,5 +1,5 @@
-import { DT_SCOPE, PROTOCOL_VIRTUAL } from "../constants.js";
-import { isAbsolute, isInNodeModules, toPosix } from "./path.js";
+import { DT_SCOPE, PROTOCOL_VIRTUAL } from '../constants.js';
+import { isAbsolute, isInNodeModules, toPosix } from './path.js';
 export const getPackageNameFromModuleSpecifier = (specifier) => {
     if (!isStartsLikePackageName(specifier))
         return;

package/dist/util/package-json.d.ts

@@ -8,5 +8,10 @@ interface ExtendedPackageJson extends PackageJson {
 export declare const load: (filePath: string) => Promise<ExtendedPackageJson>;
 export declare const save: (filePath: string, content: ExtendedPackageJson) => Promise<void>;
 export declare const getEntrySpecifiersFromManifest: (manifest: PackageJson) => Set<string>;
+export type Manifest = PackageJson & {
+    scriptNames: Set<string>;
+    getMajor: (name: string) => number | undefined;
+};
+export declare const createManifest: (raw: PackageJson) => Manifest;
 export declare const getManifestImportDependencies: (manifest: PackageJson) => Set<string>;
 export {};

package/dist/util/package-json.js

@@ -87,6 +87,15 @@ export const getEntrySpecifiersFromManifest = (manifest) => {
     }
     return entryPaths;
 };
+export const createManifest = (raw) => Object.assign(raw, {
+    ...raw,
+    scriptNames: new Set(Object.keys(raw.scripts ?? {})),
+    getMajor(name) {
+        const range = raw.dependencies?.[name] ?? raw.devDependencies?.[name];
+        const match = range?.match(/\d+/)?.[0];
+        return match ? Number.parseInt(match, 10) : undefined;
+    },
+});
 export const getManifestImportDependencies = (manifest) => {
     const dependencies = new Set();
     if (!manifest.imports)

package/dist/util/package-name.js

@@ -1,4 +1,4 @@
-import { basename, dirname } from "./path.js";
+import { basename, dirname } from './path.js';
 const getPkgName = (parent, base) => (parent.charAt(0) === '@' ? `${parent}/${base}` : base);
 const getName = (dir) => (dir ? getPkgName(basename(dirname(dir)), basename(dir)) : undefined);
 export function getPackageName(pkg, pathname) {

package/dist/util/parse-and-convert-gitignores.d.ts

@@ -1,8 +1,10 @@
+export declare const toExtendedIgnorePattern: (pattern: string) => string;
+export declare const expandIgnorePatterns: (patterns: Iterable<string>) => string[];
 export declare const convertGitignoreToPicomatchIgnorePatterns: (pattern: string) => {
     negated: boolean;
-    patterns: string[];
+    pattern: string;
 };
 export declare const parseAndConvertGitignorePatterns: (patterns: string, ancestor?: string) => {
     negated: boolean;
-    patterns: string[];
+    pattern: string;
 }[];

package/dist/util/parse-and-convert-gitignores.js

@@ -1,23 +1,35 @@
+export const toExtendedIgnorePattern = (pattern) => {
+    if (pattern === '*' || pattern === '**')
+        return pattern;
+    if (pattern.endsWith('/*'))
+        return pattern;
+    return `${pattern}/**`;
+};
+export const expandIgnorePatterns = (patterns) => {
+    const result = [];
+    for (const p of patterns) {
+        result.push(p);
+        const ext = toExtendedIgnorePattern(p);
+        if (ext !== p)
+            result.push(ext);
+    }
+    return result;
+};
 export const convertGitignoreToPicomatchIgnorePatterns = (pattern) => {
     const negated = pattern[0] === '!';
     if (negated)
         pattern = pattern.slice(1);
-    let extPattern;
     if (pattern.endsWith('/'))
         pattern = pattern.slice(0, -1);
     if (pattern.startsWith('*/**/'))
         pattern = pattern.slice(5);
     if (pattern === '*' || pattern === '**')
-        return { negated, patterns: [pattern, pattern] };
+        return { negated, pattern };
     if (pattern.startsWith('/'))
         pattern = pattern.slice(1);
     else if (!pattern.startsWith('**/'))
         pattern = `**/${pattern}`;
-    if (pattern.endsWith('/*'))
-        extPattern = pattern;
-    else
-        extPattern = `${pattern}/**`;
-    return { negated, patterns: [pattern, extPattern] };
+    return { negated, pattern };
 };
 export const parseAndConvertGitignorePatterns = (patterns, ancestor) => {
     const matchFrom = ancestor ? new RegExp(`^(!?/?)(${ancestor})`) : undefined;

package/dist/util/plugin.js

@@ -1,8 +1,8 @@
-export { _load as load } from "./loader.js";
-import { arrayify } from "./array.js";
-import { _load as load } from "./loader.js";
-import { get } from "./object.js";
-import { basename } from "./path.js";
+export { _load as load } from './loader.js';
+import { arrayify } from './array.js';
+import { _load as load } from './loader.js';
+import { get } from './object.js';
+import { basename } from './path.js';
 export const hasDependency = (dependencies, values) => values.some(value => {
     if (typeof value === 'string') {
         return dependencies.has(value);

package/dist/util/remove-export.js

@@ -1,4 +1,4 @@
-import { FIX_FLAGS } from "../constants.js";
+import { FIX_FLAGS } from '../constants.js';
 const getOpeningBracketIndex = (text) => {
     let bracketOpenIndex = -1;
     let j = text.length - 1;

package/dist/util/reporter.js

@@ -1,6 +1,6 @@
-import internalReporters from "../reporters/index.js";
-import { _load } from "./loader.js";
-import { isAbsolute, isInternal, resolve } from "./path.js";
+import internalReporters from '../reporters/index.js';
+import { _load } from './loader.js';
+import { isAbsolute, isInternal, resolve } from './path.js';
 export const runPreprocessors = async (processors, data) => {
     const preprocessors = await Promise.all(processors.map(proc => _load(isInternal(proc) && !isAbsolute(proc) ? resolve(proc) : proc)));
     return preprocessors.length === 0

package/dist/util/require.js

@@ -1,4 +1,4 @@
 import { createRequire } from 'node:module';
-import { timerify } from "./Performance.js";
+import { timerify } from './Performance.js';
 const require = createRequire(process.cwd());
 export const _require = timerify(require);

package/dist/util/resolve.js

@@ -1,7 +1,7 @@
 import { ResolverFactory } from 'oxc-resolver';
-import { DEFAULT_EXTENSIONS, DTS_EXTENSIONS } from "../constants.js";
-import { timerify } from "./Performance.js";
-import { toPosix } from "./path.js";
+import { DEFAULT_EXTENSIONS, DTS_EXTENSIONS } from '../constants.js';
+import { timerify } from './Performance.js';
+import { toPosix } from './path.js';
 const extensionAlias = {
     '.js': ['.js', '.ts', '.tsx', '.d.ts'],
     '.jsx': ['.jsx', '.tsx'],

package/dist/util/string.d.ts

@@ -1,5 +1,5 @@
 export declare const ELLIPSIS = "\u2026";
 export declare const truncate: (text: string, width: number) => string;
 export declare const truncateStart: (text: string, width: number) => string;
-export declare const pad: (text: string, width: number, fillString?: string, align?: "left" | "center" | "right") => string;
+export declare const pad: (text: string, width: number, fillString?: string, align?: 'left' | 'center' | 'right') => string;
 export declare const prettyMilliseconds: (ms: number) => string;

package/dist/util/table.js

@@ -1,5 +1,5 @@
 import { stripVTControlCharacters } from 'node:util';
-import { pad, truncate, truncateStart } from "./string.js";
+import { pad, truncate, truncateStart } from './string.js';
 const DEFAULT_MAX_WIDTH = process.stdout.columns || 120;
 const MIN_TRUNCATED_WIDTH = 4;
 const COLUMN_SEPARATOR = '  ';

package/dist/util/tag.js

@@ -1,4 +1,4 @@
-import { ALIAS_TAG, BETA_TAG, INTERNAL_TAG, PUBLIC_TAG } from "../constants.js";
+import { ALIAS_TAG, BETA_TAG, INTERNAL_TAG, PUBLIC_TAG } from '../constants.js';
 export const splitTags = (rawTags) => {
     const tags = rawTags.flatMap(tag => tag.split(','));
     return tags.reduce(([incl, excl], tag) => {

package/dist/util/to-source-path.d.ts

@@ -1,6 +1,8 @@
+import type { SourceMap } from '../types/config.ts';
 import type { CompilerOptions } from '../types/project.ts';
 import type { ConfigurationChief, Workspace } from '../ConfigurationChief.ts';
-export declare const augmentWorkspace: (workspace: Workspace, dir: string, compilerOptions: CompilerOptions) => void;
+export declare const augmentWorkspace: (workspace: Workspace, dir: string, compilerOptions: CompilerOptions | undefined, pluginSourceMaps?: SourceMap[]) => void;
 export declare const getModuleSourcePathHandler: (chief: ConfigurationChief) => (filePath: string) => string | undefined;
-export declare const getToSourcePathsHandler: (chief: ConfigurationChief) => (specifiers: Set<string>, dir: string, extensions: string | undefined, label: string) => Promise<string[]>;
+export declare const getToSourcePathsHandler: (chief: ConfigurationChief) => (specifiers: Set<string>, dir: string, extensions: (string | undefined) | undefined, label: string) => Promise<string[]>;
+export declare const toSourceMappedSpecifiers: (ws: Workspace | undefined, absSpecifier: string, extensions?: string) => string[];
 export type ToSourceFilePath = ReturnType<typeof getModuleSourcePathHandler>;

package/dist/util/to-source-path.js

@@ -1,17 +1,32 @@
-import { DEFAULT_EXTENSIONS } from "../constants.js";
-import { debugLog, debugLogArray } from "./debug.js";
-import { findFileWithExtensions, isDirectory } from "./fs.js";
-import { _glob, prependDirToPattern } from "./glob.js";
-import { isAbsolute, isInternal, join, toRelative } from "./path.js";
+import { DEFAULT_EXTENSIONS } from '../constants.js';
+import { debugLog, debugLogArray } from './debug.js';
+import { findFileWithExtensions, isDirectory } from './fs.js';
+import { _glob, prependDirToPattern } from './glob.js';
+import { isAbsolute, isInternal, join, toRelative } from './path.js';
 const defaultExtensions = `.{${[...DEFAULT_EXTENSIONS].map(ext => ext.slice(1)).join(',')}}`;
 const hasTSExt = /(?<!\.d)\.(m|c)?tsx?$/;
 const matchExt = /(\.d)?\.(m|c)?(j|t)s$/;
 const sourceExtensions = [...DEFAULT_EXTENSIONS];
-export const augmentWorkspace = (workspace, dir, compilerOptions) => {
+const tsconfigSourceMap = (dir, compilerOptions) => {
     const srcDir = join(dir, 'src');
     const outDirHasSrc = compilerOptions.outDir && isDirectory(compilerOptions.outDir, 'src');
-    workspace.srcDir = compilerOptions.rootDir ?? (outDirHasSrc ? dir : isDirectory(srcDir) ? srcDir : dir);
-    workspace.outDir = compilerOptions.outDir || workspace.srcDir;
+    const resolvedSrc = compilerOptions.rootDir ?? (outDirHasSrc ? dir : isDirectory(srcDir) ? srcDir : dir);
+    return { srcDir: resolvedSrc, outDir: compilerOptions.outDir || resolvedSrc };
+};
+export const augmentWorkspace = (workspace, dir, compilerOptions, pluginSourceMaps = []) => {
+    const all = compilerOptions ? [...pluginSourceMaps, tsconfigSourceMap(dir, compilerOptions)] : pluginSourceMaps;
+    if (all.length === 0)
+        return;
+    workspace.sourceMaps = all.sort((a, b) => b.outDir.length - a.outDir.length);
+};
+const isUnderOutDir = (absPath, outDir) => absPath === outDir || absPath.startsWith(`${outDir}/`);
+const isUnderSrcDir = (absPath, srcDir) => absPath === srcDir || absPath.startsWith(`${srcDir}/`);
+const rewritePattern = (sourceMaps, absSpecifier, extensions) => {
+    for (const { srcDir, outDir } of sourceMaps) {
+        if (!isUnderSrcDir(absSpecifier, srcDir) && isUnderOutDir(absSpecifier, outDir)) {
+            return srcDir + absSpecifier.slice(outDir.length).replace(matchExt, extensions);
+        }
+    }
 };
 export const getModuleSourcePathHandler = (chief) => {
     const toSourceMapCache = new Map();
@@ -21,13 +36,16 @@ export const getModuleSourcePathHandler = (chief) => {
         if (toSourceMapCache.has(filePath))
             return toSourceMapCache.get(filePath);
         const workspace = chief.findWorkspaceByFilePath(filePath);
-        if (workspace?.srcDir && workspace.outDir) {
-            if (filePath.startsWith(workspace.outDir) || workspace.srcDir === workspace.outDir) {
-                const basePath = filePath.replace(workspace.outDir, workspace.srcDir).replace(matchExt, '');
-                const srcFilePath = findFileWithExtensions(basePath, sourceExtensions);
-                if (srcFilePath)
-                    toSourceMapCache.set(filePath, srcFilePath);
-                if (srcFilePath && srcFilePath !== filePath) {
+        if (!workspace?.sourceMaps)
+            return;
+        for (const { srcDir, outDir } of workspace.sourceMaps) {
+            if (!(isUnderOutDir(filePath, outDir) || srcDir === outDir))
+                continue;
+            const basePath = (srcDir + filePath.slice(outDir.length)).replace(matchExt, '');
+            const srcFilePath = findFileWithExtensions(basePath, sourceExtensions);
+            if (srcFilePath) {
+                toSourceMapCache.set(filePath, srcFilePath);
+                if (srcFilePath !== filePath) {
                     debugLog('*', `Source mapping ${toRelative(filePath, chief.cwd)} → ${toRelative(srcFilePath, chief.cwd)}`);
                     return srcFilePath;
                 }
@@ -41,16 +59,22 @@ export const getToSourcePathsHandler = (chief) => {
         for (const specifier of specifiers) {
             const absSpecifier = isAbsolute(specifier) ? specifier : prependDirToPattern(dir, specifier);
             const ws = chief.findWorkspaceByFilePath(absSpecifier);
-            if (ws?.srcDir && ws.outDir && !absSpecifier.startsWith(ws.srcDir) && absSpecifier.startsWith(ws.outDir)) {
-                const pattern = absSpecifier.replace(ws.outDir, ws.srcDir).replace(matchExt, extensions);
-                patterns.add(pattern);
-            }
-            else {
-                patterns.add(absSpecifier);
-            }
+            const mapped = ws?.sourceMaps && rewritePattern(ws.sourceMaps, absSpecifier, extensions);
+            patterns.add(mapped ?? absSpecifier);
         }
         const filePaths = await _glob({ patterns: Array.from(patterns), cwd: dir, label });
         debugLogArray(toRelative(dir, chief.cwd), 'Source mapping (package.json)', filePaths);
         return filePaths;
     };
 };
+export const toSourceMappedSpecifiers = (ws, absSpecifier, extensions = defaultExtensions) => {
+    const out = [];
+    if (!ws?.sourceMaps)
+        return out;
+    for (const { srcDir, outDir } of ws.sourceMaps) {
+        if (!isUnderSrcDir(absSpecifier, srcDir) && isUnderOutDir(absSpecifier, outDir)) {
+            out.push(srcDir + absSpecifier.slice(outDir.length).replace(matchExt, extensions));
+        }
+    }
+    return out;
+};

package/dist/util/trace.js

@@ -1,13 +1,13 @@
-import pc from 'picocolors';
+import st from './colors.js';
 export const formatTrace = (node, toRelative, isReferenced, memberStatuses) => {
     const lines = [];
-    const file = pc.white;
-    const id = pc.cyanBright;
-    const ref = pc.cyanBright;
-    const via = pc.dim;
-    const ok = pc.green;
-    const fail = pc.red;
-    const dim = pc.dim;
+    const file = st.white;
+    const id = st.cyanBright;
+    const ref = st.cyanBright;
+    const via = st.dim;
+    const ok = st.green;
+    const fail = st.red;
+    const dim = st.dim;
     const entryMarker = node.isEntry ? dim(' ⎆') : '';
     lines.push(`${file(toRelative(node.filePath))}${dim(':')}${id(node.identifier)}${entryMarker}`);
     const formatVia = (child) => {

package/dist/util/watch.js

@@ -1,12 +1,12 @@
 import { readFileSync } from 'node:fs';
-import { invalidateCache } from "../graph-explorer/cache.js";
-import { debugLog } from "./debug.js";
-import { isFile } from "./fs.js";
-import { updateImportMap } from "./module-graph.js";
-import { toAbsolute, toPosix, toRelative } from "./path.js";
-import { clearModuleResolutionCaches } from "../typescript/resolve-module-names.js";
-import { clearGlobCache } from "./glob-cache.js";
-import { clearResolverCache } from "./resolve.js";
+import { invalidateCache } from '../graph-explorer/cache.js';
+import { debugLog } from './debug.js';
+import { isFile } from './fs.js';
+import { updateImportMap } from './module-graph.js';
+import { toAbsolute, toPosix, toRelative } from './path.js';
+import { clearModuleResolutionCaches } from '../typescript/resolve-module-names.js';
+import { clearGlobCache } from './glob-cache.js';
+import { clearResolverCache } from './resolve.js';
 const createUpdate = (options) => {
     const duration = performance.now() - options.startTime;
     const mem = process.memoryUsage().heapUsed;

package/dist/util/workspace-file-filter.js

@@ -1,5 +1,5 @@
-import { ROOT_WORKSPACE_NAME } from "../constants.js";
-import { join } from "./path.js";
+import { ROOT_WORKSPACE_NAME } from '../constants.js';
+import { join } from './path.js';
 export const createWorkspaceFilePathFilter = (cwd, selectedWorkspaces, availableWorkspaceNames) => {
     if (!selectedWorkspaces || !availableWorkspaceNames)
         return () => true;

package/dist/util/workspace-selectors.js

@@ -1,8 +1,8 @@
 import picomatch from 'picomatch';
-import { partition } from "./array.js";
-import { ConfigurationError } from "./errors.js";
-import { isDirectory, isFile } from "./fs.js";
-import { join } from "./path.js";
+import { partition } from './array.js';
+import { ConfigurationError } from './errors.js';
+import { isDirectory, isFile } from './fs.js';
+import { join } from './path.js';
 export function parseWorkspaceSelector(token, cwd) {
     const trimmed = token.trim();
     let isNegated = false;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "6.4.1";
+export declare const version = "6.6.1";

package/dist/version.js

@@ -1 +1 @@
-export const version = '6.4.1';
+export const version = '6.6.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "6.4.1",
+  "version": "6.6.1",
   "description": "Find and fix unused dependencies, exports and files in your TypeScript and JavaScript projects",
   "keywords": [
     "analysis",
@@ -77,18 +77,17 @@
     }
   },
   "dependencies": {
-    "@nodelib/fs.walk": "^1.2.3",
-    "fast-glob": "^3.3.3",
+    "fdir": "^6.5.0",
     "formatly": "^0.3.0",
-    "get-tsconfig": "4.13.7",
+    "get-tsconfig": "4.14.0",
     "jiti": "^2.6.0",
     "minimist": "^1.2.8",
-    "oxc-parser": "^0.121.0",
+    "oxc-parser": "^0.126.0",
     "oxc-resolver": "^11.19.1",
-    "picocolors": "^1.1.1",
-    "picomatch": "^4.0.1",
+    "picomatch": "^4.0.4",
     "smol-toml": "^1.6.1",
     "strip-json-comments": "5.0.3",
+    "tinyglobby": "^0.2.16",
     "unbash": "^2.2.0",
     "yaml": "^2.8.2",
     "zod": "^4.1.11"
@@ -99,12 +98,11 @@
     "@types/minimist": "^1.2.5",
     "@types/picomatch": "^4.0.1",
     "@types/webpack": "^5.28.5",
+    "@typescript/native-preview": "7.0.0-dev.20260415.1",
     "@wdio/types": "^9.20.0",
     "codeclimate-types": "^0.3.1",
-    "glob-bin": "^1.0.0",
     "prettier": "^3.8.1",
-    "tsx": "^4.21.0",
-    "typescript": "^5.8.3"
+    "tsx": "^4.21.0"
   },
   "engines": {
     "node": "^20.19.0 || >=22.12.0"
@@ -114,16 +112,11 @@
     "knip": "node ./src/cli.ts --directory ../..",
     "knip:production": "node ./src/cli.ts --directory ../.. --production --strict",
     "lint": "oxlint",
-    "format": "oxfmt -c ../../.oxfmtrc.json --ignore-path ../../.prettierignore",
-    "test": "node scripts/run-test.ts",
-    "test:node": "tsx --test test/*.test.ts test/**/*.test.ts",
-    "test:bun": "bun test test/*.test.ts test/**/*.test.ts",
-    "test:smoke": "glob-bin -c \"tsx --test\" \"test/*.test.ts\" && glob-bin -c \"tsx --test\" \"test/plugins/*.test.ts\" && glob-bin -c \"tsx --test\" \"test/util/*.test.ts\"",
-    "test:bun:smoke": "bun test test/*.test.ts test/{plugins,util}/*.test.ts",
-    "watch": "npm link && tsc --watch",
+    "fmt": "oxfmt -c ../../.oxfmtrc.json --ignore-path ../../.prettierignore",
+    "test": "node scripts/run-test.js",
     "prebuild": "pnpm run generate-plugin-defs && node rmdir.js dist",
-    "build": "tsc",
-    "qa": "pnpm lint && pnpm build && pnpm knip && pnpm knip:production && pnpm run test",
+    "build": "tsgo",
+    "qa": "pnpm lint && pnpm build && pnpm knip && pnpm knip:production && pnpm test",
     "release": "NODE_OPTIONS=--no-deprecation release-it",
     "create-plugin": "node ./scripts/create-new-plugin.ts",
     "postcreate-plugin": "pnpm run build && (oxfmt schema.json schema-jsonc.json src/schema/plugins.ts || true)",