knip 6.34.0 → 6.35.0

package/dist/plugins/mise/index.js

@@ -0,0 +1,82 @@
+import { isFile } from '../../util/fs.js';
+import { isEntry } from '../../util/input.js';
+import { basename, dirname, join, toAbsolute } from '../../util/path.js';
+const title = 'mise';
+const enablers = 'This plugin is enabled when `mise.toml` or `.mise.toml` is found.';
+const config = [
+    '{mise,.mise}{,.*}.toml',
+    '{mise,.mise}/config{,.*}.toml',
+    '.config/mise{,.*}.toml',
+    '.config/mise/config{,.*}.toml',
+    '.config/mise/mise{,.local}.toml',
+    '{mise,.mise}/conf.d/[!.]*.toml',
+    '.config/mise/conf.d/[!.]*.toml',
+];
+const isEnabled = ({ cwd }) => isFile(cwd, 'mise.toml') || isFile(cwd, '.mise.toml');
+const getConfigRoot = (configFileDir, configFileName) => {
+    const isFragment = basename(configFileDir) === 'conf.d';
+    const groupedDir = isFragment ? dirname(configFileDir) : configFileDir;
+    const name = basename(groupedDir);
+    const root = (isFragment || configFileName.startsWith('config.')) && (name === 'mise' || name === '.mise')
+        ? dirname(groupedDir)
+        : configFileDir;
+    return basename(root) === '.config' ? dirname(root) : root;
+};
+const hasTemplate = (value) => value.includes('{{') || value.includes('{%');
+const resolvePath = (value, root) => {
+    const expanded = value.replace(/\{\{\s*config_root\s*\}\}/g, () => root);
+    if (hasTemplate(expanded) || expanded.startsWith('~') || expanded.includes('$'))
+        return;
+    return join(toAbsolute(expanded, root), '.');
+};
+const resolveConfig = async (localConfig, options) => {
+    const { getInputsFromMiseScript } = await import('./scripts.js');
+    const { configFileDir, configFileName, getManifest, isProduction } = options;
+    const configRoot = getConfigRoot(configFileDir, configFileName);
+    const inputs = [];
+    for (const task of Object.values(localConfig.tasks ?? {})) {
+        const taskConfig = typeof task === 'string' || Array.isArray(task) ? { run: task } : task;
+        const dir = resolvePath(taskConfig.dir ?? localConfig.task_config?.dir ?? '.', configRoot);
+        if (!dir)
+            continue;
+        let hasLocalBinPath = false;
+        for (const env of [localConfig.env ?? [], taskConfig.env ?? []].flat()) {
+            if (Object.hasOwn(env, 'PATH'))
+                hasLocalBinPath = false;
+            const paths = env._?.path;
+            for (const path of typeof paths === 'string' ? [paths] : Array.isArray(paths) ? paths : []) {
+                if (typeof path === 'string' && resolvePath(path, configRoot) === join(dir, 'node_modules/.bin')) {
+                    hasLocalBinPath = true;
+                }
+            }
+        }
+        const manifest = getManifest(dir) ?? options.manifest;
+        const scriptOptions = {
+            ...options,
+            cwd: dir,
+            manifest,
+            containingFilePath: options.configFilePath,
+        };
+        for (const script of [taskConfig.run ?? [], taskConfig.run_windows ?? []].flat()) {
+            if (typeof script !== 'string' || hasTemplate(script))
+                continue;
+            for (const input of getInputsFromMiseScript(script, scriptOptions, hasLocalBinPath)) {
+                if (isProduction)
+                    input.optional = true;
+                input.dir ??= dir;
+                if (isEntry(input))
+                    input.specifier = toAbsolute(input.specifier, input.dir);
+                inputs.push(input);
+            }
+        }
+    }
+    return inputs;
+};
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    resolveConfig,
+};
+export default plugin;

package/dist/plugins/mise/scripts.d.ts

@@ -0,0 +1,7 @@
+import type { GetInputsFromScriptsOptions, GetInputsFromScriptsPartial } from '../../types/config.ts';
+import { type Input } from '../../util/input.ts';
+type Options = GetInputsFromScriptsOptions & {
+    getInputsFromScripts: GetInputsFromScriptsPartial;
+};
+export declare const getInputsFromMiseScript: (script: string, options: Options, hasLocalBinPath: boolean) => Input[];
+export {};

package/dist/plugins/mise/scripts.js

