@cjser/globby 16.2.1-cjser.2 → 16.2.3-cjser.2

package/ignore.js

@@ -15,6 +15,8 @@ import {
 	findGitRoot,
 	findGitRootSync,
 	getParentGitignorePaths,
+	buildPrunePatternsAndGuards,
+	negationsCouldRescue,
 } from './utilities.js';
 
 const defaultIgnoredDirectories = [
@@ -117,14 +119,43 @@ const globIgnoreFiles = (globFunction, patterns, normalizedOptions) => globFunct
 	...ignoreFilesGlobOptions, // Must be last to ensure absolute/dot flags stick
 });
 
-const getParentIgnorePaths = (gitRoot, normalizedOptions) => gitRoot
-	? getParentGitignorePaths(gitRoot, normalizedOptions.cwd)
-	: [];
+// Normalize a raw ignore-file line the way git does: strip a byte order mark and trailing whitespace. "Trailing spaces are ignored unless they are quoted with backslash" - a backslash-escaped trailing space is kept, still escaped, so the line can be re-fed to the `ignore` package without being stripped again.
+const normalizeIgnoreFileLine = line => {
+	line = line.replace(/^\uFEFF/u, '');
 
-const combineIgnoreFilePaths = (gitRoot, normalizedOptions, childPaths) => dedupePaths([
-	...getParentIgnorePaths(gitRoot, normalizedOptions),
-	...childPaths,
-]);
+	let whitespaceStart = line.length;
+	while (whitespaceStart > 0 && /\s/u.test(line[whitespaceStart - 1])) {
+		whitespaceStart--;
+	}
+
+	if (whitespaceStart === line.length) {
+		return line;
+	}
+
+	let backslashCount = 0;
+	for (let index = whitespaceStart - 1; index >= 0 && line[index] === '\\'; index--) {
+		backslashCount++;
+	}
+
+	return backslashCount % 2 === 1
+		? line.slice(0, whitespaceStart) + ' '
+		: line.slice(0, whitespaceStart);
+};
+
+const readIgnoreFileLines = content => content
+	.split(/\r?\n/)
+	.map(line => normalizeIgnoreFileLine(line))
+	.filter(line => line && !line.startsWith('#'));
+
+/**
+Get the lines of every ignore file, as git reads them, each paired with the directory of the file that declared them.
+
+Anchoring is only meaningful relative to that directory, and the rebased patterns have already lost it, so keep the originals for anything that has to reason about which paths a rule covers.
+*/
+const getIgnoreRules = files => files.flatMap(file => {
+	const directory = path.dirname(file.filePath);
+	return readIgnoreFileLines(file.content).map(pattern => ({pattern, directory}));
+});
 
 const buildIgnoreResult = (files, normalizedOptions, gitRoot) => {
 	const baseDir = gitRoot || normalizedOptions.cwd;
@@ -133,6 +164,7 @@ const buildIgnoreResult = (files, normalizedOptions, gitRoot) => {
 
 	return {
 		patterns,
+		rules: getIgnoreRules(files),
 		matcher,
 		predicate: fileOrDirectory => matcher(fileOrDirectory).ignored,
 		usingGitRoot: Boolean(gitRoot && gitRoot !== normalizedOptions.cwd),
@@ -177,11 +209,7 @@ const applyBaseToPattern = (pattern, base) => {
 
 const parseIgnoreFile = (file, cwd) => {
 	const base = slash(path.relative(cwd, path.dirname(file.filePath)));
-
-	return file.content
-		.split(/\r?\n/)
-		.filter(line => line && !line.startsWith('#'))
-		.map(pattern => applyBaseToPattern(pattern, base));
+	return readIgnoreFileLines(file.content).map(pattern => applyBaseToPattern(pattern, base));
 };
 
 const toRelativePath = (fileOrDirectory, cwd) => {
@@ -515,6 +543,7 @@ const createExcludesFileValue = (value, declaringFilePath) => ({
 
 /**
 Parse git config content and return the excludesFile value and any include paths to recurse into.
+
 The caller is responsible for reading files and recursing (sync or async).
 */
 const parseGitConfigForExcludesFile = (content, normalizedPath, gitDirectory) => {
@@ -789,30 +818,149 @@ export const buildGlobalPredicate = (globalIgnoreFile, cwd, rootDirectory = cwd)
 	return fileOrDirectory => matcher(fileOrDirectory).ignored;
 };
 
+/**
+Ignore files at or above the cwd can be located without traversing anything.
+
+Reading them before searching for the nested ones lets the search itself skip whole ignored directories. Otherwise the recursive search for ignore files walks even the directories that the same `.gitignore` excludes, so a large ignored directory (a mounted share, a build output) is enumerated on every call.
+*/
+const getKnownIgnoreFilePaths = (patterns, normalizedOptions, gitRoot) => {
+	const searchPatterns = [patterns].flat();
+	const isGitignoreSearch = searchPatterns.includes(GITIGNORE_FILES_PATTERN);
+	if (!isGitignoreSearch) {
+		return [];
+	}
+
+	return gitRoot
+		? getParentGitignorePaths(gitRoot, normalizedOptions.cwd)
+		: [path.join(normalizedOptions.cwd, '.gitignore')];
+};
+
+const getKnownIgnoreFileSearchOptions = (patterns, normalizedOptions) => ({
+	...normalizedOptions,
+	ignore: [
+		...normalizedOptions.ignore,
+		// Keep negative search patterns active when the known candidates are matched independently.
+		...[patterns].flat()
+			.filter(pattern => isNegativePattern(pattern))
+			.map(pattern => pattern.slice(1)),
+	],
+});
+
+const getKnownIgnoreFilePattern = (filePath, cwd) => {
+	// Relative candidates keep cwd-relative exclusions such as `.gitignore` meaningful; parent candidates must remain absolute because they are outside cwd.
+	const pattern = isPathInside(filePath, cwd) ? path.relative(cwd, filePath) : filePath;
+	return fastGlob.convertPathToPattern(pattern);
+};
+
+const getMatchingKnownIgnoreFilePaths = (knownPaths, matchingPaths) => {
+	// Fast-glob normalizes its results, so compare resolved paths before returning the original paths for reading.
+	const matchingPathSet = new Set(matchingPaths.map(filePath => path.resolve(filePath)));
+
+	return knownPaths.filter(filePath => matchingPathSet.has(path.resolve(filePath)));
+};
+
+const globKnownIgnoreFilePaths = (globFunction, knownPaths, patterns, normalizedOptions) => {
+	if (knownPaths.length === 0) {
+		return [];
+	}
+
+	return globIgnoreFiles(
+		globFunction,
+		knownPaths.map(filePath => getKnownIgnoreFilePattern(filePath, normalizedOptions.cwd)),
+		getKnownIgnoreFileSearchOptions(patterns, normalizedOptions),
+	);
+};
+
+const filterKnownIgnoreFilePathsAsync = async (knownPaths, patterns, normalizedOptions) => {
+	const matchingPaths = await globKnownIgnoreFilePaths(fastGlob, knownPaths, patterns, normalizedOptions);
+	return getMatchingKnownIgnoreFilePaths(knownPaths, matchingPaths);
+};
+
+const filterKnownIgnoreFilePathsSync = (knownPaths, patterns, normalizedOptions) => {
+	const matchingPaths = globKnownIgnoreFilePaths(fastGlob.sync, knownPaths, patterns, normalizedOptions);
+	return getMatchingKnownIgnoreFilePaths(knownPaths, matchingPaths);
+};
+
+const getIgnoreFileSearchPrune = (searchPatterns, files, normalizedOptions, gitRoot) => {
+	if (files.length === 0) {
+		return {patterns: [], guardNames: []};
+	}
+
+	const {cwd} = normalizedOptions;
+	const baseDir = gitRoot || cwd;
+	const ignorePatterns = getPatternsFromIgnoreFiles(files, baseDir);
+	const matcher = createIgnoreMatcher(ignorePatterns, cwd, baseDir);
+
+	// Custom ignore files can live anywhere, including beside the cwd, so only a pure `.gitignore` search may treat the rules at or above the cwd as complete.
+	const searchPatternsArray = [searchPatterns].flat();
+	const gitignoreOnlySearch = searchPatternsArray.every(pattern => pattern === GITIGNORE_FILES_PATTERN);
+	const searchesForGitignoreFiles = searchPatternsArray.includes(GITIGNORE_FILES_PATTERN);
+
+	return buildPrunePatternsAndGuards(getIgnoreRules(files), matcher, cwd, {gitignoreOnlySearch, searchesForGitignoreFiles});
+};
+
+const withPrunedSearch = (normalizedOptions, prunePatterns) => prunePatterns.length === 0
+	? normalizedOptions
+	: {...normalizedOptions, ignore: [...normalizedOptions.ignore, ...prunePatterns]};
+
+// The known ignore files have already been read; only the newly discovered ones are left.
+const getUnreadPaths = (childPaths, knownPaths) => {
+	const alreadyRead = new Set(knownPaths.map(filePath => path.resolve(filePath)));
+	return dedupePaths(childPaths).filter(filePath => !alreadyRead.has(path.resolve(filePath)));
+};
+
 const collectIgnoreFileArtifactsAsync = async (patterns, options, includeParentIgnoreFiles) => {
 	const normalizedOptions = normalizeOptions(options);
-	const childPaths = await globIgnoreFiles(fastGlob, patterns, normalizedOptions);
+	const readFileMethod = getReadFileMethod(normalizedOptions.fs);
 	const gitRoot = includeParentIgnoreFiles
 		? await findGitRoot(normalizedOptions.cwd, normalizedOptions.fs)
 		: undefined;
-	const allPaths = combineIgnoreFilePaths(gitRoot, normalizedOptions, childPaths);
-	const readFileMethod = getReadFileMethod(normalizedOptions.fs);
-	const files = await readIgnoreFilesSafely(allPaths, readFileMethod, normalizedOptions.suppressErrors);
 
-	return {files, normalizedOptions, gitRoot};
+	const knownPaths = await filterKnownIgnoreFilePathsAsync(
+		getKnownIgnoreFilePaths(patterns, normalizedOptions, gitRoot),
+		patterns,
+		normalizedOptions,
+	);
+	const knownFiles = await readIgnoreFilesSafely(knownPaths, readFileMethod, normalizedOptions.suppressErrors);
+	const {patterns: prunePatterns, guardNames} = getIgnoreFileSearchPrune(patterns, knownFiles, normalizedOptions, gitRoot);
+
+	const childPaths = await globIgnoreFiles(fastGlob, patterns, withPrunedSearch(normalizedOptions, prunePatterns));
+	let childFiles = await readIgnoreFilesSafely(getUnreadPaths(childPaths, knownPaths), readFileMethod, normalizedOptions.suppressErrors);
+
+	// A negation found by the pruned search can re-include a directory the prune patterns skipped, hiding the ignore files inside it. Repeat the search without pruning when that happens; a single unpruned pass finds everything, so once is enough.
+	if (negationsCouldRescue(getIgnoreRules(childFiles), guardNames)) {
+		const allPaths = await globIgnoreFiles(fastGlob, patterns, normalizedOptions);
+		childFiles = await readIgnoreFilesSafely(getUnreadPaths(allPaths, knownPaths), readFileMethod, normalizedOptions.suppressErrors);
+	}
+
+	return {files: [...knownFiles, ...childFiles], normalizedOptions, gitRoot};
 };
 
 const collectIgnoreFileArtifactsSync = (patterns, options, includeParentIgnoreFiles) => {
 	const normalizedOptions = normalizeOptions(options);
-	const childPaths = globIgnoreFiles(fastGlob.sync, patterns, normalizedOptions);
+	const readFileSyncMethod = getReadFileSyncMethod(normalizedOptions.fs);
 	const gitRoot = includeParentIgnoreFiles
 		? findGitRootSync(normalizedOptions.cwd, normalizedOptions.fs)
 		: undefined;
-	const allPaths = combineIgnoreFilePaths(gitRoot, normalizedOptions, childPaths);
-	const readFileSyncMethod = getReadFileSyncMethod(normalizedOptions.fs);
-	const files = readIgnoreFilesSafelySync(allPaths, readFileSyncMethod, normalizedOptions.suppressErrors);
 
-	return {files, normalizedOptions, gitRoot};
+	const knownPaths = filterKnownIgnoreFilePathsSync(
+		getKnownIgnoreFilePaths(patterns, normalizedOptions, gitRoot),
+		patterns,
+		normalizedOptions,
+	);
+	const knownFiles = readIgnoreFilesSafelySync(knownPaths, readFileSyncMethod, normalizedOptions.suppressErrors);
+	const {patterns: prunePatterns, guardNames} = getIgnoreFileSearchPrune(patterns, knownFiles, normalizedOptions, gitRoot);
+
+	const childPaths = globIgnoreFiles(fastGlob.sync, patterns, withPrunedSearch(normalizedOptions, prunePatterns));
+	let childFiles = readIgnoreFilesSafelySync(getUnreadPaths(childPaths, knownPaths), readFileSyncMethod, normalizedOptions.suppressErrors);
+
+	// See `collectIgnoreFileArtifactsAsync`: a rescuing negation means the pruned search may have missed files.
+	if (negationsCouldRescue(getIgnoreRules(childFiles), guardNames)) {
+		const allPaths = globIgnoreFiles(fastGlob.sync, patterns, normalizedOptions);
+		childFiles = readIgnoreFilesSafelySync(getUnreadPaths(allPaths, knownPaths), readFileSyncMethod, normalizedOptions.suppressErrors);
+	}
+
+	return {files: [...knownFiles, ...childFiles], normalizedOptions, gitRoot};
 };
 
 export const isIgnoredByIgnoreFiles = async (patterns, options) => {
@@ -834,7 +982,7 @@ This avoids reading the same files twice (once for patterns, once for filtering)
 @param {string[]} patterns - Patterns to find ignore files
 @param {Object} options - Options object
 @param {boolean} [includeParentIgnoreFiles=false] - Whether to search for parent .gitignore files
-@returns {Promise<{patterns: string[], matcher: Function, predicate: Function, usingGitRoot: boolean}>}
+@returns {Promise<{patterns: string[], rules: Array<{pattern: string, directory: string}>, matcher: Function, predicate: Function, usingGitRoot: boolean}>}
 */
 export const getIgnorePatternsAndPredicate = async (patterns, options, includeParentIgnoreFiles = false) => {
 	const {files, normalizedOptions, gitRoot} = await collectIgnoreFileArtifactsAsync(
@@ -852,7 +1000,7 @@ Read ignore files and return both patterns and predicate (sync version).
 @param {string[]} patterns - Patterns to find ignore files
 @param {Object} options - Options object
 @param {boolean} [includeParentIgnoreFiles=false] - Whether to search for parent .gitignore files
-@returns {{patterns: string[], matcher: Function, predicate: Function, usingGitRoot: boolean}}
+@returns {{patterns: string[], rules: Array<{pattern: string, directory: string}>, matcher: Function, predicate: Function, usingGitRoot: boolean}}
 */
 export const getIgnorePatternsAndPredicateSync = (patterns, options, includeParentIgnoreFiles = false) => {
 	const {files, normalizedOptions, gitRoot} = collectIgnoreFileArtifactsSync(

package/index.js

@@ -19,7 +19,6 @@ import {
 	isNegativePattern,
 	getStaticAbsolutePathPrefix,
 	normalizeNegativePattern,
-	normalizeDirectoryPatternForFastGlob,
 	adjustIgnorePatternsForParentDirectories,
 	convertPatternsForFastGlob,
 	findGitRoot,
@@ -233,31 +232,28 @@ const combinePredicate = (matcher, globalMatcher) => {
 	};
 };
 
-const buildIgnoreFilterResult = (options, cwd, {patterns, matcher, usingGitRoot}, globalMatcher, createFilter) => {
+const buildIgnoreFilterResult = ({options, cwd, ignoreResult: {rules, matcher}, globalMatcher, createFilter}) => {
 	const finalPredicate = combinePredicate(matcher, globalMatcher);
 
-	// Convert patterns to fast-glob format (may return empty array if predicate should handle everything)
-	const patternsForFastGlob = convertPatternsForFastGlob(patterns, usingGitRoot, normalizeDirectoryPatternForFastGlob);
+	// Patterns fast-glob can use to skip ignored directories while traversing. The predicate below stays authoritative, so this only ever needs to be safe, never exhaustive. They are returned separately from `options.ignore` so they skip directory expansion and the parent-directory adjustment, which would rebase them outside the scope their ignore files govern.
+	const pruneIgnorePatterns = convertPatternsForFastGlob(rules, matcher, cwd);
 
 	return {
-		options: {
-			...options,
-			ignore: [...options.ignore, ...patternsForFastGlob],
-		},
+		options,
+		pruneIgnorePatterns,
 		filter: createFilter(finalPredicate, cwd, options.fs),
 	};
 };
 
 /**
-Apply gitignore patterns to options and return filter predicate.
-
-When negation patterns are present (e.g., '!important.log'), we cannot pass positive patterns to fast-glob because it would filter out files before our predicate can re-include them. In this case, we rely entirely on the predicate for filtering, which handles negations correctly.
+Apply ignore files to options and return the filter predicate.
 
-When there are no negations, we optimize by passing patterns to fast-glob's ignore option to skip directories during traversal (performance optimization).
+The predicate handles every rule, including negations, and is the authoritative filter applied
+to fast-glob's results. Rules that provably cannot be affected by negations are additionally
+translated into fast-glob `ignore` patterns, so whole ignored directories are skipped during
+traversal; see `convertPatternsForFastGlob`.
 
-All patterns (including negated) are always used in the filter predicate to ensure correct Git-compatible behavior.
-
-@returns {Promise<{options: Object, filter: Function}>}
+@returns {Promise<{options: Object, pruneIgnorePatterns: string[], filter: Function}>}
 */
 const applyIgnoreFilesAndGetFilter = async options => {
 	const cwd = options.cwd ?? process.cwd();
@@ -267,6 +263,7 @@ const applyIgnoreFilesAndGetFilter = async options => {
 	if (ignoreFilesPatterns.length === 0 && !globalIgnoreFile) {
 		return {
 			options,
+			pruneIgnorePatterns: [],
 			filter: createFilterFunctionAsync(false, cwd, options.fs),
 		};
 	}
@@ -276,18 +273,24 @@ const applyIgnoreFilesAndGetFilter = async options => {
 	const includeParentIgnoreFiles = options.gitignore === true;
 	const ignoreResult = ignoreFilesPatterns.length > 0
 		? await getIgnorePatternsAndPredicate(ignoreFilesPatterns, options, includeParentIgnoreFiles)
-		: {patterns: [], matcher: false, usingGitRoot: false};
+		: {rules: [], matcher: false};
 
 	const globalGitRoot = globalIgnoreFile ? await findGitRoot(cwd, options.fs) : undefined;
 	const globalMatcher = globalIgnoreFile ? buildGlobalMatcher(globalIgnoreFile, cwd, globalGitRoot ?? cwd) : undefined;
 
-	return buildIgnoreFilterResult(options, cwd, ignoreResult, globalMatcher, createFilterFunctionAsync);
+	return buildIgnoreFilterResult({
+		options,
+		cwd,
+		ignoreResult,
+		globalMatcher,
+		createFilter: createFilterFunctionAsync,
+	});
 };
 
 /**
-Apply gitignore patterns to options and return filter predicate (sync version).
+Apply ignore files to options and return the filter predicate (sync version).
 
-@returns {{options: Object, filter: Function}}
+@returns {{options: Object, pruneIgnorePatterns: string[], filter: Function}}
 */
 const applyIgnoreFilesAndGetFilterSync = options => {
 	const cwd = options.cwd ?? process.cwd();
@@ -297,6 +300,7 @@ const applyIgnoreFilesAndGetFilterSync = options => {
 	if (ignoreFilesPatterns.length === 0 && !globalIgnoreFile) {
 		return {
 			options,
+			pruneIgnorePatterns: [],
 			filter: createFilterFunction(false, cwd, options.fs),
 		};
 	}
@@ -306,12 +310,18 @@ const applyIgnoreFilesAndGetFilterSync = options => {
 	const includeParentIgnoreFiles = options.gitignore === true;
 	const ignoreResult = ignoreFilesPatterns.length > 0
 		? getIgnorePatternsAndPredicateSync(ignoreFilesPatterns, options, includeParentIgnoreFiles)
-		: {patterns: [], matcher: false, usingGitRoot: false};
+		: {rules: [], matcher: false};
 
 	const globalGitRoot = globalIgnoreFile ? findGitRootSync(cwd, options.fs) : undefined;
 	const globalMatcher = globalIgnoreFile ? buildGlobalMatcher(globalIgnoreFile, cwd, globalGitRoot ?? cwd) : undefined;
 
-	return buildIgnoreFilterResult(options, cwd, ignoreResult, globalMatcher, createFilterFunction);
+	return buildIgnoreFilterResult({
+		options,
+		cwd,
+		ignoreResult,
+		globalMatcher,
+		createFilter: createFilterFunction,
+	});
 };
 
 const assertGlobalGitignoreSyncSupport = options => {
@@ -545,18 +555,31 @@ const applyParentDirectoryIgnoreAdjustments = tasks => tasks.map(task => ({
 	},
 }));
 
+// Prune patterns are appended after directory expansion and the parent-directory adjustment on
+// purpose: they are already glob-shaped, and rebasing them onto a `../` prefix would let them
+// ignore paths outside the scope of the ignore files they came from.
+const appendPruneIgnorePatterns = (tasks, pruneIgnorePatterns) => pruneIgnorePatterns.length === 0
+	? tasks
+	: tasks.map(task => ({
+		patterns: task.patterns,
+		options: {
+			...task.options,
+			ignore: [...task.options.ignore, ...pruneIgnorePatterns],
+		},
+	}));
+
 const normalizeExpandDirectoriesOption = (options, cwd) => ({
 	...(cwd ? {cwd} : {}),
 	...(Array.isArray(options) ? {files: options} : options),
 });
 
-const generateTasks = async (patterns, options) => {
+const generateTasks = async (patterns, options, pruneIgnorePatterns = []) => {
 	const globTasks = convertNegativePatterns(patterns, options);
 
 	const {cwd, expandDirectories, fs: fsImplementation} = options;
 
 	if (!expandDirectories) {
-		return applyParentDirectoryIgnoreAdjustments(globTasks);
+		return appendPruneIgnorePatterns(applyParentDirectoryIgnoreAdjustments(globTasks), pruneIgnorePatterns);
 	}
 
 	const directoryToGlobOptions = {
@@ -564,7 +587,7 @@ const generateTasks = async (patterns, options) => {
 		fs: fsImplementation,
 	};
 
-	return Promise.all(globTasks.map(async task => {
+	const tasks = await Promise.all(globTasks.map(async task => {
 		let {patterns, options} = task;
 
 		[
@@ -580,14 +603,16 @@ const generateTasks = async (patterns, options) => {
 
 		return {patterns, options};
 	}));
+
+	return appendPruneIgnorePatterns(tasks, pruneIgnorePatterns);
 };
 
-const generateTasksSync = (patterns, options) => {
+const generateTasksSync = (patterns, options, pruneIgnorePatterns = []) => {
 	const globTasks = convertNegativePatterns(patterns, options);
 	const {cwd, expandDirectories, fs: fsImplementation} = options;
 
 	if (!expandDirectories) {
-		return applyParentDirectoryIgnoreAdjustments(globTasks);
+		return appendPruneIgnorePatterns(applyParentDirectoryIgnoreAdjustments(globTasks), pruneIgnorePatterns);
 	}
 
 	const directoryToGlobSyncOptions = {
@@ -595,7 +620,7 @@ const generateTasksSync = (patterns, options) => {
 		fs: fsImplementation,
 	};
 
-	return globTasks.map(task => {
+	const tasks = globTasks.map(task => {
 		let {patterns, options} = task;
 		patterns = directoryToGlobSync(patterns, directoryToGlobSyncOptions);
 		options.ignore = directoryToGlobSync(options.ignore, {cwd, fs: fsImplementation});
@@ -605,16 +630,18 @@ const generateTasksSync = (patterns, options) => {
 
 		return {patterns, options};
 	});
+
+	return appendPruneIgnorePatterns(tasks, pruneIgnorePatterns);
 };
 
 export const globby = normalizeArguments(async (patterns, options) => {
 	assertGlobalGitignoreAsyncSupport(options);
 
 	// Apply ignore files and get filter (reads .gitignore files once)
-	const {options: modifiedOptions, filter} = await applyIgnoreFilesAndGetFilter(options);
+	const {options: modifiedOptions, pruneIgnorePatterns, filter} = await applyIgnoreFilesAndGetFilter(options);
 
-	// Generate tasks with modified options (includes gitignore patterns in ignore option)
-	const tasks = await generateTasks(patterns, modifiedOptions);
+	// Generate tasks, attaching the prune patterns so fast-glob skips ignored directories
+	const tasks = await generateTasks(patterns, modifiedOptions, pruneIgnorePatterns);
 
 	const results = await Promise.all(tasks.map(task => fastGlob(task.patterns, task.options)));
 	return unionFastGlobResultsAsync(results, filter);
@@ -624,10 +651,10 @@ export const globbySync = normalizeArgumentsSync((patterns, options) => {
 	assertGlobalGitignoreSyncSupport(options);
 
 	// Apply ignore files and get filter (reads .gitignore files once)
-	const {options: modifiedOptions, filter} = applyIgnoreFilesAndGetFilterSync(options);
+	const {options: modifiedOptions, pruneIgnorePatterns, filter} = applyIgnoreFilesAndGetFilterSync(options);
 
-	// Generate tasks with modified options (includes gitignore patterns in ignore option)
-	const tasks = generateTasksSync(patterns, modifiedOptions);
+	// Generate tasks, attaching the prune patterns so fast-glob skips ignored directories
+	const tasks = generateTasksSync(patterns, modifiedOptions, pruneIgnorePatterns);
 
 	const results = tasks.map(task => fastGlob.sync(task.patterns, task.options));
 	return unionFastGlobResults(results, filter);
@@ -639,10 +666,10 @@ export const globbyStream = normalizeArgumentsSync((patterns, options) => {
 	const seen = new Set();
 	const stream = Readable.from((async function * () {
 		// Apply ignore files and get filter (reads .gitignore files once)
-		const {options: modifiedOptions, filter} = await applyIgnoreFilesAndGetFilter(options);
+		const {options: modifiedOptions, pruneIgnorePatterns, filter} = await applyIgnoreFilesAndGetFilter(options);
 
-		// Generate tasks with modified options (includes gitignore patterns in ignore option)
-		const tasks = await generateTasks(patterns, modifiedOptions);
+		// Generate tasks, attaching the prune patterns so fast-glob skips ignored directories
+		const tasks = await generateTasks(patterns, modifiedOptions, pruneIgnorePatterns);
 
 		if (tasks.length === 0) {
 			return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjser/globby",
-  "version": "16.2.1-cjser.2",
+  "version": "16.2.3-cjser.2",
   "description": "User-friendly glob matching",
   "license": "MIT",
   "repository": {
@@ -99,11 +99,11 @@
   "types": "./index.d.ts",
   "main": "./dist-cjser/index.cjs",
   "cjser": {
-    "sourceVersion": "16.2.1",
+    "sourceVersion": "16.2.3",
     "cjserVersion": 2,
     "original": {
       "name": "globby",
-      "version": "16.2.1",
+      "version": "16.2.3",
       "exports": {
         "types": "./index.d.ts",
         "default": "./index.js"

package/readme.md

@@ -93,7 +93,7 @@ When enabled, globby searches for `.gitignore` files from the current working di
 
 Gitignore patterns take priority over user patterns, matching Git's behavior. To include gitignored files, set this to `false`.
 
-**Performance:** Globby reads `.gitignore` files before globbing. When there are no negation patterns (like `!important.log`) and no parent `.gitignore` files are found, it passes ignore patterns to fast-glob to skip traversing ignored directories entirely, which significantly improves performance for large `node_modules` or build directories. When negation patterns or parent `.gitignore` files are present, all filtering is done after traversal to ensure correct Git-compatible behavior. For optimal performance, prefer specific `.gitignore` patterns without negations, or use `ignoreFiles: '.gitignore'` to target only the root ignore file.
+**Performance:** Globby reads `.gitignore` files before globbing and hands fast-glob patterns for the directories it can prove are ignored, so whole ignored directories (like large `node_modules` or build outputs) are skipped during traversal instead of being enumerated and filtered afterwards. This holds even when negation patterns (like `!important.log`) or parent `.gitignore` files are present: only the rules that provably cannot be re-included by a negation are used to skip directories, while the final filtering always matches Git's behavior. To read fewer ignore files, use `ignoreFiles: '.gitignore'` to target only the root ignore file.
 
 ##### globalGitignore