@cjser/globby 16.2.2-cjser.2 → 16.2.4-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-1784218928215/index.js
+// packages/@cjser/globby.tmp-25-1788279925204/index.js
 var index_exports = {};
 __export(index_exports, {
   convertPathToPattern: () => convertPathToPattern,
@@ -50,7 +50,7 @@ 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-1784218928215/ignore.js
+// packages/@cjser/globby.tmp-25-1788279925204/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);
@@ -62,13 +62,14 @@ var import_is_path_inside2 = __toESM(require("@cjser/is-path-inside"), 1);
 var import_slash2 = __toESM(require("@cjser/slash"), 1);
 var import_node = require("@cjser/unicorn-magic/node");
 
-// packages/@cjser/globby.tmp-26-1784218928215/utilities.js
+// packages/@cjser/globby.tmp-25-1788279925204/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_micromatch = __toESM(require("micromatch"), 1);
 var import_slash = __toESM(require("@cjser/slash"), 1);
 var isNegativePattern = (pattern) => pattern[0] === "!";
 var normalizeAbsolutePatternToRelative = (pattern) => {
@@ -274,8 +275,10 @@ var GITIGNORE_WILDCARDS = /(?<!\\)[*?[]/u;
 var hasGitignoreWildcards = (value) => GITIGNORE_WILDCARDS.test(value);
 var MICROMATCH_ONLY_SYNTAX = /[(){}|\\]/u;
 var unescapeGitignorePattern = (value) => value.replaceAll(/\\(.)/gu, "$1");
+var normalizeGitignorePatternForIgnore = (value) => value.replaceAll(/\\(.)/gu, (match, character) => "*[]\\".includes(character) ? match : character);
 var toLiteralPattern = (value) => import_fast_glob.default.escapePath(unescapeGitignorePattern(value));
 var finalSegment = (value) => value.replace(/\/+$/u, "").split("/").pop();
+var toStandaloneRule = (value) => value.replace(/^([#!])/u, String.raw`\$1`);
 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)));
@@ -284,12 +287,17 @@ var anchorToCwd = (directory, body, cwd) => {
 var createNameComparer = () => {
   const nameMatchers = /* @__PURE__ */ new Map();
   const matchesName = (pattern, name) => {
-    let nameMatcher = nameMatchers.get(pattern);
+    const namePath = unescapeGitignorePattern(name);
+    if (!(0, import_ignore.isPathValid)(namePath)) {
+      return true;
+    }
+    const normalizedPattern = normalizeGitignorePatternForIgnore(pattern);
+    let nameMatcher = nameMatchers.get(normalizedPattern);
     if (!nameMatcher) {
-      nameMatcher = (0, import_ignore.default)().add([pattern]);
-      nameMatchers.set(pattern, nameMatcher);
+      nameMatcher = (0, import_ignore.default)().add([toStandaloneRule(normalizedPattern)]);
+      nameMatchers.set(normalizedPattern, nameMatcher);
     }
-    return nameMatcher.ignores(name);
+    return nameMatcher.ignores(namePath);
   };
   return (pattern, name) => {
     if (hasGitignoreWildcards(pattern) && hasGitignoreWildcards(name)) {
@@ -306,6 +314,32 @@ var negationsCouldRescue = (rules, names) => {
   const couldNameTheSamePath = createNameComparer();
   return getNegationFinalSegments(rules).some((negation) => names.some((name) => couldNameTheSamePath(name, negation)));
 };
+var expandBraceGroups = (pattern) => {
+  if (!pattern.includes("{")) {
+    return [pattern];
+  }
+  const expandedPatterns = import_fast_glob.default.generateTasks(pattern).flatMap((task) => task.patterns);
+  return expandedPatterns.length > 0 ? expandedPatterns : [pattern];
+};
+var convertIgnorePatternsForIgnoreFileSearch = (ignorePatterns, searchPatterns) => {
+  if (ignorePatterns.length === 0) {
+    return ignorePatterns;
+  }
+  const couldNameTheSamePath = createNameComparer();
+  const expandedSearchPatterns = searchPatterns.flatMap((pattern) => expandBraceGroups(pattern));
+  if (expandedSearchPatterns.some((pattern) => MICROMATCH_ONLY_SYNTAX.test(pattern.slice(0, pattern.lastIndexOf("/") + 1)))) {
+    return [];
+  }
+  const ignoreFileNames = expandedSearchPatterns.map((pattern) => finalSegment(pattern)).filter(Boolean);
+  const couldNameAnIgnoreFile = (pattern) => {
+    const name = finalSegment(pattern.replace(/\/\*\*$/u, ""));
+    if (!name || MICROMATCH_ONLY_SYNTAX.test(name)) {
+      return true;
+    }
+    return ignoreFileNames.some((ignoreFileName) => MICROMATCH_ONLY_SYNTAX.test(ignoreFileName) ? hasGitignoreWildcards(name) || import_micromatch.default.isMatch(unescapeGitignorePattern(name), ignoreFileName, { dot: true, nocase: true }) : couldNameTheSamePath(name, ignoreFileName));
+  };
+  return ignorePatterns.filter((pattern) => !expandBraceGroups(pattern).some((expanded) => couldNameAnIgnoreFile(expanded)));
+};
 var getRulePrune = ({ pattern, directory }, { cwd, matcher, hasNegations, canSkipAtAnyDepth, canMatchIgnoreFile, gitignoreOnlySearch }) => {
   if (isNegativePattern(pattern)) {
     return void 0;
@@ -334,8 +368,9 @@ var getRulePrune = ({ pattern, directory }, { cwd, matcher, hasNegations, canSki
   if (target === void 0) {
     return void 0;
   }
+  const guardName = finalSegment(anchoredBody);
   if (isGlob) {
-    return hasNegations ? void 0 : { pattern: toFastGlob(target), guardName: finalSegment(target) };
+    return hasNegations ? void 0 : { pattern: toFastGlob(target), guardName };
   }
   if (!matcher(import_node_path.default.resolve(cwd, target) + import_node_path.default.sep).ignored) {
     return void 0;
@@ -343,7 +378,7 @@ var getRulePrune = ({ pattern, directory }, { cwd, matcher, hasNegations, canSki
   const needsGuard = !gitignoreOnlySearch || target.includes("/");
   return {
     pattern: toFastGlob(import_fast_glob.default.escapePath(target)),
-    guardName: needsGuard ? finalSegment(target) : void 0
+    guardName: needsGuard ? guardName : void 0
   };
 };
 var buildPrunePatternsAndGuards = (rules, matcher, cwd, { gitignoreOnlySearch = false, searchesForGitignoreFiles = false } = {}) => {
@@ -376,7 +411,7 @@ var buildPrunePatternsAndGuards = (rules, matcher, cwd, { gitignoreOnlySearch =
 };
 var convertPatternsForFastGlob = (rules, matcher, cwd) => buildPrunePatternsAndGuards(rules, matcher, cwd).patterns;
 
-// packages/@cjser/globby.tmp-26-1784218928215/ignore.js
+// packages/@cjser/globby.tmp-25-1788279925204/ignore.js
 var defaultIgnoredDirectories = [
   "**/node_modules",
   "**/flow-typed",
@@ -1064,7 +1099,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-1784218928215/index.js
+// packages/@cjser/globby.tmp-25-1788279925204/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");
@@ -1223,6 +1258,10 @@ var buildIgnoreFilterResult = ({ options, cwd, ignoreResult: { rules, matcher },
     filter: createFilter(finalPredicate, cwd, options.fs)
   };
 };
+var getIgnoreFileSearchOptions = (options, searchPatterns) => ({
+  ...options,
+  ignore: convertIgnorePatternsForIgnoreFileSearch(options.ignore, searchPatterns)
+});
 var applyIgnoreFilesAndGetFilter = async (options) => {
   const cwd = options.cwd ?? import_node_process2.default.cwd();
   const ignoreFilesPatterns = getIgnoreFilesPatterns(options);
@@ -1235,7 +1274,7 @@ var applyIgnoreFilesAndGetFilter = async (options) => {
     };
   }
   const includeParentIgnoreFiles = options.gitignore === true;
-  const ignoreResult = ignoreFilesPatterns.length > 0 ? await getIgnorePatternsAndPredicate(ignoreFilesPatterns, options, includeParentIgnoreFiles) : { rules: [], matcher: false };
+  const ignoreResult = ignoreFilesPatterns.length > 0 ? await getIgnorePatternsAndPredicate(ignoreFilesPatterns, getIgnoreFileSearchOptions(options, ignoreFilesPatterns), 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({
@@ -1258,7 +1297,7 @@ var applyIgnoreFilesAndGetFilterSync = (options) => {
     };
   }
   const includeParentIgnoreFiles = options.gitignore === true;
-  const ignoreResult = ignoreFilesPatterns.length > 0 ? getIgnorePatternsAndPredicateSync(ignoreFilesPatterns, options, includeParentIgnoreFiles) : { rules: [], matcher: false };
+  const ignoreResult = ignoreFilesPatterns.length > 0 ? getIgnorePatternsAndPredicateSync(ignoreFilesPatterns, getIgnoreFileSearchOptions(options, ignoreFilesPatterns), 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({

package/index.d.ts

@@ -46,7 +46,9 @@ export type Options = {
 
 	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.
+	The `ignore` option applies to the results only. A pattern that could name an ignore file, such as `'**\/.gitignore'`, is not used when searching for the ignore files, so it hides them from the results without disabling this option.
+
+	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.
 
 	@default false
 	*/
@@ -57,6 +59,8 @@ export type Options = {
 
 	This is a more generic form of the `gitignore` option, allowing you to find ignore files with a [compatible syntax](http://git-scm.com/docs/gitignore). For instance, this works with Babel's `.babelignore`, Prettier's `.prettierignore`, or ESLint's `.eslintignore` files.
 
+	The `ignore` option applies to the results only, as with the `gitignore` option.
+
 	Performance tip: Using a specific path like `'.gitignore'` is much faster than recursive patterns.
 
 	@default undefined
@@ -137,6 +141,8 @@ export type GitignoreOptions = {
 	/**
 	Glob patterns to exclude from ignore file search.
 
+	Unlike the `ignore` option of `globby()`, which applies to the results only, this one excludes files from the search itself, so a pattern that names an ignore file stops that file from being read.
+
 	@default []
 	*/
 	readonly ignore?: string | readonly string[];

package/index.js

@@ -21,6 +21,7 @@ import {
 	normalizeNegativePattern,
 	adjustIgnorePatternsForParentDirectories,
 	convertPatternsForFastGlob,
+	convertIgnorePatternsForIgnoreFileSearch,
 	findGitRoot,
 	findGitRootSync,
 } from './utilities.js';
@@ -245,6 +246,12 @@ const buildIgnoreFilterResult = ({options, cwd, ignoreResult: {rules, matcher},
 	};
 };
 
+// The ignore files are searched for with the same options as the glob itself, except for `ignore`, which excludes paths from the results and must not decide which ignore files are read. The patterns that cannot hide one are still passed on, so the search keeps skipping the directories they name.
+const getIgnoreFileSearchOptions = (options, searchPatterns) => ({
+	...options,
+	ignore: convertIgnorePatternsForIgnoreFileSearch(options.ignore, searchPatterns),
+});
+
 /**
 Apply ignore files to options and return the filter predicate.
 
@@ -272,7 +279,7 @@ const applyIgnoreFilesAndGetFilter = async options => {
 	// Enable parent .gitignore search when using gitignore option
 	const includeParentIgnoreFiles = options.gitignore === true;
 	const ignoreResult = ignoreFilesPatterns.length > 0
-		? await getIgnorePatternsAndPredicate(ignoreFilesPatterns, options, includeParentIgnoreFiles)
+		? await getIgnorePatternsAndPredicate(ignoreFilesPatterns, getIgnoreFileSearchOptions(options, ignoreFilesPatterns), includeParentIgnoreFiles)
 		: {rules: [], matcher: false};
 
 	const globalGitRoot = globalIgnoreFile ? await findGitRoot(cwd, options.fs) : undefined;
@@ -309,7 +316,7 @@ const applyIgnoreFilesAndGetFilterSync = options => {
 	// Enable parent .gitignore search when using gitignore option
 	const includeParentIgnoreFiles = options.gitignore === true;
 	const ignoreResult = ignoreFilesPatterns.length > 0
-		? getIgnorePatternsAndPredicateSync(ignoreFilesPatterns, options, includeParentIgnoreFiles)
+		? getIgnorePatternsAndPredicateSync(ignoreFilesPatterns, getIgnoreFileSearchOptions(options, ignoreFilesPatterns), includeParentIgnoreFiles)
 		: {rules: [], matcher: false};
 
 	const globalGitRoot = globalIgnoreFile ? findGitRootSync(cwd, options.fs) : undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjser/globby",
-  "version": "16.2.2-cjser.2",
+  "version": "16.2.4-cjser.2",
   "description": "User-friendly glob matching",
   "license": "MIT",
   "repository": {
@@ -70,6 +70,7 @@
   "dependencies": {
     "fast-glob": "^3.3.3",
     "ignore": "^7.0.5",
+    "micromatch": "^4.0.8",
     "@cjser/sindresorhus__merge-streams": "4.0.0-cjser.2",
     "@cjser/is-path-inside": "4.0.0-cjser.2",
     "@cjser/slash": "5.1.0-cjser.2",
@@ -99,11 +100,11 @@
   "types": "./index.d.ts",
   "main": "./dist-cjser/index.cjs",
   "cjser": {
-    "sourceVersion": "16.2.2",
+    "sourceVersion": "16.2.4",
     "cjserVersion": 2,
     "original": {
       "name": "globby",
-      "version": "16.2.2",
+      "version": "16.2.4",
       "exports": {
         "types": "./index.d.ts",
         "default": "./index.js"
@@ -114,6 +115,7 @@
         "fast-glob": "^3.3.3",
         "ignore": "^7.0.5",
         "is-path-inside": "^4.0.0",
+        "micromatch": "^4.0.8",
         "slash": "^5.1.0",
         "unicorn-magic": "^0.4.0"
       },

package/readme.md

@@ -93,6 +93,8 @@ 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`.
 
+The `ignore` option applies to the results only. A pattern that could name an ignore file, such as `'**/.gitignore'`, is not used when searching for the ignore files, so it hides them from the results without disabling this option.
+
 **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
@@ -117,6 +119,8 @@ Glob patterns to look for ignore files, which are then used to ignore globbed fi
 
 This is a more generic form of the `gitignore` option, allowing you to find ignore files with a [compatible syntax](http://git-scm.com/docs/gitignore). For instance, this works with Babel's `.babelignore`, Prettier's `.prettierignore`, or ESLint's `.eslintignore` files.
 
+The `ignore` option applies to the results only, as with the [`gitignore`](#gitignore) option.
+
 **Performance tip:** Using a specific path like `'.gitignore'` is much faster than recursive patterns.
 
 ##### expandNegationOnlyPatterns
@@ -248,6 +252,8 @@ Default: `[]`
 
 Glob patterns to exclude from `.gitignore` file search.
 
+Unlike the `ignore` option of [`globby()`](#options), which applies to the results only, this one excludes files from the search itself, so a pattern that names an ignore file stops that file from being read.
+
 ##### followSymbolicLinks
 
 Type: `boolean`\

package/utilities.js

@@ -2,8 +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 gitIgnore, {isPathValid} from 'ignore';
 import isPathInside from '@cjser/is-path-inside';
+import micromatch from 'micromatch';
 import slash from '@cjser/slash';
 
 export const isNegativePattern = pattern => pattern[0] === '!';
@@ -359,12 +360,18 @@ const MICROMATCH_ONLY_SYNTAX = /[(){}|\\]/u;
 // In gitignore, `\x` means the literal character x.
 const unescapeGitignorePattern = value => value.replaceAll(/\\(.)/gu, '$1');
 
+// Normalize ordinary escaped characters for the ignore package, while preserving escapes that it handles as literals. An escaped question mark is widened to a wildcard because the ignore package does not match it literally, and a possible match is safer here than pruning too much.
+const normalizeGitignorePatternForIgnore = value => value.replaceAll(/\\(.)/gu, (match, character) => '*[]\\'.includes(character) ? match : character);
+
 // 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();
 
+// A fragment of rule text is not a rule on its own: `#name` would open a comment and `!name` a negation, both of which stop naming anything. Escape the leading character so the fragment keeps naming what it did inside the rule it came from.
+const toStandaloneRule = value => value.replace(/^([#!])/u, String.raw`\$1`);
+
 const isInsideCwd = relativePath => relativePath !== '' && !relativePath.startsWith('..') && !path.isAbsolute(relativePath);
 
 /**
@@ -385,13 +392,20 @@ const anchorToCwd = (directory, body, cwd) => {
 const createNameComparer = () => {
 	const nameMatchers = new Map();
 	const matchesName = (pattern, name) => {
-		let nameMatcher = nameMatchers.get(pattern);
+		// The name is rule text, not a path: in gitignore `\#foo` names the file `#foo`. `Ignore#ignores()` only accepts a `path.relative()`d string and throws otherwise, so unescape first and treat whatever it still rejects (`.`, `..`, anything anchored) as a possible match.
+		const namePath = unescapeGitignorePattern(name);
+		if (!isPathValid(namePath)) {
+			return true;
+		}
+
+		const normalizedPattern = normalizeGitignorePatternForIgnore(pattern);
+		let nameMatcher = nameMatchers.get(normalizedPattern);
 		if (!nameMatcher) {
-			nameMatcher = gitIgnore().add([pattern]);
-			nameMatchers.set(pattern, nameMatcher);
+			nameMatcher = gitIgnore().add([toStandaloneRule(normalizedPattern)]);
+			nameMatchers.set(normalizedPattern, nameMatcher);
 		}
 
-		return nameMatcher.ignores(name);
+		return nameMatcher.ignores(namePath);
 	};
 
 	// 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.
@@ -427,6 +441,64 @@ export const negationsCouldRescue = (rules, names) => {
 	return getNegationFinalSegments(rules).some(negation => names.some(name => couldNameTheSamePath(name, negation)));
 };
 
+// Brace groups are expanded before the patterns are matched, so every alternative has to be checked on its own: `{**/.gitignore,dist}` names an ignore file even though the text it ends in, `dist}`, names nothing. `generateTasks()` is the only public fast-glob API that hands the expanded alternatives back as text, and it also leaves escaped braces alone.
+const expandBraceGroups = pattern => {
+	// Skipping the call also keeps the patterns `generateTasks()` rejects, such as an empty one, out of it.
+	if (!pattern.includes('{')) {
+		return [pattern];
+	}
+
+	// A pattern that yields no task, such as a negated one, has no alternatives to check, so fall back to the pattern as written rather than to nothing.
+	const expandedPatterns = fastGlob.generateTasks(pattern).flatMap(task => task.patterns);
+	return expandedPatterns.length > 0 ? expandedPatterns : [pattern];
+};
+
+/**
+Drop the `ignore` patterns that could exclude an ignore file from the search that looks for them.
+
+`ignore` excludes paths from the results, while the ignore files decide what is ignored, so it must never be able to hide one of them. See https://github.com/sindresorhus/globby/issues/281
+
+The rest are normally kept unchanged, so that unreadable or unwanted directories are still skipped while searching. Advanced micromatch syntax in the directory portion makes filename comparison unreliable, so optional pruning is disabled for that rare pattern shape. See https://github.com/sindresorhus/globby/pull/259
+
+A pattern that names a directory is safe to keep even when that directory holds an ignore file: nothing inside an excluded directory ends up in the results either. Only the final segment can name the ignore file itself, and a trailing `/**` does not protect it, since fast-glob matches `foo/**` against `foo` as well.
+
+@param {string[]} ignorePatterns - The `ignore` option, as an array.
+@param {string[]} searchPatterns - The patterns the ignore files are searched with.
+@returns {string[]} The patterns that are left, to be used as the `ignore` option of that search.
+*/
+export const convertIgnorePatternsForIgnoreFileSearch = (ignorePatterns, searchPatterns) => {
+	if (ignorePatterns.length === 0) {
+		return ignorePatterns;
+	}
+
+	const couldNameTheSamePath = createNameComparer();
+	const expandedSearchPatterns = searchPatterns.flatMap(pattern => expandBraceGroups(pattern));
+
+	// Filename comparison is not reliable when micromatch-only syntax appears in the directory part, so skip this optional pruning for that rare pattern shape.
+	if (expandedSearchPatterns.some(pattern => MICROMATCH_ONLY_SYNTAX.test(pattern.slice(0, pattern.lastIndexOf('/') + 1)))) {
+		return [];
+	}
+
+	// The names the search looks for, such as `.gitignore` for the `gitignore` option, or whatever `ignoreFiles` asked for. Only the final segment can name a file; the rest of a search pattern says where to look.
+	const ignoreFileNames = expandedSearchPatterns.map(pattern => finalSegment(pattern)).filter(Boolean);
+
+	const couldNameAnIgnoreFile = pattern => {
+		// A trailing `/**` excludes the contents of the directory it names, so only that name is left to compare. A wildcard final segment, as in `src/*`, still compares as one: it does not skip `src`, so the search walks in and would then throw the `.gitignore` it finds away.
+		const name = finalSegment(pattern.replace(/\/\*\*$/u, ''));
+
+		// Nothing left to compare means the pattern names no path of its own, as with `/`. Treat it as a possible match, since keeping it can only cost a missed ignore file. The same goes for micromatch syntax the comparison below cannot read, such as the extglob in `+(.gitignore)`.
+		if (!name || MICROMATCH_ONLY_SYNTAX.test(name)) {
+			return true;
+		}
+
+		return ignoreFileNames.some(ignoreFileName => MICROMATCH_ONLY_SYNTAX.test(ignoreFileName)
+			? hasGitignoreWildcards(name) || micromatch.isMatch(unescapeGitignorePattern(name), ignoreFileName, {dot: true, nocase: true})
+			: couldNameTheSamePath(name, ignoreFileName));
+	};
+
+	return ignorePatterns.filter(pattern => !expandBraceGroups(pattern).some(expanded => couldNameAnIgnoreFile(expanded)));
+};
+
 // 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)) {
@@ -472,11 +544,14 @@ const getRulePrune = ({pattern, directory}, {cwd, matcher, hasNegations, canSkip
 		return undefined;
 	}
 
+	// The guard name is compared against negations as rule text, so it has to keep the escapes the rule was written with; the target has already lost them.
+	const guardName = finalSegment(anchoredBody);
+
 	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)};
+			: {pattern: toFastGlob(target), guardName};
 	}
 
 	if (!matcher(path.resolve(cwd, target) + path.sep).ignored) {
@@ -487,7 +562,7 @@ const getRulePrune = ({pattern, directory}, {cwd, matcher, hasNegations, canSkip
 	const needsGuard = !gitignoreOnlySearch || target.includes('/');
 	return {
 		pattern: toFastGlob(fastGlob.escapePath(target)),
-		guardName: needsGuard ? finalSegment(target) : undefined,
+		guardName: needsGuard ? guardName : undefined,
 	};
 };