knip 6.4.1 → 6.5.0

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.js

@@ -3,8 +3,8 @@ import { readFile } from 'node:fs/promises';
 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, toPosix } from "./path.js";
+import { LoaderError } from './errors.js';
+import { extname, join, toPosix } from './path.js';
 export const isDirectory = (cwdOrPath, name) => {
     try {
         return statSync(name ? join(cwdOrPath, name) : cwdOrPath).isDirectory();

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 = ['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-cache.js

@@ -2,10 +2,10 @@ import { createHash } from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { deserialize, serialize } from 'node:v8';
-import { version } from "../version.js";
-import { debugLog } from "./debug.js";
-import { isDirectory, isFile } from "./fs.js";
-import { dirname } from "./path.js";
+import { version } from '../version.js';
+import { debugLog } from './debug.js';
+import { isDirectory, isFile } from './fs.js';
+import { dirname } from './path.js';
 const CACHE_FILENAME = `glob-${version}.cache`;
 let cacheFilePath;
 let cache;

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

@@ -1,9 +1,9 @@
-import { type Options as FastGlobOptions } from 'fast-glob';
+import { type GlobOptions as TinyGlobOptions } from 'tinyglobby';
 type Options = {
     gitignore: boolean;
     cwd: string;
 };
-interface GlobOptions extends FastGlobOptions {
+interface GlobOptions extends TinyGlobOptions {
     gitignore: boolean;
     cwd: string;
     dir: string;
@@ -12,7 +12,7 @@ interface GlobOptions extends FastGlobOptions {
 export declare const findAndParseGitignores: (cwd: string, workspaceDirs?: Set<string>) => Promise<{
     gitignoreFiles: string[];
     ignores: Set<string>;
-    unignores: string[];
+    unignores: Set<string>;
 }>;
 export declare function glob(_patterns: string[], options: GlobOptions): Promise<string[]>;
 export declare function getGitIgnoredHandler(options: Options, workspaceDirs?: Set<string>): Promise<(path: string) => boolean>;

package/dist/util/glob-core.js

@@ -1,15 +1,15 @@
 import { readFileSync } from 'node:fs';
 import { promisify } from 'node:util';
 import { walk as _walk } from '@nodelib/fs.walk';
-import fg, {} from 'fast-glob';
+import { glob as tinyGlob } from 'tinyglobby';
 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 { expandIgnorePatterns, parseAndConvertGitignorePatterns } from './parse-and-convert-gitignores.js';
+import { dirname, join, relative, toPosix } from './path.js';
 const walk = promisify(_walk);
 const cachedGitIgnores = new Map();
 const cachedGlobIgnores = new Map();
@@ -46,20 +46,21 @@ const findAncestorGitignoreFiles = (cwd) => {
 };
 export const findAndParseGitignores = async (cwd, workspaceDirs) => {
     const ignores = new Set(GLOBAL_IGNORE_PATTERNS);
-    const unignores = [];
+    const unignores = new Set();
     const gitignoreFiles = [];
-    const pmOptions = { ignore: unignores };
     let deepFilterMatcher;
-    let prevUnignoreLength = unignores.length;
+    let prevUnignoreSize = unignores.size;
+    let unignoresArray = [];
     const pendingIgnores = [];
     const getMatcher = () => {
         if (!deepFilterMatcher) {
-            deepFilterMatcher = picomatch(Array.from(ignores), pmOptions);
+            unignoresArray = Array.from(unignores);
+            deepFilterMatcher = picomatch(Array.from(ignores), { ignore: unignoresArray });
             pendingIgnores.length = 0;
         }
         else if (pendingIgnores.length > 0) {
             const prev = deepFilterMatcher;
-            const incr = picomatch(pendingIgnores.splice(0), pmOptions);
+            const incr = picomatch(pendingIgnores.splice(0), { ignore: unignoresArray });
             deepFilterMatcher = (path) => prev(path) || incr(path);
         }
         return deepFilterMatcher;
@@ -73,41 +74,29 @@ export const findAndParseGitignores = async (cwd, workspaceDirs) => {
         const unignoresForDir = new Set();
         const prevIgnoreSize = ignores.size;
         const patterns = readFileSync(filePath, 'utf8');
-        for (const rule of parseAndConvertGitignorePatterns(patterns, ancestor)) {
-            const [pattern, extraPattern] = rule.patterns;
-            if (rule.negated) {
-                if (base === '' || base.startsWith('..')) {
-                    if (!unignores.includes(extraPattern)) {
-                        unignores.push(...rule.patterns);
+        const isRoot = base === '' || base.startsWith('..');
+        for (const { negated, pattern } of parseAndConvertGitignorePatterns(patterns, ancestor)) {
+            if (negated) {
+                if (isRoot) {
+                    if (!unignores.has(pattern)) {
+                        unignores.add(pattern);
                         unignoresForDir.add(pattern);
-                        unignoresForDir.add(extraPattern);
                     }
                 }
-                else {
-                    if (!unignores.includes(extraPattern.startsWith('**/') ? extraPattern : `**/${extraPattern}`)) {
-                        const unignore = join(base, pattern);
-                        const extraUnignore = join(base, extraPattern);
-                        unignores.push(unignore, extraUnignore);
-                        unignoresForDir.add(unignore);
-                        unignoresForDir.add(extraUnignore);
-                    }
+                else if (!unignores.has(pattern)) {
+                    const unignore = join(base, pattern);
+                    unignores.add(unignore);
+                    unignoresForDir.add(unignore);
                 }
             }
-            else {
-                if (base === '' || base.startsWith('..')) {
-                    ignores.add(pattern);
-                    ignores.add(extraPattern);
-                    ignoresForDir.add(pattern);
-                    ignoresForDir.add(extraPattern);
-                }
-                else if (!unignores.includes(extraPattern.startsWith('**/') ? extraPattern : `**/${extraPattern}`)) {
-                    const ignore = join(base, pattern);
-                    const extraIgnore = join(base, extraPattern);
-                    ignores.add(ignore);
-                    ignores.add(extraIgnore);
-                    ignoresForDir.add(ignore);
-                    ignoresForDir.add(extraIgnore);
-                }
+            else if (isRoot) {
+                ignores.add(pattern);
+                ignoresForDir.add(pattern);
+            }
+            else if (!unignores.has(pattern)) {
+                const ignore = join(base, pattern);
+                ignores.add(ignore);
+                ignoresForDir.add(ignore);
             }
         }
         const cacheDir = ancestor ? cwd : dir;
@@ -121,9 +110,9 @@ export const findAndParseGitignores = async (cwd, workspaceDirs) => {
         else {
             cachedGitIgnores.set(cacheDir, { ignores: ignoresForDir, unignores: unignoresForDir });
         }
-        if (unignores.length !== prevUnignoreLength) {
+        if (unignores.size !== prevUnignoreSize) {
             deepFilterMatcher = undefined;
-            prevUnignoreLength = unignores.length;
+            prevUnignoreSize = unignores.size;
         }
         else if (ignores.size !== prevIgnoreSize) {
             for (const p of ignoresForDir)
@@ -179,6 +168,30 @@ export const findAndParseGitignores = async (cwd, workspaceDirs) => {
         entryFilter,
         deepFilter,
     });
+    if (unignores.size > 0) {
+        const unignorePaths = new Set();
+        for (const u of unignores) {
+            let p = u.replace(/^\*\*\//, '');
+            while (p && p !== '.' && p !== '/') {
+                unignorePaths.add(p);
+                const parent = dirname(p);
+                if (parent === p)
+                    break;
+                p = parent;
+            }
+        }
+        for (const cacheForDir of cachedGitIgnores.values()) {
+            for (const pattern of cacheForDir.ignores) {
+                const match = picomatch(pattern);
+                for (const p of unignorePaths) {
+                    if (match(p)) {
+                        cacheForDir.ignores.delete(pattern);
+                        break;
+                    }
+                }
+            }
+        }
+    }
     debugLogObject('*', 'Parsed gitignore files', { gitignoreFiles });
     return { gitignoreFiles, ignores, unignores };
 };
@@ -196,9 +209,8 @@ export async function glob(_patterns, options) {
         let prev;
         while (dir) {
             const cacheForDir = cachedGitIgnores.get(dir);
-            if (cacheForDir) {
+            if (cacheForDir)
                 _ignore.push(...cacheForDir.ignores);
-            }
             dir = dirname((prev = dir));
             if (prev === dir || dir === '.')
                 break;
@@ -207,8 +219,8 @@ export async function glob(_patterns, options) {
     if (willCache)
         cachedGlobIgnores.set(options.dir, compact(_ignore));
     const ignorePatterns = (cachedIgnores || _ignore).concat(negatedPatterns.map(pattern => pattern.slice(1)));
-    const { dir, label, ...fgOptions } = { ...options, ignore: ignorePatterns };
-    const paths = await fg.glob(patterns, fgOptions);
+    const { dir, label, ...fgOptions } = { ...options, ignore: ignorePatterns, expandDirectories: false };
+    const paths = await tinyGlob(patterns, fgOptions);
     debugLogObject(relative(options.cwd, dir), label ? `Finding ${label}` : 'Finding paths', () => ({
         patterns,
         ...fgOptions,
@@ -224,7 +236,7 @@ export async function getGitIgnoredHandler(options, workspaceDirs) {
     if (options.gitignore === false)
         return () => false;
     const { ignores, unignores } = await _parseFindGitignores(options.cwd, workspaceDirs);
-    const matcher = picomatch(Array.from(ignores), { ignore: unignores });
+    const matcher = picomatch(expandIgnorePatterns(ignores), { ignore: expandIgnorePatterns(unignores) });
     const cache = new Map();
     const isGitIgnored = (filePath) => {
         let result = cache.get(filePath);

package/dist/util/glob.d.ts

@@ -13,7 +13,7 @@ export declare const hasProductionSuffix: (pattern: string) => boolean;
 export declare const hasNoProductionSuffix: (pattern: string) => boolean;
 export declare const _glob: ({ cwd, dir, patterns, gitignore, label }: GlobOptions) => Promise<string[]>;
 export declare const _syncGlob: ({ cwd, patterns }: {
-    cwd?: string;
+    cwd: string;
     patterns: string | string[];
 }) => string[];
 export declare const _dirGlob: ({ cwd, patterns, gitignore }: GlobOptions) => Promise<string[]>;

package/dist/util/glob.js

@@ -1,9 +1,9 @@
-import fg from 'fast-glob';
-import { compact } from "./array.js";
-import { computeGlobCacheKey, getCachedGlob, isGlobCacheEnabled, setCachedGlob } from "./glob-cache.js";
-import { glob } from "./glob-core.js";
-import { timerify } from "./Performance.js";
-import { isAbsolute, join, relative } from "./path.js";
+import { globSync } from 'tinyglobby';
+import { compact } from './array.js';
+import { computeGlobCacheKey, getCachedGlob, isGlobCacheEnabled, setCachedGlob } from './glob-cache.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);
@@ -44,7 +44,14 @@ const defaultGlob = async ({ cwd, dir = cwd, patterns, gitignore = true, label }
         setCachedGlob(cacheKey, paths, dir);
     return paths;
 };
-const syncGlob = ({ cwd, patterns }) => fg.sync(patterns, { cwd, followSymbolicLinks: false });
+const syncGlob = ({ cwd, patterns }) => {
+    return globSync(patterns, {
+        cwd,
+        absolute: true,
+        followSymbolicLinks: false,
+        expandDirectories: false,
+    });
+};
 const dirGlob = async ({ cwd, patterns, gitignore = true }) => glob(patterns, {
     cwd,
     dir: cwd,

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.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, {}]));
 export const initCounters = () => ({
     ...Object.fromEntries(ISSUE_TYPES.map(issueType => [issueType, 0])),

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.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,9 +1,7 @@
-import { readFileSync } from 'node:fs';
 import { parseTsconfig } from 'get-tsconfig';
-import stripJsonComments from 'strip-json-comments';
-import { isFile as _isFile } from "./fs.js";
-import { _syncGlob } from "./glob.js";
-import { dirname, isAbsolute, join, toAbsolute } from "./path.js";
+import { isFile } from './fs.js';
+import { _syncGlob } from './glob.js';
+import { dirname, isAbsolute, join, toAbsolute } from './path.js';
 const hasGlobChar = (p) => p.includes('*') || p.includes('?');
 const hasExtension = (p) => {
     const last = p.lastIndexOf('/');
@@ -47,56 +45,70 @@ const expandFileNames = (dir, compilerOptions, include, exclude, files) => {
     }
     return result;
 };
-const findRootDirsBase = (tsConfigFilePath) => {
-    try {
-        const raw = JSON.parse(stripJsonComments(readFileSync(tsConfigFilePath, 'utf8')));
-        if (raw.compilerOptions?.rootDirs)
-            return dirname(tsConfigFilePath);
-        if (raw.extends) {
-            const extPath = join(dirname(tsConfigFilePath), raw.extends);
-            return findRootDirsBase(extPath);
-        }
-    }
-    catch { }
-    return undefined;
+const resolveReference = (refPath, dir) => {
+    const abs = isAbsolute(refPath) ? refPath : join(dir, refPath);
+    if (isFile(abs))
+        return abs;
+    const withTsconfig = join(abs, 'tsconfig.json');
+    return isFile(withTsconfig) ? withTsconfig : undefined;
 };
-const resolveConfig = (tsConfigFilePath) => {
-    try {
-        return parseTsconfig(tsConfigFilePath);
-    }
-    catch {
-        try {
-            const raw = readFileSync(tsConfigFilePath, 'utf8');
-            return JSON.parse(stripJsonComments(raw));
-        }
-        catch {
-            return undefined;
-        }
+const fillFromReferences = (target, references, dir, visited) => {
+    if (!references?.length)
+        return;
+    for (const ref of references) {
+        if (target.outDir && target.rootDir)
+            return;
+        const refPath = resolveReference(ref.path, dir);
+        if (!refPath || visited.has(refPath))
+            continue;
+        visited.add(refPath);
+        const refConfig = parseTsconfig(refPath);
+        const refDir = dirname(refPath);
+        const refOpts = refConfig.compilerOptions;
+        if (refOpts?.outDir && !target.outDir)
+            target.outDir = toAbsolute(refOpts.outDir, refDir).replace(/\/+$/, '');
+        if (refOpts?.rootDir && !target.rootDir)
+            target.rootDir = toAbsolute(refOpts.rootDir, refDir).replace(/\/+$/, '');
+        if (!refOpts?.outDir || !refOpts?.rootDir)
+            fillFromReferences(target, refConfig.references, refDir, visited);
     }
 };
 export const loadTSConfig = async (tsConfigFilePath) => {
-    if (_isFile(tsConfigFilePath)) {
-        const config = resolveConfig(tsConfigFilePath);
-        if (!config)
-            return { isFile: true, compilerOptions: {}, fileNames: [] };
-        const dir = dirname(tsConfigFilePath);
-        const compilerOptions = (config.compilerOptions ?? {});
-        if (compilerOptions.outDir)
-            compilerOptions.outDir = toAbsolute(compilerOptions.outDir, dir).replace(/\/+$/, '');
-        if (compilerOptions.rootDir)
-            compilerOptions.rootDir = toAbsolute(compilerOptions.rootDir, dir).replace(/\/+$/, '');
-        if (compilerOptions.paths) {
-            compilerOptions.pathsBasePath ??= dir;
+    if (isFile(tsConfigFilePath)) {
+        try {
+            const config = parseTsconfig(tsConfigFilePath);
+            const dir = dirname(tsConfigFilePath);
+            const compilerOptions = (config.compilerOptions ?? {});
+            if (compilerOptions.outDir)
+                compilerOptions.outDir = toAbsolute(compilerOptions.outDir, dir).replace(/\/+$/, '');
+            if (compilerOptions.rootDir)
+                compilerOptions.rootDir = toAbsolute(compilerOptions.rootDir, dir).replace(/\/+$/, '');
+            if (compilerOptions.paths) {
+                compilerOptions.pathsBasePath ??= dir;
+            }
+            if (compilerOptions.rootDirs) {
+                compilerOptions.rootDirs = compilerOptions.rootDirs.map((d) => (isAbsolute(d) ? d : join(dir, d)));
+            }
+            if ((!compilerOptions.outDir || !compilerOptions.rootDir) && config.references?.length) {
+                fillFromReferences(compilerOptions, config.references, dir, new Set([tsConfigFilePath]));
+            }
+            const include = resolvePatterns(config.include, dir, true);
+            const exclude = resolvePatterns(config.exclude, dir, true);
+            const files = resolvePatterns(config.files, dir);
+            const fileNames = expandFileNames(dir, compilerOptions, include, exclude, files);
+            return { isFile: true, compilerOptions, fileNames };
         }
-        if (compilerOptions.rootDirs) {
-            const rootDirsBase = findRootDirsBase(tsConfigFilePath) ?? dir;
-            compilerOptions.rootDirs = compilerOptions.rootDirs.map((d) => isAbsolute(d) ? d : join(rootDirsBase, d));
+        catch {
+            return {
+                isFile: true,
+                compilerOptions: {},
+                fileNames: [],
+            };
         }
-        const include = resolvePatterns(config.include, dir, true);
-        const exclude = resolvePatterns(config.exclude, dir, true);
-        const files = resolvePatterns(config.files, dir);
-        const fileNames = expandFileNames(dir, compilerOptions, include, exclude, files);
-        return { isFile: true, compilerOptions, fileNames };
     }
-    return { isFile: false, compilerOptions: {}, fileNames: [] };
+    return {
+        isFile: false,
+        compilerOptions: {},
+        fileNames: [],
+    };
 };

package/dist/util/loader.js

@@ -6,11 +6,11 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
-import { LoaderError } from "./errors.js";
-import { loadFile, loadJSON, loadJSONC, loadTOML, loadYAML, parseJSONC, parseYAML } from "./fs.js";
-import { jiti } from "./jiti.js";
-import { timerify } from "./Performance.js";
-import { extname, isInternal } from "./path.js";
+import { LoaderError } from './errors.js';
+import { loadFile, loadJSON, loadJSONC, loadTOML, loadYAML, parseJSONC, parseYAML } from './fs.js';
+import { jiti } from './jiti.js';
+import { timerify } from './Performance.js';
+import { extname, isInternal } from './path.js';
 const load = async (filePath) => {
     try {
         const ext = extname(filePath);

package/dist/util/map-workspaces.js

@@ -1,9 +1,9 @@
 import { readFile } from 'node:fs/promises';
-import fg from 'fast-glob';
-import { partition } from "./array.js";
-import { ConfigurationError } from "./errors.js";
-import { getPackageName } from "./package-name.js";
-import { join } from "./path.js";
+import { glob } from 'tinyglobby';
+import { partition } from './array.js';
+import { ConfigurationError } from './errors.js';
+import { getPackageName } from './package-name.js';
+import { join } from './path.js';
 export default async function mapWorkspaces(cwd, workspaces) {
     const [negatedPatterns, patterns] = partition(workspaces, p => p.match(/^!/));
     const packages = new Map();
@@ -11,7 +11,7 @@ export default async function mapWorkspaces(cwd, workspaces) {
     if (patterns.length === 0 && negatedPatterns.length === 0)
         return [packages, wsPkgNames];
     const manifestPatterns = patterns.map(p => join(p, 'package.json'));
-    const matches = await fg.glob(manifestPatterns, {
+    const matches = await glob(manifestPatterns, {
         cwd,
         ignore: ['**/node_modules/**', ...negatedPatterns.map(p => p.slice(1))],
     });

package/dist/util/modules.js

@@ -1,5 +1,5 @@
-import { DT_SCOPE, PROTOCOL_VIRTUAL } from "../constants.js";
-import { isAbsolute, isInNodeModules, toPosix } from "./path.js";
+import { DT_SCOPE, PROTOCOL_VIRTUAL } from '../constants.js';
+import { isAbsolute, isInNodeModules, toPosix } from './path.js';
 export const getPackageNameFromModuleSpecifier = (specifier) => {
     if (!isStartsLikePackageName(specifier))
         return;

package/dist/util/package-name.js

@@ -1,4 +1,4 @@
-import { basename, dirname } from "./path.js";
+import { basename, dirname } from './path.js';
 const getPkgName = (parent, base) => (parent.charAt(0) === '@' ? `${parent}/${base}` : base);
 const getName = (dir) => (dir ? getPkgName(basename(dirname(dir)), basename(dir)) : undefined);
 export function getPackageName(pkg, pathname) {

package/dist/util/parse-and-convert-gitignores.d.ts

@@ -1,8 +1,10 @@
+export declare const toExtendedIgnorePattern: (pattern: string) => string;
+export declare const expandIgnorePatterns: (patterns: Iterable<string>) => string[];
 export declare const convertGitignoreToPicomatchIgnorePatterns: (pattern: string) => {
     negated: boolean;
-    patterns: string[];
+    pattern: string;
 };
 export declare const parseAndConvertGitignorePatterns: (patterns: string, ancestor?: string) => {
     negated: boolean;
-    patterns: string[];
+    pattern: string;
 }[];

package/dist/util/parse-and-convert-gitignores.js

@@ -1,23 +1,35 @@
+export const toExtendedIgnorePattern = (pattern) => {
+    if (pattern === '*' || pattern === '**')
+        return pattern;
+    if (pattern.endsWith('/*'))
+        return pattern;
+    return `${pattern}/**`;
+};
+export const expandIgnorePatterns = (patterns) => {
+    const result = [];
+    for (const p of patterns) {
+        result.push(p);
+        const ext = toExtendedIgnorePattern(p);
+        if (ext !== p)
+            result.push(ext);
+    }
+    return result;
+};
 export const convertGitignoreToPicomatchIgnorePatterns = (pattern) => {
     const negated = pattern[0] === '!';
     if (negated)
         pattern = pattern.slice(1);
-    let extPattern;
     if (pattern.endsWith('/'))
         pattern = pattern.slice(0, -1);
     if (pattern.startsWith('*/**/'))
         pattern = pattern.slice(5);
     if (pattern === '*' || pattern === '**')
-        return { negated, patterns: [pattern, pattern] };
+        return { negated, pattern };
     if (pattern.startsWith('/'))
         pattern = pattern.slice(1);
     else if (!pattern.startsWith('**/'))
         pattern = `**/${pattern}`;
-    if (pattern.endsWith('/*'))
-        extPattern = pattern;
-    else
-        extPattern = `${pattern}/**`;
-    return { negated, patterns: [pattern, extPattern] };
+    return { negated, pattern };
 };
 export const parseAndConvertGitignorePatterns = (patterns, ancestor) => {
     const matchFrom = ancestor ? new RegExp(`^(!?/?)(${ancestor})`) : undefined;

package/dist/util/plugin.js

@@ -1,8 +1,8 @@
-export { _load as load } from "./loader.js";
-import { arrayify } from "./array.js";
-import { _load as load } from "./loader.js";
-import { get } from "./object.js";
-import { basename } from "./path.js";
+export { _load as load } from './loader.js';
+import { arrayify } from './array.js';
+import { _load as load } from './loader.js';
+import { get } from './object.js';
+import { basename } from './path.js';
 export const hasDependency = (dependencies, values) => values.some(value => {
     if (typeof value === 'string') {
         return dependencies.has(value);

package/dist/util/remove-export.js

@@ -1,4 +1,4 @@
-import { FIX_FLAGS } from "../constants.js";
+import { FIX_FLAGS } from '../constants.js';
 const getOpeningBracketIndex = (text) => {
     let bracketOpenIndex = -1;
     let j = text.length - 1;

package/dist/util/reporter.js

@@ -1,6 +1,6 @@
-import internalReporters from "../reporters/index.js";
-import { _load } from "./loader.js";
-import { isAbsolute, isInternal, resolve } from "./path.js";
+import internalReporters from '../reporters/index.js';
+import { _load } from './loader.js';
+import { isAbsolute, isInternal, resolve } from './path.js';
 export const runPreprocessors = async (processors, data) => {
     const preprocessors = await Promise.all(processors.map(proc => _load(isInternal(proc) && !isAbsolute(proc) ? resolve(proc) : proc)));
     return preprocessors.length === 0

package/dist/util/require.js

@@ -1,4 +1,4 @@
 import { createRequire } from 'node:module';
-import { timerify } from "./Performance.js";
+import { timerify } from './Performance.js';
 const require = createRequire(process.cwd());
 export const _require = timerify(require);