knip 5.83.1 → 5.84.1

package/dist/ConfigurationChief.d.ts

@@ -196,6 +196,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        execa?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         expo?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -431,6 +436,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        pm2?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         pnpm?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -461,6 +471,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'react-native'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         'react-router'?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -711,6 +726,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        zx?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
         paths?: Record<string, string[]> | undefined;
@@ -761,6 +781,7 @@ export declare class ConfigurationChief {
         drizzle?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         eleventy?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         eslint?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        execa?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         expo?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         "expressive-code"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         gatsby?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
@@ -806,11 +827,13 @@ export declare class ConfigurationChief {
         "playwright-ct"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         "playwright-test"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         plop?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        pm2?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         postcss?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         preconstruct?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         prettier?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         prisma?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         "react-cosmos"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        "react-native"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         "react-router"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         relay?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         "release-it"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
@@ -859,6 +882,7 @@ export declare class ConfigurationChief {
         wrangler?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         xo?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         yorkie?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        zx?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         entry: string[];
         project: string[];
         paths: Record<string, string[]>;

package/dist/IssueCollector.d.ts

@@ -17,10 +17,22 @@ export declare class IssueCollector {
     private isMatch;
     private isFileMatch;
     private issueMatchers;
+    private isTrackUnusedIgnorePatterns;
+    private unusedIgnorePatterns;
+    private unusedIgnoreFilesPatterns;
     constructor(options: MainOptions);
     setWorkspaceFilter(workspaceFilePathFilter: WorkspaceFilePathFilter | undefined): void;
-    addIgnorePatterns(patterns: string[]): void;
-    addIgnoreFilesPatterns(patterns: string[]): void;
+    addIgnorePatterns(entries: {
+        pattern: string;
+        id: string;
+        workspaceName?: string;
+    }[]): void;
+    addIgnoreFilesPatterns(entries: {
+        pattern: string;
+        id: string;
+        workspaceName?: string;
+    }[]): void;
+    private markUsedPatterns;
     setIgnoreIssues(ignoreIssues?: IgnoreIssues): void;
     private shouldIgnoreIssue;
     addFileCounts({ processed, unused }: {
@@ -38,6 +50,7 @@ export declare class IssueCollector {
         tagHints: Set<TagHint>;
         configurationHints: ConfigurationHint[];
     };
+    getUnusedIgnorePatternHints(options: MainOptions): ConfigurationHint[];
     private retainedIssues;
     retainIssue(issue: Issue): void;
     getRetainedIssues(): Issue[];

package/dist/IssueCollector.js

@@ -25,27 +25,61 @@ export class IssueCollector {
     isMatch;
     isFileMatch;
     issueMatchers = new Map();
+    isTrackUnusedIgnorePatterns;
+    unusedIgnorePatterns = new Map();
+    unusedIgnoreFilesPatterns = new Map();
     constructor(options) {
         this.cwd = options.cwd;
         this.rules = options.rules;
         this.workspaceFilter = () => true;
         this.isMatch = () => false;
         this.isFileMatch = () => false;
+        this.isTrackUnusedIgnorePatterns = !options.isDisableConfigHints;
     }
     setWorkspaceFilter(workspaceFilePathFilter) {
         if (workspaceFilePathFilter)
             this.workspaceFilter = workspaceFilePathFilter;
     }
-    addIgnorePatterns(patterns) {
-        for (const pattern of patterns)
-            this.ignorePatterns.add(pattern);
+    addIgnorePatterns(entries) {
+        for (const entry of entries) {
+            this.ignorePatterns.add(entry.pattern);
+            if (!this.isTrackUnusedIgnorePatterns)
+                continue;
+            if (entry.pattern.startsWith('!'))
+                continue;
+            if (this.unusedIgnorePatterns.has(entry.pattern))
+                continue;
+            this.unusedIgnorePatterns.set(entry.pattern, {
+                hint: { type: 'ignore', identifier: entry.id, workspaceName: entry.workspaceName },
+                isMatch: picomatch(entry.pattern, { dot: true }),
+            });
+        }
         this.isMatch = createMatcher(this.ignorePatterns);
     }
-    addIgnoreFilesPatterns(patterns) {
-        for (const pattern of patterns)
-            this.ignoreFilesPatterns.add(pattern);
+    addIgnoreFilesPatterns(entries) {
+        for (const entry of entries) {
+            this.ignoreFilesPatterns.add(entry.pattern);
+            if (!this.isTrackUnusedIgnorePatterns)
+                continue;
+            if (entry.pattern.startsWith('!'))
+                continue;
+            if (this.unusedIgnoreFilesPatterns.has(entry.pattern))
+                continue;
+            this.unusedIgnoreFilesPatterns.set(entry.pattern, {
+                hint: { type: 'ignoreFiles', identifier: entry.id, workspaceName: entry.workspaceName },
+                isMatch: picomatch(entry.pattern, { dot: true }),
+            });
+        }
         this.isFileMatch = createMatcher(this.ignoreFilesPatterns);
     }
+    markUsedPatterns(filePath, unused) {
+        if (unused.size === 0)
+            return;
+        for (const [pattern, { isMatch }] of unused) {
+            if (isMatch(filePath))
+                unused.delete(pattern);
+        }
+    }
     setIgnoreIssues(ignoreIssues) {
         if (!ignoreIssues)
             return;
@@ -78,10 +112,14 @@ export class IssueCollector {
                 continue;
             if (this.referencedFiles.has(filePath))
                 continue;
-            if (this.isMatch(filePath))
+            if (this.isMatch(filePath)) {
+                this.markUsedPatterns(filePath, this.unusedIgnorePatterns);
                 continue;
-            if (this.isFileMatch(filePath))
+            }
+            if (this.isFileMatch(filePath)) {
+                this.markUsedPatterns(filePath, this.unusedIgnoreFilesPatterns);
                 continue;
+            }
             if (this.shouldIgnoreIssue(filePath, 'files'))
                 continue;
             this.issues.files.add(filePath);
@@ -94,8 +132,10 @@ export class IssueCollector {
     addIssue(issue) {
         if (!this.workspaceFilter(issue.filePath))
             return;
-        if (this.isMatch(issue.filePath))
+        if (this.isMatch(issue.filePath)) {
+            this.markUsedPatterns(issue.filePath, this.unusedIgnorePatterns);
             return;
+        }
         if (this.shouldIgnoreIssue(issue.filePath, issue.type))
             return;
         if (this.rules[issue.type] === 'off')
@@ -133,6 +173,16 @@ export class IssueCollector {
             configurationHints: Array.from(this.configurationHints.values()),
         };
     }
+    getUnusedIgnorePatternHints(options) {
+        if (!options.isReportFiles)
+            return [];
+        const hints = [];
+        for (const p of this.unusedIgnorePatterns.values())
+            hints.push(p.hint);
+        for (const p of this.unusedIgnoreFilesPatterns.values())
+            hints.push(p.hint);
+        return hints;
+    }
     retainedIssues = [];
     retainIssue(issue) {
         this.retainedIssues.push(issue);

package/dist/ProjectPrincipal.d.ts

@@ -1,7 +1,7 @@
 import ts from 'typescript';
 import { CacheConsultant } from './CacheConsultant.js';
 import type { AsyncCompilers, SyncCompilers } from './compilers/types.js';
-import type { GetImportsAndExportsOptions, IgnoreExportsUsedInFile } from './types/config.js';
+import type { GetImportsAndExportsOptions, IgnoreExportsUsedInFile, Visitors } from './types/config.js';
 import type { Export, ExportMember, FileNode, ModuleGraph } from './types/module-graph.js';
 import type { Paths, PrincipalOptions } from './types/project.js';
 import type { ResolveModuleNames } from './typescript/resolve-module-names.js';
@@ -13,6 +13,7 @@ export declare class ProjectPrincipal {
     projectPaths: Set<string>;
     programPaths: Set<string>;
     skipExportsAnalysis: Set<string>;
+    visitors: Visitors;
     cwd: string;
     compilerOptions: ts.CompilerOptions;
     extensions: Set<string>;

package/dist/ProjectPrincipal.js

@@ -31,6 +31,7 @@ export class ProjectPrincipal {
     projectPaths = new Set();
     programPaths = new Set();
     skipExportsAnalysis = new Set();
+    visitors = { dynamicImport: [], script: [] };
     cwd;
     compilerOptions;
     extensions;
@@ -165,7 +166,7 @@ export class ProjectPrincipal {
             throw new Error(`Unable to find ${filePath}`);
         const skipExports = this.skipExportsAnalysis.has(filePath);
         const resolve = (specifier) => this.backend.resolveModuleNames([specifier], sourceFile.fileName)[0];
-        return _getImportsAndExports(sourceFile, resolve, typeChecker, options, ignoreExportsUsedInFile, skipExports);
+        return _getImportsAndExports(sourceFile, resolve, typeChecker, options, ignoreExportsUsedInFile, skipExports, this.visitors);
     }
     invalidateFile(filePath) {
         this.backend.fileManager.invalidate(filePath);

package/dist/WorkspaceWorker.d.ts

@@ -1,6 +1,6 @@
 import { CacheConsultant } from './CacheConsultant.js';
 import { type Workspace } from './ConfigurationChief.js';
-import type { GetSourceFile, HandleInput, WorkspaceConfiguration } from './types/config.js';
+import type { GetSourceFile, HandleInput, RegisterCompiler, RegisterVisitor, WorkspaceConfiguration } from './types/config.js';
 import type { ConfigurationHint } from './types/issues.js';
 import type { PluginName } from './types/PluginNames.js';
 import type { PackageJson } from './types/package-json.js';
@@ -59,7 +59,10 @@ export declare class WorkspaceWorker {
     getProductionEntryFilePatterns(negatedTestFilePatterns: string[]): string[];
     getProductionProjectFilePatterns(negatedTestFilePatterns: string[]): string[];
     private getConfigurationFilePatterns;
+    registerCompilers(registerCompiler: RegisterCompiler): Promise<void>;
+    registerVisitors(registerVisitors: RegisterVisitor): void;
     runPlugins(): Promise<Input[]>;
+    private filterTransitiveDependencies;
     getConfigurationHints(type: 'entry' | 'project', patterns: string[], filePaths: string[], includedPaths: Set<string>): ConfigurationHint[];
     onDispose(): void;
 }

package/dist/WorkspaceWorker.js

@@ -5,13 +5,15 @@ import { isDefaultPattern } from './ConfigurationChief.js';
 import { ROOT_WORKSPACE_NAME } from './constants.js';
 import { getFilteredScripts } from './manifest/helpers.js';
 import { PluginEntries, Plugins } from './plugins.js';
+import { collectStringLiterals, isExternalReExportsOnly } from './typescript/ast-helpers.js';
 import { compact } from './util/array.js';
 import { debugLogArray, debugLogObject } from './util/debug.js';
 import { _glob, hasNoProductionSuffix, hasProductionSuffix, negate } from './util/glob.js';
-import { isConfig, toConfig, toDebugString, toEntry, toProductionEntry, } from './util/input.js';
+import { isConfig, isDeferResolve, isDependency, toConfig, toDebugString, toEntry, toProductionEntry, } from './util/input.js';
+import { getPackageNameFromSpecifier } from './util/modules.js';
 import { getKeysByValue } from './util/object.js';
 import { timerify } from './util/Performance.js';
-import { basename, dirname, join } from './util/path.js';
+import { basename, dirname, extname, isInternal, join } from './util/path.js';
 import { loadConfigForPlugin } from './util/plugin.js';
 import { ELLIPSIS } from './util/string.js';
 const nullConfig = { config: null, entry: null, project: null };
@@ -153,6 +155,26 @@ export class WorkspaceWorker {
         const pluginConfig = this.getConfigForPlugin(pluginName);
         return pluginConfig.config ?? this.getPluginConfig(plugin) ?? [];
     }
+    async registerCompilers(registerCompiler) {
+        const cwd = this.dir;
+        const hasDependency = (packageName) => this.dependencies.has(packageName);
+        for (const [pluginName, plugin] of PluginEntries) {
+            if (!plugin.registerCompilers)
+                continue;
+            if (this.config[pluginName] === false)
+                continue;
+            if (this.options.cwd !== this.dir && plugin.isRootOnly)
+                continue;
+            await plugin.registerCompilers({ cwd, hasDependency, registerCompiler });
+        }
+    }
+    registerVisitors(registerVisitors) {
+        for (const pluginName of this.enabledPlugins) {
+            const plugin = Plugins[pluginName];
+            if (plugin.registerVisitors)
+                plugin.registerVisitors({ registerVisitors });
+        }
+    }
     async runPlugins() {
         const wsName = this.name;
         const cwd = this.dir;
@@ -237,6 +259,8 @@ export class WorkspaceWorker {
                     for (const id of plugin.production)
                         inputs.push(toProductionEntry(id));
             }
+            if (typeof plugin.setup === 'function')
+                await plugin.setup();
             for (const configFilePath of configFilePaths) {
                 const isManifest = basename(configFilePath) === 'package.json';
                 const fd = isManifest ? undefined : this.cache.getFileDescriptor(configFilePath);
@@ -262,18 +286,25 @@ export class WorkspaceWorker {
                 const cache = {};
                 const key = `${wsName}:${pluginName}`;
                 if (plugin.resolveConfig && !seen.get(key)?.has(configFilePath)) {
-                    if (typeof plugin.setup === 'function')
-                        await plugin.setup(resolveOpts);
-                    const isLoad = typeof plugin.isLoadConfig === 'function' ? plugin.isLoadConfig(resolveOpts, this.dependencies) : true;
-                    const localConfig = isLoad && (await loadConfigForPlugin(configFilePath, plugin, resolveOpts, pluginName));
-                    if (localConfig) {
-                        const inputs = await plugin.resolveConfig(localConfig, resolveOpts);
-                        for (const input of inputs)
-                            addInput(input, configFilePath);
-                        cache.resolveConfig = inputs;
+                    if (extname(configFilePath) !== '.json') {
+                        const sourceFile = this.getSourceFile(configFilePath);
+                        if (sourceFile && isExternalReExportsOnly(sourceFile)) {
+                            cache.resolveConfig = [];
+                        }
+                    }
+                    if (!cache.resolveConfig) {
+                        const isLoad = typeof plugin.isLoadConfig === 'function' ? plugin.isLoadConfig(resolveOpts, this.dependencies) : true;
+                        const localConfig = isLoad && (await loadConfigForPlugin(configFilePath, plugin, resolveOpts, pluginName));
+                        if (localConfig) {
+                            const inputs = await plugin.resolveConfig(localConfig, resolveOpts);
+                            if (plugin.isFilterTransitiveDependencies && !isManifest) {
+                                this.filterTransitiveDependencies(inputs, configFilePath);
+                            }
+                            for (const input of inputs)
+                                addInput(input, configFilePath);
+                            cache.resolveConfig = inputs;
+                        }
                     }
-                    if (typeof plugin.teardown === 'function')
-                        await plugin.teardown(resolveOpts);
                 }
                 if (plugin.resolveFromAST) {
                     const sourceFile = this.getSourceFile(configFilePath);
@@ -336,6 +367,31 @@ export class WorkspaceWorker {
         debugLogArray(wsName, 'Plugin dependencies', () => compact(inputs.map(input => toDebugString(input, rootCwd))));
         return inputs;
     }
+    filterTransitiveDependencies(inputs, configFilePath) {
+        const literals = new Set();
+        const visited = new Set();
+        const collect = (filePath) => {
+            if (visited.has(filePath))
+                return;
+            visited.add(filePath);
+            const sourceFile = this.getSourceFile(filePath);
+            if (!sourceFile)
+                return;
+            for (const literal of collectStringLiterals(sourceFile)) {
+                literals.add(literal);
+                if (isInternal(literal))
+                    collect(join(dirname(filePath), literal));
+            }
+        };
+        collect(configFilePath);
+        for (const input of inputs) {
+            if (!input.optional && (isDeferResolve(input) || isDependency(input))) {
+                const name = getPackageNameFromSpecifier(input.specifier);
+                if (name && !literals.has(name))
+                    input.optional = true;
+            }
+        }
+    }
     getConfigurationHints(type, patterns, filePaths, includedPaths) {
         const hints = [];
         const entries = this.config[type].filter(pattern => !pattern.startsWith('!'));

package/dist/binaries/bash-parser.d.ts

@@ -1,4 +1,3 @@
 import type { GetInputsFromScriptsOptions } from '../types/config.js';
 import { type Input } from '../util/input.js';
-export declare const isValidBinary: (str: string) => boolean;
 export declare const getDependenciesFromScript: (script: string, options: GetInputsFromScriptsOptions) => Input[];

package/dist/binaries/bash-parser.js

@@ -2,7 +2,7 @@ import parse, {} from '../../vendor/bash-parser/index.js';
 import { Plugins, pluginArgsMap } from '../plugins.js';
 import { debugLogObject } from '../util/debug.js';
 import { toBinary, toDeferResolve } from '../util/input.js';
-import { extractBinary } from '../util/modules.js';
+import { extractBinary, isValidBinary } from '../util/modules.js';
 import { relative } from '../util/path.js';
 import { truncate } from '../util/string.js';
 import { resolve as fallbackResolve } from './fallback.js';
@@ -12,7 +12,6 @@ import { parseNodeArgs } from './util.js';
 const spawningBinaries = ['cross-env', 'retry-cli'];
 const isExpansion = (node) => 'expansion' in node;
 const isAssignment = (node) => 'type' in node && node.type === 'AssignmentWord';
-export const isValidBinary = (str) => !/[*:!()]/.test(str);
 export const getDependenciesFromScript = (script, options) => {
     if (!script)
         return [];
@@ -21,8 +20,8 @@ export const getDependenciesFromScript = (script, options) => {
             return [];
         return getDependenciesFromScript(args.filter(arg => arg !== '--').join(' '), {
             ...options,
-            ...opts,
             knownBinsOnly: false,
+            ...opts,
         });
     };
     const definedFunctions = new Set();

package/dist/binaries/fallback.js

@@ -1,7 +1,7 @@
 import parseArgs from 'minimist';
 import { compact } from '../util/array.js';
 import { toBinary, toDeferResolve, toEntry } from '../util/input.js';
-import { isValidBinary } from './bash-parser.js';
+import { isValidBinary } from '../util/modules.js';
 const spawningBinaries = ['cross-env', 'retry-cli'];
 const endOfCommandBinaries = ['dotenvx', 'env-cmd', 'op'];
 const positionals = new Set(['babel-node', 'esbuild', 'execa', 'jiti', 'oxnode', 'vite-node', 'zx']);

package/dist/binaries/package-manager/npm.js

@@ -3,7 +3,7 @@ export const resolve = (_binary, args, options) => {
     const { fromArgs, manifestScriptNames } = options;
     const parsed = parseArgs(args, { '--': true });
     const [command, script] = parsed._;
-    const _childArgs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(parsed['--']) : [];
+    const _childArgs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(parsed['--'], { knownBinsOnly: true }) : [];
     if (command === 'exec')
         return _childArgs;
     if (command === 'run' && manifestScriptNames.has(script))

package/dist/binaries/package-manager/pnpm.js

@@ -1,5 +1,6 @@
 import parseArgs from 'minimist';
 import { toBinary } from '../../util/input.js';
+import { isValidBinary } from '../../util/modules.js';
 import { resolveDlx } from './pnpx.js';
 const commands = [
     'add',
@@ -62,7 +63,7 @@ const commands = [
 ];
 export const resolve = (_binary, args, options) => {
     const parsed = parseArgs(args, {
-        boolean: ['recursive', 'silent', 'shell-mode'],
+        boolean: ['aggregate-output', 'if-present', 'parallel', 'recursive', 'reverse', 'shell-mode', 'silent', 'stream'],
         alias: { recursive: 'r', silent: 's', 'shell-mode': 'c', filter: 'F' },
         '--': true,
     });
@@ -74,12 +75,12 @@ export const resolve = (_binary, args, options) => {
     const { manifestScriptNames, fromArgs } = options;
     if (parsed.filter && !parsed.recursive)
         return [];
-    const childInputs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(parsed['--']) : [];
+    const childInputs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(parsed['--'], { knownBinsOnly: true }) : [];
     if (command === 'exec') {
         return childInputs.length > 0 ? childInputs : fromArgs(parsed._.slice(1));
     }
     const isScript = manifestScriptNames.has(command);
     if (isScript || commands.includes(command))
         return childInputs;
-    return command ? [toBinary(command)] : [];
+    return command && isValidBinary(command) ? [toBinary(command)] : [];
 };

package/dist/binaries/package-manager/yarn.js

@@ -55,7 +55,7 @@ export const resolve = (_binary, args, options) => {
     const [command, binary] = parsed._;
     if (!command && !binary)
         return [];
-    const _childArgs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(parsed['--']) : [];
+    const _childArgs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(parsed['--'], { knownBinsOnly: true }) : [];
     if (command === 'run') {
         if (manifestScriptNames.has(binary))
             return _childArgs;

package/dist/compilers/compilers.d.ts

@@ -1,8 +1,8 @@
-import type { SyncCompilerFn } from './types.js';
+import type { CompilerSync } from './types.js';
 export declare const fencedCodeBlockMatcher: RegExp;
 export declare const inlineCodeMatcher: RegExp;
 export declare const importMatcher: RegExp;
-export declare const importsWithinScripts: SyncCompilerFn;
-export declare const scriptBodies: SyncCompilerFn;
+export declare const importsWithinScripts: CompilerSync;
+export declare const scriptBodies: CompilerSync;
 export declare const frontmatterMatcher: RegExp;
 export declare const importsWithinFrontmatter: (text: string, keys?: string[]) => string;

package/dist/compilers/index.d.ts

@@ -1,9 +1,10 @@
 import type { RawConfiguration } from '../types/config.js';
 import type { DependencySet } from '../types/workspace.js';
-import type { AsyncCompilerFn, AsyncCompilers, RawSyncCompilers, SyncCompilerFn, SyncCompilers } from './types.js';
+import type { AsyncCompilers, CompilerAsync, CompilerSync, Compilers, RawSyncCompilers, SyncCompilers } from './types.js';
+export declare const normalizeCompilerExtension: (ext: string) => string;
 export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
-    syncCompilers: Record<string, true | SyncCompilerFn>;
-    asyncCompilers: Record<string, AsyncCompilerFn>;
+    syncCompilers: Record<string, true | CompilerSync>;
+    asyncCompilers: Record<string, CompilerAsync>;
     angular?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -144,6 +145,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    execa?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     expo?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -379,6 +385,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    pm2?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     pnpm?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -409,6 +420,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    'react-native'?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     'react-router'?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -659,6 +675,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    zx?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     workspaces?: Record<string, {
         angular?: string | boolean | string[] | {
             config?: string | string[] | undefined;
@@ -800,6 +821,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        execa?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         expo?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1035,6 +1061,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        pm2?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         pnpm?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1065,6 +1096,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'react-native'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         'react-router'?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1315,6 +1351,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        zx?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
         paths?: Record<string, string[]> | undefined;
@@ -1347,5 +1388,5 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
     tags?: string[] | undefined;
     treatConfigHintsAsErrors?: boolean | undefined;
 };
-export declare const getIncludedCompilers: (syncCompilers: RawSyncCompilers, asyncCompilers: AsyncCompilers, dependencies: DependencySet) => [SyncCompilers, AsyncCompilers];
+export declare const getIncludedCompilers: (syncCompilers: RawSyncCompilers, asyncCompilers: AsyncCompilers, dependencies: DependencySet) => Compilers;
 export declare const getCompilerExtensions: (compilers: [SyncCompilers, AsyncCompilers]) => string[];