knip 5.25.1 → 5.26.0

package/dist/ConfigurationChief.js

@@ -152,11 +152,12 @@ export class ConfigurationChief {
     }
     async setWorkspaces() {
         this.ignoredWorkspacePatterns = this.getIgnoredWorkspacePatterns();
-        const [byName, byPkgName] = await mapWorkspaces(this.cwd, this.getListedWorkspaces());
+        this.additionalWorkspaceNames = await this.getAdditionalWorkspaceNames();
+        const workspaceNames = compact([...this.getListedWorkspaces(), ...this.additionalWorkspaceNames]);
+        const [byName, byPkgName] = await mapWorkspaces(this.cwd, workspaceNames);
         this.workspacePackages = byName;
         this.workspacePackagesByName = byPkgName;
         this.addRootPackage();
-        this.additionalWorkspaceNames = await this.getAdditionalWorkspaceNames();
         this.availableWorkspaceNames = this.getAvailableWorkspaceNames(byName.keys());
         this.availableWorkspacePkgNames = this.getAvailableWorkspacePkgNames(byPkgName.keys());
         this.availableWorkspaceDirs = this.availableWorkspaceNames

package/dist/DependencyDeputy.js

@@ -1,5 +1,5 @@
 import { isBuiltin } from 'node:module';
-import { IGNORED_DEPENDENCIES, IGNORED_GLOBAL_BINARIES, IGNORED_RUNTIME_DEPENDENCIES, IGNORE_DEFINITELY_TYPED, ROOT_WORKSPACE_NAME, } from './constants.js';
+import { DT_SCOPE, IGNORED_DEPENDENCIES, IGNORED_GLOBAL_BINARIES, IGNORED_RUNTIME_DEPENDENCIES, IGNORE_DEFINITELY_TYPED, ROOT_WORKSPACE_NAME, } from './constants.js';
 import { getDependencyMetaData } from './manifest/index.js';
 import { getDefinitelyTypedFor, getPackageFromDefinitelyTyped, isDefinitelyTyped } from './util/modules.js';
 import { findMatch, toRegexOrString } from './util/regex.js';
@@ -174,7 +174,7 @@ export class DependencyDeputy {
                 if (isPeerDep && peerDepRecs[dependency])
                     return false;
                 const [scope, typedDependency] = dependency.split('/');
-                if (scope === '@types') {
+                if (scope === DT_SCOPE) {
                     if (hasTypesIncluded?.has(typedDependency))
                         return false;
                     const typedPackageName = getPackageFromDefinitelyTyped(typedDependency);

package/dist/PrincipalFactory.d.ts

@@ -1,4 +1,4 @@
-import type ts from 'typescript';
+import ts from 'typescript';
 import { ProjectPrincipal } from './ProjectPrincipal.js';
 import type { AsyncCompilers, SyncCompilers } from './compilers/types.js';
 type Paths = ts.CompilerOptions['paths'];
@@ -11,6 +11,7 @@ type Principal = {
 type Principals = Set<Principal>;
 export type PrincipalOptions = {
     cwd: string;
+    isFile: boolean;
     compilerOptions: ts.CompilerOptions;
     paths: Paths;
     compilers: [SyncCompilers, AsyncCompilers];

package/dist/PrincipalFactory.js

@@ -1,3 +1,4 @@
+import ts from 'typescript';
 import { ProjectPrincipal } from './ProjectPrincipal.js';
 import { debugLog } from './util/debug.js';
 import { toAbsolute, toRelative } from './util/path.js';
@@ -16,8 +17,10 @@ const mergePaths = (cwd, compilerOptions, paths = {}) => {
 export class PrincipalFactory {
     principals = new Set();
     getPrincipal(options) {
-        const { cwd, compilerOptions, paths, pkgName, isIsolateWorkspaces, compilers } = options;
+        const { cwd, compilerOptions, isFile, paths, pkgName, isIsolateWorkspaces, compilers } = options;
         options.compilerOptions = mergePaths(cwd, compilerOptions, paths);
+        if (isFile)
+            compilerOptions.moduleResolution ??= ts.ModuleResolutionKind.Bundler;
         const principal = this.findReusablePrincipal(compilerOptions);
         if (!isIsolateWorkspaces && principal) {
             this.linkPrincipal(principal, cwd, compilerOptions, pkgName, compilers);
@@ -41,6 +44,7 @@ export class PrincipalFactory {
         const { pathsBasePath, paths } = compilerOptions;
         if (pathsBasePath)
             principal.principal.compilerOptions.pathsBasePath = pathsBasePath;
+        principal.principal.compilerOptions.moduleResolution ??= compilerOptions.moduleResolution;
         for (const p of Object.keys(paths ?? {}))
             principal.pathKeys.add(p);
         principal.principal.addPaths(paths);

package/dist/ProjectPrincipal.js

@@ -1,7 +1,7 @@
 import ts from 'typescript';
 import { CacheConsultant } from './CacheConsultant.js';
 import { getCompilerExtensions } from './compilers/index.js';
-import { ANONYMOUS, DEFAULT_EXTENSIONS, FOREIGN_FILE_EXTENSIONS } from './constants.js';
+import { ANONYMOUS, DEFAULT_EXTENSIONS, FOREIGN_FILE_EXTENSIONS, PUBLIC_TAG } from './constants.js';
 import { createHosts } from './typescript/createHosts.js';
 import { _getImportsAndExports } from './typescript/getImportsAndExports.js';
 import { timerify } from './util/Performance.js';
@@ -19,11 +19,11 @@ const baseCompilerOptions = {
     jsx: ts.JsxEmit.Preserve,
     jsxImportSource: undefined,
     lib: [],
-    types: ['node'],
     noEmit: true,
     skipDefaultLibCheck: true,
     skipLibCheck: true,
     sourceMap: false,
+    types: ['node'],
 };
 const tsCreateProgram = timerify(ts.createProgram);
 export class ProjectPrincipal {
@@ -47,7 +47,7 @@ export class ProjectPrincipal {
         this.compilerOptions = {
             ...compilerOptions,
             ...baseCompilerOptions,
-            types: compact([...(compilerOptions.types ?? []), ...baseCompilerOptions.types]),
+            types: compact([...(compilerOptions.types ?? []), ...(baseCompilerOptions.types ?? [])]),
             allowNonTsExtensions: true,
         };
         const [syncCompilers, asyncCompilers] = compilers;
@@ -218,7 +218,7 @@ export class ProjectPrincipal {
             this.findReferences = timerify(languageService.findReferences);
         }
         return members.filter(member => {
-            if (member.jsDocTags.has('@public'))
+            if (member.jsDocTags.has(PUBLIC_TAG))
                 return false;
             const referencedSymbols = this.findReferences?.(filePath, member.pos) ?? [];
             const refs = referencedSymbols.flatMap(refs => refs.references).filter(ref => !ref.isDefinition);
@@ -226,7 +226,7 @@ export class ProjectPrincipal {
         });
     }
     hasExternalReferences(filePath, exportedItem) {
-        if (exportedItem.jsDocTags.has('@public'))
+        if (exportedItem.jsDocTags.has(PUBLIC_TAG))
             return false;
         if (!this.findReferences) {
             const languageService = ts.createLanguageService(this.backend.languageServiceHost, ts.createDocumentRegistry());

package/dist/constants.d.ts

@@ -5,6 +5,11 @@ export declare const ANONYMOUS = "__anonymous";
 export declare const KNIP_CONFIG_LOCATIONS: string[];
 export declare const DEFAULT_EXTENSIONS: string[];
 export declare const GLOBAL_IGNORE_PATTERNS: string[];
+export declare const PUBLIC_TAG = "@public";
+export declare const INTERNAL_TAG = "@internal";
+export declare const BETA_TAG = "@beta";
+export declare const ALIAS_TAG = "@alias";
+export declare const DT_SCOPE = "@types";
 export declare const IGNORED_GLOBAL_BINARIES: Set<string>;
 export declare const IGNORED_DEPENDENCIES: Set<string>;
 export declare const IGNORED_RUNTIME_DEPENDENCIES: Set<string>;

package/dist/constants.js

@@ -13,6 +13,11 @@ export const KNIP_CONFIG_LOCATIONS = [
 ];
 export const DEFAULT_EXTENSIONS = ['.js', '.mjs', '.cjs', '.jsx', '.ts', '.tsx', '.mts', '.cts'];
 export const GLOBAL_IGNORE_PATTERNS = ['**/node_modules/**', '.yarn'];
+export const PUBLIC_TAG = '@public';
+export const INTERNAL_TAG = '@internal';
+export const BETA_TAG = '@beta';
+export const ALIAS_TAG = '@alias';
+export const DT_SCOPE = '@types';
 export const IGNORED_GLOBAL_BINARIES = new Set([
     'aws',
     'bash',

package/dist/index.js

@@ -15,7 +15,7 @@ import { debugLog, debugLogArray, debugLogObject } from './util/debug.js';
 import { addNsValues, addValues, createFileNode } from './util/dependency-graph.js';
 import { isFile } from './util/fs.js';
 import { _glob, negate } from './util/glob.js';
-import { getGitIgnoredFn } from './util/globby.js';
+import { getGitIgnoredHandler } from './util/globby.js';
 import { getHandler } from './util/handle-dependency.js';
 import { getHasStrictlyNsReferences, getType } from './util/has-strictly-ns-references.js';
 import { getIsIdentifierReferencedHandler } from './util/is-identifier-referenced.js';
@@ -33,7 +33,7 @@ export const main = async (unresolvedConfiguration) => {
     const deputy = new DependencyDeputy({ isProduction, isStrict });
     const factory = new PrincipalFactory();
     const streamer = new ConsoleStreamer({ isEnabled: isShowProgress });
-    const isGitIgnored = await getGitIgnoredFn({ cwd, gitignore });
+    const isGitIgnored = await getGitIgnoredHandler({ cwd, gitignore });
     const toSourceFilePath = getToSourcePathHandler(chief);
     streamer.cast('Reading workspace configuration(s)...');
     await chief.init();
@@ -74,6 +74,7 @@ export const main = async (unresolvedConfiguration) => {
         const principal = factory.getPrincipal({
             cwd: dir,
             paths: config.paths,
+            isFile,
             compilerOptions,
             compilers,
             pkgName,
@@ -270,9 +271,8 @@ export const main = async (unresolvedConfiguration) => {
             const resolvedFiles = principal.getUsedResolvedFiles();
             const files = resolvedFiles.filter(filePath => !analyzedFiles.has(filePath));
             debugLogArray('*', `Analyzing used resolved files [P${principals.indexOf(principal) + 1}/${++round}]`, files);
-            for (const filePath of files) {
+            for (const filePath of files)
                 analyzeSourceFile(filePath, principal);
-            }
         } while (size !== principal.entryPaths.size);
         for (const filePath of principal.getUnreferencedFiles())
             unreferencedFiles.add(filePath);

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

@@ -29,11 +29,13 @@ const resolveConfig = config => {
     const presets = configurationOutput
         .map(configOutput => (configOutput.preset ? configOutput.preset : undefined))
         .filter((preset) => typeof preset === 'string')
-        .map(presetName => `@graphql-codegen/${presetName}${presetName.endsWith('-preset') ? '' : '-preset'}`);
+        .map(presetName => presetName.startsWith('@graphql-codegen/')
+        ? presetName
+        : `@graphql-codegen/${presetName}${presetName.endsWith('-preset') ? '' : '-preset'}`);
     const flatPlugins = generateSet
         .filter((config) => !isConfigurationOutput(config))
         .flatMap(item => Object.keys(item))
-        .map(plugin => `@graphql-codegen/${plugin}`);
+        .map(plugin => plugin.includes('codegen-') ? plugin : `@graphql-codegen/${plugin}`);
     const nestedPlugins = configurationOutput
         .flatMap(configOutput => (configOutput.plugins ? configOutput.plugins : []))
         .flatMap(plugin => {
@@ -46,7 +48,7 @@ const resolveConfig = config => {
             return [];
         if (isInternal(plugin))
             return [toEntryPattern(plugin)];
-        return [`@graphql-codegen/${plugin}`];
+        return [plugin.includes('codegen-') ? plugin : `@graphql-codegen/${plugin}`];
     });
     return [...presets, ...flatPlugins, ...nestedPlugins];
 };

package/dist/typescript/find-internal-references.d.ts

@@ -0,0 +1,3 @@
+import ts from 'typescript';
+import type { Export, ExportMember } from '../types/dependency-graph.js';
+export declare const findInternalReferences: (item: Export | ExportMember, sourceFile: ts.SourceFile, typeChecker: ts.TypeChecker, referencedSymbolsInExportedTypes: Set<ts.Symbol>) => [number, boolean];

package/dist/typescript/find-internal-references.js

@@ -0,0 +1,45 @@
+import ts from 'typescript';
+import { isIdChar } from '../util/regex.js';
+const isType = (item) => item.type === 'type' || item.type === 'interface' || item.type === 'member';
+export const findInternalReferences = (item, sourceFile, typeChecker, referencedSymbolsInExportedTypes) => {
+    if (!item.symbol)
+        return [0, false];
+    if (item.symbol.flags & ts.SymbolFlags.AliasExcludes)
+        return [1, false];
+    const text = sourceFile.text;
+    const id = item.identifier;
+    const symbols = new Set();
+    let refCount = 0;
+    let isSymbolInExportedType = false;
+    let index = 0;
+    while (index < text.length && (index = text.indexOf(id, index)) !== -1) {
+        if (!isIdChar(text.charAt(index - 1)) && !isIdChar(text.charAt(index + id.length))) {
+            const isExportDeclaration = index === item.pos || index === item.pos + 1;
+            if (!isExportDeclaration) {
+                const symbol = typeChecker.getSymbolAtLocation(ts.getTokenAtPosition(sourceFile, index));
+                if (symbol) {
+                    const isInExportedType = referencedSymbolsInExportedTypes.has(symbol);
+                    if (isInExportedType)
+                        isSymbolInExportedType = true;
+                    if (item.symbol === symbol) {
+                        refCount++;
+                        if (isInExportedType || isType(item))
+                            return [refCount, isSymbolInExportedType];
+                    }
+                    const declaration = symbol.declarations?.[0];
+                    if (declaration) {
+                        if (item.symbol === declaration.name?.flowNode?.node?.symbol) {
+                            return [++refCount, isSymbolInExportedType];
+                        }
+                        if (ts.isImportSpecifier(declaration) && symbols.has(symbol)) {
+                            return [++refCount, isSymbolInExportedType];
+                        }
+                    }
+                    symbols.add(symbol);
+                }
+            }
+        }
+        index += id.length;
+    }
+    return [refCount, isSymbolInExportedType];
+};

package/dist/typescript/getImportsAndExports.js

@@ -1,13 +1,13 @@
 import { isBuiltin } from 'node:module';
 import ts from 'typescript';
-import { ANONYMOUS, DEFAULT_EXTENSIONS, IMPORT_STAR } from '../constants.js';
+import { ALIAS_TAG, ANONYMOUS, DEFAULT_EXTENSIONS, IMPORT_STAR } from '../constants.js';
 import { timerify } from '../util/Performance.js';
 import { addNsValue, addValue, createImports } from '../util/dependency-graph.js';
 import { isStartsLikePackageName, sanitizeSpecifier } from '../util/modules.js';
 import { extname, isInNodeModules } from '../util/path.js';
-import { isIdChar } from '../util/regex.js';
 import { shouldIgnore } from '../util/tag.js';
 import { getAccessMembers, getDestructuredIds, getJSDocTags, getLineAndCharacterOfPosition, getTypeName, isAccessExpression, isConsiderReferencedNS, isDestructuring, isImportSpecifier, isReferencedInExportedType, } from './ast-helpers.js';
+import { findInternalReferences } from './find-internal-references.js';
 import getDynamicImportVisitors from './visitors/dynamic-imports/index.js';
 import getExportVisitors from './visitors/exports/index.js';
 import { getImportsFromPragmas } from './visitors/helpers.js';
@@ -33,7 +33,6 @@ const createMember = (node, member, pos) => {
         jsDocTags: getJSDocTags(member.node),
     };
 };
-const isType = (item) => item.type === 'type' || item.type === 'interface' || item.type === 'member';
 const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options) => {
     const { skipTypeOnly, tags, ignoreExportsUsedInFile } = options;
     const internalImports = new Map();
@@ -193,7 +192,7 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options) =
                 isReExport,
             });
         }
-        if (!jsDocTags.has('@alias')) {
+        if (!jsDocTags.has(ALIAS_TAG)) {
             if (ts.isExportAssignment(node))
                 maybeAddAliasedExport(node.expression, 'default');
             if (ts.isVariableDeclaration(node))
@@ -308,54 +307,13 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options) =
     if (pragmaImports)
         for (const node of pragmaImports)
             addImport(node, sourceFile);
-    const setRefs = (item) => {
-        if (!item.symbol)
-            return;
-        if (item.symbol.flags & ts.SymbolFlags.AliasExcludes) {
-            item.refs = [1, false];
-            return;
-        }
-        const symbols = new Set();
-        let index = 0;
-        const text = sourceFile.text;
-        const id = item.identifier;
-        while (index < text.length && (index = text.indexOf(id, index)) !== -1) {
-            if (!isIdChar(text.charAt(index - 1)) && !isIdChar(text.charAt(index + id.length))) {
-                const isExportDeclaration = index === item.pos || index === item.pos + 1;
-                if (!isExportDeclaration) {
-                    const symbol = typeChecker.getSymbolAtLocation(ts.getTokenAtPosition(sourceFile, index));
-                    if (symbol) {
-                        const isInExportedType = referencedSymbolsInExportedTypes.has(symbol);
-                        if (item.symbol === symbol) {
-                            item.refs = [1, isInExportedType];
-                            if (isInExportedType || isType(item))
-                                break;
-                        }
-                        const declaration = symbol.declarations?.[0];
-                        if (declaration) {
-                            if (item.symbol === declaration.name?.flowNode?.node?.symbol) {
-                                item.refs = [1, isInExportedType];
-                                break;
-                            }
-                            if (ts.isImportSpecifier(declaration) && symbols.has(symbol)) {
-                                item.refs = [1, isInExportedType];
-                                break;
-                            }
-                        }
-                        symbols.add(symbol);
-                    }
-                }
-            }
-            index += id.length;
-        }
-    };
     const isSetRefs = ignoreExportsUsedInFile;
     for (const item of exports.values()) {
         if (isSetRefs === true || (typeof isSetRefs === 'object' && item.type !== 'unknown' && !!isSetRefs[item.type])) {
-            setRefs(item);
+            item.refs = findInternalReferences(item, sourceFile, typeChecker, referencedSymbolsInExportedTypes);
         }
         for (const member of item.members) {
-            setRefs(member);
+            member.refs = findInternalReferences(member, sourceFile, typeChecker, referencedSymbolsInExportedTypes);
             member.symbol = undefined;
         }
         item.symbol = undefined;

package/dist/typescript/resolveModuleNames.js

@@ -1,11 +1,10 @@
 import { existsSync } from 'node:fs';
 import { isBuiltin } from 'node:module';
-import { createMatchPath } from 'tsconfig-paths';
 import ts from 'typescript';
 import { DEFAULT_EXTENSIONS } from '../constants.js';
 import { timerify } from '../util/Performance.js';
 import { sanitizeSpecifier } from '../util/modules.js';
-import { dirname, extname, isAbsolute, isInNodeModules, join, toPosix } from '../util/path.js';
+import { dirname, extname, isAbsolute, isInNodeModules, join } from '../util/path.js';
 import { resolveSync } from '../util/resolve.js';
 import { isDeclarationFileExtension } from './ast-helpers.js';
 const resolutionCache = new Map();
@@ -23,6 +22,21 @@ const fileExists = (name, containingFile) => {
 export function createCustomModuleResolver(compilerOptions, customCompilerExtensions, toSourceFilePath, useCache = true) {
     const customCompilerExtensionsSet = new Set(customCompilerExtensions);
     const extensions = [...DEFAULT_EXTENSIONS, ...customCompilerExtensions];
+    const virtualDeclarationFiles = new Map();
+    const tsSys = {
+        ...ts.sys,
+        fileExists(path) {
+            if (ts.sys.fileExists(path)) {
+                return true;
+            }
+            const original = originalFromDeclarationPath(path);
+            if (original && ts.sys.fileExists(original.path)) {
+                virtualDeclarationFiles.set(path, original);
+                return true;
+            }
+            return false;
+        },
+    };
     function resolveModuleNames(moduleNames, containingFile) {
         return moduleNames.map(moduleName => {
             if (!useCache)
@@ -38,7 +52,6 @@ export function createCustomModuleResolver(compilerOptions, customCompilerExtens
             return resolvedModule;
         });
     }
-    const tsMatchPath = createMatchPath(compilerOptions.baseUrl ?? '/', compilerOptions.paths || {});
     function resolveModuleName(name, containingFile) {
         const sanitizedSpecifier = sanitizeSpecifier(name);
         if (isBuiltin(sanitizedSpecifier) || isInNodeModules(name))
@@ -64,16 +77,7 @@ export function createCustomModuleResolver(compilerOptions, customCompilerExtens
                 resolvedUsingTsExtension: false,
             };
         }
-        const pathMappedFileName = tsMatchPath(sanitizedSpecifier, undefined, undefined, []);
-        if (pathMappedFileName) {
-            const ext = extname(pathMappedFileName);
-            return {
-                resolvedFileName: toPosix(pathMappedFileName),
-                extension: customCompilerExtensionsSet.has(ext) ? ts.Extension.Js : ext,
-                isExternalLibraryImport: false,
-            };
-        }
-        const tsResolvedModule = ts.resolveModuleName(sanitizedSpecifier, containingFile, compilerOptions, ts.sys).resolvedModule;
+        const tsResolvedModule = ts.resolveModuleName(sanitizedSpecifier, containingFile, compilerOptions, tsSys).resolvedModule;
         if (tsResolvedModule) {
             if (isDeclarationFileExtension(tsResolvedModule.extension)) {
                 const srcFilePath = toSourceFilePath(tsResolvedModule.resolvedFileName);
@@ -86,6 +90,14 @@ export function createCustomModuleResolver(compilerOptions, customCompilerExtens
                     };
                 }
             }
+            const original = virtualDeclarationFiles.get(tsResolvedModule.resolvedFileName);
+            if (original) {
+                return {
+                    ...tsResolvedModule,
+                    resolvedFileName: original.path,
+                    extension: customCompilerExtensionsSet.has(original.ext) ? ts.Extension.Js : original.ext,
+                };
+            }
             return tsResolvedModule;
         }
         const module = fileExists(sanitizedSpecifier, containingFile);
@@ -95,3 +107,13 @@ export function createCustomModuleResolver(compilerOptions, customCompilerExtens
     }
     return timerify(resolveModuleNames);
 }
+const declarationPathRe = /^(.*)\.d(\.[^.]+)\.ts$/;
+function originalFromDeclarationPath(path) {
+    const match = declarationPathRe.exec(path);
+    if (match) {
+        return {
+            path: match[1] + match[2],
+            ext: match[2],
+        };
+    }
+}

package/dist/util/globby.d.ts

@@ -1,4 +1,4 @@
-import type { Options as FastGlobOptions } from 'fast-glob';
+import { type Options as FastGlobOptions } from 'fast-glob';
 type Options = {
     gitignore: boolean;
     cwd: string;
@@ -10,5 +10,5 @@ type GlobOptions = {
 } & FastGlobOptionsWithoutCwd;
 type FastGlobOptionsWithoutCwd = Pick<FastGlobOptions, 'onlyDirectories' | 'ignore' | 'absolute' | 'dot'>;
 export declare function globby(patterns: string | string[], options: GlobOptions): Promise<string[]>;
-export declare function getGitIgnoredFn(options: Options): Promise<(path: string) => boolean>;
+export declare function getGitIgnoredHandler(options: Options): Promise<(path: string) => boolean>;
 export {};

package/dist/util/globby.js

@@ -1,7 +1,7 @@
 import { readFileSync } from 'node:fs';
 import { promisify } from 'node:util';
 import { walk as _walk } from '@nodelib/fs.walk';
-import fg from 'fast-glob';
+import fg, {} from 'fast-glob';
 import picomatch from 'picomatch';
 import { GLOBAL_IGNORE_PATTERNS, ROOT_WORKSPACE_NAME } from '../constants.js';
 import { timerify } from './Performance.js';
@@ -128,7 +128,7 @@ export async function globby(patterns, options) {
     debugLogObject(relative(options.cwd, dir) || ROOT_WORKSPACE_NAME, 'Glob options', { patterns, ...options });
     return fg.glob(patterns, fastGlobOptions);
 }
-export async function getGitIgnoredFn(options) {
+export async function getGitIgnoredHandler(options) {
     cachedIgnores.clear();
     if (options.gitignore === false)
         return () => false;

package/dist/util/modules.js

@@ -1,4 +1,5 @@
 import { isBuiltin } from 'node:module';
+import { DT_SCOPE } from '../constants.js';
 import { _glob } from './glob.js';
 import { getStringValues } from './object.js';
 import { isAbsolute, toPosix } from './path.js';
@@ -8,26 +9,28 @@ export const getPackageNameFromModuleSpecifier = (moduleSpecifier) => {
     const parts = moduleSpecifier.split('/').slice(0, 2);
     return moduleSpecifier.startsWith('@') ? parts.join('/') : parts[0];
 };
+const lastPackageNameMatch = /(?<=node_modules\/)(@[^/]+\/[^/]+|[^/]+)/g;
 export const getPackageNameFromFilePath = (value) => {
-    const match = toPosix(value).match(/(?<=node_modules\/)(@[^/]+\/[^/]+|[^/]+)/g);
+    const match = toPosix(value).match(lastPackageNameMatch);
     if (match)
         return match[match.length - 1];
     return value;
 };
+const packageNameMatch = /.*\/node_modules\/(.+)/;
 export const normalizeSpecifierFromFilePath = (value) => {
-    const match = toPosix(value).match(/.*\/node_modules\/(.+)/);
+    const match = toPosix(value).match(packageNameMatch);
     if (match)
         return match[match.length - 1];
     return value;
 };
 export const isStartsLikePackageName = (specifier) => /^@?[a-z0-9]/.test(specifier);
-export const isDefinitelyTyped = (packageName) => packageName.startsWith('@types/');
+export const isDefinitelyTyped = (packageName) => packageName.startsWith(`${DT_SCOPE}/`);
 export const getDefinitelyTypedFor = (packageName) => {
     if (isDefinitelyTyped(packageName))
         return packageName;
     if (packageName.startsWith('@'))
-        return `@types/${packageName.slice(1).replace('/', '__')}`;
-    return `@types/${packageName}`;
+        return [DT_SCOPE, packageName.slice(1).replace('/', '__')].join('/');
+    return [DT_SCOPE, packageName].join('/');
 };
 export const getPackageFromDefinitelyTyped = (typedDependency) => {
     if (typedDependency.includes('__')) {
@@ -58,6 +61,7 @@ export const getEntryPathFromManifest = (manifest, sharedGlobOptions) => {
         entryPaths.add(typings);
     return _glob({ ...sharedGlobOptions, patterns: Array.from(entryPaths) });
 };
+const matchDirectives = /^([?!|-]+)?([^!?:]+).*/;
 export const sanitizeSpecifier = (specifier) => {
     if (isBuiltin(specifier))
         return specifier;
@@ -65,5 +69,5 @@ export const sanitizeSpecifier = (specifier) => {
         return specifier;
     if (specifier.startsWith('virtual:'))
         return specifier;
-    return specifier.replace(/^([?!|-]+)?([^!?:]+).*/, '$2');
+    return specifier.replace(matchDirectives, '$2');
 };

package/dist/util/regex.js

@@ -1,4 +1,5 @@
-export const toRegexOrString = (value) => typeof value === 'string' && /[*+\\(|{^$]/.test(value) ? new RegExp(value) : value;
+const isRegexLike = /[*+\\(|{^$]/;
+export const toRegexOrString = (value) => typeof value === 'string' && isRegexLike.test(value) ? new RegExp(value) : value;
 export const findMatch = (haystack, needle) => haystack?.find(n => (typeof n === 'string' ? n === needle : n.test(needle)));
 const idCharMatch = /[a-zA-Z0-9$_]/;
 export const isIdChar = (text) => idCharMatch.test(text);

package/dist/util/tag.js

@@ -1,3 +1,4 @@
+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) => {
@@ -16,8 +17,8 @@ export const shouldIgnore = (jsDocTags, tags) => {
         return true;
     return false;
 };
-export const getShouldIgnoreHandler = (isProduction) => (jsDocTags) => jsDocTags.has('@public') ||
-    jsDocTags.has('@beta') ||
-    jsDocTags.has('@alias') ||
-    (isProduction && jsDocTags.has('@internal'));
+export const getShouldIgnoreHandler = (isProduction) => (jsDocTags) => jsDocTags.has(PUBLIC_TAG) ||
+    jsDocTags.has(BETA_TAG) ||
+    jsDocTags.has(ALIAS_TAG) ||
+    (isProduction && jsDocTags.has(INTERNAL_TAG));
 export const getShouldIgnoreTagHandler = (tags) => (jsDocTags) => shouldIgnore(jsDocTags, tags);

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.25.1";
+export declare const version = "5.26.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '5.25.1';
+export const version = '5.26.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "5.25.1",
+  "version": "5.26.0",
   "description": "Find unused files, dependencies and exports in your TypeScript and JavaScript projects",
   "homepage": "https://knip.dev",
   "repository": {
@@ -75,7 +75,6 @@
     "smol-toml": "^1.1.4",
     "strip-json-comments": "5.0.1",
     "summary": "2.1.0",
-    "tsconfig-paths": "^4.2.0",
     "zod": "^3.22.4",
     "zod-validation-error": "^3.0.3"
   },