@@ -0,0 +1,108 @@
+import { parse } from 'unbash';
+import { getDependenciesFromCommand, getInputsFromNodeOptions } from '../../binaries/command.js';
+import { spawningBinaries } from '../../binaries/fallback.js';
+import { isWrapper } from '../../binaries/plugins.js';
+import KnownResolvers from '../../binaries/resolvers/index.js';
+import { toScript } from '../../binaries/util.js';
+import { SCRIPT_INTERPOLATION } from '../../constants.js';
+import { isBinary } from '../../util/input.js';
+import { extractBinary } from '../../util/modules.js';
+import { walkCommands } from '../../util/scripts.js';
+export const getInputsFromMiseScript = (script, options, hasLocalBinPath) => {
+    const inputs = [];
+    const definedFunctions = new Set();
+    const readParts = (parts) => {
+        let text = '';
+        let value = '';
+        let hasExpansion = false;
+        for (const part of parts) {
+            if (part.type === 'CommandExpansion' || part.type === 'ProcessSubstitution') {
+                if (part.script)
+                    readScript(part.script);
+                text += SCRIPT_INTERPOLATION;
+                value += SCRIPT_INTERPOLATION;
+                hasExpansion = true;
+            }
+            else if (part.type === 'DoubleQuoted' || part.type === 'LocaleString') {
+                const inner = readParts(part.parts);
+                text += `${part.type === 'LocaleString' ? '$"' : '"'}${inner.text}"`;
+                value += inner.value;
+                if (inner.hasExpansion)
+                    hasExpansion = true;
+            }
+            else {
+                text += part.text;
+                value += 'value' in part ? part.value : part.text;
+            }
+        }
+        return { text, value, hasExpansion };
+    };
+    const readWord = (word) => {
+        if (!word.parts)
+            return word;
+        const { text, value, hasExpansion } = readParts(word.parts);
+        return hasExpansion ? { ...word, text, value } : word;
+    };
+    const readScript = (parsed) => {
+        for (const statement of parsed.commands) {
+            if (statement.command.type === 'Function')
+                definedFunctions.add(statement.command.name.value);
+        }
+        for (const statement of parsed.commands) {
+            for (const command of walkCommands(statement.command)) {
+                const name = command.name?.value;
+                const word = command.name && readWord(command.name);
+                const prefix = command.prefix.map(assignment => {
+                    const value = assignment.value && readWord(assignment.value);
+                    return value && value !== assignment.value
+                        ? { ...assignment, value, text: `${assignment.name}=${value.text}` }
+                        : assignment;
+                });
+                const words = command.suffix.map(readWord);
+                if (!name || !word || definedFunctions.has(name))
+                    continue;
+                const binary = extractBinary(name);
+                const isPackageManager = binary in KnownResolvers && binary !== 'find';
+                const isExplicit = isPackageManager || name.startsWith('./') || /^(?:\.\.?\/)*node_modules\/\.bin\//.test(name);
+                const isLocal = hasLocalBinPath && !command.prefix.some(assignment => assignment.name === 'PATH');
+                const isWrapperCommand = !isPackageManager && isWrapper(binary);
+                if (!isExplicit && !isLocal && !isWrapperCommand && binary !== 'node' && binary !== 'find')
+                    continue;
+                let commandInputs;
+                if (isWrapperCommand || binary === 'find') {
+                    const fromScript = (script) => {
+                        inputs.push(...getInputsFromMiseScript(script, options, isLocal));
+                        return [];
+                    };
+                    const fromArgs = args => fromScript(toScript(args));
+                    commandInputs = getDependenciesFromCommand({ ...command, name: word, prefix, suffix: words }, { ...options, fromArgs });
+                }
+                else {
+                    commandInputs = options.getInputsFromScripts([...prefix.map(assignment => assignment.text), word.text, ...words.map(word => word.text)].join(' '), { cwd: options.cwd, manifest: options.manifest });
+                }
+                if (!isExplicit && !isLocal && binary !== 'node' && binary !== 'find')
+                    continue;
+                if (isWrapperCommand && spawningBinaries.includes(binary)) {
+                    commandInputs.push(...getInputsFromNodeOptions(prefix));
+                }
+                const binaryInput = commandInputs.find(input => isBinary(input) && input.specifier === binary);
+                if (!isExplicit && isLocal && binaryInput)
+                    binaryInput.optional = true;
+                for (const input of commandInputs) {
+                    if (!input.specifier || input.specifier.includes(SCRIPT_INTERPOLATION))
+                        continue;
+                    if (!isExplicit && !isLocal && input === binaryInput)
+                        continue;
+                    inputs.push(input);
+                }
+            }
+        }
+    };
+    try {
+        readScript(parse(script));
+    }
+    catch {
+        return [];
+    }
+    return inputs;
+};

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

@@ -0,0 +1,26 @@
+type MiseEnvironment = {
+    PATH?: unknown;
+    _?: {
+        path?: string | string[];
+    };
+};
+type TaskReference = {
+    task: string;
+} | {
+    tasks: string[];
+};
+type Run = string | (string | TaskReference)[];
+type MiseTask = {
+    run?: Run;
+    run_windows?: Run;
+    dir?: string;
+    env?: MiseEnvironment;
+};
+export type MiseConfig = {
+    tasks?: Record<string, string | string[] | MiseTask>;
+    env?: MiseEnvironment | MiseEnvironment[];
+    task_config?: {
+        dir?: string;
+    };
+};
+export {};

package/dist/plugins/mise/types.js

@@ -0,0 +1 @@
+export {};

package/dist/plugins/rstest/index.js

