knip 6.42.0 → 6.43.0

package/dist/ConfigurationChief.d.ts

@@ -102,6 +102,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        buf?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         bumpp?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -202,6 +207,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'electron-forge'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         'electron-vite'?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -382,6 +392,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        mcp?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         mdx?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1074,6 +1089,7 @@ export declare class ConfigurationChief {
         babel?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         biome?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         borp?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        buf?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         bumpp?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         bun?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         c8?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
@@ -1094,6 +1110,7 @@ export declare class ConfigurationChief {
         docusaurus?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         dotenv?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         drizzle?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        "electron-forge"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "electron-vite"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         eleventy?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         esbuild?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
@@ -1130,6 +1147,7 @@ export declare class ConfigurationChief {
         lunaria?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         markdownlint?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         marko?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        mcp?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         mdx?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         mdxlint?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         metro?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;

package/dist/IssueFixer.js

@@ -75,9 +75,12 @@ class IssueFixer {
                 continue;
             const absFilePath = join(this.options.cwd, filePath);
             const originalSource = await readFile(absFilePath, 'utf-8');
-            let sourceFileText = fixes
-                .sort((a, b) => b[0] - a[0])
-                .reduce((text, [start, end, flags]) => removeExport({ text, start, end, flags }), originalSource);
+            const disjointFixes = [];
+            for (const fix of fixes.sort((a, b) => a[0] - b[0] || b[1] - a[1])) {
+                if (fix[0] >= (disjointFixes.at(-1)?.[1] ?? 0))
+                    disjointFixes.push(fix);
+            }
+            let sourceFileText = disjointFixes.reduceRight((text, [start, end, flags]) => removeExport({ text, start, end, flags }), originalSource);
             if (MODULE_MARKER.test(originalSource) && !MODULE_MARKER.test(sourceFileText)) {
                 sourceFileText = `${sourceFileText.trimEnd()}\n\nexport {};\n`;
             }
@@ -87,7 +90,8 @@ class IssueFixer {
                 const issueMap = issues[type]?.[filePath];
                 if (issueMap)
                     for (const issue of Object.values(issueMap))
-                        issue.isFixed = true;
+                        if (issue.fixes.length > 0)
+                            issue.isFixed = true;
             }
         }
         return touchedFiles;
@@ -131,7 +135,8 @@ class IssueFixer {
                 const keep = (_, i) => !remove.has(i + 1);
                 await writeFile(absFilePath, fileContent.split('\n').filter(keep).join('\n'));
                 for (const issue of issuesForFile)
-                    issue.isFixed = true;
+                    if (issue.fixes.length > 0)
+                        issue.isFixed = true;
                 touchedFiles.add(filePath);
             }
             else {

package/dist/WorkspaceWorker.js

@@ -9,12 +9,12 @@ import { createManifest } from './util/package-json.js';
 import { isExternalReExportsOnly } from './typescript/ast-helpers.js';
 import { _parseFile } from './typescript/ast-nodes.js';
 import { compact } from './util/array.js';
-import { debugLogArray, debugLogObject } from './util/debug.js';
+import { debugLog, debugLogArray, debugLogObject } from './util/debug.js';
 import { _glob, hasNoProductionSuffix, hasProductionSuffix, negate } from './util/glob.js';
 import { isCatalog, isConfig, toConfig, toDebugString, toEntry, toProductionEntry, } from './util/input.js';
 import { filterTransitiveDependencies } from './util/filter-transitive-dependencies.js';
 import { timerify } from './util/Performance.js';
-import { basename, dirname, join, relative, toRelative } from './util/path.js';
+import { basename, dirname, extname, join, relative, toRelative } from './util/path.js';
 import { extractPatternExtensions } from './util/pattern-extensions.js';
 import { formatCauseMessage } from './util/errors.js';
 import { logError } from './util/log.js';
@@ -378,14 +378,17 @@ export class WorkspaceWorker {
                                 }
                             }
                             catch (error) {
-                                if (!(error instanceof Error))
-                                    throw error;
                                 hasLoadConfigError = true;
-                                this.handleConfigLoadError();
                                 const relPath = toRelative(configFilePath, this.options.cwd);
-                                const cause = formatCauseMessage(error, this.options.cwd);
-                                logError(`Error loading ${relPath} (${cause})`);
-                                logError('Please fix or visit https://knip.dev/reference/known-issues');
+                                const cause = formatCauseMessage(error instanceof Error ? error : new Error(String(error)), this.options.cwd);
+                                if (plugin.isLoadConfigOptional) {
+                                    debugLog(wsName, `Error loading ${relPath} (${cause})`);
+                                }
+                                else {
+                                    this.handleConfigLoadError();
+                                    logError(`Error loading ${relPath} (${cause})`);
+                                    logError('Please fix or visit https://knip.dev/reference/known-issues');
+                                }
                             }
                         }
                     }
@@ -398,9 +401,11 @@ export class WorkspaceWorker {
                     cache.resolveFromAST = inputs;
                 }
                 if (!isManifest) {
-                    inputs.push(toEntry(configFilePath));
+                    if (extname(configFilePath)) {
+                        inputs.push(toEntry(configFilePath));
+                        cache.configFile = toEntry(configFilePath);
+                    }
                     storeConfigFilePath(pluginName, toConfig(pluginName, configFilePath));
-                    cache.configFile = toEntry(configFilePath);
                     if (hasLoadConfigError) {
                         this.cache.removeEntry(configFilePath);
                     }

package/dist/binaries/resolvers/bun.js

@@ -21,6 +21,7 @@ const commands = new Set([
     'discord',
     'exec',
     'feedback',
+    'fmt',
     'fuzzilli',
     'getcompletes',
     'help',

package/dist/binaries/resolvers/npm.js

@@ -3,6 +3,15 @@ import { isBinary, toBinary, toDependency } from '../../util/input.js';
 import { extractBinary, isValidBinary, stripVersionFromSpecifier } from '../../util/modules.js';
 import { isInternal } from '../../util/path.js';
 import { argsAfter, expandScript } from '../util.js';
+const runCommands = new Set(['run', 'run-script', 'rum', 'urn']);
+const lifecycleScripts = new Map([
+    ['start', 'start'],
+    ['stop', 'stop'],
+    ['restart', 'restart'],
+    ['test', 'test'],
+    ['t', 'test'],
+    ['tst', 'test'],
+]);
 export const resolve = (_binary, words, options) => {
     const { fromArgs, manifest } = options;
     const parsed = parseArgs(words, {
@@ -49,8 +58,9 @@ export const resolve = (_binary, words, options) => {
         return [...packageInputs, ...inputs];
     }
     const _childArgs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(argsAfter(words, '--'), { isForwardedArgs: true }) : [];
-    if (command === 'run' && manifest.scriptNames.has(script)) {
-        return expandScript(script, argsAfter(words, '--'), manifest.scripts, options) ?? _childArgs;
+    const name = runCommands.has(command) ? script : lifecycleScripts.get(command);
+    if (name && manifest.scriptNames.has(name)) {
+        return expandScript(name, argsAfter(words, '--'), manifest.scripts, options) ?? _childArgs;
     }
     return [];
 };

package/dist/binaries/resolvers/pnpm.js

@@ -89,6 +89,7 @@ const commands = [
     'with',
 ];
 const recursiveCommands = ['recursive', 'multi', 'm'];
+const testAliases = new Set(['t', 'tst']);
 export const resolve = (_binary, words, options) => {
     const parseOptions = {
         isStorePositions: true,
@@ -120,16 +121,17 @@ export const resolve = (_binary, words, options) => {
     if (parsed.filter && !parsed.recursive)
         return [];
     const childInputs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(argsAfter(words, '--'), { isForwardedArgs: true }) : [];
-    if (command === 'run') {
+    if (command === 'run' || command === 'run-script') {
         const script = parsed._[1];
         if (script && manifest.scriptNames.has(script)) {
             return expandScript(script, argsAfter(words, script), manifest.scripts, options) ?? childInputs;
         }
         return childInputs;
     }
-    const isScript = manifest.scriptNames.has(command);
+    const name = testAliases.has(command) ? 'test' : command;
+    const isScript = manifest.scriptNames.has(name);
     if (isScript)
-        return expandScript(command, argsAfter(words, command), manifest.scripts, options) ?? childInputs;
+        return expandScript(name, argsAfter(words, command), manifest.scripts, options) ?? childInputs;
     if (commands.includes(command))
         return childInputs;
     return command && isValidBinary(command) ? [toBinary(command)] : [];

package/dist/compilers/compilers.js

@@ -1,7 +1,7 @@
 export const fencedCodeBlockMatcher = /```[\s\S]*?```/g;
 export const inlineCodeMatcher = /`[^`]+`/g;
-export const scriptExtractor = /<script\b((?:[^>"']|"[^"]*"|'[^']*')*)(?<!\/)>([\s\S]*?)<\/script>/gi;
-export const styleExtractor = /<style\b((?:[^>"']|"[^"]*"|'[^']*')*)>([\s\S]*?)<\/style>/gi;
+export const scriptExtractor = /<script(?=[\s/>])((?:[^>"']|"[^"]*"|'[^']*')*)(?<!\/)>([\s\S]*?)<\/script>/gi;
+export const styleExtractor = /<style(?![\w-])((?:[^>"']|"[^"]*"|'[^']*')*)>([\s\S]*?)<\/style>/gi;
 const langAttrMatcher = /\blang\s*=\s*["']([^"']+)["']/i;
 export const blockCommentMatcher = /\/\*[\s\S]*?\*\//g;
 export const lineCommentMatcher = /^[ \t]*\/\/.*$/gm;

package/dist/compilers/scss.js

@@ -1,26 +1,6 @@
-import { ensureRelative, isScopedPackage, isTildePackage, splitSpec } from './shared.js';
-import { hasUrlScheme } from '../util/url.js';
+import { getUrlSpecifier, isScopedPackage, isTildePackage, splitSpec } from './shared.js';
 const dependencies = ['sass', 'sass-embedded', 'node-sass'];
-const dependencyMatcher = /"(?:\\(?:\r\n|[\s\S]|$)|[^"\\\r\n\f])*(?:"|[\r\n\f]|$)|'(?:\\(?:\r\n|[\s\S]|$)|[^'\\\r\n\f])*(?:'|[\r\n\f]|$)|\/\*[\s\S]*?(?:\*\/|$)|\/\/[^\r\n]*(?:[\r\n]|$)|@(?:use|import|forward)\s+['"](pkg:)?([^'"]+)['"]|url\(\s*(?:["']([^"']*)["']|([^'")\s]+))\s*\)/g;
-const getUrlSpecifier = (url) => {
-    if (!url ||
-        url.startsWith('//') ||
-        url.startsWith('/') ||
-        url.startsWith('#') ||
-        hasUrlScheme(url) ||
-        url.includes('$') ||
-        url.includes('#{'))
-        return;
-    let end = url.length;
-    const queryIndex = url.indexOf('?');
-    if (queryIndex !== -1)
-        end = queryIndex;
-    const fragmentIndex = url.indexOf('#');
-    if (fragmentIndex !== -1 && fragmentIndex < end)
-        end = fragmentIndex;
-    const path = url.slice(0, end);
-    return path ? ensureRelative(path) : undefined;
-};
+const dependencyMatcher = /"(?:\\(?:\r\n|[\s\S]|$)|[^"\\\r\n\f])*(?:"|[\r\n\f]|$)|'(?:\\(?:\r\n|[\s\S]|$)|[^'\\\r\n\f])*(?:'|[\r\n\f]|$)|\/\*[\s\S]*?(?:\*\/|$)|\/\/[^\r\n]*(?:[\r\n]|$)|@(?:use|import|forward)\s+['"](pkg:)?([^'"]+)['"]|url\(\s*(?:["']([^"'\r\n]*)["']|([^'")\s]+))\s*\)/g;
 const candidates = (specifier) => {
     const { dir, name } = splitSpec(specifier);
     const hasExt = name.endsWith('.scss') || name.endsWith('.sass');

package/dist/compilers/shared.d.ts

@@ -1,6 +1,6 @@
 export declare const isScopedPackage: (s: string) => boolean;
 export declare const isTildePackage: (s: string) => boolean;
-export declare const ensureRelative: (spec: string) => string;
+export declare const getUrlSpecifier: (url: string) => string | undefined;
 export declare const splitSpec: (specifier: string) => {
     dir: string;
     name: string;

package/dist/compilers/shared.js

@@ -1,8 +1,31 @@
 import { basename, dirname } from '../util/path.js';
+import { hasUrlScheme } from '../util/url.js';
 const isAlias = (s) => (s.charCodeAt(0) === 64 && s.charCodeAt(1) === 47) || s.charCodeAt(0) === 126 || s.charCodeAt(0) === 35;
 export const isScopedPackage = (s) => s.charCodeAt(0) === 64 && s.charCodeAt(1) !== 47;
 export const isTildePackage = (s) => s.charCodeAt(0) === 126 && s.charCodeAt(1) !== 47;
-export const ensureRelative = (spec) => (spec.startsWith('.') || isAlias(spec) ? spec : `./${spec}`);
+export const getUrlSpecifier = (url) => {
+    if (!url ||
+        url.startsWith('//') ||
+        url.startsWith('/') ||
+        url.startsWith('#') ||
+        hasUrlScheme(url) ||
+        url.includes('$') ||
+        url.includes('#{') ||
+        url.includes('('))
+        return;
+    let end = url.length;
+    const queryIndex = url.indexOf('?');
+    if (queryIndex !== -1)
+        end = queryIndex;
+    const fragmentIndex = url.indexOf('#');
+    if (fragmentIndex !== -1 && fragmentIndex < end)
+        end = fragmentIndex;
+    const path = url.slice(0, end);
+    if (!path)
+        return;
+    return isScopedPackage(path) ? path : ensureRelative(path);
+};
+const ensureRelative = (spec) => (spec.startsWith('.') || isAlias(spec) ? spec : `./${spec}`);
 export const splitSpec = (specifier) => {
     const spec = ensureRelative(specifier);
     return { dir: dirname(spec), name: basename(spec) };

package/dist/constants.js

@@ -101,6 +101,7 @@ export const IGNORED_GLOBAL_BINARIES = new Set([
     'nub',
     'nubx',
     'open',
+    'osascript',
     'paste',
     'pnpm',
     'pnpx',
@@ -186,6 +187,7 @@ export const FOREIGN_FILE_EXTENSIONS = new Set([
     '.jpg',
     '.less',
     '.mp3',
+    '.otf',
     '.png',
     '.sass',
     '.scss',

package/dist/plugins/_vue/auto-import.js

@@ -250,9 +250,36 @@ const getImportedComponentImports = (maps, names) => {
     }
     return imports;
 };
+const srcBlockMatcher = /<!--[\s\S]*?-->|<(script|style)(?=[\s/>])((?:[^>"']|"[^"]*"|'[^']*')*?)(?:\/>|>[\s\S]*?<\/\1\s*>)/g;
+const attributeMatcher = /([^\s=/>]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'>]+)))?/g;
+const getSrc = (attrs) => {
+    for (const [, name, double, single, unquoted] of attrs.matchAll(attributeMatcher)) {
+        if (name === 'src')
+            return double ?? single ?? unquoted;
+    }
+};
+const getSrcImports = (source) => {
+    if (!source.includes('src'))
+        return '';
+    const imports = [];
+    for (const [, tag, attrs] of source.matchAll(srcBlockMatcher)) {
+        const src = tag && getSrc(attrs);
+        if (!src)
+            continue;
+        const specifier = JSON.stringify(src);
+        if (tag === 'script') {
+            imports.push(`import _sfc_main from ${specifier};\nexport * from ${specifier};\nexport default _sfc_main;`);
+        }
+        else
+            imports.push(`import ${specifier};`);
+    }
+    return imports.join('\n');
+};
 const compileVueSfc = (source, path, maps, root) => {
     if (maps.importMap.size === 0 && maps.componentMap.size === 0) {
-        return [scriptBodies(source, path), stylePreprocessorImports(source, path)].filter(Boolean).join(';\n');
+        return [scriptBodies(source, path), getSrcImports(source), stylePreprocessorImports(source, path)]
+            .filter(Boolean)
+            .join(';\n');
     }
     const sfc = sfcForRoot(root);
     const { descriptor } = sfc.parse(source, path);
@@ -284,6 +311,9 @@ const compileVueSfc = (source, path, maps, root) => {
     }
     scripts.push(...getSyntheticImports(maps, identifiers, path, templateTags));
     scripts.push(...getImportedComponentImports(maps, importedComponents));
+    const srcImports = getSrcImports(source);
+    if (srcImports)
+        scripts.push(srcImports);
     const styles = stylePreprocessorImports(source, path);
     if (styles)
         scripts.push(styles);

package/dist/plugins/buf/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '../../types/config.ts';
+declare const plugin: Plugin;
+export default plugin;

package/dist/plugins/buf/index.js

@@ -0,0 +1,33 @@
+import { hasDependency } from '../../util/plugin.js';
+import { toShellCommand } from '../../util/scripts.js';
+const title = 'Buf';
+const enablers = ['@bufbuild/buf', '@bufbuild/protoc-gen-es'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['buf.gen.yaml'];
+const args = {
+    config: ['template'],
+};
+const resolveConfig = (config, options) => {
+    const inputs = [];
+    for (const plugin of config.plugins ?? []) {
+        const name = plugin.plugin ?? plugin.name;
+        const command = plugin.local ?? plugin.path ?? (name && !name.includes('/') ? `protoc-gen-${name}` : undefined);
+        if (!command)
+            continue;
+        const script = toShellCommand(typeof command === 'string' ? [command] : command);
+        for (const input of options.getInputsFromScripts(script, { optionalBinaries: true })) {
+            input.dir ??= options.cwd;
+            inputs.push(input);
+        }
+    }
+    return inputs;
+};
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    args,
+    resolveConfig,
+};
+export default plugin;

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

@@ -0,0 +1,8 @@
+export interface BufGenConfig {
+    plugins?: Array<{
+        local?: string | string[];
+        path?: string | string[];
+        plugin?: string;
+        name?: string;
+    }>;
+}

package/dist/plugins/buf/types.js

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

package/dist/plugins/bun/index.js

@@ -21,9 +21,22 @@ const resolveConfig = localConfig => {
     const preload = localConfig.test?.preload ?? [];
     return preload.map(specifier => toDeferResolve(specifier));
 };
+const isPath = (arg) => /^\.{0,2}\//.test(arg);
+const toFilterPatterns = (filter) => {
+    if (filter === '.')
+        return patterns;
+    if (/\.[cm]?[jt]sx?$/.test(filter))
+        return [`**/*${filter}`];
+    return [
+        ...patterns.map(pattern => `**/*${filter}*/${pattern}`),
+        ...patterns.map(pattern => pattern.replace('**/*', `**/*${filter}*`)),
+    ];
+};
 const toPatterns = (arg) => {
     if (/[*{?]/.test(arg))
         return [arg];
+    if (!isPath(arg))
+        return toFilterPatterns(arg);
     if (/\.\w+$/.test(arg))
         return [arg];
     const dir = arg.replace(/\/+$/, '');

package/dist/plugins/electron-forge/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '../../types/config.ts';
+declare const plugin: Plugin;
+export default plugin;

package/dist/plugins/electron-forge/index.js

@@ -0,0 +1,94 @@
+import { toConfig, toDependency, toProductionEntry } from '../../util/input.js';
+import { toAbsolute } from '../../util/path.js';
+import { hasDependency } from '../../util/plugin.js';
+import { findWebpackDependenciesFromConfig } from '../webpack/index.js';
+const title = 'Electron Forge';
+const enablers = ['@electron-forge/cli'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const packageJsonPath = 'config.forge';
+const config = ['package.json', 'forge.config.{js,mjs,cjs,ts,mts,cts}'];
+const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const isPlainObject = (value) => isObject(value) && Object.getPrototypeOf(value) === Object.prototype;
+const toArray = (value) => (Array.isArray(value) ? value : value === undefined ? [] : [value]);
+const toStrings = (value) => {
+    const values = [];
+    for (const item of isObject(value) ? Object.values(value) : toArray(value)) {
+        if (typeof item === 'string')
+            values.push(item);
+    }
+    return values;
+};
+const getPluginInputs = async (name, opts, options) => {
+    if (!isObject(opts))
+        return [];
+    const { cwd, configFilePath } = options;
+    const inputs = [];
+    const addEntry = (value) => {
+        for (const id of toStrings(value))
+            inputs.push(toProductionEntry(toAbsolute(id, cwd)));
+    };
+    const addConfig = async (pluginName, value) => {
+        if (typeof value === 'string') {
+            inputs.push(toConfig(pluginName, value, { dir: cwd, containingFilePath: configFilePath }));
+        }
+        else if (pluginName === 'webpack' && isObject(value)) {
+            for (const input of await findWebpackDependenciesFromConfig(value, options))
+                inputs.push(input);
+        }
+    };
+    if (name === 'vite' || name === '@electron-forge/plugin-vite') {
+        for (const build of toArray(opts.build)) {
+            if (!isObject(build))
+                continue;
+            addEntry(build.entry);
+            await addConfig('vite', build.config);
+        }
+        for (const renderer of toArray(opts.renderer))
+            if (isObject(renderer))
+                await addConfig('vite', renderer.config);
+    }
+    else if (name === 'webpack' || name === '@electron-forge/plugin-webpack') {
+        await addConfig('webpack', opts.mainConfig);
+        for (const renderer of toArray(opts.renderer)) {
+            if (!isObject(renderer))
+                continue;
+            await addConfig('webpack', renderer.config);
+            for (const entryPoint of toArray(renderer.entryPoints)) {
+                if (!isObject(entryPoint))
+                    continue;
+                addEntry(entryPoint.js);
+                if (!isObject(entryPoint.preload))
+                    continue;
+                addEntry(entryPoint.preload.js);
+                await addConfig('webpack', entryPoint.preload.config);
+            }
+        }
+    }
+    return inputs;
+};
+const resolveConfig = async (localConfig, options) => {
+    if (typeof localConfig === 'string') {
+        return [toConfig('electron-forge', localConfig, { containingFilePath: options.configFilePath })];
+    }
+    if (!isObject(localConfig))
+        return [];
+    const inputs = [];
+    for (const item of [localConfig.makers, localConfig.publishers, localConfig.plugins].flatMap(toArray)) {
+        if (!isObject(item))
+            continue;
+        if (isPlainObject(item) && typeof item.name === 'string')
+            inputs.push(toDependency(item.name));
+        for (const input of await getPluginInputs(item.name, item.config, options))
+            inputs.push(input);
+    }
+    return inputs;
+};
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    packageJsonPath,
+    config,
+    resolveConfig,
+};
+export default plugin;

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

@@ -4,6 +4,7 @@ import { type ConfigInput, type Input } from '../../util/input.ts';
 import type { ESLintConfig, ESLintConfigDeprecated, OverrideConfigDeprecated, Settings } from './types.ts';
 export declare const isFlatConfig: (fileName: string) => boolean;
 export declare const getInputs: (config: ESLintConfigDeprecated | OverrideConfigDeprecated | ESLintConfig, options: PluginOptions) => (Input | ConfigInput)[];
+export declare const toParser: (name: string) => Input;
 export type ImportSettingKind = 'resolver' | 'parsers';
 export declare const importSettingKinds: Map<string, ImportSettingKind>;
 export declare const getInputsFromSettings: (settings?: Settings) => Input[];

package/dist/plugins/eslint/helpers.js

@@ -33,7 +33,7 @@ const getInputsDeprecated = (config, options) => {
     return [...extendConfigs, ...deferred, ...parsers, ...babelDependencies, ...overrides];
 };
 const isParserObject = (value) => typeof value.parseForESLint === 'function' || typeof value.parse === 'function';
-const toParser = (name) => toDeferResolve(name, name === 'espree' ? { optional: true } : {});
+export const toParser = (name) => toDeferResolve(name, name === 'espree' ? { optional: true } : {});
 const getParsers = ({ parser, parserOptions }) => {
     const inputs = [];
     for (const value of [parser, parserOptions?.parser]) {

package/dist/plugins/eslint/resolveFromAST.js

@@ -3,7 +3,17 @@ import { toDeferResolve } from '../../util/input.js';
 import { findProperty, getPropertyKey } from '../../typescript/ast-helpers.js';
 import { getStringValue } from '../../typescript/ast-nodes.js';
 import { isInternal } from '../../util/path.js';
-import { importSettingKinds } from './helpers.js';
+import { importSettingKinds, toParser } from './helpers.js';
+const isParserObjectExpression = (node) => {
+    for (const prop of node.properties) {
+        if (prop.type === 'SpreadElement')
+            return true;
+        const key = getPropertyKey(prop);
+        if (key === 'parse' || key === 'parseForESLint')
+            return true;
+    }
+    return false;
+};
 const getInputsFromSettingsAST = (program) => {
     const inputs = [];
     const addResolver = (kind, resolver) => {
@@ -12,6 +22,10 @@ const getInputsFromSettingsAST = (program) => {
         const dep = kind === 'resolver' ? `eslint-import-resolver-${resolver}` : resolver;
         inputs.push(toDeferResolve(dep, { optional: true }));
     };
+    const addParser = (name) => {
+        if (name)
+            inputs.push(toParser(name));
+    };
     const addResolvers = (kind, node) => {
         if (node?.type === 'ArrayExpression') {
             for (const element of node.elements)
@@ -32,15 +46,26 @@ const getInputsFromSettingsAST = (program) => {
     const visitor = new Visitor({
         ObjectExpression(node) {
             const settingsNode = findProperty(node, 'settings');
-            if (!settingsNode || settingsNode.type !== 'ObjectExpression')
-                return;
-            for (const prop of settingsNode.properties ?? []) {
-                if (prop.type !== 'Property')
-                    continue;
-                const key = getPropertyKey(prop);
-                const kind = key && importSettingKinds.get(key);
-                if (kind)
-                    addResolvers(kind, prop.value);
+            if (settingsNode?.type === 'ObjectExpression') {
+                for (const prop of settingsNode.properties ?? []) {
+                    if (prop.type !== 'Property')
+                        continue;
+                    const key = getPropertyKey(prop);
+                    const kind = key && importSettingKinds.get(key);
+                    if (kind)
+                        addResolvers(kind, prop.value);
+                }
+            }
+            const parser = findProperty(findProperty(node, 'parserOptions'), 'parser');
+            if (parser?.type === 'ObjectExpression') {
+                if (isParserObjectExpression(parser))
+                    return;
+                for (const prop of parser.properties)
+                    if (prop.type === 'Property')
+                        addParser(getStringValue(prop.value));
+            }
+            else {
+                addParser(getStringValue(parser));
             }
         },
     });

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

@@ -15,6 +15,6 @@ export declare const getConfig: (localConfig: ExpoConfig, options: PluginOptions
         userInterfaceStyle?: 'automatic' | 'light' | 'dark';
     };
     androidNavigationBar?: Record<string, unknown>;
-    plugins?: (string | [string, Record<string, unknown>])[];
+    plugins?: (string | ((config: unknown) => unknown) | [string | ((config: unknown) => unknown), Record<string, unknown>])[];
 };
 export declare const getDependencies: ResolveConfig<ExpoConfig>;