knip 6.43.0 → 6.44.0

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

@@ -18,6 +18,7 @@ export class FileEntryCache {
     filePath;
     cache = new Map();
     normalizedEntries = new Map();
+    isDirty = false;
     constructor(cacheId, _path) {
         this.filePath = path.resolve(_path, cacheId);
         if (isFile(this.filePath))
@@ -58,22 +59,39 @@ export class FileEntryCache {
             meta = { size: cSize, mtime: cTime };
             this.cache.set(filePath, meta);
         }
+        if (changed)
+            this.isDirty = true;
         const fd = { key: filePath, changed, meta };
         this.normalizedEntries.set(filePath, fd);
         return fd;
     }
+    setFileData(filePath, data) {
+        const fd = this.getFileDescriptor(filePath);
+        if (!fd.meta)
+            return;
+        fd.meta.data = data;
+        this.isDirty = true;
+    }
     removeEntry(entryName) {
         if (!isAbsolute(entryName))
             entryName = resolve(entryName);
         this.normalizedEntries.delete(entryName);
-        this.cache.delete(entryName);
+        if (this.cache.delete(entryName))
+            this.isDirty = true;
     }
     reconcile() {
+        for (const filePath of this.cache.keys()) {
+            if (!this.normalizedEntries.has(filePath))
+                this.removeEntry(filePath);
+        }
+        if (!this.isDirty)
+            return;
         try {
             const dir = path.dirname(this.filePath);
             if (!isDirectory(dir))
                 fs.mkdirSync(dir, { recursive: true });
             fs.writeFileSync(this.filePath, serialize(this.cache));
+            this.isDirty = false;
         }
         catch (_err) {
             debugLog('*', `Error writing cache to ${this.filePath}`);

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

@@ -5,6 +5,7 @@ export interface CachedGitignoreResult {
     gitignoreFiles: string[];
     perDirIgnores: Map<string, Gitignores>;
 }
+export declare const clearGitignoreCache: () => void;
 export declare const initGitignoreCache: (cacheLocation: string) => void;
 export declare const isGitignoreCacheEnabled: () => boolean;
 export declare const flushGitignoreCache: () => void;

package/dist/util/gitignore-cache.js

@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { createDiskCache, mtimeMatches } from './disk-cache.js';
 const store = createDiskCache('gitignore');
+export const clearGitignoreCache = store.clear;
 export const initGitignoreCache = store.init;
 export const isGitignoreCacheEnabled = store.isEnabled;
 export const flushGitignoreCache = store.flush;

package/dist/util/glob-core.js

@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto';
 import { readdir, readFileSync } from 'node:fs';
-import { escapePath, glob as tinyGlob } from 'tinyglobby';
+import { escapePath, glob as tinyGlob, isDynamicPattern } from 'tinyglobby';
 import picomatch from 'picomatch';
 import { GLOBAL_IGNORE_PATTERNS } from '../constants.js';
 import { compact, partition } from './array.js';
@@ -292,7 +292,9 @@ export async function glob(_patterns, options) {
         }
         cachedGlobIgnores.set(options.dir, compact(_ignore));
     }
-    const ignorePatterns = (cachedIgnores ?? _ignore).concat(negatedPatterns.map(pattern => pattern.slice(1)));
+    const ignores = cachedIgnores ?? _ignore;
+    const isStatic = options.gitignore && !patterns.some(pattern => isDynamicPattern(pattern));
+    const ignorePatterns = (isStatic ? expandIgnorePatterns(ignores) : ignores).concat(negatedPatterns.map(pattern => pattern.slice(1)));
     const { dir, label, ...fgOptions } = {
         ...options,
         ignore: ignorePatterns,

package/dist/util/glob.d.ts

@@ -8,6 +8,7 @@ interface GlobOptions {
 }
 export declare const removeProductionSuffix: (pattern: string) => string;
 export declare const prependDirToPattern: (dir: string, pattern: string) => string;
+export declare const rebasePattern: (pattern: string, base: string, dir: string) => string;
 export declare const negate: (pattern: string) => string;
 export declare const hasProductionSuffix: (pattern: string) => boolean;
 export declare const hasNoProductionSuffix: (pattern: string) => boolean;

package/dist/util/glob.js

@@ -23,6 +23,12 @@ export const prependDirToPattern = (dir, pattern) => {
         return `!${join(dir, pattern.slice(1))}`;
     return join(dir, pattern);
 };
+export const rebasePattern = (pattern, base, dir) => {
+    const isNegated = pattern.startsWith('!');
+    const id = isNegated ? pattern.slice(1) : pattern;
+    const rebased = relative(dir, isAbsolute(id) ? id : join(base, id));
+    return isNegated ? `!${rebased}` : rebased;
+};
 export const negate = (pattern) => pattern.replace(/^!?/, '!');
 export const hasProductionSuffix = (pattern) => pattern.endsWith('!');
 export const hasNoProductionSuffix = (pattern) => !pattern.endsWith('!');

package/dist/util/input.d.ts

@@ -7,6 +7,7 @@ export interface Input {
     production?: boolean;
     optional?: boolean;
     isTypeOnly?: boolean;
+    alsoReferenceOwner?: boolean;
     dir?: string;
     containingFilePath?: string;
     allowIncludeExports?: boolean;
@@ -33,6 +34,7 @@ interface IgnoreInput extends Input {
 type Options = {
     optional?: boolean;
     isTypeOnly?: boolean;
+    alsoReferenceOwner?: boolean;
     dir?: string;
     containingFilePath?: string;
     allowIncludeExports?: boolean;

package/dist/util/loader.d.ts

@@ -1,3 +1,4 @@
 declare const load: (filePath: string) => Promise<any>;
 export declare const _load: typeof load;
+export declare const unload: (filePaths: Iterable<string>) => void;
 export {};

package/dist/util/loader.js

@@ -6,11 +6,36 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
 import { LoaderError } from './errors.js';
-import { loadFile, loadJSON, loadJSONC, loadTOML, loadYAML, parseJSONC, parseYAML } from './fs.js';
+import { findFile, 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 { dirname, extname, isInternal, toNative } from './path.js';
+const unloaded = new Map();
+const isNativeModule = (filePath) => {
+    const ext = extname(filePath);
+    if (ext !== '.js')
+        return ext === '.mjs';
+    for (let dir = dirname(filePath); dir !== dirname(dir); dir = dirname(dir)) {
+        const manifestPath = findFile(dir, 'package.json');
+        if (manifestPath)
+            return JSON.parse(readFileSync(manifestPath, 'utf8')).type === 'module';
+    }
+    return false;
+};
+const reload = async (filePath, version) => {
+    let imported;
+    try {
+        imported = jiti(filePath);
+    }
+    catch {
+        imported = await import(__rewriteRelativeImportExtension(`${pathToFileURL(filePath).href}?v=${version}`));
+    }
+    return imported.default ?? imported;
+};
 const load = async (filePath) => {
     try {
         const ext = extname(filePath);
@@ -42,6 +67,9 @@ const load = async (filePath) => {
         if (ext === '.toml') {
             return await loadTOML(filePath);
         }
+        const version = unloaded.get(filePath);
+        if (version && isNativeModule(filePath))
+            return await reload(filePath, version);
         return await jiti.import(filePath, { default: true });
     }
     catch (error) {
@@ -49,3 +77,11 @@ const load = async (filePath) => {
     }
 };
 export const _load = timerify(load);
+const { cache } = createRequire(import.meta.url);
+export const unload = (filePaths) => {
+    for (const filePath of filePaths) {
+        delete cache[filePath];
+        delete cache[toNative(filePath)];
+        unloaded.set(filePath, (unloaded.get(filePath) ?? 0) + 1);
+    }
+};

package/dist/util/modules.js

@@ -53,7 +53,9 @@ const isPackageNameStart = (ch) => (ch >= 65 && ch <= 90) || (ch >= 97 && ch <=
 const isPackageScopeStart = (ch) => isPackageNameStart(ch) || ch === 46 || ch === 95 || ch === 126;
 export const isStartsLikePackageName = (specifier) => {
     const ch = specifier.charCodeAt(0);
-    return ch === 64 ? isPackageScopeStart(specifier.charCodeAt(1)) : isPackageNameStart(ch);
+    return ch === 64
+        ? isPackageScopeStart(specifier.charCodeAt(1))
+        : isPackageNameStart(ch) && specifier.charCodeAt(1) !== 58;
 };
 const isTildePackageName = (specifier) => specifier.charCodeAt(0) === 126 && isPackageNameStart(specifier.charCodeAt(1));
 export const stripVersionFromSpecifier = (specifier) => specifier.replace(/(\S+)@.*/, '$1');

package/dist/util/path.d.ts

@@ -5,6 +5,7 @@ export declare const extname: typeof path.extname;
 export declare const basename: typeof path.basename;
 export declare const join: typeof path.join;
 export declare const toPosix: (value: string) => string;
+export declare const toNative: (value: string) => string;
 export declare const resolve: typeof path.resolve;
 export declare const resolveCwd: (dir: string) => string;
 export declare const relative: (from: string, to: string) => string;

package/dist/util/path.js

@@ -6,6 +6,7 @@ export const extname = path.posix.extname;
 export const basename = path.posix.basename;
 export const join = path.posix.join;
 export const toPosix = isWin ? (value) => value.split(path.sep).join(path.posix.sep) : (value) => value;
+export const toNative = isWin ? path.win32.normalize : (value) => value;
 export const resolve = path.posix.resolve;
 export const resolveCwd = (dir) => toPosix(path.resolve(dir));
 export const relative = (from, to) => {

package/dist/util/reporter.d.ts

@@ -1,2 +1,2 @@
 import type { ReporterOptions } from '../types/issues.ts';
-export declare const runReporters: (reporter: string[], options: ReporterOptions) => Promise<void>;
+export declare const runReporters: (reporter: string[], outputFiles: string[], options: ReporterOptions) => Promise<void>;

package/dist/util/reporter.js

@@ -1,12 +1,56 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { stripVTControlCharacters } from 'node:util';
 import internalReporters from '../reporters/index.js';
+import { ConfigurationError } from './errors.js';
 import { _load } from './loader.js';
-import { isAbsolute, isInternal, resolve } from './path.js';
-export const runReporters = async (reporter, options) => {
-    const reporters = await Promise.all(reporter.map(async (reporter) => {
-        return reporter in internalReporters
-            ? internalReporters[reporter]
-            : await _load(isInternal(reporter) && !isAbsolute(reporter) ? resolve(reporter) : reporter);
-    }));
-    for (const reporter of reporters)
-        await reporter(options);
+import { dirname, isAbsolute, isInternal, resolve, toAbsolute, toPosix } from './path.js';
+const writeStdout = (output) => {
+    if (!output)
+        return;
+    process.stdout._handle?.setBlocking?.(true);
+    process.stdout.write(`${output}\n`);
+};
+const getOutputFiles = (reporters, outputFiles, cwd) => {
+    const targets = new Map();
+    for (const outputFile of outputFiles) {
+        const index = outputFile.indexOf('=');
+        const name = index === -1 ? reporters[0] : outputFile.slice(0, index);
+        const filePath = index === -1 ? outputFile : outputFile.slice(index + 1);
+        if (index === -1 && reporters.length > 1) {
+            throw new ConfigurationError(`Option --output-file needs a reporter prefix when using multiple reporters (${reporters.join(', ')}), e.g. --output-file ${reporters[0]}=${outputFile}`);
+        }
+        if (!reporters.includes(name)) {
+            throw new ConfigurationError(`Option --output-file refers to reporter "${name}", but it is not selected with --reporter`);
+        }
+        targets.set(name, toAbsolute(toPosix(filePath), cwd));
+    }
+    return targets;
+};
+const loadReporter = (reporter) => reporter in internalReporters
+    ? Promise.resolve(internalReporters[reporter])
+    : _load(isInternal(reporter) && !isAbsolute(reporter) ? resolve(reporter) : reporter);
+export const runReporters = async (reporter, outputFiles, options) => {
+    const targets = getOutputFiles(reporter, outputFiles, options.cwd);
+    const reporters = await Promise.all(reporter.map(loadReporter));
+    for (let i = 0; i < reporters.length; i++) {
+        const target = targets.get(reporter[i]);
+        if (!target) {
+            await reporters[i]({ ...options, write: writeStdout });
+            continue;
+        }
+        let output = '';
+        const write = (text) => {
+            if (text)
+                output += `${text}\n`;
+        };
+        await reporters[i]({ ...options, write });
+        try {
+            await mkdir(dirname(target), { recursive: true });
+            await writeFile(target, stripVTControlCharacters(output));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new ConfigurationError(`Option --output-file failed to write: ${message}`);
+        }
+    }
 };

package/dist/util/watch.d.ts

@@ -1,15 +1,9 @@
-import type { WatchListener } from 'node:fs';
 import type { ConfigurationChief } from '../ConfigurationChief.ts';
 import type { IssueCollector } from '../IssueCollector.ts';
 import type { ProjectPrincipal } from '../ProjectPrincipal.ts';
-import type { Issues } from '../types/issues.ts';
+import type { ConfigurationFiles } from '../session/configuration.ts';
 import type { ModuleGraph } from '../types/module-graph.ts';
 import type { MainOptions } from './create-options.ts';
-export type OnFileChange = (options: {
-    issues: Issues;
-    duration?: number;
-    mem?: number;
-}) => void;
 export type WatchChange = {
     type: 'added' | 'deleted' | 'modified';
     filePath: string;
@@ -23,13 +17,12 @@ type WatchOptions = {
     analyze: () => Promise<void>;
     principal: ProjectPrincipal;
     graph: ModuleGraph;
+    configurationFiles?: ConfigurationFiles;
     isIgnored: (path: string) => boolean;
-    onFileChange?: OnFileChange;
     unreferencedFiles: Set<string>;
     entryPaths: Set<string>;
 };
-export declare const getSessionHandler: (options: MainOptions, { analyzedFiles, analyzeSourceFile, chief, collector, analyze, principal, graph, isIgnored, onFileChange, unreferencedFiles, entryPaths, }: WatchOptions) => Promise<{
-    listener: WatchListener<string | Buffer<ArrayBufferLike>>;
+export declare const getSessionHandler: (options: MainOptions, { analyzedFiles, analyzeSourceFile, chief, collector, analyze, principal, graph, configurationFiles, isIgnored, unreferencedFiles, entryPaths, }: WatchOptions) => Promise<{
     handleFileChanges: (changes: WatchChange[]) => Promise<{
         duration: number;
         mem: number;
@@ -37,11 +30,12 @@ export declare const getSessionHandler: (options: MainOptions, { analyzedFiles,
     getEntryPaths: () => Set<string>;
     getGraph: () => ModuleGraph;
     getIssues: () => {
-        issues: Issues;
+        issues: import("../types/issues.ts").Issues;
         counters: import("../types/issues.ts").Counters;
         tagHints: Set<import("../types/issues.ts").TagHint>;
         configurationHints: import("../types/issues.ts").ConfigurationHint[];
         hasConfigLoadErrors: boolean;
     };
+    configurationFiles: ConfigurationFiles | undefined;
 }>;
 export {};

package/dist/util/watch.js

@@ -1,10 +1,8 @@
 import { invalidateCache } from '../graph-explorer/cache.js';
+import { getFileTopology, hasSameTopology, isIncrementalFile } from '../session/incremental.js';
 import { debugLog } from './debug.js';
-import { hasErrorCause } from './errors.js';
-import { isFile } from './fs.js';
-import { logError } from './log.js';
 import { updateImportMap } from './module-graph.js';
-import { toAbsolute, toPosix, toRelative } from './path.js';
+import { toAbsolute, toRelative } from './path.js';
 import { clearModuleResolutionCaches } from '../typescript/resolve-module-names.js';
 import { clearGlobCache } from './glob-cache.js';
 import { clearResolverCache } from './resolve.js';
@@ -13,13 +11,18 @@ const createUpdate = (options) => {
     const mem = process.memoryUsage().heapUsed;
     return { duration, mem };
 };
-export const getSessionHandler = async (options, { analyzedFiles, analyzeSourceFile, chief, collector, analyze, principal, graph, isIgnored, onFileChange, unreferencedFiles, entryPaths, }) => {
+export const getSessionHandler = async (options, { analyzedFiles, analyzeSourceFile, chief, collector, analyze, principal, graph, configurationFiles, isIgnored, unreferencedFiles, entryPaths, }) => {
     const added = new Set();
     const deleted = new Set();
     const modified = new Set();
+    if (configurationFiles)
+        principal.collectConfigurationImports(configurationFiles.paths);
     const processFileChanges = async (changes) => {
         const startTime = performance.now();
         let hasRelevantChanges = false;
+        const configurationChange = configurationFiles?.getChange(changes, options.cwd);
+        if (configurationChange)
+            throw configurationChange;
         for (const change of changes) {
             const filePath = toAbsolute(change.filePath, options.cwd);
             const relativePath = toRelative(change.filePath, options.cwd);
@@ -60,76 +63,104 @@ export const getSessionHandler = async (options, { analyzedFiles, analyzeSourceF
         }
         if (!hasRelevantChanges || (added.size === 0 && deleted.size === 0 && modified.size === 0))
             return;
-        clearResolverCache();
-        clearModuleResolutionCaches();
-        clearGlobCache();
-        invalidateCache(graph);
-        const filePaths = await principal.getUsedResolvedFiles();
-        unreferencedFiles.clear();
-        const cachedUnusedFiles = collector.purge();
-        for (const filePath of added)
-            cachedUnusedFiles.add(filePath);
-        for (const filePath of deleted)
-            cachedUnusedFiles.delete(filePath);
-        if (added.size > 0 || deleted.size > 0) {
-            graph.clear();
-            for (const filePath of filePaths) {
-                const workspace = chief.findWorkspaceByFilePath(filePath);
-                if (workspace) {
-                    await analyzeSourceFile(filePath);
+        let incremental = added.size === 0 && deleted.size === 0;
+        if (incremental) {
+            for (const filePath of modified) {
+                const file = graph.get(filePath);
+                if (!file || !analyzedFiles.has(filePath) || !isIncrementalFile(file)) {
+                    incremental = false;
+                    break;
                 }
             }
         }
-        else {
-            for (const [filePath, file] of graph) {
-                if (filePaths.has(filePath)) {
-                    file.importedBy = undefined;
+        if (incremental) {
+            for (const filePath of modified) {
+                const file = graph.get(filePath);
+                if (!file) {
+                    incremental = false;
+                    break;
                 }
-                else {
-                    graph.delete(filePath);
-                    analyzedFiles.delete(filePath);
-                    const workspace = chief.findWorkspaceByFilePath(filePath);
-                    if (workspace && principal.projectPaths.has(filePath))
-                        cachedUnusedFiles.add(filePath);
+                const before = getFileTopology(file);
+                await analyzeSourceFile(filePath);
+                if (!hasSameTopology(before, file)) {
+                    incremental = false;
+                    break;
                 }
             }
-            for (const filePath of filePaths) {
-                if (!graph.has(filePath)) {
+        }
+        if (incremental) {
+            invalidateCache(graph, true);
+            collector.purge();
+        }
+        else {
+            clearResolverCache();
+            clearModuleResolutionCaches();
+            clearGlobCache();
+            invalidateCache(graph);
+            const filePaths = await principal.getUsedResolvedFiles();
+            const cachedUnusedFiles = collector.purge();
+            for (const filePath of added)
+                cachedUnusedFiles.add(filePath);
+            for (const filePath of deleted)
+                cachedUnusedFiles.delete(filePath);
+            if (added.size > 0 || deleted.size > 0) {
+                graph.clear();
+                for (const filePath of filePaths) {
                     const workspace = chief.findWorkspaceByFilePath(filePath);
                     if (workspace) {
                         await analyzeSourceFile(filePath);
                     }
                 }
             }
-            for (const filePath of modified) {
-                if (!cachedUnusedFiles.has(filePath)) {
-                    const workspace = chief.findWorkspaceByFilePath(filePath);
-                    if (workspace) {
-                        if (principal.projectPaths.has(filePath) || graph.has(filePath)) {
+            else {
+                for (const [filePath, file] of graph) {
+                    if (filePaths.has(filePath)) {
+                        file.importedBy = undefined;
+                    }
+                    else {
+                        graph.delete(filePath);
+                        analyzedFiles.delete(filePath);
+                        const workspace = chief.findWorkspaceByFilePath(filePath);
+                        if (workspace && principal.projectPaths.has(filePath))
+                            cachedUnusedFiles.add(filePath);
+                    }
+                }
+                for (const filePath of filePaths) {
+                    if (!graph.has(filePath) || !analyzedFiles.has(filePath)) {
+                        const workspace = chief.findWorkspaceByFilePath(filePath);
+                        if (workspace) {
                             await analyzeSourceFile(filePath);
                         }
                     }
                 }
+                for (const filePath of modified) {
+                    if (!cachedUnusedFiles.has(filePath)) {
+                        const workspace = chief.findWorkspaceByFilePath(filePath);
+                        if (workspace) {
+                            if (principal.projectPaths.has(filePath) || graph.has(filePath)) {
+                                await analyzeSourceFile(filePath);
+                            }
+                        }
+                    }
+                }
+                for (const filePath of filePaths) {
+                    const file = graph.get(filePath);
+                    if (file?.internalImportCache)
+                        updateImportMap(file, file.internalImportCache, graph);
+                }
             }
-            for (const filePath of filePaths) {
-                const file = graph.get(filePath);
-                if (file?.internalImportCache)
-                    updateImportMap(file, file.internalImportCache, graph);
-            }
+            const unusedFiles = [...cachedUnusedFiles].filter(filePath => !analyzedFiles.has(filePath));
+            unreferencedFiles.clear();
+            for (const filePath of unusedFiles)
+                unreferencedFiles.add(filePath);
         }
-        await analyze();
-        const unusedFiles = [...cachedUnusedFiles].filter(filePath => !analyzedFiles.has(filePath));
-        collector.addFilesIssues(unusedFiles);
-        collector.addFileCounts({ processed: analyzedFiles.size, unused: unusedFiles.length });
         for (const issue of collector.getRetainedIssues())
             collector.addIssue(issue);
+        await analyze();
         added.clear();
         deleted.clear();
         modified.clear();
-        const update = createUpdate({ startTime });
-        if (onFileChange)
-            onFileChange(Object.assign({ issues: getIssues().issues }, update));
-        return update;
+        return createUpdate({ startTime });
     };
     const clearSourceText = () => principal.fileManager.sourceTextCache.clear();
     let pending = Promise.resolve();
@@ -138,23 +169,8 @@ export const getSessionHandler = async (options, { analyzedFiles, analyzeSourceF
         pending = update.then(clearSourceText, clearSourceText);
         return update;
     };
-    const listener = (eventType, filePath) => {
-        debugLog('*', `(raw) ${eventType} ${filePath}`);
-        if (typeof filePath === 'string') {
-            const normalizedPath = toPosix(filePath);
-            const type = eventType === 'rename' ? (isFile(options.cwd, normalizedPath) ? 'added' : 'deleted') : 'modified';
-            handleFileChanges([{ type, filePath: normalizedPath }]).catch(error => {
-                const message = error instanceof Error ? error.message : String(error);
-                const reason = error instanceof Error && hasErrorCause(error) ? `\nReason: ${error.cause.message}` : '';
-                logError(message + reason);
-                process.exitCode = 2;
-            });
-        }
-    };
     const getIssues = () => collector.getIssues();
     const getEntryPaths = () => entryPaths;
     const getGraph = () => graph;
-    if (onFileChange)
-        onFileChange({ issues: getIssues().issues });
-    return { listener, handleFileChanges, getEntryPaths, getGraph, getIssues };
+    return { handleFileChanges, getEntryPaths, getGraph, getIssues, configurationFiles };
 };

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "6.43.0";
+export declare const version = "6.44.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '6.43.0';
+export const version = '6.44.0';

package/package.json

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

package/schema.json

@@ -638,6 +638,10 @@
           "title": "knex plugin configuration (https://knip.dev/reference/plugins/knex)",
           "$ref": "#/definitions/plugin"
         },
+        "kysely-codegen": {
+          "title": "kysely-codegen plugin configuration (https://knip.dev/reference/plugins/kysely-codegen)",
+          "$ref": "#/definitions/plugin"
+        },
         "ladle": {
           "title": "ladle plugin configuration (https://knip.dev/reference/plugins/ladle)",
           "$ref": "#/definitions/plugin"
@@ -650,6 +654,10 @@
           "title": "lefthook plugin configuration (https://knip.dev/reference/plugins/lefthook)",
           "$ref": "#/definitions/plugin"
         },
+        "lingui": {
+          "title": "lingui plugin configuration (https://knip.dev/reference/plugins/lingui)",
+          "$ref": "#/definitions/plugin"
+        },
         "lint-staged": {
           "title": "lint-staged plugin configuration (https://knip.dev/reference/plugins/lint-staged)",
           "$ref": "#/definitions/plugin"
@@ -682,6 +690,10 @@
           "title": "marko plugin configuration (https://knip.dev/reference/plugins/marko)",
           "$ref": "#/definitions/plugin"
         },
+        "mastra": {
+          "title": "mastra plugin configuration (https://knip.dev/reference/plugins/mastra)",
+          "$ref": "#/definitions/plugin"
+        },
         "mcp": {
           "title": "mcp plugin configuration (https://knip.dev/reference/plugins/mcp)",
           "$ref": "#/definitions/plugin"
@@ -862,6 +874,10 @@
           "title": "Prisma plugin configuration (https://knip.dev/reference/plugins/prisma)",
           "$ref": "#/definitions/plugin"
         },
+        "purgecss": {
+          "title": "purgecss plugin configuration (https://knip.dev/reference/plugins/purgecss)",
+          "$ref": "#/definitions/plugin"
+        },
         "quasar": {
           "title": "quasar plugin configuration (https://knip.dev/reference/plugins/quasar)",
           "$ref": "#/definitions/plugin"