@@ -7,9 +7,10 @@ const config = ['rstest.config.{js,cjs,mjs,ts,cts,mts}'];
 const mocks = ['**/__mocks__/**/*.?(c|m)[jt]s?(x)'];
 const entry = ['**/*.{test,spec}.?(c|m)[jt]s?(x)'];
 function testEnvironment(config) {
-    if (!config.testEnvironment || config.testEnvironment === 'node')
+    const environment = typeof config.testEnvironment === 'string' ? config.testEnvironment : config.testEnvironment?.name;
+    if (!environment || environment === 'node')
         return [];
-    return [config.testEnvironment];
+    return [environment];
 }
 const resolveConfig = async (config) => {
     const entries = (config.include ?? entry)

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

@@ -1,6 +1,8 @@
 export type RstestConfig = {
     include?: string[];
     exclude?: string[];
-    testEnvironment?: 'node' | 'jsdom' | 'happy-dom';
+    testEnvironment?: 'node' | 'jsdom' | 'happy-dom' | {
+        name: 'node' | 'jsdom' | 'happy-dom';
+    };
     setupFiles?: string[];
 };

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

@@ -1,6 +1,6 @@
 import type { Program } from 'oxc-parser';
 import { type Input } from '../../util/input.ts';
 export declare const getBabelInputs: (program: Program) => Input[];
-export declare const getHtmlScriptEntries: (htmlPath: string) => Promise<Input[]>;
-export declare const getIndexHtmlEntries: (rootDir: string) => Promise<Input[]>;
+export declare const getHtmlScriptEntries: (htmlPath: string, publicDir?: string) => Promise<Input[]>;
+export declare const getIndexHtmlEntries: (rootDir: string, publicDir?: string) => Promise<Input[]>;
 export declare const getVitePluginDirs: (program: Program, specifiers: string[], key: string) => string[] | undefined;

package/dist/plugins/vite/helpers.js

@@ -3,7 +3,7 @@ import { findImportedCalls, findProperty, getStringValues } from '../../typescri
 import { getStringValue } from '../../typescript/ast-nodes.js';
 import { isFile, loadFile } from '../../util/fs.js';
 import { toProductionEntry } from '../../util/input.js';
-import { dirname, join } from '../../util/path.js';
+import { dirname, join, toAbsolute } from '../../util/path.js';
 import { getDependenciesFromConfig } from '../babel/index.js';
 const babelPluginSources = ['@rolldown/plugin-babel', '@vitejs/plugin-react', 'vite-plugin-babel'];
 const isBabelWrappingPlugin = (path) => babelPluginSources.some(source => path === source || path.startsWith(`${source}/`));
@@ -26,19 +26,26 @@ const srcAttrPattern = /\bsrc\s*=\s*["']([^"']+)["']/i;
 const importSpecPattern = /\bimport\b(?:\s*\(\s*|(?:[\w$*,{}\s]*\bfrom\b)?\s*)(['"])([^'"]+)\1/g;
 const isFilePath = (specifier) => specifier.startsWith('/') || specifier.startsWith('./') || specifier.startsWith('../');
 const normalizeModuleScriptSrc = (value) => value.trim().replace(/^\//, '');
-const getModuleScriptSources = (html) => {
+const getScriptSources = (html, publicDir) => {
     const sources = [];
     for (const [, attrs, body] of html.matchAll(scriptExtractor)) {
-        if (!moduleTypePattern.test(attrs))
-            continue;
         const srcMatch = attrs.match(srcAttrPattern);
         if (srcMatch) {
-            const src = normalizeModuleScriptSrc(srcMatch[1]);
-            if (src)
-                sources.push(src);
+            const src = srcMatch[1].trim();
+            if (!src || /^(?:[\w+.-]+:|\/\/)/.test(src))
+                continue;
+            if (publicDir && src.startsWith('/')) {
+                const publicPath = join(publicDir, src.split(/[?#]/, 1)[0]);
+                if (publicPath.startsWith(join(publicDir, '/')) && isFile(publicPath)) {
+                    sources.push(publicPath);
+                    continue;
+                }
+            }
+            if (moduleTypePattern.test(attrs))
+                sources.push(normalizeModuleScriptSrc(src));
             continue;
         }
-        if (body) {
+        if (moduleTypePattern.test(attrs) && body) {
             const code = body.replace(blockCommentMatcher, '').replace(lineCommentMatcher, '');
             for (const importMatch of code.matchAll(importSpecPattern)) {
                 const specifier = importMatch[2];
@@ -49,14 +56,14 @@ const getModuleScriptSources = (html) => {
     }
     return sources;
 };
-export const getHtmlScriptEntries = async (htmlPath) => {
+export const getHtmlScriptEntries = async (htmlPath, publicDir) => {
     if (!isFile(htmlPath))
         return [];
     const html = await loadFile(htmlPath);
     const dir = dirname(htmlPath);
-    return getModuleScriptSources(html).map(src => toProductionEntry(join(dir, src)));
+    return getScriptSources(html, publicDir).map(src => toProductionEntry(toAbsolute(src, dir)));
 };
-export const getIndexHtmlEntries = (rootDir) => getHtmlScriptEntries(join(rootDir, 'index.html'));
+export const getIndexHtmlEntries = (rootDir, publicDir) => getHtmlScriptEntries(join(rootDir, 'index.html'), publicDir);
 export const getVitePluginDirs = (program, specifiers, key) => {
     let dirs;
     for (const call of findImportedCalls(program, specifiers)) {

package/dist/plugins/vite/visitors/importMetaGlob.js

@@ -1,4 +1,6 @@
+import { findProperty } from '../../../typescript/ast-helpers.js';
 import { getStringValue, isStringLiteral } from '../../../typescript/ast-nodes.js';
+const RAW_QUERY_RE = /(\?|&)raw(?:&|$)/;
 export function createImportMetaGlobVisitor(ctx) {
     return {
         CallExpression(node) {
@@ -22,6 +24,16 @@ export function createImportMetaGlobVisitor(ctx) {
             }
             if (!patterns?.length)
                 return;
+            const options = node.arguments[1];
+            if (options?.type === 'ObjectExpression') {
+                const queryNode = findProperty(options, 'query');
+                const query = getStringValue(queryNode);
+                const isRaw = getStringValue(findProperty(options, 'as')) === 'raw' ||
+                    (query !== undefined && RAW_QUERY_RE.test(query.startsWith('?') ? query : `?${query}`)) ||
+                    getStringValue(findProperty(queryNode, 'raw')) === '';
+                if (isRaw)
+                    return ctx.addImportGlob(patterns, { analyzeExports: true });
+            }
             ctx.addImportGlob(patterns);
         },
     };

package/dist/plugins/vitest/index.js

@@ -2,7 +2,7 @@ import { DEFAULT_EXTENSIONS } from '../../constants.js';
 import { _glob } from '../../util/glob.js';
 import { toConfig, toDeferResolve, toDependency, toEntry } from '../../util/input.js';
 import { getPackageNameFromModuleSpecifier } from '../../util/modules.js';
-import { isAbsolute, isInternal, join, toAbsolute } from '../../util/path.js';
+import { isAbsolute, isInternal, join, toAbsolute, toPosix } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 import { getIndexHtmlEntries } from '../vite/helpers.js';
 import { getAliasInputs, getEnvSpecifier, getExternalReporters } from './helpers.js';
@@ -137,7 +137,10 @@ export const resolveConfig = async (localConfig, options) => {
         const viteRoot = toAbsolute(cfg.root ?? '.', options.cwd);
         if (!seenRoots.has(viteRoot)) {
             seenRoots.add(viteRoot);
-            for (const entry of await getIndexHtmlEntries(viteRoot))
+            const publicDir = cfg.publicDir === false || cfg.publicDir === ''
+                ? undefined
+                : toAbsolute(toPosix(cfg.publicDir ?? 'public'), viteRoot);
+            for (const entry of await getIndexHtmlEntries(viteRoot, publicDir))
                 inputs.add(entry);
         }
         const vitestRoot = toAbsolute(cfg.test?.root ?? '.', options.cwd);

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

@@ -39,6 +39,7 @@ interface VitestConfig {
 export interface ViteConfig extends VitestConfig {
     extends?: string | true;
     root?: string;
+    publicDir?: string | false;
     plugins?: unknown[];
     build?: {
         lib?: {

package/dist/schema/configuration.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod/mini';
-import type { CompilerAsync, CompilerSync } from '../compilers/types.ts';
+import type { Compiler } from '../compilers/types.ts';
 export declare const workspaceConfigurationSchema: z.ZodMiniObject<{
     angular: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
         config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
@@ -321,6 +321,11 @@ export declare const workspaceConfigurationSchema: z.ZodMiniObject<{
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
     }, z.core.$strip>]>>;
+    mise: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
+        config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+    }, z.core.$strip>]>>;
     mocha: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
         config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
@@ -1247,6 +1252,11 @@ export declare const knipConfigurationSchema: z.ZodMiniObject<{
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
     }, z.core.$strip>]>>;
+    mise: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
+        config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+    }, z.core.$strip>]>>;
     mocha: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
         config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
@@ -1862,12 +1872,13 @@ export declare const knipConfigurationSchema: z.ZodMiniObject<{
     }, z.core.$strict>>;
     ignoreWorkspaces: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
     includeEntryExports: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
-    compilers: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnion<readonly [z.ZodMiniUnion<readonly [z.ZodMiniLiteral<true>, z.ZodMiniCustom<CompilerSync, CompilerSync>]>, z.ZodMiniCustom<CompilerAsync, CompilerAsync>]>>>;
-    syncCompilers: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnion<readonly [z.ZodMiniLiteral<true>, z.ZodMiniCustom<CompilerSync, CompilerSync>]>>>;
-    asyncCompilers: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniCustom<CompilerAsync, CompilerAsync>>>;
+    compilers: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnion<readonly [z.ZodMiniLiteral<true>, z.ZodMiniCustom<Compiler, Compiler>]>>>;
+    asyncCompilers: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniCustom<Compiler, Compiler>>>;
     tags: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
     treatConfigHintsAsErrors: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
     treatTagHintsAsErrors: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+    preprocessor: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+    preprocessorOptions: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>>;
     include: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"files">, z.ZodMiniLiteral<"dependencies">, z.ZodMiniLiteral<"devDependencies">, z.ZodMiniLiteral<"optionalPeerDependencies">, z.ZodMiniLiteral<"unlisted">, z.ZodMiniLiteral<"binaries">, z.ZodMiniLiteral<"unresolved">, z.ZodMiniLiteral<"exports">, z.ZodMiniLiteral<"types">, z.ZodMiniLiteral<"nsExports">, z.ZodMiniLiteral<"nsTypes">, z.ZodMiniLiteral<"duplicates">, z.ZodMiniLiteral<"enumMembers">, z.ZodMiniLiteral<"namespaceMembers">, z.ZodMiniLiteral<"catalog">, z.ZodMiniLiteral<"catalogReferences">, z.ZodMiniLiteral<"cycles">]>>>;
     exclude: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"files">, z.ZodMiniLiteral<"dependencies">, z.ZodMiniLiteral<"devDependencies">, z.ZodMiniLiteral<"optionalPeerDependencies">, z.ZodMiniLiteral<"unlisted">, z.ZodMiniLiteral<"binaries">, z.ZodMiniLiteral<"unresolved">, z.ZodMiniLiteral<"exports">, z.ZodMiniLiteral<"types">, z.ZodMiniLiteral<"nsExports">, z.ZodMiniLiteral<"nsTypes">, z.ZodMiniLiteral<"duplicates">, z.ZodMiniLiteral<"enumMembers">, z.ZodMiniLiteral<"namespaceMembers">, z.ZodMiniLiteral<"catalog">, z.ZodMiniLiteral<"catalogReferences">, z.ZodMiniLiteral<"cycles">]>>>;
     workspaces: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniObject<{
@@ -2191,6 +2202,11 @@ export declare const knipConfigurationSchema: z.ZodMiniObject<{
             entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
             project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         }, z.core.$strip>]>>;
+        mise: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
+            config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+            entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+            project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        }, z.core.$strip>]>>;
         mocha: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
             config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
             entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;

package/dist/schema/configuration.js

@@ -2,10 +2,8 @@ import { z } from 'zod/mini';
 import { SYMBOL_TYPE } from '../constants.js';
 import { globSchema, pluginsSchema } from './plugins.js';
 const pathsSchema = z.record(z.string(), z.array(z.string()));
-const syncCompilerSchema = z.union([z.literal(true), z.custom()]);
-const asyncCompilerSchema = z.custom();
-const compilerSchema = z.union([syncCompilerSchema, asyncCompilerSchema]);
-const compilersSchema = z.record(z.string(), compilerSchema);
+const compilerSchema = z.custom();
+const compilersSchema = z.record(z.string(), z.union([z.literal(true), compilerSchema]));
 const stringOrRegexSchema = z.array(z.union([z.string(), z.instanceof(RegExp)]));
 const issueTypeSchema = z.union([
     z.literal('files'),
@@ -53,11 +51,12 @@ const rootConfigurationSchema = z.object({
     ignoreWorkspaces: z.optional(z.array(z.string())),
     includeEntryExports: z.optional(z.boolean()),
     compilers: z.optional(compilersSchema),
-    syncCompilers: z.optional(z.record(z.string(), syncCompilerSchema)),
-    asyncCompilers: z.optional(z.record(z.string(), asyncCompilerSchema)),
+    asyncCompilers: z.optional(z.record(z.string(), compilerSchema)),
     tags: z.optional(z.array(z.string())),
     treatConfigHintsAsErrors: z.optional(z.boolean()),
     treatTagHintsAsErrors: z.optional(z.boolean()),
+    preprocessor: z.optional(z.union([z.string(), z.array(z.string())])),
+    preprocessorOptions: z.optional(z.record(z.string(), z.unknown())),
 });
 const reportConfigSchema = z.object({
     include: z.optional(z.array(issueTypeSchema)),

package/dist/schema/plugins.d.ts

@@ -326,6 +326,11 @@ export declare const pluginsSchema: z.ZodMiniObject<{
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
     }, z.core.$strip>]>;
+    mise: z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
+        config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+    }, z.core.$strip>]>;
     mocha: z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
         config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;

package/dist/schema/plugins.js

@@ -74,6 +74,7 @@ export const pluginsSchema = z.object({
     mdx: pluginSchema,
     mdxlint: pluginSchema,
     metro: pluginSchema,
+    mise: pluginSchema,
     mocha: pluginSchema,
     moonrepo: pluginSchema,
     msw: pluginSchema,

package/dist/session/index.d.ts

@@ -1,4 +1,4 @@
-export { IMPORT_STAR, KNIP_CONFIG_LOCATIONS, SIDE_EFFECTS } from '../constants.ts';
+export { IMPORT_STAR, ISSUE_TYPES, KNIP_CONFIG_LOCATIONS, SIDE_EFFECTS } from '../constants.ts';
 export type { DependencyNode, DependencyNodes } from '../graph-explorer/operations/get-dependency-usage.ts';
 export { finalizeConfigurationHints } from '../reporters/util/configuration-hints.ts';
 export { getIssuePrefix } from '../reporters/util/util.ts';

package/dist/session/index.js

@@ -1,4 +1,4 @@
-export { IMPORT_STAR, KNIP_CONFIG_LOCATIONS, SIDE_EFFECTS } from '../constants.js';
+export { IMPORT_STAR, ISSUE_TYPES, KNIP_CONFIG_LOCATIONS, SIDE_EFFECTS } from '../constants.js';
 export { finalizeConfigurationHints } from '../reporters/util/configuration-hints.js';
 export { getIssuePrefix } from '../reporters/util/util.js';
 export { createOptions } from '../util/create-options.js';

package/dist/session/session.js

@@ -1,18 +1,36 @@
 import { run } from '../run.js';
+import { createPreprocessor, toReporterOptions } from '../util/preprocessor.js';
 import { buildFileDescriptor } from './file-descriptor.js';
 import { buildPackageJsonDescriptor } from './package-json-descriptor.js';
 export const createSession = async (options) => {
     const { session, results } = await run(options);
     if (!session)
         throw new Error('Unable to initialize watch session');
-    return createSessionAdapter(session, results, options);
-};
-const createSessionAdapter = (session, results, options) => {
-    return {
+    const adapter = {
         handleFileChanges: session.handleFileChanges,
         getIssues: session.getIssues,
         getResults: () => results,
         describeFile: (filePath, opts) => buildFileDescriptor(filePath, options.cwd, session.getGraph(), session.getEntryPaths(), opts),
         describePackageJson: () => buildPackageJsonDescriptor(session.getGraph(), session.getEntryPaths()),
     };
+    if (options.preprocessor.length === 0)
+        return adapter;
+    const input = toReporterOptions(options, results);
+    const preprocess = await createPreprocessor(options.preprocessor);
+    const updateResults = async () => {
+        const data = await preprocess({ ...input, ...structuredClone(session.getIssues()) });
+        results.issues = data.issues;
+        results.counters = data.counters;
+        results.tagHints = data.tagHints;
+        results.configurationHints = data.configurationHints;
+    };
+    await updateResults();
+    adapter.handleFileChanges = async (changes) => {
+        const update = await session.handleFileChanges(changes);
+        if (update)
+            await updateResults();
+        return update;
+    };
+    adapter.getIssues = () => results;
+    return adapter;
 };

package/dist/types/PluginNames.d.ts

@@ -1,2 +1,2 @@
-export type PluginName = 'angular' | 'astro' | 'astro-db' | 'astro-markdoc' | 'astro-og-canvas' | 'ava' | 'babel' | 'biome' | 'borp' | 'bumpp' | 'bun' | 'c8' | 'capacitor' | 'catalyst' | 'changelogen' | 'changelogithub' | 'changesets' | 'commitizen' | 'commitlint' | 'convex' | 'create-typescript-app' | 'cspell' | 'cucumber' | 'cypress' | 'danger' | 'dependency-cruiser' | 'docusaurus' | 'dotenv' | 'drizzle' | 'electron-vite' | 'eleventy' | 'esbuild' | 'eslint' | 'eve' | 'execa' | 'expo' | 'expressive-code' | 'fast' | 'fumadocs' | 'gatsby' | 'github-action' | 'github-actions' | 'glob' | 'graphql-codegen' | 'hardhat' | 'husky' | 'i18next-parser' | 'jest' | 'karma' | 'knex' | 'ladle' | 'laravel-vite-plugin' | 'lefthook' | 'lint-staged' | 'linthtml' | 'lit' | 'lockfile-lint' | 'lost-pixel' | 'lunaria' | 'markdownlint' | 'marko' | 'mdx' | 'mdxlint' | 'metro' | 'mocha' | 'moonrepo' | 'msw' | 'nano-spawn' | 'nano-staged' | 'nest' | 'netlify' | 'next' | 'next-intl' | 'next-mdx' | 'nitro' | 'node' | 'node-modules-inspector' | 'nodemon' | 'npm-package-json-lint' | 'nuxt' | 'nuxtjs-i18n' | 'nx' | 'nyc' | 'oclif' | 'openapi-ts' | 'openclaw' | 'orval' | 'oxfmt' | 'oxlint' | 'panda-css' | 'parcel' | 'payload' | 'pino' | 'playwright' | 'playwright-ct' | 'playwright-test' | 'plop' | 'pm2' | 'pnpm' | 'postcss' | 'pre-commit' | 'preconstruct' | 'prettier' | 'prisma' | 'quasar' | 'qwik' | 'raycast' | 'react-cosmos' | 'react-email' | 'react-native' | 'react-router' | 'relay' | 'release-it' | 'remark' | 'remix' | 'rolldown' | 'rollup' | 'rsbuild' | 'rslib' | 'rspack' | 'rstest' | 'sanity' | 'semantic-release' | 'sentry' | 'serverless-framework' | 'simple-git-hooks' | 'size-limit' | 'sst' | 'starlight' | 'stencil' | 'storybook' | 'stryker' | 'stylelint' | 'svelte' | 'sveltejs-package' | 'sveltekit' | 'svgo' | 'svgr' | 'swc' | 'syncpack' | 'tailwind' | 'tanstack-router' | 'taskfile' | 'tauri' | 'temporal' | 'travis' | 'ts-node' | 'tsd' | 'tsdown' | 'tsup' | 'tsx' | 'typedoc' | 'typescript' | 'unbuild' | 'unocss' | 'unplugin-auto-import' | 'unplugin-icons' | 'unplugin-vue-components' | 'unplugin-vue-i18n' | 'unplugin-vue-markdown' | 'unplugin-vue-router' | 'vercel' | 'vercel-og' | 'vike' | 'vite' | 'vite-plugin-pages' | 'vite-plugin-pwa' | 'vite-plugin-vue-layouts-next' | 'vite-plus' | 'vite-pwa-assets-generator' | 'vitepress' | 'vitest' | 'vue' | 'webdriver-io' | 'webpack' | 'wireit' | 'wrangler' | 'wxt' | 'xo' | 'yarn' | 'yorkie' | 'zx';
-export declare const pluginNames: readonly ['angular', 'astro', 'astro-db', 'astro-markdoc', 'astro-og-canvas', 'ava', 'babel', 'biome', 'borp', 'bumpp', 'bun', 'c8', 'capacitor', 'catalyst', 'changelogen', 'changelogithub', 'changesets', 'commitizen', 'commitlint', 'convex', 'create-typescript-app', 'cspell', 'cucumber', 'cypress', 'danger', 'dependency-cruiser', 'docusaurus', 'dotenv', 'drizzle', 'electron-vite', 'eleventy', 'esbuild', 'eslint', 'eve', 'execa', 'expo', 'expressive-code', 'fast', 'fumadocs', 'gatsby', 'github-action', 'github-actions', 'glob', 'graphql-codegen', 'hardhat', 'husky', 'i18next-parser', 'jest', 'karma', 'knex', 'ladle', 'laravel-vite-plugin', 'lefthook', 'lint-staged', 'linthtml', 'lit', 'lockfile-lint', 'lost-pixel', 'lunaria', 'markdownlint', 'marko', 'mdx', 'mdxlint', 'metro', 'mocha', 'moonrepo', 'msw', 'nano-spawn', 'nano-staged', 'nest', 'netlify', 'next', 'next-intl', 'next-mdx', 'nitro', 'node', 'node-modules-inspector', 'nodemon', 'npm-package-json-lint', 'nuxt', 'nuxtjs-i18n', 'nx', 'nyc', 'oclif', 'openapi-ts', 'openclaw', 'orval', 'oxfmt', 'oxlint', 'panda-css', 'parcel', 'payload', 'pino', 'playwright', 'playwright-ct', 'playwright-test', 'plop', 'pm2', 'pnpm', 'postcss', 'pre-commit', 'preconstruct', 'prettier', 'prisma', 'quasar', 'qwik', 'raycast', 'react-cosmos', 'react-email', 'react-native', 'react-router', 'relay', 'release-it', 'remark', 'remix', 'rolldown', 'rollup', 'rsbuild', 'rslib', 'rspack', 'rstest', 'sanity', 'semantic-release', 'sentry', 'serverless-framework', 'simple-git-hooks', 'size-limit', 'sst', 'starlight', 'stencil', 'storybook', 'stryker', 'stylelint', 'svelte', 'sveltejs-package', 'sveltekit', 'svgo', 'svgr', 'swc', 'syncpack', 'tailwind', 'tanstack-router', 'taskfile', 'tauri', 'temporal', 'travis', 'ts-node', 'tsd', 'tsdown', 'tsup', 'tsx', 'typedoc', 'typescript', 'unbuild', 'unocss', 'unplugin-auto-import', 'unplugin-icons', 'unplugin-vue-components', 'unplugin-vue-i18n', 'unplugin-vue-markdown', 'unplugin-vue-router', 'vercel', 'vercel-og', 'vike', 'vite', 'vite-plugin-pages', 'vite-plugin-pwa', 'vite-plugin-vue-layouts-next', 'vite-plus', 'vite-pwa-assets-generator', 'vitepress', 'vitest', 'vue', 'webdriver-io', 'webpack', 'wireit', 'wrangler', 'wxt', 'xo', 'yarn', 'yorkie', 'zx'];
+export type PluginName = 'angular' | 'astro' | 'astro-db' | 'astro-markdoc' | 'astro-og-canvas' | 'ava' | 'babel' | 'biome' | 'borp' | 'bumpp' | 'bun' | 'c8' | 'capacitor' | 'catalyst' | 'changelogen' | 'changelogithub' | 'changesets' | 'commitizen' | 'commitlint' | 'convex' | 'create-typescript-app' | 'cspell' | 'cucumber' | 'cypress' | 'danger' | 'dependency-cruiser' | 'docusaurus' | 'dotenv' | 'drizzle' | 'electron-vite' | 'eleventy' | 'esbuild' | 'eslint' | 'eve' | 'execa' | 'expo' | 'expressive-code' | 'fast' | 'fumadocs' | 'gatsby' | 'github-action' | 'github-actions' | 'glob' | 'graphql-codegen' | 'hardhat' | 'husky' | 'i18next-parser' | 'jest' | 'karma' | 'knex' | 'ladle' | 'laravel-vite-plugin' | 'lefthook' | 'lint-staged' | 'linthtml' | 'lit' | 'lockfile-lint' | 'lost-pixel' | 'lunaria' | 'markdownlint' | 'marko' | 'mdx' | 'mdxlint' | 'metro' | 'mise' | 'mocha' | 'moonrepo' | 'msw' | 'nano-spawn' | 'nano-staged' | 'nest' | 'netlify' | 'next' | 'next-intl' | 'next-mdx' | 'nitro' | 'node' | 'node-modules-inspector' | 'nodemon' | 'npm-package-json-lint' | 'nuxt' | 'nuxtjs-i18n' | 'nx' | 'nyc' | 'oclif' | 'openapi-ts' | 'openclaw' | 'orval' | 'oxfmt' | 'oxlint' | 'panda-css' | 'parcel' | 'payload' | 'pino' | 'playwright' | 'playwright-ct' | 'playwright-test' | 'plop' | 'pm2' | 'pnpm' | 'postcss' | 'pre-commit' | 'preconstruct' | 'prettier' | 'prisma' | 'quasar' | 'qwik' | 'raycast' | 'react-cosmos' | 'react-email' | 'react-native' | 'react-router' | 'relay' | 'release-it' | 'remark' | 'remix' | 'rolldown' | 'rollup' | 'rsbuild' | 'rslib' | 'rspack' | 'rstest' | 'sanity' | 'semantic-release' | 'sentry' | 'serverless-framework' | 'simple-git-hooks' | 'size-limit' | 'sst' | 'starlight' | 'stencil' | 'storybook' | 'stryker' | 'stylelint' | 'svelte' | 'sveltejs-package' | 'sveltekit' | 'svgo' | 'svgr' | 'swc' | 'syncpack' | 'tailwind' | 'tanstack-router' | 'taskfile' | 'tauri' | 'temporal' | 'travis' | 'ts-node' | 'tsd' | 'tsdown' | 'tsup' | 'tsx' | 'typedoc' | 'typescript' | 'unbuild' | 'unocss' | 'unplugin-auto-import' | 'unplugin-icons' | 'unplugin-vue-components' | 'unplugin-vue-i18n' | 'unplugin-vue-markdown' | 'unplugin-vue-router' | 'vercel' | 'vercel-og' | 'vike' | 'vite' | 'vite-plugin-pages' | 'vite-plugin-pwa' | 'vite-plugin-vue-layouts-next' | 'vite-plus' | 'vite-pwa-assets-generator' | 'vitepress' | 'vitest' | 'vue' | 'webdriver-io' | 'webpack' | 'wireit' | 'wrangler' | 'wxt' | 'xo' | 'yarn' | 'yorkie' | 'zx';
+export declare const pluginNames: readonly ['angular', 'astro', 'astro-db', 'astro-markdoc', 'astro-og-canvas', 'ava', 'babel', 'biome', 'borp', 'bumpp', 'bun', 'c8', 'capacitor', 'catalyst', 'changelogen', 'changelogithub', 'changesets', 'commitizen', 'commitlint', 'convex', 'create-typescript-app', 'cspell', 'cucumber', 'cypress', 'danger', 'dependency-cruiser', 'docusaurus', 'dotenv', 'drizzle', 'electron-vite', 'eleventy', 'esbuild', 'eslint', 'eve', 'execa', 'expo', 'expressive-code', 'fast', 'fumadocs', 'gatsby', 'github-action', 'github-actions', 'glob', 'graphql-codegen', 'hardhat', 'husky', 'i18next-parser', 'jest', 'karma', 'knex', 'ladle', 'laravel-vite-plugin', 'lefthook', 'lint-staged', 'linthtml', 'lit', 'lockfile-lint', 'lost-pixel', 'lunaria', 'markdownlint', 'marko', 'mdx', 'mdxlint', 'metro', 'mise', 'mocha', 'moonrepo', 'msw', 'nano-spawn', 'nano-staged', 'nest', 'netlify', 'next', 'next-intl', 'next-mdx', 'nitro', 'node', 'node-modules-inspector', 'nodemon', 'npm-package-json-lint', 'nuxt', 'nuxtjs-i18n', 'nx', 'nyc', 'oclif', 'openapi-ts', 'openclaw', 'orval', 'oxfmt', 'oxlint', 'panda-css', 'parcel', 'payload', 'pino', 'playwright', 'playwright-ct', 'playwright-test', 'plop', 'pm2', 'pnpm', 'postcss', 'pre-commit', 'preconstruct', 'prettier', 'prisma', 'quasar', 'qwik', 'raycast', 'react-cosmos', 'react-email', 'react-native', 'react-router', 'relay', 'release-it', 'remark', 'remix', 'rolldown', 'rollup', 'rsbuild', 'rslib', 'rspack', 'rstest', 'sanity', 'semantic-release', 'sentry', 'serverless-framework', 'simple-git-hooks', 'size-limit', 'sst', 'starlight', 'stencil', 'storybook', 'stryker', 'stylelint', 'svelte', 'sveltejs-package', 'sveltekit', 'svgo', 'svgr', 'swc', 'syncpack', 'tailwind', 'tanstack-router', 'taskfile', 'tauri', 'temporal', 'travis', 'ts-node', 'tsd', 'tsdown', 'tsup', 'tsx', 'typedoc', 'typescript', 'unbuild', 'unocss', 'unplugin-auto-import', 'unplugin-icons', 'unplugin-vue-components', 'unplugin-vue-i18n', 'unplugin-vue-markdown', 'unplugin-vue-router', 'vercel', 'vercel-og', 'vike', 'vite', 'vite-plugin-pages', 'vite-plugin-pwa', 'vite-plugin-vue-layouts-next', 'vite-plus', 'vite-pwa-assets-generator', 'vitepress', 'vitest', 'vue', 'webdriver-io', 'webpack', 'wireit', 'wrangler', 'wxt', 'xo', 'yarn', 'yorkie', 'zx'];

package/dist/types/PluginNames.js

@@ -63,6 +63,7 @@ export const pluginNames = [
     'mdx',
     'mdxlint',
     'metro',
+    'mise',
     'mocha',
     'moonrepo',
     'msw',