@cjser/globby 16.2.1-cjser.2 → 16.2.3-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-1783354945470/index.js
+// packages/@cjser/globby.tmp-26-1786379054379/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-1783354945470/ignore.js
+// packages/@cjser/globby.tmp-26-1786379054379/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-1783354945470/utilities.js
+// packages/@cjser/globby.tmp-26-1786379054379/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,121 @@ 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 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)));
+  return isInsideCwd(relativePath) ? relativePath : void 0;
+};
+var createNameComparer = () => {
+  const nameMatchers = /* @__PURE__ */ new Map();
+  const matchesName = (pattern, name) => {
+    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([toStandaloneRule(normalizedPattern)]);
+      nameMatchers.set(normalizedPattern, nameMatcher);
+    }
+    return nameMatcher.ignores(namePath);
+  };
+  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;
+  }
+  const guardName = finalSegment(anchoredBody);
+  if (isGlob) {
+    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;
+  }
+  const needsGuard = !gitignoreOnlySearch || target.includes("/");
+  return {
+    pattern: toFastGlob(import_fast_glob.default.escapePath(target)),
+    guardName: needsGuard ? guardName : 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).replace(/^\//, ""));
   }
-  return hasNegations ? [] : result;
+  return { patterns, guardNames };
 };
+var convertPatternsForFastGlob = (rules, matcher, cwd) => buildPrunePatternsAndGuards(rules, matcher, cwd).patterns;
 
-// packages/@cjser/globby.tmp-26-1783354945470/ignore.js
+// packages/@cjser/globby.tmp-26-1786379054379/ignore.js
 var defaultIgnoredDirectories = [
   "**/node_modules",
   "**/flow-typed",
@@ -358,17 +458,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 +509,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 +530,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 +550,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 +676,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 +734,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 +946,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 +1072,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-1783354945470/index.js
+// packages/@cjser/globby.tmp-26-1786379054379/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 +1222,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 +1238,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 +1261,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 +1458,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 +1491,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 +1530,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;
     }