@cjser/globby 16.2.0-cjser.2 → 16.2.2-cjser.2

package/dist-cjser/index.cjs

@@ -26,7 +26,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// packages/@cjser/globby.tmp-26-1778145952693/index.js
+// packages/@cjser/globby.tmp-26-1784218928215/index.js
 var index_exports = {};
 __export(index_exports, {
   convertPathToPattern: () => convertPathToPattern,
@@ -50,24 +50,26 @@ var import_sindresorhus_merge_streams = __toESM(require("@cjser/sindresorhus__me
 var import_fast_glob3 = __toESM(require("fast-glob"), 1);
 var import_node2 = require("@cjser/unicorn-magic/node");
 
-// packages/@cjser/globby.tmp-26-1778145952693/ignore.js
+// packages/@cjser/globby.tmp-26-1784218928215/ignore.js
 var import_node_process = __toESM(require("node:process"), 1);
 var import_node_fs2 = __toESM(require("node:fs"), 1);
 var import_promises = __toESM(require("node:fs/promises"), 1);
 var import_node_path2 = __toESM(require("node:path"), 1);
 var import_node_os = __toESM(require("node:os"), 1);
 var import_fast_glob2 = __toESM(require("fast-glob"), 1);
-var import_ignore = __toESM(require("ignore"), 1);
+var import_ignore2 = __toESM(require("ignore"), 1);
 var import_is_path_inside2 = __toESM(require("@cjser/is-path-inside"), 1);
-var import_slash = __toESM(require("@cjser/slash"), 1);
+var import_slash2 = __toESM(require("@cjser/slash"), 1);
 var import_node = require("@cjser/unicorn-magic/node");
 
-// packages/@cjser/globby.tmp-26-1778145952693/utilities.js
+// packages/@cjser/globby.tmp-26-1784218928215/utilities.js
 var import_node_fs = __toESM(require("node:fs"), 1);
 var import_node_path = __toESM(require("node:path"), 1);
 var import_node_util = require("node:util");
 var import_fast_glob = __toESM(require("fast-glob"), 1);
+var import_ignore = __toESM(require("ignore"), 1);
 var import_is_path_inside = __toESM(require("@cjser/is-path-inside"), 1);
+var import_slash = __toESM(require("@cjser/slash"), 1);
 var isNegativePattern = (pattern) => pattern[0] === "!";
 var normalizeAbsolutePatternToRelative = (pattern) => {
   if (!pattern.startsWith("/")) {
@@ -268,23 +270,113 @@ var getParentGitignorePaths = (gitRoot, cwd) => {
   const chain = buildPathChain(import_node_path.default.resolve(cwd), import_node_path.default.resolve(gitRoot));
   return [...chain].reverse().map((directory) => import_node_path.default.join(directory, ".gitignore"));
 };
-var convertPatternsForFastGlob = (patterns, usingGitRoot, normalizeDirectoryPatternForFastGlob2) => {
-  if (usingGitRoot) {
-    return [];
+var GITIGNORE_WILDCARDS = /(?<!\\)[*?[]/u;
+var hasGitignoreWildcards = (value) => GITIGNORE_WILDCARDS.test(value);
+var MICROMATCH_ONLY_SYNTAX = /[(){}|\\]/u;
+var unescapeGitignorePattern = (value) => value.replaceAll(/\\(.)/gu, "$1");
+var toLiteralPattern = (value) => import_fast_glob.default.escapePath(unescapeGitignorePattern(value));
+var finalSegment = (value) => value.replace(/\/+$/u, "").split("/").pop();
+var isInsideCwd = (relativePath) => relativePath !== "" && !relativePath.startsWith("..") && !import_node_path.default.isAbsolute(relativePath);
+var anchorToCwd = (directory, body, cwd) => {
+  const relativePath = (0, import_slash.default)(import_node_path.default.relative(cwd, import_node_path.default.join(directory, body)));
+  return isInsideCwd(relativePath) ? relativePath : void 0;
+};
+var createNameComparer = () => {
+  const nameMatchers = /* @__PURE__ */ new Map();
+  const matchesName = (pattern, name) => {
+    let nameMatcher = nameMatchers.get(pattern);
+    if (!nameMatcher) {
+      nameMatcher = (0, import_ignore.default)().add([pattern]);
+      nameMatchers.set(pattern, nameMatcher);
+    }
+    return nameMatcher.ignores(name);
+  };
+  return (pattern, name) => {
+    if (hasGitignoreWildcards(pattern) && hasGitignoreWildcards(name)) {
+      return true;
+    }
+    return hasGitignoreWildcards(name) ? matchesName(name, pattern) : matchesName(pattern, name);
+  };
+};
+var getNegationFinalSegments = (rules) => rules.filter((rule) => isNegativePattern(rule.pattern)).map((rule) => finalSegment(rule.pattern.slice(1))).filter(Boolean);
+var negationsCouldRescue = (rules, names) => {
+  if (names.length === 0) {
+    return false;
   }
-  const result = [];
-  let hasNegations = false;
-  for (const pattern of patterns) {
-    if (isNegativePattern(pattern)) {
-      hasNegations = true;
-      break;
+  const couldNameTheSamePath = createNameComparer();
+  return getNegationFinalSegments(rules).some((negation) => names.some((name) => couldNameTheSamePath(name, negation)));
+};
+var getRulePrune = ({ pattern, directory }, { cwd, matcher, hasNegations, canSkipAtAnyDepth, canMatchIgnoreFile, gitignoreOnlySearch }) => {
+  if (isNegativePattern(pattern)) {
+    return void 0;
+  }
+  const isDirectoryPattern = pattern.endsWith("/");
+  const clean = pattern.replace(/\/+$/u, "");
+  if (!clean) {
+    return void 0;
+  }
+  const body = clean.startsWith("**/") && !clean.slice(3).includes("/") ? clean.slice(3) : clean;
+  if (canMatchIgnoreFile(finalSegment(body))) {
+    return void 0;
+  }
+  const isGlob = hasGitignoreWildcards(body);
+  if (isGlob && MICROMATCH_ONLY_SYNTAX.test(body)) {
+    return void 0;
+  }
+  const toFastGlob = (value) => normalizeDirectoryPatternForFastGlob(`/${value}${isDirectoryPattern ? "/" : ""}`).replace(/^\//u, "");
+  if (!body.includes("/") && canSkipAtAnyDepth(body)) {
+    const relativeDirectory = (0, import_slash.default)(import_node_path.default.relative(cwd, directory));
+    const prefix = isInsideCwd(relativeDirectory) ? `${import_fast_glob.default.escapePath(relativeDirectory)}/` : "";
+    return { pattern: toFastGlob(`${prefix}**/${isGlob ? body : toLiteralPattern(body)}`), guardName: body };
+  }
+  const anchoredBody = body.replace(/^\//u, "");
+  const target = anchorToCwd(directory, isGlob ? anchoredBody : unescapeGitignorePattern(anchoredBody), cwd);
+  if (target === void 0) {
+    return void 0;
+  }
+  if (isGlob) {
+    return hasNegations ? void 0 : { pattern: toFastGlob(target), guardName: finalSegment(target) };
+  }
+  if (!matcher(import_node_path.default.resolve(cwd, target) + import_node_path.default.sep).ignored) {
+    return void 0;
+  }
+  const needsGuard = !gitignoreOnlySearch || target.includes("/");
+  return {
+    pattern: toFastGlob(import_fast_glob.default.escapePath(target)),
+    guardName: needsGuard ? finalSegment(target) : void 0
+  };
+};
+var buildPrunePatternsAndGuards = (rules, matcher, cwd, { gitignoreOnlySearch = false, searchesForGitignoreFiles = false } = {}) => {
+  if (!matcher || !cwd || !rules || rules.length === 0) {
+    return { patterns: [], guardNames: [] };
+  }
+  const negationNames = getNegationFinalSegments(rules);
+  const couldNameTheSamePath = createNameComparer();
+  const context = {
+    cwd,
+    matcher,
+    hasNegations: negationNames.length > 0,
+    canSkipAtAnyDepth: (pattern) => !negationNames.some((name) => couldNameTheSamePath(pattern, name)),
+    canMatchIgnoreFile: (pattern) => searchesForGitignoreFiles && couldNameTheSamePath(pattern, ".gitignore"),
+    gitignoreOnlySearch
+  };
+  const patterns = [];
+  const guardNames = [];
+  for (const rule of rules) {
+    const prune = getRulePrune(rule, context);
+    if (!prune) {
+      continue;
+    }
+    patterns.push(prune.pattern);
+    if (prune.guardName !== void 0) {
+      guardNames.push(prune.guardName);
     }
-    result.push(normalizeDirectoryPatternForFastGlob2(pattern));
   }
-  return hasNegations ? [] : result;
+  return { patterns, guardNames };
 };
+var convertPatternsForFastGlob = (rules, matcher, cwd) => buildPrunePatternsAndGuards(rules, matcher, cwd).patterns;
 
-// packages/@cjser/globby.tmp-26-1778145952693/ignore.js
+// packages/@cjser/globby.tmp-26-1784218928215/ignore.js
 var defaultIgnoredDirectories = [
   "**/node_modules",
   "**/flow-typed",
@@ -358,17 +450,33 @@ var globIgnoreFiles = (globFunction, patterns, normalizedOptions) => globFunctio
   ...ignoreFilesGlobOptions
   // Must be last to ensure absolute/dot flags stick
 });
-var getParentIgnorePaths = (gitRoot, normalizedOptions) => gitRoot ? getParentGitignorePaths(gitRoot, normalizedOptions.cwd) : [];
-var combineIgnoreFilePaths = (gitRoot, normalizedOptions, childPaths) => dedupePaths([
-  ...getParentIgnorePaths(gitRoot, normalizedOptions),
-  ...childPaths
-]);
+var normalizeIgnoreFileLine = (line) => {
+  line = line.replace(/^\uFEFF/u, "");
+  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);
+};
+var readIgnoreFileLines = (content) => content.split(/\r?\n/).map((line) => normalizeIgnoreFileLine(line)).filter((line) => line && !line.startsWith("#"));
+var getIgnoreRules = (files) => files.flatMap((file) => {
+  const directory = import_node_path2.default.dirname(file.filePath);
+  return readIgnoreFileLines(file.content).map((pattern) => ({ pattern, directory }));
+});
 var buildIgnoreResult = (files, normalizedOptions, gitRoot) => {
   const baseDir = gitRoot || normalizedOptions.cwd;
   const patterns = getPatternsFromIgnoreFiles(files, baseDir);
   const matcher = createIgnoreMatcher(patterns, normalizedOptions.cwd, baseDir);
   return {
     patterns,
+    rules: getIgnoreRules(files),
     matcher,
     predicate: (fileOrDirectory) => matcher(fileOrDirectory).ignored,
     usingGitRoot: Boolean(gitRoot && gitRoot !== normalizedOptions.cwd)
@@ -393,8 +501,8 @@ var applyBaseToPattern = (pattern, base) => {
   return isNegative ? "!" + result : result;
 };
 var parseIgnoreFile = (file, cwd) => {
-  const base = (0, import_slash.default)(import_node_path2.default.relative(cwd, import_node_path2.default.dirname(file.filePath)));
-  return file.content.split(/\r?\n/).filter((line) => line && !line.startsWith("#")).map((pattern) => applyBaseToPattern(pattern, base));
+  const base = (0, import_slash2.default)(import_node_path2.default.relative(cwd, import_node_path2.default.dirname(file.filePath)));
+  return readIgnoreFileLines(file.content).map((pattern) => applyBaseToPattern(pattern, base));
 };
 var toRelativePath = (fileOrDirectory, cwd) => {
   if (import_node_path2.default.isAbsolute(fileOrDirectory)) {
@@ -414,7 +522,7 @@ var toRelativePath = (fileOrDirectory, cwd) => {
 };
 var notIgnored = { ignored: false, unignored: false };
 var createIgnoreMatcher = (patterns, cwd, baseDir) => {
-  const ignores = (0, import_ignore.default)().add(patterns);
+  const ignores = (0, import_ignore2.default)().add(patterns);
   const resolvedCwd = import_node_path2.default.normalize(import_node_path2.default.resolve(cwd));
   const resolvedBaseDir = import_node_path2.default.normalize(import_node_path2.default.resolve(baseDir));
   return (fileOrDirectory) => {
@@ -434,7 +542,7 @@ var createIgnoreMatcher = (patterns, cwd, baseDir) => {
     if (hasTrailingSeparator && !relativePath.endsWith(import_node_path2.default.sep)) {
       relativePath += import_node_path2.default.sep;
     }
-    return ignores.test((0, import_slash.default)(relativePath));
+    return ignores.test((0, import_slash2.default)(relativePath));
   };
 };
 var normalizeOptions = (options = {}) => {
@@ -560,7 +668,7 @@ var normalizeGitConfigConditionPattern = (pattern, configFilePath) => {
   if (pattern.endsWith("/")) {
     pattern += "**";
   }
-  return (0, import_slash.default)(pattern);
+  return (0, import_slash2.default)(pattern);
 };
 var gitConfigGlobToRegex = (pattern, flags) => {
   let regex = "";
@@ -618,7 +726,7 @@ var matchesIncludeIfCondition = (condition, gitDirectory, configFilePath) => {
   const pattern = normalizeGitConfigConditionPattern(rawPattern.trim(), configFilePath);
   const isCaseInsensitive = keyword.toLowerCase() === "gitdir/i";
   const regularExpression = gitConfigGlobToRegex(pattern, isCaseInsensitive ? "i" : void 0);
-  const normalizedGitDirectory = (0, import_slash.default)(import_node_path2.default.resolve(gitDirectory));
+  const normalizedGitDirectory = (0, import_slash2.default)(import_node_path2.default.resolve(gitDirectory));
   return regularExpression.test(normalizedGitDirectory);
 };
 var shouldIncludeConfigSection = (section, gitDirectory, configFilePath) => {
@@ -830,23 +938,103 @@ var buildGlobalMatcher = (globalIgnoreFile, cwd, rootDirectory = cwd) => {
   const patterns = parseIgnoreFile(globalIgnoreFile, import_node_path2.default.dirname(globalIgnoreFile.filePath));
   return createIgnoreMatcher(patterns, cwd, rootDirectory);
 };
+var getKnownIgnoreFilePaths = (patterns, normalizedOptions, gitRoot) => {
+  const searchPatterns = [patterns].flat();
+  const isGitignoreSearch = searchPatterns.includes(GITIGNORE_FILES_PATTERN);
+  if (!isGitignoreSearch) {
+    return [];
+  }
+  return gitRoot ? getParentGitignorePaths(gitRoot, normalizedOptions.cwd) : [import_node_path2.default.join(normalizedOptions.cwd, ".gitignore")];
+};
+var 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))
+  ]
+});
+var getKnownIgnoreFilePattern = (filePath, cwd) => {
+  const pattern = (0, import_is_path_inside2.default)(filePath, cwd) ? import_node_path2.default.relative(cwd, filePath) : filePath;
+  return import_fast_glob2.default.convertPathToPattern(pattern);
+};
+var getMatchingKnownIgnoreFilePaths = (knownPaths, matchingPaths) => {
+  const matchingPathSet = new Set(matchingPaths.map((filePath) => import_node_path2.default.resolve(filePath)));
+  return knownPaths.filter((filePath) => matchingPathSet.has(import_node_path2.default.resolve(filePath)));
+};
+var globKnownIgnoreFilePaths = (globFunction, knownPaths, patterns, normalizedOptions) => {
+  if (knownPaths.length === 0) {
+    return [];
+  }
+  return globIgnoreFiles(
+    globFunction,
+    knownPaths.map((filePath) => getKnownIgnoreFilePattern(filePath, normalizedOptions.cwd)),
+    getKnownIgnoreFileSearchOptions(patterns, normalizedOptions)
+  );
+};
+var filterKnownIgnoreFilePathsAsync = async (knownPaths, patterns, normalizedOptions) => {
+  const matchingPaths = await globKnownIgnoreFilePaths(import_fast_glob2.default, knownPaths, patterns, normalizedOptions);
+  return getMatchingKnownIgnoreFilePaths(knownPaths, matchingPaths);
+};
+var filterKnownIgnoreFilePathsSync = (knownPaths, patterns, normalizedOptions) => {
+  const matchingPaths = globKnownIgnoreFilePaths(import_fast_glob2.default.sync, knownPaths, patterns, normalizedOptions);
+  return getMatchingKnownIgnoreFilePaths(knownPaths, matchingPaths);
+};
+var 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);
+  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 });
+};
+var withPrunedSearch = (normalizedOptions, prunePatterns) => prunePatterns.length === 0 ? normalizedOptions : { ...normalizedOptions, ignore: [...normalizedOptions.ignore, ...prunePatterns] };
+var getUnreadPaths = (childPaths, knownPaths) => {
+  const alreadyRead = new Set(knownPaths.map((filePath) => import_node_path2.default.resolve(filePath)));
+  return dedupePaths(childPaths).filter((filePath) => !alreadyRead.has(import_node_path2.default.resolve(filePath)));
+};
 var collectIgnoreFileArtifactsAsync = async (patterns, options, includeParentIgnoreFiles) => {
   const normalizedOptions = normalizeOptions(options);
-  const childPaths = await globIgnoreFiles(import_fast_glob2.default, patterns, normalizedOptions);
-  const gitRoot = includeParentIgnoreFiles ? await findGitRoot(normalizedOptions.cwd, normalizedOptions.fs) : void 0;
-  const allPaths = combineIgnoreFilePaths(gitRoot, normalizedOptions, childPaths);
   const readFileMethod = getReadFileMethod(normalizedOptions.fs);
-  const files = await readIgnoreFilesSafely(allPaths, readFileMethod, normalizedOptions.suppressErrors);
-  return { files, normalizedOptions, gitRoot };
+  const gitRoot = includeParentIgnoreFiles ? await findGitRoot(normalizedOptions.cwd, normalizedOptions.fs) : void 0;
+  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(import_fast_glob2.default, patterns, withPrunedSearch(normalizedOptions, prunePatterns));
+  let childFiles = await readIgnoreFilesSafely(getUnreadPaths(childPaths, knownPaths), readFileMethod, normalizedOptions.suppressErrors);
+  if (negationsCouldRescue(getIgnoreRules(childFiles), guardNames)) {
+    const allPaths = await globIgnoreFiles(import_fast_glob2.default, patterns, normalizedOptions);
+    childFiles = await readIgnoreFilesSafely(getUnreadPaths(allPaths, knownPaths), readFileMethod, normalizedOptions.suppressErrors);
+  }
+  return { files: [...knownFiles, ...childFiles], normalizedOptions, gitRoot };
 };
 var collectIgnoreFileArtifactsSync = (patterns, options, includeParentIgnoreFiles) => {
   const normalizedOptions = normalizeOptions(options);
-  const childPaths = globIgnoreFiles(import_fast_glob2.default.sync, patterns, normalizedOptions);
-  const gitRoot = includeParentIgnoreFiles ? findGitRootSync(normalizedOptions.cwd, normalizedOptions.fs) : void 0;
-  const allPaths = combineIgnoreFilePaths(gitRoot, normalizedOptions, childPaths);
   const readFileSyncMethod = getReadFileSyncMethod(normalizedOptions.fs);
-  const files = readIgnoreFilesSafelySync(allPaths, readFileSyncMethod, normalizedOptions.suppressErrors);
-  return { files, normalizedOptions, gitRoot };
+  const gitRoot = includeParentIgnoreFiles ? findGitRootSync(normalizedOptions.cwd, normalizedOptions.fs) : void 0;
+  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(import_fast_glob2.default.sync, patterns, withPrunedSearch(normalizedOptions, prunePatterns));
+  let childFiles = readIgnoreFilesSafelySync(getUnreadPaths(childPaths, knownPaths), readFileSyncMethod, normalizedOptions.suppressErrors);
+  if (negationsCouldRescue(getIgnoreRules(childFiles), guardNames)) {
+    const allPaths = globIgnoreFiles(import_fast_glob2.default.sync, patterns, normalizedOptions);
+    childFiles = readIgnoreFilesSafelySync(getUnreadPaths(allPaths, knownPaths), readFileSyncMethod, normalizedOptions.suppressErrors);
+  }
+  return { files: [...knownFiles, ...childFiles], normalizedOptions, gitRoot };
 };
 var isIgnoredByIgnoreFiles = async (patterns, options) => {
   const { files, normalizedOptions, gitRoot } = await collectIgnoreFileArtifactsAsync(patterns, options, false);
@@ -876,7 +1064,7 @@ var getIgnorePatternsAndPredicateSync = (patterns, options, includeParentIgnoreF
 var isGitIgnored = (options) => isIgnoredByIgnoreFiles(GITIGNORE_FILES_PATTERN, options);
 var isGitIgnoredSync = (options) => isIgnoredByIgnoreFilesSync(GITIGNORE_FILES_PATTERN, options);
 
-// packages/@cjser/globby.tmp-26-1778145952693/index.js
+// packages/@cjser/globby.tmp-26-1784218928215/index.js
 var assertPatternsInput = (patterns) => {
   if (patterns.some((pattern) => typeof pattern !== "string")) {
     throw new TypeError("Patterns must be a string or an array of strings");
@@ -1026,14 +1214,12 @@ var combinePredicate = (matcher, globalMatcher) => {
     return isPathIgnored(matcher, globalMatcher, file);
   };
 };
-var buildIgnoreFilterResult = (options, cwd, { patterns, matcher, usingGitRoot }, globalMatcher, createFilter) => {
+var buildIgnoreFilterResult = ({ options, cwd, ignoreResult: { rules, matcher }, globalMatcher, createFilter }) => {
   const finalPredicate = combinePredicate(matcher, globalMatcher);
-  const patternsForFastGlob = convertPatternsForFastGlob(patterns, usingGitRoot, normalizeDirectoryPatternForFastGlob);
+  const pruneIgnorePatterns = convertPatternsForFastGlob(rules, matcher, cwd);
   return {
-    options: {
-      ...options,
-      ignore: [...options.ignore, ...patternsForFastGlob]
-    },
+    options,
+    pruneIgnorePatterns,
     filter: createFilter(finalPredicate, cwd, options.fs)
   };
 };
@@ -1044,14 +1230,21 @@ var applyIgnoreFilesAndGetFilter = async (options) => {
   if (ignoreFilesPatterns.length === 0 && !globalIgnoreFile) {
     return {
       options,
+      pruneIgnorePatterns: [],
       filter: createFilterFunctionAsync(false, cwd, options.fs)
     };
   }
   const includeParentIgnoreFiles = options.gitignore === true;
-  const ignoreResult = ignoreFilesPatterns.length > 0 ? await getIgnorePatternsAndPredicate(ignoreFilesPatterns, options, includeParentIgnoreFiles) : { patterns: [], matcher: false, usingGitRoot: false };
+  const ignoreResult = ignoreFilesPatterns.length > 0 ? await getIgnorePatternsAndPredicate(ignoreFilesPatterns, options, includeParentIgnoreFiles) : { rules: [], matcher: false };
   const globalGitRoot = globalIgnoreFile ? await findGitRoot(cwd, options.fs) : void 0;
   const globalMatcher = globalIgnoreFile ? buildGlobalMatcher(globalIgnoreFile, cwd, globalGitRoot ?? cwd) : void 0;
-  return buildIgnoreFilterResult(options, cwd, ignoreResult, globalMatcher, createFilterFunctionAsync);
+  return buildIgnoreFilterResult({
+    options,
+    cwd,
+    ignoreResult,
+    globalMatcher,
+    createFilter: createFilterFunctionAsync
+  });
 };
 var applyIgnoreFilesAndGetFilterSync = (options) => {
   const cwd = options.cwd ?? import_node_process2.default.cwd();
@@ -1060,14 +1253,21 @@ var applyIgnoreFilesAndGetFilterSync = (options) => {
   if (ignoreFilesPatterns.length === 0 && !globalIgnoreFile) {
     return {
       options,
+      pruneIgnorePatterns: [],
       filter: createFilterFunction(false, cwd, options.fs)
     };
   }
   const includeParentIgnoreFiles = options.gitignore === true;
-  const ignoreResult = ignoreFilesPatterns.length > 0 ? getIgnorePatternsAndPredicateSync(ignoreFilesPatterns, options, includeParentIgnoreFiles) : { patterns: [], matcher: false, usingGitRoot: false };
+  const ignoreResult = ignoreFilesPatterns.length > 0 ? getIgnorePatternsAndPredicateSync(ignoreFilesPatterns, options, includeParentIgnoreFiles) : { rules: [], matcher: false };
   const globalGitRoot = globalIgnoreFile ? findGitRootSync(cwd, options.fs) : void 0;
   const globalMatcher = globalIgnoreFile ? buildGlobalMatcher(globalIgnoreFile, cwd, globalGitRoot ?? cwd) : void 0;
-  return buildIgnoreFilterResult(options, cwd, ignoreResult, globalMatcher, createFilterFunction);
+  return buildIgnoreFilterResult({
+    options,
+    cwd,
+    ignoreResult,
+    globalMatcher,
+    createFilter: createFilterFunction
+  });
 };
 var assertGlobalGitignoreSyncSupport = (options) => {
   if (options.globalGitignore && options.fs && !options.fs.statSync) {
@@ -1250,21 +1450,28 @@ var applyParentDirectoryIgnoreAdjustments = (tasks) => tasks.map((task) => ({
     ignore: adjustIgnorePatternsForParentDirectories(task.patterns, task.options.ignore)
   }
 }));
+var appendPruneIgnorePatterns = (tasks, pruneIgnorePatterns) => pruneIgnorePatterns.length === 0 ? tasks : tasks.map((task) => ({
+  patterns: task.patterns,
+  options: {
+    ...task.options,
+    ignore: [...task.options.ignore, ...pruneIgnorePatterns]
+  }
+}));
 var normalizeExpandDirectoriesOption = (options, cwd) => ({
   ...cwd ? { cwd } : {},
   ...Array.isArray(options) ? { files: options } : options
 });
-var generateTasks = async (patterns, options) => {
+var 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 = {
     ...normalizeExpandDirectoriesOption(expandDirectories, cwd),
     fs: fsImplementation
   };
-  return Promise.all(globTasks.map(async (task) => {
+  const tasks = await Promise.all(globTasks.map(async (task) => {
     let { patterns: patterns2, options: options2 } = task;
     [
       patterns2,
@@ -1276,36 +1483,38 @@ var generateTasks = async (patterns, options) => {
     options2.ignore = adjustIgnorePatternsForParentDirectories(patterns2, options2.ignore);
     return { patterns: patterns2, options: options2 };
   }));
+  return appendPruneIgnorePatterns(tasks, pruneIgnorePatterns);
 };
-var generateTasksSync = (patterns, options) => {
+var 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 = {
     ...normalizeExpandDirectoriesOption(expandDirectories, cwd),
     fs: fsImplementation
   };
-  return globTasks.map((task) => {
+  const tasks = globTasks.map((task) => {
     let { patterns: patterns2, options: options2 } = task;
     patterns2 = directoryToGlobSync(patterns2, directoryToGlobSyncOptions);
     options2.ignore = directoryToGlobSync(options2.ignore, { cwd, fs: fsImplementation });
     options2.ignore = adjustIgnorePatternsForParentDirectories(patterns2, options2.ignore);
     return { patterns: patterns2, options: options2 };
   });
+  return appendPruneIgnorePatterns(tasks, pruneIgnorePatterns);
 };
 var globby = normalizeArguments(async (patterns, options) => {
   assertGlobalGitignoreAsyncSupport(options);
-  const { options: modifiedOptions, filter } = await applyIgnoreFilesAndGetFilter(options);
-  const tasks = await generateTasks(patterns, modifiedOptions);
+  const { options: modifiedOptions, pruneIgnorePatterns, filter } = await applyIgnoreFilesAndGetFilter(options);
+  const tasks = await generateTasks(patterns, modifiedOptions, pruneIgnorePatterns);
   const results = await Promise.all(tasks.map((task) => (0, import_fast_glob3.default)(task.patterns, task.options)));
   return unionFastGlobResultsAsync(results, filter);
 });
 var globbySync = normalizeArgumentsSync((patterns, options) => {
   assertGlobalGitignoreSyncSupport(options);
-  const { options: modifiedOptions, filter } = applyIgnoreFilesAndGetFilterSync(options);
-  const tasks = generateTasksSync(patterns, modifiedOptions);
+  const { options: modifiedOptions, pruneIgnorePatterns, filter } = applyIgnoreFilesAndGetFilterSync(options);
+  const tasks = generateTasksSync(patterns, modifiedOptions, pruneIgnorePatterns);
   const results = tasks.map((task) => import_fast_glob3.default.sync(task.patterns, task.options));
   return unionFastGlobResults(results, filter);
 });
@@ -1313,8 +1522,8 @@ var globbyStream = normalizeArgumentsSync((patterns, options) => {
   assertGlobalGitignoreAsyncSupport(options);
   const seen = /* @__PURE__ */ new Set();
   const stream = import_node_stream.Readable.from((async function* () {
-    const { options: modifiedOptions, filter } = await applyIgnoreFilesAndGetFilter(options);
-    const tasks = await generateTasks(patterns, modifiedOptions);
+    const { options: modifiedOptions, pruneIgnorePatterns, filter } = await applyIgnoreFilesAndGetFilter(options);
+    const tasks = await generateTasks(patterns, modifiedOptions, pruneIgnorePatterns);
     if (tasks.length === 0) {
       return;
     }

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.0-cjser.2",
+  "version": "16.2.2-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.0",
+    "sourceVersion": "16.2.2",
     "cjserVersion": 2,
     "original": {
       "name": "globby",
-      "version": "16.2.0",
+      "version": "16.2.2",
       "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
 

package/utilities.js

@@ -2,7 +2,9 @@ import fs from 'node:fs';
 import path from 'node:path';
 import {promisify} from 'node:util';
 import fastGlob from 'fast-glob';
+import gitIgnore from 'ignore';
 import isPathInside from '@cjser/is-path-inside';
+import slash from '@cjser/slash';
 
 export const isNegativePattern = pattern => pattern[0] === '!';
 
@@ -343,40 +345,210 @@ export const getParentGitignorePaths = (gitRoot, cwd) => {
 		.map(directory => path.join(directory, '.gitignore'));
 };
 
+// The wildcards gitignore itself understands, when not escaped. Other characters micromatch
+// treats as syntax ((){}, extglobs, alternation) are literal in gitignore.
+const GITIGNORE_WILDCARDS = /(?<!\\)[*?[]/u;
+
+const hasGitignoreWildcards = value => GITIGNORE_WILDCARDS.test(value);
+
+// Characters micromatch reads as syntax where gitignore does not. A glob rule containing them
+// cannot be translated, and backslash escapes inside a glob cannot be safely carried through
+// the path handling below, so such rules are left to the predicate.
+const MICROMATCH_ONLY_SYNTAX = /[(){}|\\]/u;
+
+// In gitignore, `\x` means the literal character x.
+const unescapeGitignorePattern = value => value.replaceAll(/\\(.)/gu, '$1');
+
+// Turn gitignore-literal text into fast-glob-literal text, so characters like `+(` cannot be
+// misread as micromatch syntax.
+const toLiteralPattern = value => fastGlob.escapePath(unescapeGitignorePattern(value));
+
+const finalSegment = value => value.replace(/\/+$/u, '').split('/').pop();
+
+const isInsideCwd = relativePath => relativePath !== '' && !relativePath.startsWith('..') && !path.isAbsolute(relativePath);
+
 /**
-Convert ignore patterns to fast-glob compatible format.
-Returns empty array if patterns should be handled by predicate only.
+Resolve a pattern anchored at the directory of its ignore file into a cwd-relative one.
+
+@param {string} directory - Directory of the ignore file that declared the rule.
+@param {string} body - The rule body, relative to that directory.
+@param {string} cwd - Directory the glob runs from.
+@returns {string|undefined} The cwd-relative pattern, or undefined when it targets something outside the cwd.
+*/
+const anchorToCwd = (directory, body, cwd) => {
+	const relativePath = slash(path.relative(cwd, path.join(directory, body)));
+	return isInsideCwd(relativePath) ? relativePath : undefined;
+};
+
+// Compare names with the `ignore` package instead of guessing from the syntax, since it is the
+// same engine the predicate uses for the real decision.
+const createNameComparer = () => {
+	const nameMatchers = new Map();
+	const matchesName = (pattern, name) => {
+		let nameMatcher = nameMatchers.get(pattern);
+		if (!nameMatcher) {
+			nameMatcher = gitIgnore().add([pattern]);
+			nameMatchers.set(pattern, nameMatcher);
+		}
+
+		return nameMatcher.ignores(name);
+	};
+
+	// A negation can only re-include the excluded path itself; nothing below it can be re-included once the directory is excluded. Two globs cannot be compared this way, so treat them as a possible match.
+	return (pattern, name) => {
+		if (hasGitignoreWildcards(pattern) && hasGitignoreWildcards(name)) {
+			return true;
+		}
+
+		return hasGitignoreWildcards(name) ? matchesName(name, pattern) : matchesName(pattern, name);
+	};
+};
+
+const getNegationFinalSegments = rules => rules
+	.filter(rule => isNegativePattern(rule.pattern))
+	.map(rule => finalSegment(rule.pattern.slice(1)))
+	.filter(Boolean);
+
+/**
+Check whether any negation in the given rules could re-include a path with one of the given names.
+
+Used after the pruned ignore-file search: a negation found by that search can re-include a directory the prune patterns skipped, which means ignore files inside it were never discovered.
+
+@param {Array<{pattern: string, directory: string}>} rules - Raw ignore-file lines and the directory of the ignore file that declared them.
+@param {string[]} names - The guard names returned by `buildPrunePatternsAndGuards`.
+@returns {boolean} Whether a negation could name one of them.
+*/
+export const negationsCouldRescue = (rules, names) => {
+	if (names.length === 0) {
+		return false;
+	}
+
+	const couldNameTheSamePath = createNameComparer();
+	return getNegationFinalSegments(rules).some(negation => names.some(name => couldNameTheSamePath(name, negation)));
+};
+
+// Compute the prune pattern for a single rule, or undefined when the rule cannot be skipped safely. The returned object also carries the guard name (if any) whose skipping relies on the rule set being complete.
+const getRulePrune = ({pattern, directory}, {cwd, matcher, hasNegations, canSkipAtAnyDepth, canMatchIgnoreFile, gitignoreOnlySearch}) => {
+	if (isNegativePattern(pattern)) {
+		return undefined;
+	}
 
-@param {string[]} patterns - Ignore patterns from .gitignore files
-@param {boolean} usingGitRoot - Whether patterns are relative to git root
-@param {Function} normalizeDirectoryPatternForFastGlob - Function to normalize directory patterns
-@returns {string[]} Patterns safe to pass to fast-glob, or empty array
+	const isDirectoryPattern = pattern.endsWith('/');
+	const clean = pattern.replace(/\/+$/u, '');
+	if (!clean) {
+		return undefined;
+	}
+
+	// A leading `**/` is gitignore's explicit spelling of "match at any depth"; for a single trailing segment it is identical to the bare name (`**/foo` == `foo`). Drop it so the rule takes the any-depth branch below instead of being treated as an anchored glob.
+	const body = clean.startsWith('**/') && !clean.slice(3).includes('/')
+		? clean.slice(3)
+		: clean;
+
+	if (canMatchIgnoreFile(finalSegment(body))) {
+		// Contents-only rules such as `foo/*` still allow traversal to `foo/.gitignore`, so the ignore-file search must read it before pruning foo's contents.
+		return undefined;
+	}
+
+	const isGlob = hasGitignoreWildcards(body);
+	if (isGlob && MICROMATCH_ONLY_SYNTAX.test(body)) {
+		return undefined;
+	}
+
+	// The leading slash stops the normalizer from prefixing `**/`; the passed value already encodes the depth, and an extra `**/` would un-anchor an anchored rule.
+	const toFastGlob = value =>
+		normalizeDirectoryPatternForFastGlob(`/${value}${isDirectoryPattern ? '/' : ''}`).replace(/^\//u, '');
+
+	// No separator: matches at any depth below the ignore file that declared it.
+	if (!body.includes('/') && canSkipAtAnyDepth(body)) {
+		const relativeDirectory = slash(path.relative(cwd, directory));
+		const prefix = isInsideCwd(relativeDirectory) ? `${fastGlob.escapePath(relativeDirectory)}/` : '';
+		return {pattern: toFastGlob(`${prefix}**/${isGlob ? body : toLiteralPattern(body)}`), guardName: body};
+	}
+
+	// Otherwise fall back to the single occurrence beside the ignore file, which names a concrete path that the matcher can verify directly.
+	const anchoredBody = body.replace(/^\//u, '');
+	const target = anchorToCwd(directory, isGlob ? anchoredBody : unescapeGitignorePattern(anchoredBody), cwd);
+	if (target === undefined) {
+		return undefined;
+	}
+
+	if (isGlob) {
+		// A glob does not name a concrete path, so the matcher cannot confirm it is ignored.
+		return hasNegations
+			? undefined
+			: {pattern: toFastGlob(target), guardName: finalSegment(target)};
+	}
+
+	if (!matcher(path.resolve(cwd, target) + path.sep).ignored) {
+		return undefined;
+	}
+
+	// A direct child of the cwd can only be re-included by a rule at or above the cwd, and in a pure gitignore search those rules are all known already. A deeper target has intermediate directories whose ignore files may not have been read yet.
+	const needsGuard = !gitignoreOnlySearch || target.includes('/');
+	return {
+		pattern: toFastGlob(fastGlob.escapePath(target)),
+		guardName: needsGuard ? finalSegment(target) : undefined,
+	};
+};
+
+/**
+Build the ignore patterns handed to fast-glob so it can skip ignored directories while traversing.
+
+The authoritative filter is always the predicate, so these patterns only ever need to be safe:
+skipping something the predicate would have kept loses files, while skipping less than possible
+merely costs time. Two facts from the gitignore spec make aggressive skipping safe anyway:
+
+- "It is not possible to re-include a file if a parent directory of that file is excluded."
+  So a directory that is still ignored once every negation has been applied can be skipped whole.
+- A pattern with no separator matches at any depth below its own ignore file, and one with a
+  separator is anchored to that file's directory. Working from the raw rules - rather than from
+  patterns already rebased onto some other directory - keeps that distinction intact, which is
+  what lets this work from a subdirectory of the repository too.
+
+The returned guard names are the directory names whose skipping relies on the given rules being
+complete. A caller working from a partial rule set (the ignore-file search) must watch for later
+negations that could name one of them; see `negationsCouldRescue`.
+
+@param {Array<{pattern: string, directory: string}>} rules - Raw ignore-file lines and the directory of the ignore file that declared them.
+@param {Function} matcher - The authoritative gitignore matcher.
+@param {string} cwd - Directory the glob runs from.
+@param {Object} [options] - Options.
+@param {boolean} [options.gitignoreOnlySearch] - Whether the rule set can only grow through nested `.gitignore` files.
+@param {boolean} [options.searchesForGitignoreFiles] - Whether the search includes `.gitignore` files.
+@returns {{patterns: string[], guardNames: string[]}} Patterns safe to pass to fast-glob, and the names their safety depends on.
 */
-export const convertPatternsForFastGlob = (patterns, usingGitRoot, normalizeDirectoryPatternForFastGlob) => {
-	// Determine which patterns are safe to pass to fast-glob
-	// If there are negation patterns, we can't pass file patterns to fast-glob
-	// because fast-glob doesn't understand negations and would filter out files
-	// that should be re-included by negation patterns.
-	// If we're using git root, patterns are relative to git root not cwd,
-	// so we can't pass them to fast-glob which expects cwd-relative patterns.
-	// We only pass patterns to fast-glob if there are NO negations AND we're not using git root.
-
-	if (usingGitRoot) {
-		return []; // Patterns are relative to git root, not cwd
-	}
-
-	const result = [];
-	let hasNegations = false;
-
-	// Single pass to check for negations and collect positive patterns
-	for (const pattern of patterns) {
-		if (isNegativePattern(pattern)) {
-			hasNegations = true;
-			break; // Early exit on first negation
+export const buildPrunePatternsAndGuards = (rules, matcher, cwd, {gitignoreOnlySearch = false, searchesForGitignoreFiles = false} = {}) => {
+	if (!matcher || !cwd || !rules || rules.length === 0) {
+		return {patterns: [], guardNames: []};
+	}
+
+	const negationNames = getNegationFinalSegments(rules);
+	const couldNameTheSamePath = createNameComparer();
+	const context = {
+		cwd,
+		matcher,
+		hasNegations: negationNames.length > 0,
+		canSkipAtAnyDepth: pattern => !negationNames.some(name => couldNameTheSamePath(pattern, name)),
+		canMatchIgnoreFile: pattern => searchesForGitignoreFiles && couldNameTheSamePath(pattern, '.gitignore'),
+		gitignoreOnlySearch,
+	};
+
+	const patterns = [];
+	const guardNames = [];
+
+	for (const rule of rules) {
+		const prune = getRulePrune(rule, context);
+		if (!prune) {
+			continue;
 		}
 
-		result.push(normalizeDirectoryPatternForFastGlob(pattern));
+		patterns.push(prune.pattern);
+		if (prune.guardName !== undefined) {
+			guardNames.push(prune.guardName);
+		}
 	}
 
-	return hasNegations ? [] : result;
+	return {patterns, guardNames};
 };
+
+export const convertPatternsForFastGlob = (rules, matcher, cwd) => buildPrunePatternsAndGuards(rules, matcher, cwd).patterns;