knip 5.84.1 → 5.86.0

package/dist/util/Performance.js

@@ -2,8 +2,8 @@ import os from 'node:os';
 import { PerformanceObserver, performance } from 'node:perf_hooks';
 import { memoryUsage } from 'node:process';
 import { parseArgs } from 'node:util';
-import { getStats } from './math.js';
-import { Table } from './table.js';
+import { getStats } from "./math.js";
+import { Table } from "./table.js";
 const { values } = parseArgs({
     strict: false,
     options: {

package/dist/util/catalog.d.ts

@@ -1,5 +1,5 @@
-import type { CatalogContainer } from '../CatalogCounselor.js';
-import type { PackageJson } from '../types/package-json.js';
+import type { CatalogContainer } from '../CatalogCounselor.ts';
+import type { PackageJson } from '../types/package-json.ts';
 export declare const DEFAULT_CATALOG = "default";
 export declare const getCatalogContainer: (cwd: string, manifest: PackageJson, manifestPath: string, pnpmWorkspacePath?: string, pnpmWorkspace?: any) => Promise<CatalogContainer>;
 export declare const parseCatalog: (container: CatalogContainer) => Set<string>;

package/dist/util/catalog.js

@@ -1,6 +1,6 @@
-import { isFile } from './fs.js';
-import { _load } from './loader.js';
-import { basename, join } from './path.js';
+import { isFile } from "./fs.js";
+import { _load } from "./loader.js";
+import { basename, join } from "./path.js";
 export const DEFAULT_CATALOG = 'default';
 export const getCatalogContainer = async (cwd, manifest, manifestPath, pnpmWorkspacePath, pnpmWorkspace) => {
     const filePath = pnpmWorkspacePath ?? (isFile(cwd, '.yarnrc.yml') ? join(cwd, '.yarnrc.yml') : manifestPath);

package/dist/util/codeowners.js

@@ -1,7 +1,7 @@
 import { readFileSync } from 'node:fs';
 import picomatch from 'picomatch';
-import { debugLog } from './debug.js';
-import { convertGitignoreToPicomatchIgnorePatterns } from './parse-and-convert-gitignores.js';
+import { debugLog } from "./debug.js";
+import { convertGitignoreToPicomatchIgnorePatterns } from "./parse-and-convert-gitignores.js";
 export function parseCodeowners(content) {
     const matchers = content
         .split(/\r?\n/)

package/dist/util/create-input-handler.d.ts

@@ -1,8 +1,8 @@
-import type { ConfigurationChief, Workspace } from '../ConfigurationChief.js';
-import type { DependencyDeputy } from '../DependencyDeputy.js';
-import type { Issue } from '../types/issues.js';
-import type { ExternalRef } from '../types/module-graph.js';
-import type { MainOptions } from './create-options.js';
-import { type Input } from './input.js';
+import type { ConfigurationChief, Workspace } from '../ConfigurationChief.ts';
+import type { DependencyDeputy } from '../DependencyDeputy.ts';
+import type { Issue } from '../types/issues.ts';
+import type { ExternalRef } from '../types/module-graph.ts';
+import type { MainOptions } from './create-options.ts';
+import { type Input } from './input.ts';
 export type ExternalRefsFromInputs = Map<string, Set<ExternalRef>>;
 export declare const createInputHandler: (deputy: DependencyDeputy, chief: ConfigurationChief, isGitIgnored: (filePath: string) => boolean, addIssue: (issue: Issue) => void, externalRefs: ExternalRefsFromInputs | undefined, options: MainOptions) => (input: Input, workspace: Workspace) => string | undefined;

package/dist/util/create-input-handler.js

@@ -1,9 +1,9 @@
-import { IGNORED_RUNTIME_DEPENDENCIES } from '../constants.js';
-import { debugLog } from './debug.js';
-import { fromBinary, isBinary, isConfig, isDeferResolve, isDeferResolveEntry, isDependency, toDebugString, } from './input.js';
-import { getPackageNameFromSpecifier } from './modules.js';
-import { dirname, isAbsolute, isInNodeModules, isInternal, join } from './path.js';
-import { _resolveModuleSync, _resolveSync } from './resolve.js';
+import { IGNORED_RUNTIME_DEPENDENCIES } from "../constants.js";
+import { debugLog } from "./debug.js";
+import { fromBinary, isBinary, isConfig, isDeferResolve, isDeferResolveEntry, isDependency, toDebugString, } from "./input.js";
+import { getPackageNameFromSpecifier } from "./modules.js";
+import { dirname, isAbsolute, isInNodeModules, isInternal, join } from "./path.js";
+import { _resolveModuleSync, _resolveSync } from "./resolve.js";
 const isJoinable = (specifier) => {
     const char = specifier.charCodeAt(0);
     return char !== 35 && char !== 126 && char !== 64 && !isAbsolute(specifier);
@@ -53,7 +53,7 @@ export const createInputHandler = (deputy, chief, isGitIgnored, addIssue, extern
         const isWorkspace = chief.workspacesByPkgName.has(packageName);
         const inputWorkspace = getWorkspaceFor(input, chief, workspace);
         if (inputWorkspace) {
-            const isHandled = deputy.maybeAddReferencedExternalDependency(inputWorkspace, packageName);
+            const isHandled = deputy.maybeAddReferencedExternalDependency(inputWorkspace, packageName, isConfig(input));
             if (externalRefs && !isWorkspace) {
                 addExternalRef(externalRefs, containingFilePath, { specifier: packageName, identifier: undefined });
             }

package/dist/util/create-options.d.ts

@@ -1,21 +1,21 @@
-import type { Options } from '../types/options.js';
-import type { ParsedCLIArgs } from './cli-arguments.js';
+import type { Options } from '../types/options.ts';
+import type { ParsedCLIArgs } from './cli-arguments.ts';
 interface CreateOptions extends Partial<Options> {
     args?: ParsedCLIArgs;
 }
 export declare const createOptions: (options: CreateOptions) => Promise<{
     cacheLocation: string;
-    catalog: import("../CatalogCounselor.js").CatalogContainer;
+    catalog: import("../CatalogCounselor.ts").CatalogContainer;
     config: string | undefined;
     configFilePath: string | undefined;
     cwd: string;
     dependencies: boolean;
-    experimentalTags: import("../types/options.js").Tags;
+    experimentalTags: import("../types/options.ts").Tags;
     exports: boolean;
     files: boolean;
     fixTypes: string[];
     gitignore: boolean;
-    includedIssueTypes: import("../types/issues.js").Report;
+    includedIssueTypes: import("../types/issues.ts").Report;
     isCache: boolean;
     isDebug: boolean;
     isDisableConfigHints: boolean;
@@ -395,6 +395,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'openapi-ts'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         oxlint?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -405,6 +410,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        payload?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         playwright?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -455,6 +465,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        qwik?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         'react-cosmos'?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1071,6 +1086,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
                 entry?: string | string[] | undefined;
                 project?: string | string[] | undefined;
             } | undefined;
+            'openapi-ts'?: string | boolean | string[] | {
+                config?: string | string[] | undefined;
+                entry?: string | string[] | undefined;
+                project?: string | string[] | undefined;
+            } | undefined;
             oxlint?: string | boolean | string[] | {
                 config?: string | string[] | undefined;
                 entry?: string | string[] | undefined;
@@ -1081,6 +1101,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
                 entry?: string | string[] | undefined;
                 project?: string | string[] | undefined;
             } | undefined;
+            payload?: string | boolean | string[] | {
+                config?: string | string[] | undefined;
+                entry?: string | string[] | undefined;
+                project?: string | string[] | undefined;
+            } | undefined;
             playwright?: string | boolean | string[] | {
                 config?: string | string[] | undefined;
                 entry?: string | string[] | undefined;
@@ -1131,6 +1156,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
                 entry?: string | string[] | undefined;
                 project?: string | string[] | undefined;
             } | undefined;
+            qwik?: string | boolean | string[] | {
+                config?: string | string[] | undefined;
+                entry?: string | string[] | undefined;
+                project?: string | string[] | undefined;
+            } | undefined;
             'react-cosmos'?: string | boolean | string[] | {
                 config?: string | string[] | undefined;
                 entry?: string | string[] | undefined;
@@ -1431,24 +1461,24 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
         treatConfigHintsAsErrors?: boolean | undefined;
     };
     rules: {
-        files: import("../types/issues.js").IssueSeverity;
-        dependencies: import("../types/issues.js").IssueSeverity;
-        devDependencies: import("../types/issues.js").IssueSeverity;
-        optionalPeerDependencies: import("../types/issues.js").IssueSeverity;
-        unlisted: import("../types/issues.js").IssueSeverity;
-        binaries: import("../types/issues.js").IssueSeverity;
-        unresolved: import("../types/issues.js").IssueSeverity;
-        exports: import("../types/issues.js").IssueSeverity;
-        nsExports: import("../types/issues.js").IssueSeverity;
-        types: import("../types/issues.js").IssueSeverity;
-        nsTypes: import("../types/issues.js").IssueSeverity;
-        enumMembers: import("../types/issues.js").IssueSeverity;
-        classMembers: import("../types/issues.js").IssueSeverity;
-        duplicates: import("../types/issues.js").IssueSeverity;
-        catalog: import("../types/issues.js").IssueSeverity;
-        _files: import("../types/issues.js").IssueSeverity;
+        files: import("../types/issues.ts").IssueSeverity;
+        dependencies: import("../types/issues.ts").IssueSeverity;
+        devDependencies: import("../types/issues.ts").IssueSeverity;
+        optionalPeerDependencies: import("../types/issues.ts").IssueSeverity;
+        unlisted: import("../types/issues.ts").IssueSeverity;
+        binaries: import("../types/issues.ts").IssueSeverity;
+        unresolved: import("../types/issues.ts").IssueSeverity;
+        exports: import("../types/issues.ts").IssueSeverity;
+        nsExports: import("../types/issues.ts").IssueSeverity;
+        types: import("../types/issues.ts").IssueSeverity;
+        nsTypes: import("../types/issues.ts").IssueSeverity;
+        enumMembers: import("../types/issues.ts").IssueSeverity;
+        classMembers: import("../types/issues.ts").IssueSeverity;
+        duplicates: import("../types/issues.ts").IssueSeverity;
+        catalog: import("../types/issues.ts").IssueSeverity;
+        _files: import("../types/issues.ts").IssueSeverity;
     };
-    tags: import("../types/options.js").Tags;
+    tags: import("../types/options.ts").Tags;
     traceDependency: string | undefined;
     traceExport: string | undefined;
     traceFile: string | undefined;

package/dist/util/create-options.js

@@ -1,16 +1,16 @@
-import { partitionCompilers } from '../compilers/index.js';
-import { KNIP_CONFIG_LOCATIONS } from '../constants.js';
-import { knipConfigurationSchema } from '../schema/configuration.js';
-import { getCatalogContainer } from './catalog.js';
-import { ConfigurationError } from './errors.js';
-import { findFile, loadJSON } from './fs.js';
-import { getIncludedIssueTypes, shorthandDeps, shorthandExports, shorthandFiles } from './get-included-issue-types.js';
-import { defaultRules } from './issue-initializers.js';
-import { loadResolvedConfigFile } from './load-config.js';
-import { _load } from './loader.js';
-import { getKeysByValue } from './object.js';
-import { isAbsolute, join, normalize, toAbsolute, toPosix } from './path.js';
-import { splitTags } from './tag.js';
+import { partitionCompilers } from "../compilers/index.js";
+import { KNIP_CONFIG_LOCATIONS } from "../constants.js";
+import { knipConfigurationSchema } from "../schema/configuration.js";
+import { getCatalogContainer } from "./catalog.js";
+import { ConfigurationError } from "./errors.js";
+import { findFile, loadJSON } from "./fs.js";
+import { getIncludedIssueTypes, shorthandDeps, shorthandExports, shorthandFiles } from "./get-included-issue-types.js";
+import { defaultRules } from "./issue-initializers.js";
+import { loadResolvedConfigFile } from "./load-config.js";
+import { _load } from "./loader.js";
+import { getKeysByValue } from "./object.js";
+import { isAbsolute, join, normalize, toAbsolute, toPosix } from "./path.js";
+import { splitTags } from "./tag.js";
 export const createOptions = async (options) => {
     const { args = {} } = options;
     const pcwd = process.cwd();

package/dist/util/create-workspace-graph.d.ts

@@ -1,3 +1,3 @@
-import type { WorkspacePackage } from '../types/package-json.js';
+import type { WorkspacePackage } from '../types/package-json.ts';
 export type WorkspaceGraph = Map<string, Set<string>>;
 export declare function createWorkspaceGraph(cwd: string, wsNames: string[], wsPkgNames: Set<string>, wsPackages: Map<string, WorkspacePackage>): WorkspaceGraph;

package/dist/util/create-workspace-graph.js

@@ -1,4 +1,4 @@
-import { join } from './path.js';
+import { join } from "./path.js";
 const types = ['peerDependencies', 'devDependencies', 'optionalDependencies', 'dependencies'];
 export function createWorkspaceGraph(cwd, wsNames, wsPkgNames, wsPackages) {
     const graph = new Map();

package/dist/util/file-entry-cache.js

@@ -1,10 +1,10 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { deserialize, serialize } from 'node:v8';
-import { debugLog } from './debug.js';
-import { isDirectory, isFile } from './fs.js';
-import { timerify } from './Performance.js';
-import { dirname, isAbsolute, resolve } from './path.js';
+import { debugLog } from "./debug.js";
+import { isDirectory, isFile } from "./fs.js";
+import { timerify } from "./Performance.js";
+import { dirname, isAbsolute, resolve } from "./path.js";
 const createCache = (filePath) => {
     try {
         return deserialize(fs.readFileSync(filePath));

package/dist/util/fs.d.ts

@@ -5,7 +5,7 @@ export declare const loadFile: (filePath: string) => Promise<string>;
 export declare const hasFileWithExtension: (cwd: string, dirName: string, extensions: string[]) => boolean;
 export declare const loadJSON: (filePath: string) => Promise<any>;
 export declare const loadJSONC: (filePath: string) => Promise<any>;
-export declare const loadYAML: (filePath: string) => Promise<unknown>;
+export declare const loadYAML: (filePath: string) => Promise<any>;
 export declare const loadTOML: (filePath: string) => Promise<import("smol-toml").TomlTable>;
 export declare const parseJSONC: (filePath: string, contents: string) => Promise<any>;
-export declare const parseYAML: (contents: string) => unknown;
+export declare const parseYAML: (contents: string) => any;

package/dist/util/fs.js

@@ -1,10 +1,10 @@
 import { readdirSync, statSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
-import yaml from 'js-yaml';
+import { parse as parseYAMLContents } from 'yaml';
 import { parse as parseTOML } from 'smol-toml';
 import stripJsonComments from 'strip-json-comments';
-import { LoaderError } from './errors.js';
-import { extname, join } from './path.js';
+import { LoaderError } from "./errors.js";
+import { extname, join } from "./path.js";
 export const isDirectory = (cwdOrPath, name) => {
     try {
         return statSync(name ? join(cwdOrPath, name) : cwdOrPath).isDirectory();
@@ -77,5 +77,5 @@ export const parseJSONC = async (filePath, contents) => {
     }
 };
 export const parseYAML = (contents) => {
-    return yaml.load(contents);
+    return parseYAMLContents(contents, { logLevel: 'error' });
 };

package/dist/util/get-included-issue-types.d.ts

@@ -1,4 +1,4 @@
-import type { Report } from '../types/issues.js';
+import type { Report } from '../types/issues.ts';
 type GetIncludedIssueTypesOptions = {
     isProduction?: boolean;
     include: string[];

package/dist/util/get-included-issue-types.js

@@ -1,5 +1,5 @@
-import { ISSUE_TYPES } from '../constants.js';
-import { ConfigurationError } from './errors.js';
+import { ISSUE_TYPES } from "../constants.js";
+import { ConfigurationError } from "./errors.js";
 export const defaultExcludedIssueTypes = ['classMembers', 'nsExports', 'nsTypes'];
 const defaultIssueTypes = ISSUE_TYPES.filter(type => !defaultExcludedIssueTypes.includes(type));
 const normalize = (values) => values.flatMap(value => value.split(','));

package/dist/util/git.js

@@ -1,5 +1,5 @@
 import { execSync } from 'node:child_process';
-import { join } from './path.js';
+import { join } from "./path.js";
 const hookFileNames = [
     'prepare-commit-msg',
     'commit-msg',

package/dist/util/glob-core.d.ts

@@ -9,11 +9,11 @@ interface GlobOptions extends FastGlobOptions {
     dir: string;
     label?: string;
 }
-export declare const findAndParseGitignores: (cwd: string) => Promise<{
+export declare const findAndParseGitignores: (cwd: string, workspaceDirs?: Set<string>) => Promise<{
     gitignoreFiles: string[];
     ignores: Set<string>;
     unignores: string[];
 }>;
 export declare function glob(_patterns: string[], options: GlobOptions): Promise<string[]>;
-export declare function getGitIgnoredHandler(options: Options): Promise<(path: string) => boolean>;
+export declare function getGitIgnoredHandler(options: Options, workspaceDirs?: Set<string>): Promise<(path: string) => boolean>;
 export {};

package/dist/util/glob-core.js

@@ -3,13 +3,13 @@ import { promisify } from 'node:util';
 import { walk as _walk } from '@nodelib/fs.walk';
 import fg, {} from 'fast-glob';
 import picomatch from 'picomatch';
-import { GLOBAL_IGNORE_PATTERNS } from '../constants.js';
-import { compact, partition } from './array.js';
-import { debugLogObject } from './debug.js';
-import { isDirectory, isFile } from './fs.js';
-import { timerify } from './Performance.js';
-import { parseAndConvertGitignorePatterns } from './parse-and-convert-gitignores.js';
-import { dirname, join, relative, toPosix } from './path.js';
+import { GLOBAL_IGNORE_PATTERNS } from "../constants.js";
+import { compact, partition } from "./array.js";
+import { debugLogObject } from "./debug.js";
+import { isDirectory, isFile } from "./fs.js";
+import { timerify } from "./Performance.js";
+import { parseAndConvertGitignorePatterns } from "./parse-and-convert-gitignores.js";
+import { dirname, join, relative, toPosix } from "./path.js";
 const walk = promisify(_walk);
 const _picomatch = timerify(picomatch);
 const cachedGitIgnores = new Map();
@@ -45,27 +45,23 @@ const findAncestorGitignoreFiles = (cwd) => {
     }
     return gitignorePaths;
 };
-export const findAndParseGitignores = async (cwd) => {
-    const init = ['.git', ...GLOBAL_IGNORE_PATTERNS];
-    const ignores = new Set(init);
+export const findAndParseGitignores = async (cwd, workspaceDirs) => {
+    const ignores = new Set(GLOBAL_IGNORE_PATTERNS);
     const unignores = [];
     const gitignoreFiles = [];
     const pmOptions = { ignore: unignores };
-    const matchers = new Set(init.map(pattern => _picomatch(pattern, pmOptions)));
-    const matcher = (str) => {
-        for (const isMatch of matchers) {
-            const state = isMatch(str);
-            if (state)
-                return state;
-        }
-        return false;
+    let deepFilterMatcher;
+    const getMatcher = () => {
+        if (!deepFilterMatcher)
+            deepFilterMatcher = _picomatch(Array.from(ignores), pmOptions);
+        return deepFilterMatcher;
     };
     const addFile = (filePath, baseDir) => {
         gitignoreFiles.push(relative(cwd, filePath));
         const dir = baseDir ?? dirname(toPosix(filePath));
         const base = relative(cwd, dir);
         const ancestor = base.startsWith('..') ? `${relative(dir, cwd)}/` : undefined;
-        const ignoresForDir = new Set(base === '' ? init : []);
+        const ignoresForDir = new Set(base === '' ? GLOBAL_IGNORE_PATTERNS : []);
         const unignoresForDir = new Set();
         const patterns = readFileSync(filePath, 'utf8');
         for (const rule of parseAndConvertGitignorePatterns(patterns, ancestor)) {
@@ -116,8 +112,7 @@ export const findAndParseGitignores = async (cwd) => {
         else {
             cachedGitIgnores.set(cacheDir, { ignores: ignoresForDir, unignores: unignoresForDir });
         }
-        for (const pattern of ignoresForDir)
-            matchers.add(_picomatch(pattern, pmOptions));
+        deepFilterMatcher = undefined;
     };
     for (const filePath of findAncestorGitignoreFiles(cwd))
         addFile(filePath);
@@ -127,6 +122,33 @@ export const findAndParseGitignores = async (cwd) => {
         if (isFile(excludePath))
             addFile(excludePath, cwd);
     }
+    let isRelevantDir;
+    if (workspaceDirs && workspaceDirs.size > 0) {
+        const relevantAncestors = new Set();
+        const nonRootDirs = new Set();
+        for (const wsDir of workspaceDirs) {
+            if (wsDir !== cwd)
+                nonRootDirs.add(wsDir);
+            let dir = wsDir;
+            while (dir.length >= cwd.length) {
+                relevantAncestors.add(dir);
+                const parent = dirname(dir);
+                if (parent === dir)
+                    break;
+                dir = parent;
+            }
+        }
+        if (nonRootDirs.size > 0) {
+            isRelevantDir = (absPath) => {
+                if (relevantAncestors.has(absPath))
+                    return true;
+                for (const wsDir of nonRootDirs)
+                    if (absPath.startsWith(`${wsDir}/`))
+                        return true;
+                return false;
+            };
+        }
+    }
     const entryFilter = (entry) => {
         if (entry.dirent.isFile() && entry.name === '.gitignore') {
             addFile(entry.path);
@@ -134,8 +156,9 @@ export const findAndParseGitignores = async (cwd) => {
         }
         return false;
     };
-    const deepFilter = (entry) => !matcher(relative(cwd, entry.path));
+    const deepFilter = (entry) => (!isRelevantDir || isRelevantDir(toPosix(entry.path))) && !getMatcher()(relative(cwd, entry.path));
     await walk(cwd, {
+        concurrency: 16,
         entryFilter: timerify(entryFilter),
         deepFilter: timerify(deepFilter),
     });
@@ -149,26 +172,21 @@ export async function glob(_patterns, options) {
     const hasCache = cachedGlobIgnores.has(options.dir);
     const willCache = !hasCache && options.gitignore && options.label;
     const cachedIgnores = options.gitignore ? cachedGlobIgnores.get(options.dir) : undefined;
-    const _ignore = [];
+    const _ignore = [...GLOBAL_IGNORE_PATTERNS];
     const [negatedPatterns, patterns] = partition(_patterns, pattern => pattern.startsWith('!'));
-    if (options.gitignore) {
-        if (willCache) {
-            let dir = options.dir;
-            let prev;
-            while (dir) {
-                const cacheForDir = cachedGitIgnores.get(dir);
-                if (cacheForDir) {
-                    _ignore.push(...cacheForDir.ignores);
-                }
-                dir = dirname((prev = dir));
-                if (prev === dir || dir === '.')
-                    break;
+    if (options.gitignore && willCache) {
+        let dir = options.dir;
+        let prev;
+        while (dir) {
+            const cacheForDir = cachedGitIgnores.get(dir);
+            if (cacheForDir) {
+                _ignore.push(...cacheForDir.ignores);
             }
+            dir = dirname((prev = dir));
+            if (prev === dir || dir === '.')
+                break;
         }
     }
-    else {
-        _ignore.push(...GLOBAL_IGNORE_PATTERNS);
-    }
     if (willCache)
         cachedGlobIgnores.set(options.dir, compact(_ignore));
     const ignorePatterns = (cachedIgnores || _ignore).concat(negatedPatterns.map(pattern => pattern.slice(1)));
@@ -184,11 +202,11 @@ export async function glob(_patterns, options) {
     }));
     return paths;
 }
-export async function getGitIgnoredHandler(options) {
+export async function getGitIgnoredHandler(options, workspaceDirs) {
     cachedGitIgnores.clear();
     if (options.gitignore === false)
         return () => false;
-    const { ignores, unignores } = await _parseFindGitignores(options.cwd);
+    const { ignores, unignores } = await _parseFindGitignores(options.cwd, workspaceDirs);
     const matcher = _picomatch(Array.from(ignores), { ignore: unignores });
     const isGitIgnored = (filePath) => matcher(relative(options.cwd, filePath));
     return timerify(isGitIgnored);

package/dist/util/glob.js

@@ -1,8 +1,8 @@
 import fg from 'fast-glob';
-import { compact } from './array.js';
-import { glob } from './glob-core.js';
-import { timerify } from './Performance.js';
-import { isAbsolute, join, relative } from './path.js';
+import { compact } from "./array.js";
+import { glob } from "./glob-core.js";
+import { timerify } from "./Performance.js";
+import { isAbsolute, join, relative } from "./path.js";
 const prepend = (pattern, relativePath) => isAbsolute(pattern.replace(/^!/, '')) ? pattern : prependDirToPattern(relativePath, pattern);
 const prependDirToPatterns = (cwd, dir, patterns) => {
     const relativePath = relative(cwd, dir);

package/dist/util/input.d.ts

@@ -1,5 +1,5 @@
-import type { IssueType } from '../types/issues.js';
-import type { PluginName } from '../types/PluginNames.js';
+import type { IssueType } from '../types/issues.ts';
+import type { PluginName } from '../types/PluginNames.ts';
 type InputType = 'binary' | 'entry' | 'project' | 'config' | 'dependency' | 'deferResolve' | 'deferResolveEntry' | 'alias' | 'ignore';
 export interface Input {
     type: InputType;

package/dist/util/input.js

@@ -1,4 +1,4 @@
-import { isAbsolute, toRelative } from './path.js';
+import { isAbsolute, toRelative } from "./path.js";
 export const fromBinary = (input) => input.specifier;
 export const toBinary = (specifier, options = {}) => ({
     type: 'binary',

package/dist/util/issue-initializers.d.ts

@@ -1,4 +1,4 @@
-import type { Counters, Issues, Rules } from '../types/issues.js';
+import type { Counters, Issues, Rules } from '../types/issues.ts';
 export declare const initIssues: () => Issues;
 export declare const initCounters: () => Counters;
 export declare const defaultRules: Rules;

package/dist/util/issue-initializers.js

@@ -1,4 +1,4 @@
-import { ISSUE_TYPES } from '../constants.js';
+import { ISSUE_TYPES } from "../constants.js";
 export const initIssues = () => ({
     ...Object.fromEntries(ISSUE_TYPES.map(issueType => [issueType, {}])),
     files: new Set(),

package/dist/util/jiti.js

@@ -1,6 +1,6 @@
 import { fileURLToPath } from 'node:url';
 import { createJiti } from 'jiti';
-import { join } from './path.js';
+import { join } from "./path.js";
 const empty = join(fileURLToPath(import.meta.url), '../empty.js');
 const options = {
     alias: {

package/dist/util/load-config.d.ts

@@ -1,2 +1,2 @@
-import type { ParsedCLIArgs } from './cli-arguments.js';
+import type { ParsedCLIArgs } from './cli-arguments.ts';
 export declare function loadResolvedConfigFile(configPath: string, options: ParsedCLIArgs): Promise<any>;

package/dist/util/load-config.js

@@ -1,6 +1,6 @@
-import { debugLogObject } from './debug.js';
-import { ConfigurationError } from './errors.js';
-import { _load } from './loader.js';
+import { debugLogObject } from "./debug.js";
+import { ConfigurationError } from "./errors.js";
+import { _load } from "./loader.js";
 const unwrapFunction = async (maybeFunction, options) => {
     if (typeof maybeFunction === 'function') {
         try {

package/dist/util/load-tsconfig.js

@@ -1,6 +1,6 @@
 import ts from 'typescript';
-import { isFile } from './fs.js';
-import { dirname } from './path.js';
+import { isFile } from "./fs.js";
+import { dirname } from "./path.js";
 export const loadTSConfig = async (tsConfigFilePath) => {
     if (isFile(tsConfigFilePath)) {
         const config = ts.readConfigFile(tsConfigFilePath, ts.sys.readFile);