knip 6.3.1 → 6.4.1

package/dist/typescript/comments.d.ts

@@ -0,0 +1,4 @@
+import type { Comment } from 'oxc-parser';
+type CommentImportAdder = (specifier: string, identifier: string | undefined, alias: string | undefined, namespace: string | undefined, pos: number, modifiers: number) => void;
+export declare const extractImportsFromComments: (comments: readonly Comment[], firstStmtStart: number, addImport: CommentImportAdder) => void;
+export {};

package/dist/typescript/comments.js

@@ -0,0 +1,64 @@
+import { IMPORT_FLAGS } from "../constants.js";
+const jsDocImportRe = /import\(\s*['"]([^'"]+)['"]\s*\)(?:\.(\w+))?/g;
+const jsDocImportTagRe = /@import\s+(?:\{[^}]*\}|\*\s+as\s+\w+)\s+from\s+['"]([^'"]+)['"]/g;
+const jsxImportSourceRe = /@jsxImportSource\s+(\S+)/;
+const referenceTypesRe = /\s*<reference\s+types\s*=\s*"([^"]+)"[^/]*\/>/;
+const envPragmaRe = /@(vitest|jest)-environment\s+([@\w./-]+)/g;
+const resolveEnvironmentPragma = (tool, value) => {
+    if (value === 'node')
+        return undefined;
+    if (value.startsWith('.') || value.startsWith('/'))
+        return value;
+    if (tool === 'jest') {
+        if (value === 'jsdom')
+            return 'jest-environment-jsdom';
+        return value;
+    }
+    if (value === 'edge-runtime')
+        return '@edge-runtime/vm';
+    return value;
+};
+export const extractImportsFromComments = (comments, firstStmtStart, addImport) => {
+    for (const comment of comments) {
+        const text = comment.value;
+        let results;
+        if (comment.type === 'Block') {
+            jsDocImportRe.lastIndex = 0;
+            while ((results = jsDocImportRe.exec(text)) !== null) {
+                const before = text.slice(0, results.index);
+                const lastOpen = before.lastIndexOf('{');
+                if (lastOpen === -1 || before.indexOf('}', lastOpen) !== -1)
+                    continue;
+                const specifier = results[1];
+                const member = results[2];
+                addImport(specifier, member, undefined, undefined, comment.start + results.index, IMPORT_FLAGS.TYPE_ONLY);
+            }
+            jsDocImportTagRe.lastIndex = 0;
+            while ((results = jsDocImportTagRe.exec(text)) !== null) {
+                const specifier = results[1];
+                addImport(specifier, undefined, undefined, undefined, comment.start + results.index, IMPORT_FLAGS.TYPE_ONLY);
+            }
+        }
+        const jsxMatch = text.match(jsxImportSourceRe);
+        if (jsxMatch) {
+            addImport(jsxMatch[1], undefined, undefined, undefined, comment.start, IMPORT_FLAGS.TYPE_ONLY);
+        }
+        if (comment.end <= firstStmtStart) {
+            envPragmaRe.lastIndex = 0;
+            while ((results = envPragmaRe.exec(text)) !== null) {
+                const id = resolveEnvironmentPragma(results[1], results[2]);
+                if (!id)
+                    continue;
+                const isLocal = id.startsWith('.') || id.startsWith('/');
+                const modifiers = isLocal ? IMPORT_FLAGS.ENTRY : IMPORT_FLAGS.NONE;
+                addImport(id, undefined, undefined, undefined, comment.start + results.index, modifiers);
+            }
+        }
+        if (comment.type === 'Line') {
+            const refMatch = comment.value.match(referenceTypesRe);
+            if (refMatch) {
+                addImport(refMatch[1], undefined, undefined, undefined, comment.start, IMPORT_FLAGS.TYPE_ONLY);
+            }
+        }
+    }
+};

package/dist/typescript/get-imports-and-exports.js

