knip 6.40.0 → 6.42.0

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

@@ -226,6 +226,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'expo-router'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         'expressive-code'?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -236,6 +241,16 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'filesystem-routing'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
+        flue?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         fumadocs?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -701,6 +716,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'solidjs-vite-plugin'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         sst?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -816,6 +836,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        tsrs?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         tsup?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1208,6 +1233,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
                 entry?: string | string[] | undefined;
                 project?: string | string[] | undefined;
             } | undefined;
+            'expo-router'?: string | boolean | string[] | {
+                config?: string | string[] | undefined;
+                entry?: string | string[] | undefined;
+                project?: string | string[] | undefined;
+            } | undefined;
             'expressive-code'?: string | boolean | string[] | {
                 config?: string | string[] | undefined;
                 entry?: string | string[] | undefined;
@@ -1218,6 +1248,16 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
                 entry?: string | string[] | undefined;
                 project?: string | string[] | undefined;
             } | undefined;
+            'filesystem-routing'?: string | boolean | string[] | {
+                config?: string | string[] | undefined;
+                entry?: string | string[] | undefined;
+                project?: string | string[] | undefined;
+            } | undefined;
+            flue?: string | boolean | string[] | {
+                config?: string | string[] | undefined;
+                entry?: string | string[] | undefined;
+                project?: string | string[] | undefined;
+            } | undefined;
             fumadocs?: string | boolean | string[] | {
                 config?: string | string[] | undefined;
                 entry?: string | string[] | undefined;
@@ -1683,6 +1723,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
                 entry?: string | string[] | undefined;
                 project?: string | string[] | undefined;
             } | undefined;
+            'solidjs-vite-plugin'?: string | boolean | string[] | {
+                config?: string | string[] | undefined;
+                entry?: string | string[] | undefined;
+                project?: string | string[] | undefined;
+            } | undefined;
             sst?: string | boolean | string[] | {
                 config?: string | string[] | undefined;
                 entry?: string | string[] | undefined;
@@ -1798,6 +1843,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
                 entry?: string | string[] | undefined;
                 project?: string | string[] | undefined;
             } | undefined;
