knip 3.0.0-canary.3 → 3.0.0

package/dist/ProjectPrincipal.d.ts

@@ -5,6 +5,7 @@ import type { PrincipalOptions } from './PrincipalFactory.js';
 import type { SyncCompilers, AsyncCompilers } from './types/compilers.js';
 import type { ExportItem, ExportItemMember } from './types/exports.js';
 import type { UnresolvedImport } from './types/imports.js';
+import type { ProgramMaybe53 } from './typescript/SourceFile.js';
 import type { GlobbyFilterFunction } from 'globby';
 export declare class ProjectPrincipal {
     entryPaths: Set<string>;
@@ -21,7 +22,7 @@ export declare class ProjectPrincipal {
         compilerHost: ts.CompilerHost;
         resolveModuleNames: ReturnType<typeof createCustomModuleResolver>;
         lsFindReferences: ts.LanguageService['findReferences'];
-        program?: ts.Program;
+        program?: ProgramMaybe53;
     };
     constructor({ compilerOptions, cwd, compilers, isGitIgnored }: PrincipalOptions);
     private createProgram;

package/dist/ProjectPrincipal.js

@@ -111,7 +111,13 @@ export class ProjectPrincipal {
         if (!sourceFile)
             throw new Error(`Unable to find ${filePath}`);
         const skipExports = this.skipExportsAnalysis.has(filePath);
-        const { imports, exports, scripts } = getImportsAndExports(sourceFile, { skipTypeOnly, skipExports });
+        const getResolvedModule = specifier => this.backend.program?.getResolvedModule
+            ? this.backend.program.getResolvedModule(sourceFile, specifier, undefined)
+            : sourceFile.resolvedModules?.get(specifier, undefined);
+        const { imports, exports, scripts } = getImportsAndExports(sourceFile, getResolvedModule, {
+            skipTypeOnly,
+            skipExports,
+        });
         const { internal, unresolved, external } = imports;
         const unresolvedImports = new Set();
         unresolved.forEach(unresolvedImport => {

package/dist/binaries/resolvers/node.js

@@ -4,7 +4,7 @@ import { tryResolveFilePath, tryResolveSpecifiers } from '../util.js';
 export const resolve = (binary, args, { cwd }) => {
     const parsed = parseArgs(args, {
         string: ['r'],
-        alias: { require: ['r', 'loader', 'experimental-loader', 'test-reporter', 'watch'] },
+        alias: { require: ['r', 'loader', 'experimental-loader', 'test-reporter', 'watch', 'import'] },
     });
     return compact([tryResolveFilePath(cwd, parsed._[0]), ...tryResolveSpecifiers(cwd, [parsed.require].flat())]);
 };

package/dist/constants.d.ts

@@ -5,7 +5,6 @@ export declare const DEFAULT_EXTENSIONS: string[];
 export declare const GLOBAL_IGNORE_PATTERNS: string[];
 export declare const IGNORED_GLOBAL_BINARIES: string[];
 export declare const IGNORED_DEPENDENCIES: string[];
-export declare const VIRTUAL_FILE_EXTENSIONS: string[];
 export declare const IGNORED_FILE_EXTENSIONS: string[];
 export declare const IGNORE_DEFINITELY_TYPED: string[];
 export declare const ISSUE_TYPES: IssueType[];

package/dist/constants.js

@@ -35,12 +35,12 @@ export const IGNORED_GLOBAL_BINARIES = [
     'yarn',
 ];
 export const IGNORED_DEPENDENCIES = ['knip', 'typescript'];
-export const VIRTUAL_FILE_EXTENSIONS = ['.css', '.html', '.svg'];
 export const IGNORED_FILE_EXTENSIONS = [
-    ...VIRTUAL_FILE_EXTENSIONS,
     '.avif',
+    '.css',
     '.eot',
     '.gif',
+    '.html',
     '.ico',
     '.jpeg',
     '.jpg',
@@ -49,6 +49,7 @@ export const IGNORED_FILE_EXTENSIONS = [
     '.sass',
     '.scss',
     '.sh',
+    '.svg',
     '.ttf',
     '.webp',
     '.woff',

package/dist/plugins/babel/helpers.d.ts

@@ -1,5 +1,4 @@
-export declare const resolvePluginName: (pluginName: string) => string;
-export declare const resolvePresetName: (pluginName: string) => string;
+export declare const resolveName: (identifier: string, namespace: 'preset' | 'plugin') => string;
 export declare const api: {
     assertVersion: () => boolean;
     cache: {

package/dist/plugins/babel/helpers.js

@@ -1,24 +1,32 @@
-export const resolvePluginName = (pluginName) => {
-    if (!/babel/.test(pluginName))
-        return `babel-plugin-${pluginName}`;
-    if (pluginName.startsWith('@babel/')) {
-        if (pluginName.startsWith('@babel/plugin'))
-            return pluginName;
-        const [, name] = pluginName.split('/');
-        return `@babel/plugin-${name}`;
+import { isAbsolute, isInternal } from '../../util/path.js';
+export const resolveName = (identifier, namespace) => {
+    if (isAbsolute(identifier) || isInternal(identifier))
+        return identifier;
+    if (identifier.startsWith('module:'))
+        return identifier.replace(/^module:/, '');
+    if (identifier.startsWith('@')) {
+        const [scope, name, ...rest] = identifier.split('/');
+        if (rest.length > 0)
+            return identifier;
+        if (scope) {
+            if (!name)
+                return [scope, `babel-${namespace}`].join('/');
+            if (scope === '@babel') {
+                if (name.startsWith(namespace))
+                    return identifier;
+                return `@babel/${namespace}-${name}`;
+            }
+            if (name.includes(`babel-${namespace}`))
+                return identifier;
+            return [scope, `babel-${namespace}-${name}`].join('/');
+        }
     }
-    return pluginName;
-};
-export const resolvePresetName = (pluginName) => {
-    if (!/babel/.test(pluginName))
-        return `babel-preset-${pluginName}`;
-    if (pluginName.startsWith('@babel/')) {
-        if (pluginName.startsWith('@babel/preset'))
-            return pluginName;
-        const [, name] = pluginName.split('/');
-        return `@babel/preset-${name}`;
-    }
-    return pluginName;
+    const [name, ...rest] = identifier.split('/');
+    if (rest.length > 0)
+        return identifier;
+    if (name.startsWith(`babel-${namespace}`))
+        return identifier;
+    return `babel-${namespace}-${name}`;
 };
 const cacheFn = () => void 0;
 cacheFn.forever = () => cacheFn;

package/dist/plugins/babel/index.js

@@ -1,22 +1,20 @@
 import { compact } from '../../util/array.js';
 import { timerify } from '../../util/Performance.js';
 import { hasDependency, load } from '../../util/plugin.js';
-import { resolvePresetName, resolvePluginName, api } from './helpers.js';
+import { resolveName, api } from './helpers.js';
 export const NAME = 'Babel';
 export const ENABLERS = [/^@babel\//];
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
 export const CONFIG_FILE_PATTERNS = [
-    'babel.config.json',
-    'babel.config.js',
-    '.babelrc.json',
-    '.babelrc.js',
+    'babel.config.{json,js,cjs,mjs,cts}',
+    '.babelrc.{json,js,cjs,mjs,cts}',
     '.babelrc',
     'package.json',
 ];
-const getItemName = (value) => typeof value === 'string' ? [value] : Array.isArray(value) ? [value[0]] : [];
+const getName = (value) => typeof value === 'string' ? [value] : Array.isArray(value) ? [value[0]] : [];
 export const getDependenciesFromConfig = (config) => {
-    const presets = config.presets?.flatMap(getItemName).map(resolvePresetName) ?? [];
-    const plugins = config.plugins?.flatMap(getItemName).map(resolvePluginName) ?? [];
+    const presets = config.presets?.flatMap(getName).map(name => resolveName(name, 'preset')) ?? [];
+    const plugins = config.plugins?.flatMap(getName).map(name => resolveName(name, 'plugin')) ?? [];
     const nested = config.env ? Object.values(config.env).flatMap(getDependenciesFromConfig) : [];
     return compact([...presets, ...plugins, ...nested]);
 };

package/dist/plugins/eslint/helpers.js

@@ -3,6 +3,7 @@ import { getPackageNameFromModuleSpecifier } from '../../util/modules.js';
 import { isInternal, dirname, toAbsolute } from '../../util/path.js';
 import { load } from '../../util/plugin.js';
 import { _resolve } from '../../util/require.js';
+import { getDependenciesFromConfig } from '../babel/index.js';
 import { fallback } from './fallback.js';
 import { PACKAGE_JSON_PATH } from './index.js';
 const getDependencies = (config) => {
@@ -11,19 +12,12 @@ const getDependencies = (config) => {
         extendsSpecifiers.push('eslint-config-prettier');
     const plugins = config.plugins ? config.plugins.map(resolvePluginSpecifier) : [];
     const parser = config.parser;
-    const extraPlugins = config.parserOptions?.babelOptions?.plugins ?? [];
-    const extraParsers = config.parserOptions?.babelOptions?.presets ?? [];
+    const babelDependencies = config.parserOptions?.babelOptions
+        ? getDependenciesFromConfig(config.parserOptions.babelOptions)
+        : [];
     const settings = config.settings ? getDependenciesFromSettings(config.settings) : [];
     const overrides = config.overrides ? [config.overrides].flat().flatMap(getDependencies) : [];
-    return compact([
-        ...extendsSpecifiers,
-        ...plugins,
-        ...extraPlugins,
-        parser,
-        ...extraParsers,
-        ...settings,
-        ...overrides,
-    ]);
+    return compact([...extendsSpecifiers, ...plugins, parser, ...babelDependencies, ...settings, ...overrides]);
 };
 export const getDependenciesDeep = async (configFilePath, options, dependencies = new Set()) => {
     const addAll = (deps) => deps.forEach(dependency => dependencies.add(dependency));

package/dist/plugins/graphql-codegen/index.js

@@ -1,11 +1,18 @@
+import { isInternal } from '../../util/path.js';
 import { timerify } from '../../util/Performance.js';
 import { hasDependency, load } from '../../util/plugin.js';
+import { toEntryPattern } from '../../util/protocols.js';
 import { isConfigurationOutput } from './types.js';
 export const NAME = 'GraphQL Codegen';
 export const ENABLERS = [/^@graphql-codegen\//];
 export const PACKAGE_JSON_PATH = 'codegen';
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
-export const CONFIG_FILE_PATTERNS = ['codegen.{ts,js,json,yml,mjs,cts}', 'package.json'];
+export const CONFIG_FILE_PATTERNS = [
+    'codegen.{json,yml,yaml,js,ts,mjs,cts}',
+    '.codegenrc.{json,yml,yaml,js,ts}',
+    'codegen.config.js',
+    'package.json',
+];
 const findPluginDependencies = async (configFilePath, options) => {
     const { manifest, isProduction } = options;
     if (isProduction)
@@ -27,7 +34,13 @@ const findPluginDependencies = async (configFilePath, options) => {
         .map(plugin => `@graphql-codegen/${plugin}`);
     const nestedPlugins = configurationOutput
         .flatMap(configOutput => (configOutput.plugins ? configOutput.plugins : []))
-        .map(plugin => `@graphql-codegen/${plugin}`);
+        .flatMap(plugin => {
+        if (typeof plugin !== 'string')
+            return [];
+        if (isInternal(plugin))
+            return [toEntryPattern(plugin)];
+        return [`@graphql-codegen/${plugin}`];
+    });
     return [...presets, ...flatPlugins, ...nestedPlugins];
 };
 export const findDependencies = timerify(findPluginDependencies);

package/dist/plugins/vitest/index.js

@@ -7,7 +7,10 @@ import { getEnvPackageName, getExternalReporters } from './helpers.js';
 export const NAME = 'Vitest';
 export const ENABLERS = ['vitest'];
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
-export const CONFIG_FILE_PATTERNS = ['vitest.config.ts', 'vitest.{workspace,projects}.{ts,js,json}'];
+export const CONFIG_FILE_PATTERNS = [
+    'vitest.config.{js,mjs,ts,cjs,mts,cts}',
+    'vitest.{workspace,projects}.{ts,js,json}',
+];
 export const ENTRY_FILE_PATTERNS = ['**/*.{test,spec}.?(c|m)[jt]s?(x)'];
 const resolveEntry = (containingFilePath, specifier) => {
     const dir = dirname(containingFilePath);
@@ -24,7 +27,9 @@ const findConfigDependencies = (configFilePath, localConfig, options) => {
         return entryPatterns;
     const environments = testConfig.environment ? [getEnvPackageName(testConfig.environment)] : [];
     const reporters = getExternalReporters(testConfig.reporters);
-    const coverage = testConfig.coverage ? [`@vitest/coverage-${testConfig.coverage.provider ?? 'v8'}`] : [];
+    const coverage = testConfig.coverage && testConfig.coverage.enabled !== false
+        ? [`@vitest/coverage-${testConfig.coverage.provider ?? 'v8'}`]
+        : [];
     const setupFiles = [testConfig.setupFiles ?? []].flat().map(v => resolveEntry(configFilePath, v));
     const globalSetup = [testConfig.globalSetup ?? []].flat().map(v => resolveEntry(configFilePath, v));
     return [...entryPatterns, ...environments, ...reporters, ...coverage, ...setupFiles, ...globalSetup];

package/dist/plugins/vitest/types.d.ts

@@ -2,6 +2,7 @@ interface VitestConfig {
     test: {
         include: string[];
         coverage?: {
+            enabled?: boolean;
             provider: string;
         };
         environment?: string;

package/dist/reporters/symbols.js

@@ -12,7 +12,8 @@ const logIssueRecord = (issues) => {
         table.cell('symbol', print(issue.symbols ? truncate(issue.symbols.map(s => s.symbol).join(', ')) : issue.symbol));
         issue.parentSymbol && table.cell('parentSymbol', print(issue.parentSymbol));
         issue.symbolType && table.cell('symbolType', print(issue.symbolType));
-        table.cell('filePath', print(relative(issue.filePath)));
+        const filePath = `${relative(issue.filePath)}${issue.line === undefined ? '' : `:${issue.line}${issue.col === undefined ? '' : `:${issue.col}`}`}`;
+        table.cell('filePath', print(filePath));
         table.newRow();
     });
     console.log(table.sort(['filePath', 'parentSymbol', 'symbol']).print().trim());

package/dist/types/issues.js

@@ -7,4 +7,4 @@ export var SymbolType;
     SymbolType["CLASS"] = "class";
     SymbolType["MEMBER"] = "member";
     SymbolType["UNKNOWN"] = "unknown";
-})(SymbolType = SymbolType || (SymbolType = {}));
+})(SymbolType || (SymbolType = {}));

package/dist/typescript/SourceFile.d.ts

@@ -15,4 +15,8 @@ export interface BoundSourceFile extends ts.SourceFile {
     scriptKind?: ts.ScriptKind;
     pragmas?: Map<string, PragmaMap | PragmaMap[]>;
 }
+export interface ProgramMaybe53 extends ts.Program {
+    getResolvedModule?: (f: ts.SourceFile, moduleName: string, mode: ts.ResolutionMode) => ts.ResolvedModuleWithFailedLookupLocations | undefined;
+}
+export type GetResolvedModule = (name: string) => ts.ResolvedModuleWithFailedLookupLocations | undefined;
 export {};

package/dist/typescript/createHosts.js

@@ -1,7 +1,6 @@
 import { EOL } from 'node:os';
 import path from 'node:path';
 import ts from 'typescript';
-import { VIRTUAL_FILE_EXTENSIONS } from '../constants.js';
 import { createCustomModuleResolver } from './resolveModuleNames.js';
 import { SourceFileManager } from './SourceFileManager.js';
 import { createCustomSys } from './sys.js';
@@ -9,7 +8,7 @@ const libLocation = path.dirname(ts.getDefaultLibFilePath({}));
 const fileManager = new SourceFileManager();
 export const createHosts = ({ cwd, compilerOptions, entryPaths, compilers }) => {
     fileManager.installCompilers(compilers);
-    const virtualFileExtensions = [...VIRTUAL_FILE_EXTENSIONS, ...compilers[0].keys(), ...compilers[1].keys()];
+    const virtualFileExtensions = [...compilers[0].keys(), ...compilers[1].keys()];
     const sys = createCustomSys(cwd, virtualFileExtensions);
     const resolveModuleNames = createCustomModuleResolver(sys, compilerOptions, virtualFileExtensions);
     const languageServiceHost = {

package/dist/typescript/getImportsAndExports.d.ts

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import type { BoundSourceFile } from './SourceFile.js';
+import type { BoundSourceFile, GetResolvedModule } from './SourceFile.js';
 import type { ExportItems as Exports, ExportItem } from '../types/exports.js';
 import type { Imports, UnresolvedImport } from '../types/imports.js';
 import type { IssueSymbol } from '../types/issues.js';
@@ -17,7 +17,7 @@ export type AddImportOptions = {
 export type AddExportOptions = ExportItem & {
     identifier: string;
 };
-export declare const getImportsAndExports: (sourceFile: BoundSourceFile, options: GetImportsAndExportsOptions) => {
+export declare const getImportsAndExports: (sourceFile: BoundSourceFile, getResolvedModule: GetResolvedModule, options: GetImportsAndExportsOptions) => {
     imports: {
         internal: Imports;
         external: Set<string>;

package/dist/typescript/getImportsAndExports.js

@@ -13,7 +13,7 @@ const getVisitors = (sourceFile) => ({
     import: getImportVisitors(sourceFile),
     script: getScriptVisitors(sourceFile),
 });
-export const getImportsAndExports = (sourceFile, options) => {
+export const getImportsAndExports = (sourceFile, getResolvedModule, options) => {
     const internalImports = new Map();
     const externalImports = new Set();
     const unresolvedImports = new Set();
@@ -50,7 +50,7 @@ export const getImportsAndExports = (sourceFile, options) => {
         const { specifier, symbol, identifier = '__anonymous', isReExport = false, pos } = options;
         if (isBuiltin(specifier))
             return;
-        const module = sourceFile.resolvedModules?.get(specifier, undefined);
+        const module = getResolvedModule(specifier);
         if (module?.resolvedModule) {
             const filePath = module.resolvedModule.resolvedFileName;
             if (filePath) {

package/dist/typescript/resolveModuleNames.js

@@ -1,16 +1,17 @@
 import { existsSync } from 'node:fs';
+import { isBuiltin } from 'node:module';
 import ts from 'typescript';
 import { sanitizeSpecifier } from '../util/modules.js';
 import { dirname, extname, isAbsolute, isInternal, join } from '../util/path.js';
 import { isDeclarationFileExtension } from './ast-helpers.js';
 import { ensureRealFilePath, isVirtualFilePath } from './utils.js';
 const resolutionCache = new Map();
-const simpleResolver = (name, containingFile) => {
+const fileExists = (name, containingFile) => {
     const resolvedFileName = isAbsolute(name) ? name : join(dirname(containingFile), name);
     if (existsSync(resolvedFileName)) {
         return {
             resolvedFileName,
-            extension: extname(resolvedFileName),
+            extension: extname(name),
             isExternalLibraryImport: false,
             resolvedUsingTsExtension: false,
         };
@@ -29,11 +30,13 @@ export function createCustomModuleResolver(customSys, compilerOptions, virtualFi
     }
     function resolveModuleName(name, containingFile) {
         const sanitizedSpecifier = sanitizeSpecifier(name);
+        if (isBuiltin(sanitizedSpecifier))
+            return undefined;
         const tsResolvedModule = ts.resolveModuleName(sanitizedSpecifier, containingFile, compilerOptions, ts.sys).resolvedModule;
         if (!tsResolvedModule) {
             const extension = extname(sanitizedSpecifier);
-            if (extension && isInternal(sanitizedSpecifier) && !virtualFileExtensions.includes(extension)) {
-                const module = simpleResolver(sanitizedSpecifier, containingFile);
+            if (extension && !virtualFileExtensions.includes(extension)) {
+                const module = fileExists(sanitizedSpecifier, containingFile);
                 if (module)
                     return module;
             }
@@ -41,7 +44,7 @@ export function createCustomModuleResolver(customSys, compilerOptions, virtualFi
         if (tsResolvedModule &&
             isDeclarationFileExtension(tsResolvedModule?.extension) &&
             isInternal(tsResolvedModule.resolvedFileName)) {
-            const module = simpleResolver(sanitizedSpecifier, containingFile);
+            const module = fileExists(sanitizedSpecifier, containingFile);
             if (module)
                 return module;
         }

package/dist/typescript/visitors/exports/exportDeclaration.js

@@ -6,7 +6,12 @@ export default visit(() => true, node => {
         if (node.exportClause && ts.isNamedExports(node.exportClause)) {
             const type = node.isTypeOnly ? SymbolType.TYPE : SymbolType.UNKNOWN;
             return node.exportClause.elements.map(element => {
-                return { node: element, identifier: element.name.getText(), type, pos: element.name.pos };
+                return {
+                    node: element,
+                    identifier: element.name.getText(),
+                    type,
+                    pos: element.name.flowNode?.node?.pos ?? element.name.pos,
+                };
             });
         }
     }

package/dist/util/fs.js

@@ -34,7 +34,7 @@ export const parseJSON = async (filePath, contents) => {
         return JSON.parse(stripJsonComments(contents, { trailingCommas: true }));
     }
     catch (error) {
-        throw new LoaderError(`Error loading ${filePath}`, { cause: error });
+        throw new LoaderError(`Error parsing ${filePath}`, { cause: error });
     }
 };
 export const parseYAML = async (contents) => {

package/dist/util/loader.js

@@ -26,7 +26,7 @@ const load = async (filePath) => {
             const imported = await import(fileUrl.href);
             return imported.default ?? imported;
         }
-        if (isTypeModule(filePath)) {
+        if (ext === '.mts' || (ext === '.ts' && isTypeModule(filePath))) {
             return await jitiESM(filePath);
         }
         else {

package/dist/util/modules.js

@@ -1,6 +1,7 @@
+import { isBuiltin } from 'module';
 import { _glob } from './glob.js';
 import { getStringValues } from './object.js';
-import { toPosix } from './path.js';
+import { isAbsolute, toPosix } from './path.js';
 export const getPackageNameFromModuleSpecifier = (moduleSpecifier) => {
     if (!isMaybePackageName(moduleSpecifier))
         return;
@@ -52,7 +53,9 @@ export const getEntryPathFromManifest = (manifest, sharedGlobOptions) => {
     return _glob({ ...sharedGlobOptions, patterns: Array.from(entryPaths) });
 };
 export const sanitizeSpecifier = (specifier) => {
-    if (specifier.startsWith('node:'))
+    if (isBuiltin(specifier))
+        return specifier;
+    if (isAbsolute(specifier))
         return specifier;
     return specifier.replace(/^([?!|-]+)?([^!?:]+).*/, '$2');
 };

package/dist/util/parseArgs.d.ts

@@ -1,2 +1,3 @@
+/// <reference types="node" resolution-mode="require"/>
 declare let parseArgs: typeof import('node:util').parseArgs;
 export { parseArgs };

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "3.0.0-canary.3";
+export declare const version = "3.0.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '3.0.0-canary.3';
+export const version = '3.0.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "3.0.0-canary.3",
+  "version": "3.0.0",
   "description": "Find unused files, dependencies and exports in your TypeScript and JavaScript projects",
   "homepage": "https://knip.dev",
   "repository": {
@@ -46,7 +46,7 @@
     "@npmcli/map-workspaces": "3.0.4",
     "@pkgjs/parseargs": "0.11.0",
     "@pnpm/logger": "5.0.0",
-    "@pnpm/workspace.pkgs-graph": "2.0.10",
+    "@pnpm/workspace.pkgs-graph": "^2.0.10",
     "@snyk/github-codeowners": "1.1.0",
     "chalk": "^5.2.0",
     "easy-table": "1.2.0",
@@ -70,24 +70,24 @@
     "@knip/eslint-config": "0.0.0",
     "@npmcli/package-json": "5.0.0",
     "@release-it/bumper": "^6.0.1",
-    "@swc/cli": "0.1.62",
-    "@swc/core": "^1.3.96",
+    "@swc/cli": "^0.1.63",
+    "@swc/core": "^1.3.99",
     "@types/js-yaml": "^4.0.9",
-    "@types/micromatch": "^4.0.5",
+    "@types/micromatch": "^4.0.6",
     "@types/minimist": "^1.2.5",
-    "@types/node": "^20.9.0",
+    "@types/node": "^20.10.0",
     "@types/npmcli__map-workspaces": "^3.0.4",
     "@types/npmcli__package-json": "^4.0.3",
     "@types/pkgjs__parseargs": "^0.10.3",
     "@types/webpack": "^5.28.5",
     "c8": "8.0.1",
-    "eslint": "8.53.0",
-    "playwright": "1.39.0",
+    "eslint": "^8.54.0",
+    "playwright": "^1.40.0",
     "prettier": "^3.1.0",
     "release-it": "^17.0.0",
-    "tsx": "^4.1.2",
-    "type-fest": "^4.7.1",
-    "typescript": "5.0.4"
+    "tsx": "^4.5.0",
+    "type-fest": "^4.8.2",
+    "typescript": "5.3.2"
   },
   "engines": {
     "node": ">=18.6.0"