@@ -5,14 +5,10 @@ import { getPackageNameFromFilePath, isStartsLikePackageName, sanitizeSpecifier
 import { timerify } from "../util/Performance.js";
 import { dirname, isInNodeModules, resolve } from "../util/path.js";
 import { shouldIgnore } from "../util/tag.js";
-import { buildLineStarts, getLineAndCol, parseFile, shouldCountRefs, stripQuotes, } from "./visitors/helpers.js";
+import { extractImportsFromComments } from "./comments.js";
+import { buildLineStarts, getLineAndCol, parseFile, shouldCountRefs, } from "./visitors/helpers.js";
 import { buildJSDocTagLookup } from "./visitors/jsdoc.js";
 import { walkAST } from "./visitors/walk.js";
-const jsDocImportRe = /import\(\s*['"]([^'"]+)['"]\s*\)(?:\.(\w+))?/g;
-const jsDocImportTagRe = /@import\s+(?:\{[^}]*\}|\*\s+as\s+\w+)\s+from\s+['"]([^'"]+)['"]/g;
-const jsxImportSourceRe = /@jsxImportSource\s+(\S+)/;
-const referenceTypesRe = /\s*<reference\s+types\s*=\s*"([^"]+)"[^/]*\/>/;
-const envRe = /@(?:vitest|jest)-environment\s+(\S+)/g;
 const getImportsAndExports = (filePath, sourceText, resolveModule, options, ignoreExportsUsedInFile, skipExportsForFile, visitor, pluginCtx, cachedParseResult) => {
     const skipExports = skipExportsForFile || !options.isReportExports;
     const internal = new Map();
@@ -166,10 +162,19 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
     const lineStarts = buildLineStarts(sourceText);
     const getJSDocTags = buildJSDocTagLookup(result.comments, sourceText);
     let hasNodeModuleImport = false;
+    let hasWorkerThreadsImport = false;
+    let hasChildProcessImport = false;
+    let hasPathJoinImport = false;
+    let hasPathResolveImport = false;
     for (const _imports of result.module.staticImports) {
         const specifier = _imports.moduleRequest.value;
         if (specifier === 'node:module' || specifier === 'module')
             hasNodeModuleImport = true;
+        else if (specifier === 'node:worker_threads' || specifier === 'worker_threads')
+            hasWorkerThreadsImport = true;
+        else if (specifier === 'node:child_process' || specifier === 'child_process')
+            hasChildProcessImport = true;
+        const isPathImport = specifier === 'node:path' || specifier === 'path';
         const pos = _imports.moduleRequest.start;
         const jsdocTags = getJSDocTags(_imports.start);
         if (_imports.entries.length === 0) {
@@ -199,6 +204,12 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
                 const importedName = entry.importName.name;
                 const localName = entry.localName.value;
                 const alias = localName !== importedName ? localName : undefined;
+                if (isPathImport && !alias) {
+                    if (importedName === 'join')
+                        hasPathJoinImport = true;
+                    else if (importedName === 'resolve')
+                        hasPathResolveImport = true;
+                }
                 addImport(specifier, importedName, alias, undefined, entry.localName.start, modifiers, pos, jsdocTags, resolved);
                 if (internalPath)
                     localImportMap.set(localName, { importedName, filePath: internalPath, isNamespace: false });
@@ -263,52 +274,18 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
         localRefs: ignoreExportsUsedInFile ? new Set() : undefined,
         destructuredExports,
         hasNodeModuleImport,
+        hasWorkerThreadsImport,
+        hasChildProcessImport,
+        hasPathJoinImport,
+        hasPathResolveImport,
         resolveModule,
         programFiles,
         entryFiles,
         visitor,
         getJSDocTags,
     });
-    for (const comment of result.comments) {
-        const text = comment.value;
-        let results;
-        if (comment.type === 'Block') {
-            jsDocImportRe.lastIndex = 0;
-            while ((results = jsDocImportRe.exec(text)) !== null) {
-                const before = text.slice(0, results.index);
-                const lastOpen = before.lastIndexOf('{');
-                if (lastOpen === -1 || before.indexOf('}', lastOpen) !== -1)
-                    continue;
-                const specifier = results[1];
-                const member = results[2];
-                addImport(specifier, member, undefined, undefined, comment.start + results.index, IMPORT_FLAGS.TYPE_ONLY);
-            }
-            jsDocImportTagRe.lastIndex = 0;
-            while ((results = jsDocImportTagRe.exec(text)) !== null) {
-                const specifier = results[1];
-                addImport(specifier, undefined, undefined, undefined, comment.start + results.index, IMPORT_FLAGS.TYPE_ONLY);
-            }
-        }
-        const jsxMatch = text.match(jsxImportSourceRe);
-        if (jsxMatch) {
-            addImport(jsxMatch[1], undefined, undefined, undefined, comment.start, IMPORT_FLAGS.TYPE_ONLY);
-        }
-        envRe.lastIndex = 0;
-        while ((results = envRe.exec(text)) !== null) {
-            const id = stripQuotes(results[1]);
-            if (!id)
-                continue;
-            const isLocal = id.startsWith('.') || id.startsWith('/');
-            const modifiers = isLocal ? IMPORT_FLAGS.ENTRY : IMPORT_FLAGS.NONE;
-            addImport(id, undefined, undefined, undefined, comment.start + results.index, modifiers);
-        }
-        if (comment.type === 'Line') {
-            const refMatch = comment.value.match(referenceTypesRe);
-            if (refMatch) {
-                addImport(refMatch[1], undefined, undefined, undefined, comment.start, IMPORT_FLAGS.TYPE_ONLY);
-            }
-        }
-    }
+    const firstStmtStart = result.program.body[0]?.start ?? Number.POSITIVE_INFINITY;
+    extractImportsFromComments(result.comments, firstStmtStart, addImport);
     for (const [id, item] of exports) {
         item.referencedIn = referencedInExport.get(id);
         if (localRefs && shouldCountRefs(ignoreExportsUsedInFile, item.type) && (localRefs.has(id) || item.isReExport)) {

package/dist/typescript/resolve-module-names.d.ts

@@ -1,5 +1,6 @@
 import type { ToSourceFilePath } from '../util/to-source-path.ts';
 import type { ResolveModule } from './visitors/helpers.ts';
+export declare function clearModuleResolutionCaches(): void;
 export declare function createCustomModuleResolver(compilerOptions: {
     paths?: Record<string, string[]>;
     rootDirs?: string[];

package/dist/typescript/resolve-module-names.js

@@ -5,6 +5,11 @@ import { sanitizeSpecifier } from "../util/modules.js";
 import { timerify } from "../util/Performance.js";
 import { dirname, extname, isAbsolute, isInNodeModules, join } from "../util/path.js";
 import { _createSyncModuleResolver, _resolveModuleSync } from "../util/resolve.js";
+const moduleResolutionCaches = [];
+export function clearModuleResolutionCaches() {
+    for (const cache of moduleResolutionCaches)
+        cache.clear();
+}
 function compilePathMappings(paths) {
     if (!paths)
         return undefined;
@@ -40,7 +45,24 @@ export function createCustomModuleResolver(compilerOptions, customCompilerExtens
             isExternalLibraryImport: mapped === resolvedFileName && isInNodeModules(resolvedFileName),
         };
     }
+    const cache = new Map();
+    moduleResolutionCaches.push(cache);
     function resolveModuleName(name, containingFile) {
+        const dir = dirname(containingFile);
+        let byName = cache.get(dir);
+        if (byName) {
+            if (byName.has(name))
+                return byName.get(name);
+        }
+        else {
+            byName = new Map();
+            cache.set(dir, byName);
+        }
+        const result = resolveModuleNameUncached(name, containingFile);
+        byName.set(name, result);
+        return result;
+    }
+    function resolveModuleNameUncached(name, containingFile) {
         const specifier = sanitizeSpecifier(name);
         if (isBuiltin(specifier))
             return undefined;

package/dist/typescript/visitors/calls.js

@@ -1,6 +1,47 @@
 import { IMPORT_FLAGS, OPAQUE } from "../../constants.js";
 import { addValue } from "../../util/module-graph.js";
 import { getStringValue, isStringLiteral } from "./helpers.js";
+function extractInlineDirnamePath(node, s) {
+    if (node?.type !== 'CallExpression')
+        return undefined;
+    const callee = node.callee;
+    let isPathHelper = false;
+    if (callee?.type === 'MemberExpression' &&
+        !callee.computed &&
+        callee.object?.type === 'Identifier' &&
+        callee.object.name === 'path' &&
+        callee.property?.type === 'Identifier' &&
+        (callee.property.name === 'join' || callee.property.name === 'resolve')) {
+        isPathHelper = true;
+    }
+    else if (callee?.type === 'Identifier') {
+        if (callee.name === 'join' && s.hasPathJoinImport)
+            isPathHelper = true;
+        else if (callee.name === 'resolve' && s.hasPathResolveImport)
+            isPathHelper = true;
+    }
+    if (!isPathHelper)
+        return undefined;
+    const args = node.arguments;
+    if (!args || args.length < 2)
+        return undefined;
+    if (args[0]?.type !== 'Identifier' || args[0].name !== '__dirname')
+        return undefined;
+    const parts = [];
+    for (let i = 1; i < args.length; i++) {
+        if (!isStringLiteral(args[i]))
+            return undefined;
+        const value = getStringValue(args[i]);
+        if (value == null)
+            return undefined;
+        parts.push(value);
+    }
+    if (parts.length === 0)
+        return undefined;
+    const joined = parts.join('/').replace(/\/+/g, '/');
+    return joined.startsWith('.') || joined.startsWith('/') ? joined : `./${joined}`;
+}
+const CHILD_PROCESS_ENTRY_METHODS = new Set(['fork', 'spawn', 'execFile']);
 export function handleCallExpression(node, s) {
     if (node.callee.type === 'Identifier' &&
         node.callee.name === 'require' &&
@@ -53,6 +94,25 @@ export function handleCallExpression(node, s) {
             return;
         }
     }
+    if (s.hasChildProcessImport && node.arguments.length >= 1) {
+        let isChildProcessEntry = false;
+        if (node.callee.type === 'Identifier' && CHILD_PROCESS_ENTRY_METHODS.has(node.callee.name)) {
+            isChildProcessEntry = true;
+        }
+        else if (node.callee.type === 'MemberExpression' &&
+            !node.callee.computed &&
+            node.callee.property.type === 'Identifier' &&
+            CHILD_PROCESS_ENTRY_METHODS.has(node.callee.property.name)) {
+            isChildProcessEntry = true;
+        }
+        if (isChildProcessEntry) {
+            const specifier = extractInlineDirnamePath(node.arguments[0], s);
+            if (specifier) {
+                s.addImport(specifier, undefined, undefined, undefined, node.arguments[0].start, IMPORT_FLAGS.ENTRY);
+                return;
+            }
+        }
+    }
     if (node.callee.type === 'MemberExpression' &&
         !node.callee.computed &&
         node.callee.object.type === 'Identifier' &&
@@ -70,12 +130,15 @@ export function handleCallExpression(node, s) {
                     if (internalImport) {
                         if (_import.isNamespace)
                             addValue(internalImport.import, OPAQUE, s.filePath);
-                        else
+                        else {
                             internalImport.refs.add(arg.name);
+                            (internalImport.enumerated ??= new Set()).add(arg.name);
+                        }
                     }
                 }
             }
         }
+        return;
     }
     const markRefIfNs = (name) => {
         const _import = s.localImportMap.get(name);
@@ -116,5 +179,15 @@ export function handleNewExpression(node, s) {
         const specifier = getStringValue(node.arguments[0]);
         if (specifier)
             s.addImport(specifier, undefined, undefined, undefined, node.arguments[0].start, IMPORT_FLAGS.ENTRY | IMPORT_FLAGS.OPTIONAL);
+        return;
+    }
+    if (s.hasWorkerThreadsImport &&
+        node.callee.type === 'Identifier' &&
+        node.callee.name === 'Worker' &&
+        node.arguments.length >= 1) {
+        const specifier = extractInlineDirnamePath(node.arguments[0], s);
+        if (specifier) {
+            s.addImport(specifier, undefined, undefined, undefined, node.arguments[0].start, IMPORT_FLAGS.ENTRY);
+        }
     }
 }

package/dist/typescript/visitors/walk.d.ts

@@ -33,6 +33,10 @@ interface WalkContext {
     localRefs: Set<string> | undefined;
     destructuredExports: Set<string>;
     hasNodeModuleImport: boolean;
+    hasWorkerThreadsImport: boolean;
+    hasChildProcessImport: boolean;
+    hasPathJoinImport: boolean;
+    hasPathResolveImport: boolean;
     resolveModule: ResolveModule;
     programFiles: Set<string>;
     entryFiles: Set<string>;

package/dist/util/create-options.d.ts

@@ -407,6 +407,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'panda-css'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         parcel?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1123,6 +1128,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
                 entry?: string | string[] | undefined;
                 project?: string | string[] | undefined;
             } | undefined;
+            'panda-css'?: string | boolean | string[] | {
+                config?: string | string[] | undefined;
+                entry?: string | string[] | undefined;
+                project?: string | string[] | undefined;
+            } | undefined;
             parcel?: string | boolean | string[] | {
                 config?: string | string[] | undefined;
                 entry?: string | string[] | undefined;

package/dist/util/file-entry-cache.js

@@ -85,14 +85,21 @@ export class FileEntryCache {
         return meta;
     }
     reconcile() {
-        this.removeNotFoundFiles();
         for (const [entryName, cacheEntry] of this.normalizedEntries) {
             try {
-                const meta = this._getMetaForFileUsingMtimeAndSize(cacheEntry);
+                const stat = fs.statSync(entryName);
+                const meta = Object.assign(cacheEntry.meta ?? {}, {
+                    size: stat.size,
+                    mtime: stat.mtime.getTime(),
+                });
                 this.cache.set(entryName, meta);
             }
             catch (error) {
-                if (error.code !== 'ENOENT')
+                if (error.code === 'ENOENT') {
+                    this.normalizedEntries.delete(entryName);
+                    this.cache.delete(entryName);
+                }
+                else
                     throw error;
             }
         }

package/dist/util/glob-cache.d.ts

@@ -0,0 +1,12 @@
+export declare const initGlobCache: (cacheLocation: string) => void;
+export declare const isGlobCacheEnabled: () => boolean;
+export declare const computeGlobCacheKey: (input: {
+    patterns: string[];
+    cwd: string;
+    dir: string;
+    gitignore: boolean;
+}) => string;
+export declare const getCachedGlob: (key: string) => string[] | undefined;
+export declare const setCachedGlob: (key: string, paths: string[], baseDir: string) => void;
+export declare const clearGlobCache: () => void;
+export declare const flushGlobCache: () => void;

package/dist/util/glob-cache.js

@@ -0,0 +1,124 @@
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { deserialize, serialize } from 'node:v8';
+import { version } from "../version.js";
+import { debugLog } from "./debug.js";
+import { isDirectory, isFile } from "./fs.js";
+import { dirname } from "./path.js";
+const CACHE_FILENAME = `glob-${version}.cache`;
+let cacheFilePath;
+let cache;
+let isDirty = false;
+export const initGlobCache = (cacheLocation) => {
+    cacheFilePath = path.resolve(cacheLocation, CACHE_FILENAME);
+    if (isFile(cacheFilePath)) {
+        try {
+            cache = deserialize(fs.readFileSync(cacheFilePath));
+        }
+        catch {
+            debugLog('*', `Error reading glob cache from ${cacheFilePath}`);
+            cache = new Map();
+        }
+    }
+    else {
+        cache = new Map();
+    }
+};
+export const isGlobCacheEnabled = () => cache !== undefined;
+export const computeGlobCacheKey = (input) => {
+    const h = createHash('sha1');
+    h.update(input.cwd);
+    h.update('\0');
+    h.update(input.dir);
+    h.update('\0');
+    h.update(input.gitignore ? '1' : '0');
+    h.update('\0');
+    for (const p of input.patterns) {
+        h.update(p);
+        h.update('\0');
+    }
+    return h.digest('base64url');
+};
+const validateEntry = (entry) => {
+    for (const dir in entry.dirMtimes) {
+        try {
+            const stat = fs.statSync(dir);
+            if (stat.mtimeMs !== entry.dirMtimes[dir])
+                return false;
+        }
+        catch {
+            return false;
+        }
+    }
+    return true;
+};
+export const getCachedGlob = (key) => {
+    if (!cache)
+        return undefined;
+    const entry = cache.get(key);
+    if (!entry)
+        return undefined;
+    if (!validateEntry(entry)) {
+        cache.delete(key);
+        isDirty = true;
+        return undefined;
+    }
+    return entry.paths;
+};
+const captureDirMtimes = (paths, baseDir) => {
+    const dirs = new Set();
+    dirs.add(baseDir);
+    for (const p of paths) {
+        let d = dirname(p);
+        while (d.length >= baseDir.length) {
+            if (dirs.has(d))
+                break;
+            dirs.add(d);
+            const parent = dirname(d);
+            if (parent === d)
+                break;
+            d = parent;
+        }
+    }
+    const result = {};
+    for (const d of dirs) {
+        try {
+            const stat = fs.statSync(d);
+            if (stat.isDirectory())
+                result[d] = stat.mtimeMs;
+        }
+        catch {
+        }
+    }
+    return result;
+};
+export const setCachedGlob = (key, paths, baseDir) => {
+    if (!cache)
+        return;
+    cache.set(key, {
+        paths,
+        dirMtimes: captureDirMtimes(paths, baseDir),
+    });
+    isDirty = true;
+};
+export const clearGlobCache = () => {
+    if (cache) {
+        cache.clear();
+        isDirty = true;
+    }
+};
+export const flushGlobCache = () => {
+    if (!cache || !cacheFilePath || !isDirty)
+        return;
+    try {
+        const dir = dirname(cacheFilePath);
+        if (!isDirectory(dir))
+            fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(cacheFilePath, serialize(cache));
+        isDirty = false;
+    }
+    catch {
+        debugLog('*', `Error writing glob cache to ${cacheFilePath}`);
+    }
+};

package/dist/util/glob.js

@@ -1,5 +1,6 @@
 import fg from 'fast-glob';
 import { compact } from "./array.js";
+import { computeGlobCacheKey, getCachedGlob, isGlobCacheEnabled, setCachedGlob } from "./glob-cache.js";
 import { glob } from "./glob-core.js";
 import { timerify } from "./Performance.js";
 import { isAbsolute, join, relative } from "./path.js";
@@ -24,7 +25,14 @@ const defaultGlob = async ({ cwd, dir = cwd, patterns, gitignore = true, label }
     const globPatterns = prependDirToPatterns(cwd, dir, patterns);
     if (globPatterns[0].startsWith('!'))
         return [];
-    return glob(globPatterns, {
+    const cacheEnabled = isGlobCacheEnabled();
+    const cacheKey = cacheEnabled ? computeGlobCacheKey({ patterns: globPatterns, cwd, dir, gitignore }) : '';
+    if (cacheEnabled) {
+        const cached = getCachedGlob(cacheKey);
+        if (cached)
+            return cached;
+    }
+    const paths = await glob(globPatterns, {
         cwd,
         dir,
         gitignore,
@@ -32,6 +40,9 @@ const defaultGlob = async ({ cwd, dir = cwd, patterns, gitignore = true, label }
         dot: true,
         label,
     });
+    if (cacheEnabled && paths.length > 0)
+        setCachedGlob(cacheKey, paths, dir);
+    return paths;
 };
 const syncGlob = ({ cwd, patterns }) => fg.sync(patterns, { cwd, followSymbolicLinks: false });
 const dirGlob = async ({ cwd, patterns, gitignore = true }) => glob(patterns, {

package/dist/util/module-graph.js

@@ -1,6 +1,12 @@
 const updateImportMaps = (fromImportMaps, toImportMaps) => {
     for (const id of fromImportMaps.refs)
         toImportMaps.refs.add(id);
+    if (fromImportMaps.enumerated) {
+        if (!toImportMaps.enumerated)
+            toImportMaps.enumerated = new Set();
+        for (const id of fromImportMaps.enumerated)
+            toImportMaps.enumerated.add(id);
+    }
     for (const [id, v] of fromImportMaps.import)
         addValues(toImportMaps.import, id, v);
     for (const [id, v] of fromImportMaps.importAs)
@@ -46,6 +52,7 @@ export const createFileNode = () => ({
 });
 export const createImports = () => ({
     refs: new Set(),
+    enumerated: undefined,
     import: new Map(),
     importAs: new Map(),
     importNs: new Map(),

package/dist/util/pattern-extensions.d.ts

@@ -0,0 +1 @@
+export declare const extractPatternExtensions: (pattern: string) => string[];

package/dist/util/pattern-extensions.js

@@ -0,0 +1,32 @@
+const TRAILING_BRACE_RE = /\.\{([^{}]+)\}$/;
+const TRAILING_PAREN_RE = /\.[@+*?]?\(([^()]+)\)$/;
+const TRAILING_LITERAL_RE = /\.([a-zA-Z0-9]+)$/;
+const SIMPLE_EXT_RE = /^[a-zA-Z0-9]+$/;
+const collectExtensions = (inner, delim) => {
+    const parts = inner.split(delim);
+    const exts = [];
+    for (let i = 0; i < parts.length; i++) {
+        const t = parts[i].trim();
+        if (SIMPLE_EXT_RE.test(t))
+            exts.push(`.${t}`);
+    }
+    return exts;
+};
+export const extractPatternExtensions = (pattern) => {
+    const end = pattern.endsWith('!') ? pattern.length - 1 : pattern.length;
+    const slashIdx = pattern.lastIndexOf('/', end - 1);
+    const segment = pattern.slice(slashIdx + 1, end);
+    if (segment.length === 0)
+        return [];
+    const last = segment[segment.length - 1];
+    if (last === '}') {
+        const m = TRAILING_BRACE_RE.exec(segment);
+        return m ? collectExtensions(m[1], ',') : [];
+    }
+    if (last === ')') {
+        const m = TRAILING_PAREN_RE.exec(segment);
+        return m ? collectExtensions(m[1], '|') : [];
+    }
+    const m = TRAILING_LITERAL_RE.exec(segment);
+    return m ? [`.${m[1]}`] : [];
+};

package/dist/util/watch.js

@@ -4,6 +4,8 @@ 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;
@@ -56,6 +58,8 @@ export const getSessionHandler = async (options, { analyzedFiles, analyzeSourceF
         if (added.size === 0 && deleted.size === 0 && modified.size === 0)
             return;
         clearResolverCache();
+        clearModuleResolutionCaches();
+        clearGlobCache();
         invalidateCache(graph);
         unreferencedFiles.clear();
         const cachedUnusedFiles = collector.purge();

package/dist/version.d.ts

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

package/dist/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "6.3.1",
+  "version": "6.4.1",
   "description": "Find and fix unused dependencies, exports and files in your TypeScript and JavaScript projects",
   "keywords": [
     "analysis",

package/schema.json

@@ -632,6 +632,10 @@
           "title": "oxlint plugin configuration (https://knip.dev/reference/plugins/oxlint)",
           "$ref": "#/definitions/plugin"
         },
+        "panda-css": {
+          "title": "panda-css plugin configuration (https://knip.dev/reference/plugins/panda-css)",
+          "$ref": "#/definitions/plugin"
+        },
         "payload": {
           "title": "payload plugin configuration (https://knip.dev/reference/plugins/payload)",
           "$ref": "#/definitions/plugin"