knip 5.29.1 → 5.30.0

package/dist/WorkspaceWorker.d.ts

@@ -43,7 +43,8 @@ export declare class WorkspaceWorker {
     private determineEnabledPlugins;
     private getConfigForPlugin;
     getEntryFilePatterns(): string[];
-    getProjectFilePatterns(testFilePatterns: string[]): string[];
+    getProjectFilePatterns(projectFilePatterns: string[]): string[];
+    getPluginEntryFilePatterns(patterns: string[]): string[];
     getPluginProjectFilePatterns(): string[];
     getPluginConfigPatterns(): string[];
     getProductionEntryFilePatterns(negatedTestFilePatterns: string[]): string[];

package/dist/WorkspaceWorker.js

@@ -1,7 +1,7 @@
 import { CacheConsultant } from './CacheConsultant.js';
 import { plugins } from './plugins.js';
 import { debugLogArray, debugLogObject } from './util/debug.js';
-import { _pureGlob, hasNoProductionSuffix, hasProductionSuffix, negate, prependDirToPattern } from './util/glob.js';
+import { _glob, hasNoProductionSuffix, hasProductionSuffix, negate, prependDirToPattern } from './util/glob.js';
 import { get, getKeysByValue } from './util/object.js';
 import { basename, dirname, join, toPosix } from './util/path.js';
 import { getFinalEntryPaths, loadConfigForPlugin } from './util/plugin.js';
@@ -74,7 +74,7 @@ export class WorkspaceWorker {
         const excludeProductionNegations = entry.filter(pattern => !(pattern.startsWith('!') && pattern.endsWith('!')));
         return [excludeProductionNegations, this.negatedWorkspacePatterns].flat();
     }
-    getProjectFilePatterns(testFilePatterns) {
+    getProjectFilePatterns(projectFilePatterns) {
         const { project } = this.config;
         if (project.length === 0)
             return [];
@@ -85,10 +85,13 @@ export class WorkspaceWorker {
             excludeProductionNegations,
             negatedPluginConfigPatterns,
             negatedPluginProjectFilePatterns,
-            testFilePatterns,
+            projectFilePatterns,
             this.negatedWorkspacePatterns,
         ].flat();
     }
+    getPluginEntryFilePatterns(patterns) {
+        return [patterns, this.negatedWorkspacePatterns].flat();
+    }
     getPluginProjectFilePatterns() {
         const patterns = [];
         for (const [pluginName, plugin] of Object.entries(plugins)) {
@@ -175,7 +178,7 @@ export class WorkspaceWorker {
                 if (!pluginConfig)
                     continue;
                 const patterns = this.getConfigurationFilePatterns(pluginName);
-                const allConfigFilePaths = await _pureGlob({ patterns, cwd, gitignore: false });
+                const allConfigFilePaths = await _glob({ patterns, cwd: baseOptions.rootCwd, dir: cwd, gitignore: false });
                 const { packageJsonPath } = plugin;
                 const configFilePaths = allConfigFilePaths.filter(filePath => basename(filePath) !== 'package.json' ||
                     (typeof packageJsonPath === 'function'

package/dist/index.js

@@ -11,8 +11,8 @@ import { getCompilerExtensions, getIncludedCompilers } from './compilers/index.j
 import { getFilteredScripts } from './manifest/helpers.js';
 import { debugLog, debugLogArray, debugLogObject } from './util/debug.js';
 import { getOrCreateFileNode, updateImportMap } from './util/dependency-graph.js';
+import { getGitIgnoredHandler } from './util/glob-core.js';
 import { _glob, negate } from './util/glob.js';
-import { getGitIgnoredHandler } from './util/globby.js';
 import { getReferencedDependencyHandler } from './util/handle-dependency.js';
 import { getHasStrictlyNsReferences, getType } from './util/has-strictly-ns-references.js';
 import { getIsIdentifierReferencedHandler } from './util/is-identifier-referenced.js';
@@ -111,7 +111,7 @@ export const main = async (unresolvedConfiguration) => {
         principal.addEntryPaths(definitionPaths);
         debugLogArray(name, 'Definition paths', definitionPaths);
         const ignore = worker.getIgnorePatterns();
-        const sharedGlobOptions = { cwd, workingDir: dir, gitignore };
+        const sharedGlobOptions = { cwd, dir, gitignore };
         collector.addIgnorePatterns(ignore.map(pattern => join(cwd, pattern)));
         const options = { manifestScriptNames, cwd: dir, dependencies };
         const dependenciesFromManifest = _getDependenciesFromScripts(manifestScripts, options);
@@ -159,7 +159,7 @@ export const main = async (unresolvedConfiguration) => {
                     principal.addProjectPath(projectPath);
             }
             {
-                const patterns = [...entryFilePatterns, ...productionEntryFilePatterns];
+                const patterns = worker.getPluginEntryFilePatterns([...entryFilePatterns, ...productionEntryFilePatterns]);
                 const pluginWorkspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns });
                 debugLogArray(name, 'Plugin entry paths', pluginWorkspaceEntryPaths);
                 principal.addEntryPaths(pluginWorkspaceEntryPaths, { skipExportsAnalysis: true });

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

@@ -5,6 +5,5 @@ declare const _default: {
     isEnabled: IsPluginEnabled;
     entry: string[];
     production: string[];
-    project: string[];
 };
 export default _default;

package/dist/plugins/svelte/index.js

@@ -7,14 +7,12 @@ const entry = ['svelte.config.js', ...viteConfig];
 const production = [
     'src/routes/**/+{page,server,page.server,error,layout,layout.server}{,@*}.{js,ts,svelte}',
     'src/hooks.{server,client}.{js,ts}',
-    'src/params/*{js,ts}',
+    'src/params/*.{js,ts}',
 ];
-const project = ['src/**/*.{js,ts,svelte}'];
 export default {
     title,
     enablers,
     isEnabled,
     entry,
     production,
-    project,
 };

package/dist/plugins/webdriver-io/index.js

@@ -2,7 +2,7 @@ import { hasDependency } from '#p/util/plugin.js';
 const title = 'WebdriverIO';
 const enablers = ['@wdio/cli'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['wdio.conf.js'];
+const config = ['wdio.conf.{js,ts}'];
 const resolveConfig = async (config) => {
     const cfg = config?.config;
     if (!cfg)

package/dist/typescript/visitors/exports/exportDeclaration.js

@@ -8,8 +8,8 @@ export default visit(() => true, (node, { isFixExports, isFixTypes }) => {
             const sourceFile = node.getSourceFile();
             const declarations = sourceFile.getNamedDeclarations?.();
             return node.exportClause.elements.map(element => {
-                const identifier = String(element.name.escapedText);
-                const propName = element.propertyName?.escapedText;
+                const identifier = String(element.name.text);
+                const propName = element.propertyName?.text;
                 const symbol = declarations?.get(propName ?? identifier)?.[0]?.symbol;
                 const pos = element.name.pos;
                 const fix = isFixExports || isFixTypes ? [element.getStart(), element.getEnd()] : undefined;

package/dist/typescript/visitors/imports/reExportDeclaration.js

@@ -10,7 +10,7 @@ export default visit(() => true, node => {
             if (node.exportClause.kind === ts.SyntaxKind.NamespaceExport) {
                 return {
                     identifier: IMPORT_STAR,
-                    namespace: String(node.exportClause.name.escapedText),
+                    namespace: String(node.exportClause.name.text),
                     specifier: node.moduleSpecifier.text,
                     isReExport: true,
                     pos: node.exportClause.name.pos,
@@ -20,8 +20,8 @@ export default visit(() => true, node => {
             return node.exportClause.elements.map(element => {
                 if (element.propertyName && element.name) {
                     return {
-                        identifier: String(element.propertyName.escapedText),
-                        alias: String(element.name.escapedText),
+                        identifier: String(element.propertyName.text),
+                        alias: String(element.name.text),
                         specifier: specifier.text,
                         isReExport: true,
                         pos: element.pos,

package/dist/util/{globby.d.ts → glob-core.d.ts}

@@ -9,6 +9,19 @@ type GlobOptions = {
     readonly dir: string;
 } & FastGlobOptionsWithoutCwd;
 type FastGlobOptionsWithoutCwd = Pick<FastGlobOptions, 'onlyDirectories' | 'ignore' | 'absolute' | 'dot'>;
+export declare const convertGitignoreToPicomatchIgnorePatterns: (pattern: string) => {
+    negated: boolean;
+    patterns: string[];
+};
+export declare const parseAndConvertGitignorePatterns: (patterns: string, ancestor?: string) => {
+    negated: boolean;
+    patterns: string[];
+}[];
+export declare const findAndParseGitignores: (cwd: string) => Promise<{
+    gitignoreFiles: string[];
+    ignores: Set<string>;
+    unignores: string[];
+}>;
 export declare function globby(patterns: string | string[], options: GlobOptions): Promise<string[]>;
 export declare function getGitIgnoredHandler(options: Options): Promise<(path: string) => boolean>;
 export {};

package/dist/util/glob-core.js

@@ -0,0 +1,192 @@
+import { readFileSync } from 'node:fs';
+import { promisify } from 'node:util';
+import { walk as _walk } from '@nodelib/fs.walk';
+import fg, {} from 'fast-glob';
+import picomatch from 'picomatch';
+import { GLOBAL_IGNORE_PATTERNS, ROOT_WORKSPACE_NAME } from '../constants.js';
+import { timerify } from './Performance.js';
+import { debugLogObject } from './debug.js';
+import { isFile } from './fs.js';
+import { dirname, join, relative, toPosix } from './path.js';
+const walk = promisify(_walk);
+const _picomatch = timerify(picomatch);
+const cachedIgnores = new Map();
+export const convertGitignoreToPicomatchIgnorePatterns = (pattern) => {
+    const negated = pattern[0] === '!';
+    if (negated)
+        pattern = pattern.slice(1);
+    let extPattern;
+    if (pattern.endsWith('/'))
+        pattern = pattern.slice(0, -1);
+    if (pattern.startsWith('*/**/'))
+        pattern = pattern.slice(5);
+    if (pattern.startsWith('/'))
+        pattern = pattern.slice(1);
+    else if (!pattern.startsWith('**/'))
+        pattern = `**/${pattern}`;
+    if (pattern.endsWith('/*'))
+        extPattern = pattern;
+    else
+        extPattern = `${pattern}/**`;
+    return { negated, patterns: [pattern, extPattern] };
+};
+export const parseAndConvertGitignorePatterns = (patterns, ancestor) => {
+    const matchFrom = ancestor ? new RegExp(`^(!?/?)(${ancestor})`) : undefined;
+    return patterns
+        .split(/\r?\n/)
+        .filter(line => line.trim() && !line.startsWith('#'))
+        .flatMap(line => {
+        const pattern = line.replace(/(?<!\\)#.*/, '').trim();
+        if (ancestor && matchFrom) {
+            if (pattern.match(matchFrom))
+                return [pattern.replace(matchFrom, '$1')];
+            if (pattern.startsWith('/**/'))
+                return [pattern.slice(1)];
+            if (pattern.startsWith('!/**/'))
+                return [`!${pattern.slice(2)}`];
+            if (pattern.startsWith('/') || pattern.startsWith('!/'))
+                return [];
+        }
+        return [pattern];
+    })
+        .map(pattern => convertGitignoreToPicomatchIgnorePatterns(pattern));
+};
+const findAncestorGitignoreFiles = (cwd) => {
+    const gitignorePaths = [];
+    let dir = dirname(cwd);
+    let prev;
+    while (dir) {
+        const filePath = join(dir, '.gitignore');
+        if (isFile(filePath))
+            gitignorePaths.push(filePath);
+        dir = dirname((prev = dir));
+        if (prev === dir || dir === '.')
+            break;
+    }
+    return gitignorePaths;
+};
+export const findAndParseGitignores = async (cwd) => {
+    const init = ['.git', ...GLOBAL_IGNORE_PATTERNS];
+    const ignores = new Set(init);
+    const unignores = [];
+    const gitignoreFiles = [];
+    const pmOptions = { ignore: unignores };
+    const matchers = new Set(init.map(pattern => _picomatch(pattern, pmOptions)));
+    const matcher = (str) => {
+        for (const isMatch of matchers) {
+            const state = isMatch(str);
+            if (state)
+                return state;
+        }
+        return false;
+    };
+    const addFile = (filePath) => {
+        gitignoreFiles.push(relative(cwd, filePath));
+        const dir = dirname(toPosix(filePath));
+        const base = relative(cwd, dir);
+        const ancestor = base.startsWith('..') ? `${relative(dir, cwd)}/` : undefined;
+        const dirIgnores = new Set(base === '' ? init : []);
+        const dirUnignores = new Set();
+        const patterns = readFileSync(filePath, 'utf8');
+        for (const rule of parseAndConvertGitignorePatterns(patterns, ancestor)) {
+            const [pattern1, pattern2] = rule.patterns;
+            if (rule.negated) {
+                if (base === '' || base.startsWith('..')) {
+                    if (!unignores.includes(pattern2)) {
+                        unignores.push(...rule.patterns);
+                        dirUnignores.add(pattern1);
+                        dirUnignores.add(pattern2);
+                    }
+                }
+                else {
+                    if (!unignores.includes(pattern2.startsWith('**/') ? pattern2 : `**/${pattern2}`)) {
+                        const unignore = join(base, pattern1);
+                        const extraUnignore = join(base, pattern2);
+                        unignores.push(unignore, extraUnignore);
+                        dirUnignores.add(unignore);
+                        dirUnignores.add(extraUnignore);
+                    }
+                }
+            }
+            else {
+                if (base === '' || base.startsWith('..')) {
+                    ignores.add(pattern1);
+                    ignores.add(pattern2);
+                    dirIgnores.add(pattern1);
+                    dirIgnores.add(pattern2);
+                }
+                else {
+                    const ignore = join(base, pattern1);
+                    const extraIgnore = join(base, pattern2);
+                    ignores.add(ignore);
+                    ignores.add(extraIgnore);
+                    dirIgnores.add(ignore);
+                    dirIgnores.add(extraIgnore);
+                }
+            }
+        }
+        const cacheDir = ancestor ? cwd : dir;
+        const cacheForDir = cachedIgnores.get(cwd);
+        if (ancestor && cacheForDir) {
+            for (const pattern of dirIgnores)
+                cacheForDir?.ignores.add(pattern);
+            cacheForDir.unignores = Array.from(new Set([...cacheForDir.unignores, ...dirUnignores]));
+        }
+        else {
+            cachedIgnores.set(cacheDir, { ignores: dirIgnores, unignores: Array.from(dirUnignores) });
+        }
+        for (const pattern of dirIgnores)
+            matchers.add(_picomatch(pattern, pmOptions));
+    };
+    findAncestorGitignoreFiles(cwd).forEach(addFile);
+    if (isFile('.git/info/exclude'))
+        addFile('.git/info/exclude');
+    const entryFilter = (entry) => {
+        if (entry.dirent.isFile() && entry.name === '.gitignore') {
+            addFile(entry.path);
+            return true;
+        }
+        return false;
+    };
+    const deepFilter = (entry) => !matcher(relative(cwd, entry.path));
+    await walk(cwd, {
+        entryFilter: timerify(entryFilter),
+        deepFilter: timerify(deepFilter),
+    });
+    debugLogObject('*', 'Parsed gitignore files', { gitignoreFiles, ignores, unignores });
+    return { gitignoreFiles, ignores, unignores };
+};
+const _parseFindGitignores = timerify(findAndParseGitignores);
+export async function globby(patterns, options) {
+    if (Array.isArray(patterns) && patterns.length === 0)
+        return [];
+    const ignore = options.gitignore && Array.isArray(options.ignore) ? [...options.ignore] : [];
+    if (options.gitignore) {
+        let dir = options.dir;
+        let prev;
+        while (dir) {
+            const cacheForDir = cachedIgnores.get(dir);
+            if (cacheForDir) {
+                ignore.push(...cacheForDir.ignores);
+            }
+            dir = dirname((prev = dir));
+            if (prev === dir || dir === '.')
+                break;
+        }
+    }
+    else {
+        ignore.push(...GLOBAL_IGNORE_PATTERNS);
+    }
+    const fgOptions = Object.assign(options, { ignore });
+    debugLogObject(relative(options.cwd, options.dir) || ROOT_WORKSPACE_NAME, 'Glob options', { patterns, ...fgOptions });
+    return fg.glob(patterns, fgOptions);
+}
+export async function getGitIgnoredHandler(options) {
+    cachedIgnores.clear();
+    if (options.gitignore === false)
+        return () => false;
+    const gitignore = await _parseFindGitignores(options.cwd);
+    const matcher = _picomatch(Array.from(gitignore.ignores), { ignore: gitignore.unignores });
+    const isGitIgnored = (filePath) => matcher(relative(options.cwd, filePath));
+    return timerify(isGitIgnored);
+}

package/dist/util/glob.d.ts

@@ -1,17 +1,14 @@
-export declare const prependDirToPattern: (workingDir: string, pattern: string) => string;
-export declare const negate: (pattern: string) => string;
-export declare const hasProductionSuffix: (pattern: string) => boolean;
-export declare const hasNoProductionSuffix: (pattern: string) => boolean;
-interface BaseGlobOptions {
+interface GlobOptions {
     cwd: string;
+    dir?: string;
     patterns: string[];
     gitignore?: boolean;
 }
-interface GlobOptions extends BaseGlobOptions {
-    workingDir?: string;
-}
-export declare const _glob: ({ cwd, workingDir, patterns, gitignore }: GlobOptions) => Promise<string[]>;
-export declare const _pureGlob: ({ cwd, patterns, gitignore }: BaseGlobOptions) => Promise<string[]>;
-export declare const _firstGlob: ({ cwd, patterns }: BaseGlobOptions) => Promise<string | Buffer | undefined>;
-export declare const _dirGlob: ({ cwd, patterns, gitignore }: BaseGlobOptions) => Promise<string[]>;
+export declare const prependDirToPattern: (dir: string, pattern: string) => string;
+export declare const negate: (pattern: string) => string;
+export declare const hasProductionSuffix: (pattern: string) => boolean;
+export declare const hasNoProductionSuffix: (pattern: string) => boolean;
+export declare const _glob: ({ cwd, dir, patterns, gitignore }: GlobOptions) => Promise<string[]>;
+export declare const _firstGlob: ({ cwd, patterns }: GlobOptions) => Promise<string | Buffer | undefined>;
+export declare const _dirGlob: ({ cwd, patterns, gitignore }: GlobOptions) => Promise<string[]>;
 export {};

package/dist/util/glob.js

@@ -2,44 +2,37 @@ import fg from 'fast-glob';
 import { GLOBAL_IGNORE_PATTERNS } from '../constants.js';
 import { timerify } from './Performance.js';
 import { compact } from './array.js';
-import { globby } from './globby.js';
+import { globby } from './glob-core.js';
 import { join, relative } from './path.js';
-export const prependDirToPattern = (workingDir, pattern) => {
+const prependDirToPatterns = (cwd, dir, patterns) => {
+    const relativePath = relative(cwd, dir);
+    const prepend = (pattern) => prependDirToPattern(relativePath, pattern);
+    return compact([patterns].flat().map(prepend).map(removeProductionSuffix)).sort(negatedLast);
+};
+const removeProductionSuffix = (pattern) => pattern.replace(/!$/, '');
+const negatedLast = (pattern) => (pattern.startsWith('!') ? 1 : -1);
+export const prependDirToPattern = (dir, pattern) => {
     if (pattern.startsWith('!'))
-        return `!${join(workingDir, pattern.slice(1))}`;
-    return join(workingDir, pattern);
+        return `!${join(dir, pattern.slice(1))}`;
+    return join(dir, pattern);
 };
 export const negate = (pattern) => pattern.replace(/^!?/, '!');
 export const hasProductionSuffix = (pattern) => pattern.endsWith('!');
 export const hasNoProductionSuffix = (pattern) => !pattern.endsWith('!');
-const removeProductionSuffix = (pattern) => pattern.replace(/!$/, '');
-const negatedLast = (pattern) => (pattern.startsWith('!') ? 1 : -1);
-const glob = async ({ cwd, workingDir = cwd, patterns, gitignore = true }) => {
+const glob = async ({ cwd, dir = cwd, patterns, gitignore = true }) => {
     if (patterns.length === 0)
         return [];
-    const relativePath = relative(cwd, workingDir);
-    const prepend = (pattern) => prependDirToPattern(relativePath, pattern);
-    const globPatterns = compact([patterns].flat().map(prepend).map(removeProductionSuffix)).sort(negatedLast);
+    const globPatterns = prependDirToPatterns(cwd, dir, patterns);
     if (globPatterns[0].startsWith('!'))
         return [];
     return globby(globPatterns, {
         cwd,
-        dir: workingDir,
+        dir,
         gitignore,
         absolute: true,
         dot: true,
     });
 };
-const pureGlob = async ({ cwd, patterns, gitignore = true }) => {
-    if (patterns.length === 0)
-        return [];
-    return globby(patterns, {
-        cwd,
-        dir: cwd,
-        gitignore,
-        absolute: true,
-    });
-};
 const firstGlob = async ({ cwd, patterns }) => {
     const stream = fg.globStream(patterns.map(removeProductionSuffix), { cwd, ignore: GLOBAL_IGNORE_PATTERNS });
     for await (const entry of stream) {
@@ -53,6 +46,5 @@ const dirGlob = async ({ cwd, patterns, gitignore = true }) => globby(patterns,
     gitignore,
 });
 export const _glob = timerify(glob);
-export const _pureGlob = timerify(pureGlob);
 export const _firstGlob = timerify(firstGlob);
 export const _dirGlob = timerify(dirGlob);

package/dist/util/modules.d.ts

@@ -7,7 +7,7 @@ export declare const getDefinitelyTypedFor: (packageName: string) => string;
 export declare const getPackageFromDefinitelyTyped: (typedDependency: string) => string;
 export declare const getEntryPathsFromManifest: (manifest: PackageJson, sharedGlobOptions: {
     cwd: string;
-    workingDir: string;
+    dir: string;
     gitignore: boolean;
     ignore: string[];
 }) => Promise<string[]>;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.29.1";
+export declare const version = "5.30.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '5.29.1';
+export const version = '5.30.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "5.29.1",
+  "version": "5.30.0",
   "description": "Find unused files, dependencies and exports in your TypeScript and JavaScript projects",
   "homepage": "https://knip.dev",
   "repository": {

package/dist/util/globby.js

@@ -1,139 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { promisify } from 'node:util';
-import { walk as _walk } from '@nodelib/fs.walk';
-import fg, {} from 'fast-glob';
-import picomatch from 'picomatch';
-import { GLOBAL_IGNORE_PATTERNS, ROOT_WORKSPACE_NAME } from '../constants.js';
-import { timerify } from './Performance.js';
-import { debugLogObject } from './debug.js';
-import { isFile } from './fs.js';
-import { dirname, join, relative, toPosix, toRelative } from './path.js';
-const walk = promisify(_walk);
-const _picomatch = timerify(picomatch);
-const cachedIgnores = new Map();
-function convertGitignoreToPicomatch(pattern) {
-    const negated = pattern[0] === '!';
-    if (negated) {
-        pattern = pattern.slice(1);
-    }
-    let extPattern;
-    if (pattern.startsWith('*/**/'))
-        pattern = pattern.slice(5);
-    if (pattern.startsWith('/'))
-        pattern = pattern.slice(1);
-    else if (!pattern.startsWith('**/'))
-        pattern = `**/${pattern}`;
-    if (pattern.endsWith('/*'))
-        extPattern = pattern;
-    else if (pattern.endsWith('/'))
-        extPattern = `${pattern}**`;
-    else
-        extPattern = `${pattern}/**`;
-    return { negated, patterns: [pattern, extPattern] };
-}
-function parseGitignoreFile(filePath) {
-    const file = readFileSync(filePath, 'utf8');
-    return file
-        .split(/\r?\n/)
-        .filter(line => line.trim() && !line.startsWith('#'))
-        .map(pattern => convertGitignoreToPicomatch(pattern.replace(/(?<!\\)#.*/, '').trim()));
-}
-async function parseFindGitignores(options) {
-    const ignores = ['.git', ...GLOBAL_IGNORE_PATTERNS];
-    const unignores = [];
-    const gitignoreFiles = [];
-    const pmOptions = { ignore: unignores };
-    const matchers = ignores.map(ignore => _picomatch(ignore, pmOptions));
-    const matcher = (str) => {
-        for (const isMatch of matchers) {
-            const state = isMatch(str);
-            if (state)
-                return state;
-        }
-        return false;
-    };
-    const addFile = (filePath) => {
-        gitignoreFiles.push(toRelative(filePath));
-        const dir = dirname(toPosix(filePath));
-        const base = relative(options.cwd, dir);
-        const dirIgnores = base === '' ? ['.git', ...GLOBAL_IGNORE_PATTERNS] : [];
-        const dirUnignores = [];
-        for (const rule of parseGitignoreFile(filePath)) {
-            const [p, ext] = rule.patterns;
-            if (rule.negated) {
-                if (base === '') {
-                    if (!unignores.includes(ext))
-                        dirUnignores.push(...rule.patterns);
-                }
-                else {
-                    if (!unignores.includes(ext.startsWith('**/') ? ext : `**/${ext}`)) {
-                        dirUnignores.push(join(base, p), join(base, ext));
-                    }
-                }
-            }
-            else {
-                if (base === '') {
-                    if (!ignores.includes(ext))
-                        dirIgnores.push(...rule.patterns);
-                }
-                else {
-                    if (!ignores.includes(ext.startsWith('**/') ? ext : `**/${ext}`)) {
-                        dirIgnores.push(join(base, p), join(base, ext));
-                    }
-                }
-            }
-        }
-        ignores.push(...dirIgnores);
-        unignores.push(...dirUnignores);
-        cachedIgnores.set(dir, { ignores: dirIgnores, unignores: dirUnignores });
-        matchers.push(...dirIgnores.map(ignore => _picomatch(ignore, pmOptions)));
-    };
-    if (isFile('.git/info/exclude'))
-        addFile('.git/info/exclude');
-    const entryFilter = (entry) => {
-        if (entry.dirent.isFile() && entry.name === '.gitignore') {
-            addFile(entry.path);
-            return true;
-        }
-        return false;
-    };
-    const deepFilter = (entry) => !matcher(relative(options.cwd, entry.path));
-    await walk(options.cwd, {
-        entryFilter: timerify(entryFilter),
-        deepFilter: timerify(deepFilter),
-    });
-    debugLogObject('*', 'Parsed gitignore files', { gitignoreFiles, ignores, unignores });
-    return { ignores, unignores };
-}
-const _parseFindGitignores = timerify(parseFindGitignores);
-export async function globby(patterns, options) {
-    if (Array.isArray(patterns) && patterns.length === 0)
-        return [];
-    const ignore = options.gitignore && Array.isArray(options.ignore) ? [...options.ignore] : [];
-    if (options.gitignore) {
-        let dir = options.dir;
-        while (dir !== options.cwd) {
-            const i = cachedIgnores.get(dir);
-            if (i) {
-                ignore.push(...i.ignores);
-                ignore.push(...i.unignores.map(e => `!${e}`));
-            }
-            dir = dirname(dir);
-        }
-        const i = cachedIgnores.get(options.cwd);
-        if (i)
-            ignore.push(...i.ignores);
-    }
-    const { dir, ...fastGlobOptions } = { ...options, ignore };
-    debugLogObject(relative(options.cwd, dir) || ROOT_WORKSPACE_NAME, 'Glob options', { patterns, ...options });
-    return fg.glob(patterns, fastGlobOptions);
-}
-export async function getGitIgnoredHandler(options) {
-    cachedIgnores.clear();
-    if (options.gitignore === false)
-        return () => false;
-    const gitignore = await _parseFindGitignores(options);
-    const matcher = _picomatch(gitignore.ignores, { ignore: gitignore.unignores });
-    const isGitIgnored = (filePath) => matcher(relative(options.cwd, filePath));
-    return timerify(isGitIgnored);
-}