+            tsrs?: string | boolean | string[] | {
+                config?: string | string[] | undefined;
+                entry?: string | string[] | undefined;
+                project?: string | string[] | undefined;
+            } | undefined;
             tsup?: string | boolean | string[] | {
                 config?: string | string[] | undefined;
                 entry?: string | string[] | undefined;

package/dist/util/create-options.js

@@ -11,12 +11,11 @@ import { loadResolvedConfigFile } from './load-config.js';
 import { _load } from './loader.js';
 import { logWarning } from './log.js';
 import { getKeysByValue } from './object.js';
-import { isAbsolute, isInternal, join, normalize, toAbsolute, toPosix } from './path.js';
+import { isAbsolute, isInternal, join, resolveCwd, toAbsolute } from './path.js';
 import { splitTags } from './tag.js';
 export const createOptions = async (options) => {
     const { args = {} } = options;
-    const pcwd = toPosix(process.cwd());
-    const cwd = normalize(toAbsolute(toPosix(options.cwd ?? args.directory ?? pcwd), pcwd));
+    const cwd = resolveCwd(options.cwd ?? args.directory ?? '.');
     const manifestPath = findFile(cwd, 'package.json');
     const manifest = manifestPath && (await loadJSON(manifestPath));
     if (!(manifestPath && manifest)) {

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

@@ -1,4 +1,4 @@
-import type { FSLike } from 'fdir';
+import type { FileSystemAdapter } from 'tinyglobby';
 export declare const initGlobCache: (cacheLocation: string) => void;
 export declare const isGlobCacheEnabled: () => boolean;
 export declare const flushGlobCache: () => void;
@@ -13,6 +13,6 @@ export declare const computeGlobCacheKey: (input: {
 export declare const getCachedGlob: (key: string) => string[] | undefined;
 export declare const createDirTracker: () => {
     dirs: Set<string>;
-    fs: Partial<FSLike>;
+    fs: FileSystemAdapter;
 };
 export declare const setCachedGlob: (key: string, paths: string[], baseDir: string, dirs?: Iterable<string>) => void;

package/dist/util/glob-core.js

@@ -1,8 +1,6 @@
 import { createHash } from 'node:crypto';
-import { readFileSync } from 'node:fs';
-import { basename } from 'node:path';
-import { fdir } from 'fdir';
-import { glob as tinyGlob } from 'tinyglobby';
+import { readdir, readFileSync } from 'node:fs';
+import { escapePath, glob as tinyGlob } from 'tinyglobby';
 import picomatch from 'picomatch';
 import { GLOBAL_IGNORE_PATTERNS } from '../constants.js';
 import { compact, partition } from './array.js';
@@ -14,6 +12,15 @@ import { expandIgnorePatterns, parseAndConvertGitignorePatterns } from './parse-
 import { dirname, isAbsolute, join, relative, toAbsolute, toPosix } from './path.js';
 const cachedGitIgnores = new Map();
 const cachedGlobIgnores = new Map();
+let gitignoreWorkspaceDirs;
+const isInNestedWorkspace = (gitignoreDir, dir) => {
+    if (!gitignoreWorkspaceDirs)
+        return false;
+    for (let d = gitignoreDir; d.length > dir.length; d = dirname(d))
+        if (gitignoreWorkspaceDirs.has(d))
+            return true;
+    return false;
+};
 let gitignoreReconciler;
 let gitignoreMatcher = (_filePath) => false;
 export const isGitIgnored = (filePath) => gitignoreMatcher(filePath);
@@ -76,22 +83,20 @@ export const findAndParseGitignores = async (cwd, workspaceDirs) => {
     const ignores = new Set(GLOBAL_IGNORE_PATTERNS);
     const unignores = new Set();
     const gitignoreFiles = [];
-    let deepFilterMatcher;
-    let prevUnignoreSize = unignores.size;
-    let unignoresArray = [];
-    const pendingIgnores = [];
-    const getMatcher = () => {
-        if (!deepFilterMatcher) {
-            unignoresArray = Array.from(unignores);
-            deepFilterMatcher = picomatch(Array.from(ignores), { ignore: unignoresArray });
-            pendingIgnores.length = 0;
-        }
-        else if (pendingIgnores.length > 0) {
-            const prev = deepFilterMatcher;
-            const incr = picomatch(pendingIgnores.splice(0), { ignore: unignoresArray });
-            deepFilterMatcher = (path) => prev(path) || incr(path);
-        }
-        return deepFilterMatcher;
+    let isIgnored = (_path) => false;
+    let isUnignored = (_path) => false;
+    const pendingIgnores = Array.from(ignores);
+    const pendingUnignores = [];
+    const extend = (matcher, pending) => {
+        if (pending.length === 0)
+            return matcher;
+        const incr = picomatch(pending.splice(0));
+        return (path) => matcher(path) || incr(path);
+    };
+    const isExcluded = (path) => {
+        isIgnored = extend(isIgnored, pendingIgnores);
+        isUnignored = extend(isUnignored, pendingUnignores);
+        return isIgnored(path) && !isUnignored(path);
     };
     const seenGitignoreFiles = new Set();
     const addFile = (filePath, baseDir) => {
@@ -108,6 +113,7 @@ export const findAndParseGitignores = async (cwd, workspaceDirs) => {
         const prevIgnoreSize = ignores.size;
         const patterns = readFileSync(filePath, 'utf8');
         const isRoot = base === '' || base.startsWith('..');
+        const escapedBase = escapePath(base);
         for (const { negated, pattern } of parseAndConvertGitignorePatterns(patterns, ancestor)) {
             if (negated) {
                 if (isRoot) {
@@ -117,7 +123,7 @@ export const findAndParseGitignores = async (cwd, workspaceDirs) => {
                     }
                 }
                 else if (!unignores.has(pattern)) {
-                    const unignore = join(base, pattern);
+                    const unignore = join(escapedBase, pattern);
                     unignores.add(unignore);
                     unignoresForDir.add(unignore);
                 }
@@ -127,7 +133,7 @@ export const findAndParseGitignores = async (cwd, workspaceDirs) => {
                 ignoresForDir.add(pattern);
             }
             else if (!unignores.has(pattern)) {
-                const ignore = join(base, pattern);
+                const ignore = join(escapedBase, pattern);
                 ignores.add(ignore);
                 ignoresForDir.add(ignore);
             }
@@ -143,11 +149,9 @@ export const findAndParseGitignores = async (cwd, workspaceDirs) => {
         else {
             cachedGitIgnores.set(cacheDir, { ignores: ignoresForDir, unignores: unignoresForDir });
         }
-        if (unignores.size !== prevUnignoreSize) {
-            deepFilterMatcher = undefined;
-            prevUnignoreSize = unignores.size;
-        }
-        else if (ignores.size !== prevIgnoreSize) {
+        for (const p of unignoresForDir)
+            pendingUnignores.push(p);
+        if (ignores.size !== prevIgnoreSize) {
             for (const p of ignoresForDir)
                 if (!GLOBAL_IGNORE_PATTERNS.includes(p))
                     pendingIgnores.push(p);
@@ -168,15 +172,16 @@ export const findAndParseGitignores = async (cwd, workspaceDirs) => {
     const rootGitignorePath = join(cwd, '.gitignore');
     if (isFile(rootGitignorePath))
         addFile(rootGitignorePath);
+    const root = cwd.length > 1 && cwd.endsWith('/') ? cwd.slice(0, -1) : cwd;
     let isRelevantDir;
     if (workspaceDirs && workspaceDirs.size > 0) {
         const relevantAncestors = new Set();
         const nonRootDirs = new Set();
         for (const wsDir of workspaceDirs) {
-            if (wsDir !== cwd)
+            if (wsDir !== root)
                 nonRootDirs.add(wsDir);
             let dir = wsDir;
-            while (dir.length >= cwd.length) {
+            while (dir.length >= root.length) {
                 relevantAncestors.add(dir);
                 const parent = dirname(dir);
                 if (parent === dir)
@@ -195,24 +200,32 @@ export const findAndParseGitignores = async (cwd, workspaceDirs) => {
             };
         }
     }
-    const cwdPrefixLen = cwd.length + 1;
-    const walkGitignores = async () => {
-        await new fdir()
-            .withFullPaths()
-            .exclude((_dirName, dirPath) => {
-            const absPath = toPosix(dirPath.slice(0, -1));
-            return (isRelevantDir && !isRelevantDir(absPath)) || getMatcher()(absPath.slice(cwdPrefixLen));
-        })
-            .filter((filePath, isDir) => {
-            if (isDir || basename(filePath) !== '.gitignore')
-                return false;
-            addFile(filePath);
-            return true;
-        })
-            .crawl(cwd)
-            .withPromise();
-    };
-    await walkGitignores();
+    const rootPrefixLen = root.length + 1;
+    await new Promise(resolve => {
+        let pending = 0;
+        const walk = (dir) => {
+            pending++;
+            readdir(dir, { withFileTypes: true }, (error, entries) => {
+                if (!error) {
+                    for (const entry of entries) {
+                        if (entry.name === '.gitignore' && (entry.isFile() || entry.isSymbolicLink()))
+                            addFile(`${dir}/.gitignore`);
+                    }
+                    for (const entry of entries) {
+                        if (!entry.isDirectory())
+                            continue;
+                        const absPath = `${dir}/${entry.name}`;
+                        if ((isRelevantDir && !isRelevantDir(absPath)) || isExcluded(absPath.slice(rootPrefixLen)))
+                            continue;
+                        walk(absPath);
+                    }
+                }
+                if (--pending === 0)
+                    resolve();
+            });
+        };
+        walk(root);
+    });
     if (unignores.size > 0) {
         const unignorePaths = new Set();
         for (const u of unignores) {
@@ -269,6 +282,14 @@ export async function glob(_patterns, options) {
             if (prev === dir || dir === '.')
                 break;
         }
+        if (!gitignoreReconciler) {
+            const prefix = `${options.dir}/`;
+            for (const [gitignoreDir, cacheForDir] of cachedGitIgnores) {
+                if (gitignoreDir.startsWith(prefix) && !isInNestedWorkspace(gitignoreDir, options.dir)) {
+                    _ignore.push(...cacheForDir.ignores);
+                }
+            }
+        }
         cachedGlobIgnores.set(options.dir, compact(_ignore));
     }
     const ignorePatterns = (cachedIgnores ?? _ignore).concat(negatedPatterns.map(pattern => pattern.slice(1)));
@@ -301,6 +322,8 @@ export function reconcileGitignoredPaths(paths, cwd) {
 }
 export async function getGitIgnoredHandler(options, workspaceDirs) {
     cachedGitIgnores.clear();
+    cachedGlobIgnores.clear();
+    gitignoreWorkspaceDirs = workspaceDirs;
     gitignoreReconciler = undefined;
     gitignoreMatcher = () => false;
     gitignoreFingerprint = '';

package/dist/util/glob.js

@@ -4,8 +4,18 @@ import { computeGlobCacheKey, createDirTracker, getCachedGlob, isGlobCacheEnable
 import { getGitignoreFingerprint, glob, reconcileGitignoredPaths } from './glob-core.js';
 import { timerify } from './Performance.js';
 import { isAbsolute, join, relative } from './path.js';
-const prepend = (pattern, relativePath) => isAbsolute(pattern.replace(/^!/, '')) ? pattern : prependDirToPattern(relativePath, pattern);
-const prependDirToPatterns = (cwd, dir, patterns) => compact([patterns].flat().map(p => removeProductionSuffix(prepend(p, relative(cwd, dir))))).sort(negatedLast);
+const prepend = (pattern, cwd, relativePath) => {
+    const isNegated = pattern.startsWith('!');
+    const id = isNegated ? pattern.slice(1) : pattern;
+    if (id && !isAbsolute(id) && !relativePath)
+        return pattern;
+    const globPattern = isAbsolute(id) ? relative(cwd, id) : join(relativePath, id);
+    return isNegated ? `!${globPattern}` : globPattern;
+};
+const prependDirToPatterns = (cwd, dir, patterns) => {
+    const relativePath = dir === cwd ? '' : relative(cwd, dir);
+    return compact(patterns.map(p => removeProductionSuffix(prepend(p, cwd, relativePath)))).sort(negatedLast);
+};
 export const removeProductionSuffix = (pattern) => pattern.replace(/!$/, '');
 const negatedLast = (pattern) => (pattern.startsWith('!') ? 1 : -1);
 export const prependDirToPattern = (dir, pattern) => {
@@ -48,7 +58,7 @@ const defaultGlob = async ({ cwd, dir = cwd, patterns, gitignore = true, label }
 };
 const syncGlob = ({ cwd, patterns }) => {
     const cacheEnabled = isGlobCacheEnabled();
-    const patternList = Array.isArray(patterns) ? patterns : [patterns];
+    const patternList = [patterns].flat().map(pattern => prepend(pattern, cwd, ''));
     const cacheKey = cacheEnabled
         ? computeGlobCacheKey({ patterns: patternList, cwd, dir: cwd, gitignore: false, gitignoreFingerprint: '' })
         : '';
@@ -58,7 +68,7 @@ const syncGlob = ({ cwd, patterns }) => {
             return cached;
     }
     const tracker = cacheEnabled ? createDirTracker() : undefined;
-    const paths = globSync(patterns, {
+    const paths = globSync(patternList, {
         cwd,
         absolute: true,
         followSymbolicLinks: false,
@@ -69,12 +79,7 @@ const syncGlob = ({ cwd, patterns }) => {
         setCachedGlob(cacheKey, paths, cwd, tracker?.dirs);
     return paths;
 };
-const dirGlob = async ({ cwd, patterns, gitignore = true }) => glob(patterns, {
-    cwd,
-    dir: cwd,
-    onlyDirectories: true,
-    gitignore,
-});
+const dirGlob = async ({ cwd, patterns, gitignore = true }) => glob(patterns.map(pattern => prepend(pattern, cwd, '')), { cwd, dir: cwd, onlyDirectories: true, gitignore });
 export const _glob = timerify(defaultGlob);
 export const _syncGlob = timerify(syncGlob);
 export const _dirGlob = timerify(dirGlob);

package/dist/util/load-tsconfig.d.ts

@@ -9,5 +9,5 @@ interface TSConfigInfo {
     sourceMapPairs: SourceMap[];
     paths: Record<string, string[]> | undefined;
 }
-export declare const loadTSConfig: (tsConfigFilePath: string) => Promise<TSConfigInfo>;
+export declare const loadTSConfig: (tsConfigFilePath: string, isUseTscFiles?: boolean, visited?: Set<string>) => Promise<TSConfigInfo>;
 export {};

package/dist/util/load-tsconfig.js

@@ -2,19 +2,19 @@ import { parseTsconfig } from 'get-tsconfig';
 import { compact } from './array.js';
 import { isFile } from './fs.js';
 import { _syncGlob } from './glob.js';
-import { dirname, isAbsolute, join, toAbsolute, toPosix } from './path.js';
+import { dirname, isAbsolute, join, relative, toAbsolute, toPosix } from './path.js';
 const hasGlobChar = (p) => p.includes('*') || p.includes('?');
 const hasExtension = (p) => {
     const last = p.lastIndexOf('/');
     const base = last >= 0 ? p.slice(last + 1) : p;
     return base !== '.' && base !== '..' && base.includes('.');
 };
-const resolvePatterns = (patterns, dir, expandDirs = false) => {
+const toRelativePatterns = (patterns, dir) => {
     if (!patterns)
         return undefined;
     return patterns.map(p => {
-        const resolved = isAbsolute(p) ? p : join(dir, p);
-        return expandDirs && !hasGlobChar(p) && !hasExtension(p) ? join(resolved, '**/*') : resolved;
+        const pattern = isAbsolute(p) ? relative(dir, p) : p;
+        return hasGlobChar(p) || hasExtension(p) ? pattern : join(pattern, '**/*');
     });
 };
 const getImplicitBaseUrl = (compilerOptions) => {
@@ -54,11 +54,11 @@ const expandFileNames = (dir, compilerOptions, include, exclude, files) => {
         for (const file of files)
             result.push(file);
     }
-    const effectiveExclude = [...(exclude ?? []), join(dir, 'node_modules/**')];
+    const effectiveExclude = [...(exclude ?? []), 'node_modules/**'];
     if (compilerOptions.outDir) {
-        effectiveExclude.push(join(compilerOptions.outDir, '**'));
+        effectiveExclude.push(join(relative(dir, compilerOptions.outDir), '**'));
     }
-    const effectiveInclude = include ?? (files ? undefined : DEFAULT_INCLUDE.map(p => join(dir, p)));
+    const effectiveInclude = include ?? (files ? undefined : DEFAULT_INCLUDE);
     if (effectiveInclude) {
         const negated = effectiveExclude.map(p => `!${p}`);
         const globbed = _syncGlob({ patterns: [...effectiveInclude, ...negated], cwd: dir });
@@ -108,7 +108,7 @@ const EMPTY = {
     sourceMapPairs: [],
     paths: undefined,
 };
-export const loadTSConfig = async (tsConfigFilePath) => {
+export const loadTSConfig = async (tsConfigFilePath, isUseTscFiles = false, visited = new Set([tsConfigFilePath])) => {
     if (!isFile(tsConfigFilePath))
         return { isFile: false, ...EMPTY };
     try {
@@ -127,10 +127,20 @@ export const loadTSConfig = async (tsConfigFilePath) => {
         if (config.references?.length) {
             walkReferences(compilerOptions, config.references, dir, new Set([tsConfigFilePath]), sourceMapPairs, tsconfigPaths);
         }
-        const include = resolvePatterns(config.include, dir, true);
-        const exclude = resolvePatterns(config.exclude, dir, true);
-        const files = resolvePatterns(config.files, dir);
+        const include = toRelativePatterns(config.include, dir);
+        const exclude = toRelativePatterns(config.exclude, dir);
+        const files = config.files?.map(p => toAbsolute(p, dir));
         const fileNames = expandFileNames(dir, compilerOptions, include, exclude, files);
+        if (isUseTscFiles && config.references) {
+            for (const ref of config.references) {
+                const refPath = resolveReference(ref.path, dir);
+                if (!refPath?.startsWith(`${dir}/`) || visited.has(refPath))
+                    continue;
+                visited.add(refPath);
+                for (const filePath of (await loadTSConfig(refPath, true, visited)).fileNames)
+                    fileNames.push(filePath);
+            }
+        }
         const paths = Object.keys(tsconfigPaths).length > 0 ? tsconfigPaths : undefined;
         return { isFile: true, compilerOptions, fileNames, include, exclude, sourceMapPairs, paths };
     }

package/dist/util/module-graph.js

@@ -87,13 +87,18 @@ const addValues = (map, id, values) => {
         for (const v of values)
             existing.add(v);
     else
-        map.set(id, values);
+        map.set(id, new Set(values));
 };
 const addNsValues = (map, id, value) => {
     const existing = map.get(id);
-    if (existing)
+    if (existing) {
         for (const [ns, v] of value)
             addValues(existing, ns, v);
-    else
-        map.set(id, value);
+    }
+    else {
+        const copy = new Map();
+        for (const [ns, v] of value)
+            copy.set(ns, new Set(v));
+        map.set(id, copy);
+    }
 };

package/dist/util/path.d.ts

@@ -6,6 +6,7 @@ export declare const basename: typeof path.basename;
 export declare const join: typeof path.join;
 export declare const toPosix: (value: string) => string;
 export declare const resolve: typeof path.resolve;
+export declare const resolveCwd: (dir: string) => string;
 export declare const relative: (from: string, to: string) => string;
 export declare const isInNodeModules: (filePath: string) => boolean;
 export declare const toAbsolute: (id: string, base: string) => string;

package/dist/util/path.js

@@ -7,6 +7,7 @@ export const basename = path.posix.basename;
 export const join = path.posix.join;
 export const toPosix = isWin ? (value) => value.split(path.sep).join(path.posix.sep) : (value) => value;
 export const resolve = path.posix.resolve;
+export const resolveCwd = (dir) => toPosix(path.resolve(dir));
 export const relative = (from, to) => {
     if (to.startsWith(from)) {
         const next = to[from.length];

package/dist/util/scripts.d.ts

@@ -1,8 +1,10 @@
-import { type Command, type Node } from 'unbash';
+import { type ArithmeticCommandExpansion, type Command, type CommandExpansionPart, type ProcessSubstitutionPart, type SyntaxNode, type Word } from 'unbash';
 export interface ScriptCommand {
     binary: string;
     args: string[];
 }
 export declare const toShellCommand: (argv: string[]) => string;
-export declare function walkCommands(node: Node): Generator<Command>;
+export declare const getCommandWords: (node: Pick<Command, 'args'>) => Word[];
+export declare const collectCommands: (root: SyntaxNode) => Command[];
+export declare const isScriptExpansion: (node: SyntaxNode) => node is CommandExpansionPart | ProcessSubstitutionPart | ArithmeticCommandExpansion;
 export declare const getScriptCommands: (script: string) => ScriptCommand[];

package/dist/util/scripts.js

@@ -1,80 +1,46 @@
-import { parse } from 'unbash';
+import { forEachChild, parse, } from 'unbash';
 import { extractBinary } from './modules.js';
 const spawningBinaries = new Set(['c8', 'cross-env', 'retry-cli']);
 export const toShellCommand = (argv) => argv.map(arg => `'${arg.replaceAll("'", `'\\''`)}'`).join(' ');
-export function* walkCommands(node) {
-    switch (node.type) {
-        case 'Command':
-            yield node;
-            break;
-        case 'AndOr':
-        case 'Pipeline':
-            for (const command of node.commands)
-                yield* walkCommands(command);
-            break;
-        case 'If':
-            for (const statement of node.clause.commands)
-                yield* walkCommands(statement.command);
-            for (const statement of node.then.commands)
-                yield* walkCommands(statement.command);
-            if (node.else)
-                yield* walkCommands(node.else);
-            break;
-        case 'While':
-            for (const statement of node.clause.commands)
-                yield* walkCommands(statement.command);
-            for (const statement of node.body.commands)
-                yield* walkCommands(statement.command);
-            break;
-        case 'For':
-        case 'Select':
-        case 'Subshell':
-        case 'BraceGroup':
-            for (const statement of node.body.commands)
-                yield* walkCommands(statement.command);
-            break;
-        case 'CompoundList':
-            for (const statement of node.commands)
-                yield* walkCommands(statement.command);
-            break;
-        case 'Function':
-        case 'Coproc':
-            yield* walkCommands(node.body);
-            break;
-        case 'Statement':
-            yield* walkCommands(node.command);
-            break;
-    }
-}
+export const getCommandWords = (node) => node.args.filter((arg) => arg.type === 'Word');
+export const collectCommands = (root) => {
+    const commands = [];
+    const visit = (node) => {
+        if (node.type === 'Command')
+            commands.push(node);
+        if (!isScriptExpansion(node))
+            forEachChild(node, visit);
+    };
+    visit(root);
+    return commands;
+};
+export const isScriptExpansion = (node) => node.type === 'CommandExpansion' || node.type === 'ProcessSubstitution' || node.type === 'ArithmeticCommandExpansion';
 export const getScriptCommands = (script) => {
     if (!script)
         return [];
-    let parsed;
+    const out = [];
     try {
-        parsed = parse(script);
+        for (const statement of parse(script).commands) {
+            for (const node of collectCommands(statement.command)) {
+                const text = node.name?.value;
+                if (!text)
+                    continue;
+                const binary = extractBinary(text);
+                const words = getCommandWords(node);
+                if (spawningBinaries.has(binary)) {
+                    const rest = words
+                        .filter(word => word.text !== '--')
+                        .map(word => word.text)
+                        .join(' ');
+                    out.push(...getScriptCommands(rest));
+                }
+                else
+                    out.push({ binary, args: words.map(word => word.value) });
+            }
+        }
     }
     catch {
         return [];
     }
-    if (!parsed.commands)
-        return [];
-    const out = [];
-    for (const statement of parsed.commands) {
-        for (const node of walkCommands(statement.command)) {
-            const text = node.name?.value;
-            if (!text)
-                continue;
-            const binary = extractBinary(text);
-            if (spawningBinaries.has(binary)) {
-                const rest = node.suffix
-                    .filter(word => word.text !== '--')
-                    .map(word => word.text)
-                    .join(' ');
-                out.push(...getScriptCommands(rest));
-            }
-            else
-                out.push({ binary, args: node.suffix.map(word => word.value) });
-        }
-    }
     return out;
 };

package/dist/util/to-source-path.js

@@ -104,7 +104,7 @@ export const getToSourcePathsHandler = (chief) => {
             const absSpecifier = isAbsolute(id) ? id : prependDirToPattern(dir, id);
             const ws = chief.findWorkspaceByFilePath(absSpecifier);
             const mapped = ws?.sourceMaps && rewritePattern(ws.sourceMaps, absSpecifier, extensions);
-            patterns.add(negation + (mapped ?? absSpecifier));
+            patterns.add(negation + (mapped ?? id));
         }
         const filePaths = await _glob({ patterns: Array.from(patterns), cwd: chief.cwd, dir, label });
         debugLogArray(toRelative(dir, chief.cwd), 'Source mapping (package.json)', filePaths);

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "6.40.0";
+export declare const version = "6.42.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '6.40.0';
+export const version = '6.42.0';