fast-glob-fast 0.2.0

package/out/index.d.ts

@@ -0,0 +1,49 @@
+import * as taskManager from './managers/tasks';
+import type { Options as OptionsInternal } from './settings';
+import type { Entry as EntryInternal, FileSystemAdapter as FileSystemAdapterInternal, Pattern as PatternInternal } from './types';
+type InputPattern = PatternInternal | readonly PatternInternal[];
+type EntryObjectModePredicate = {
+    [TKey in keyof Pick<OptionsInternal, 'objectMode'>]-?: true;
+};
+type EntryStatsPredicate = {
+    [TKey in keyof Pick<OptionsInternal, 'stats'>]-?: true;
+};
+type EntryObjectPredicate = EntryObjectModePredicate | EntryStatsPredicate;
+export type Options = OptionsInternal;
+export type Entry = EntryInternal;
+export type Task = taskManager.Task;
+export type Pattern = PatternInternal;
+export type FileSystemAdapter = FileSystemAdapterInternal;
+export declare function glob(source: InputPattern, options: EntryObjectPredicate & OptionsInternal): Promise<EntryInternal[]>;
+export declare function glob(source: InputPattern, options?: OptionsInternal): Promise<string[]>;
+/**
+ * @deprecated
+ * This method will be removed in v5, use the `.glob` method instead.
+ */
+export declare const async: typeof glob;
+export declare function globSync(source: InputPattern, options: EntryObjectPredicate & OptionsInternal): EntryInternal[];
+export declare function globSync(source: InputPattern, options?: OptionsInternal): string[];
+/**
+ * @deprecated
+ * This method will be removed in v5, use the `.globSync` method instead.
+ */
+export declare const sync: typeof globSync;
+export declare function globStream(source: InputPattern, options?: OptionsInternal): NodeJS.ReadableStream;
+/**
+ * @deprecated
+ * This method will be removed in v5, use the `.globStream` method instead.
+ */
+export declare const stream: typeof globStream;
+export declare function generateTasks(source: InputPattern, options?: OptionsInternal): Task[];
+export declare function isDynamicPattern(source: PatternInternal, options?: OptionsInternal): boolean;
+export declare const escapePath: (source: string) => string;
+export declare const convertPathToPattern: (source: string) => string;
+export declare const posix: {
+    escapePath: (source: string) => string;
+    convertPathToPattern: (source: string) => string;
+};
+export declare const win32: {
+    escapePath: (source: string) => string;
+    convertPathToPattern: (source: string) => string;
+};
+export {};

package/out/index.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.win32 = exports.posix = exports.convertPathToPattern = exports.escapePath = exports.stream = exports.sync = exports.async = void 0;
+exports.glob = glob;
+exports.globSync = globSync;
+exports.globStream = globStream;
+exports.generateTasks = generateTasks;
+exports.isDynamicPattern = isDynamicPattern;
+const taskManager = require("./managers/tasks");
+const settings_1 = require("./settings");
+const utils = require("./utils");
+const providers_1 = require("./providers");
+const readers_1 = require("./readers");
+async function glob(source, options) {
+    assertPatternsInput(source);
+    const settings = new settings_1.default(options);
+    const reader = new readers_1.ReaderAsync(settings);
+    const provider = new providers_1.ProviderAsync(reader, settings);
+    const tasks = getTasks(source, settings);
+    const promises = tasks.map((task) => provider.read(task));
+    const result = await Promise.all(promises);
+    return utils.array.flatFirstLevel(result);
+}
+/**
+ * @deprecated
+ * This method will be removed in v5, use the `.glob` method instead.
+ */
+exports.async = glob;
+function globSync(source, options) {
+    assertPatternsInput(source);
+    const settings = new settings_1.default(options);
+    const reader = new readers_1.ReaderSync(settings);
+    const provider = new providers_1.ProviderSync(reader, settings);
+    const tasks = getTasks(source, settings);
+    const entries = tasks.map((task) => provider.read(task));
+    return utils.array.flatFirstLevel(entries);
+}
+/**
+ * @deprecated
+ * This method will be removed in v5, use the `.globSync` method instead.
+ */
+exports.sync = globSync;
+function globStream(source, options) {
+    assertPatternsInput(source);
+    const settings = new settings_1.default(options);
+    const reader = new readers_1.ReaderStream(settings);
+    const provider = new providers_1.ProviderStream(reader, settings);
+    const tasks = getTasks(source, settings);
+    const streams = tasks.map((task) => provider.read(task));
+    /**
+     * The stream returned by the provider cannot work with an asynchronous iterator.
+     * To support asynchronous iterators, regardless of the number of tasks, we always multiplex streams.
+     * This affects performance (+25%). I don't see best solution right now.
+     */
+    return utils.stream.merge(streams);
+}
+/**
+ * @deprecated
+ * This method will be removed in v5, use the `.globStream` method instead.
+ */
+exports.stream = globStream;
+function generateTasks(source, options) {
+    assertPatternsInput(source);
+    const patterns = [].concat(source);
+    const settings = new settings_1.default(options);
+    return taskManager.generate(patterns, settings);
+}
+function isDynamicPattern(source, options) {
+    assertPatternsInput(source);
+    const settings = new settings_1.default(options);
+    return utils.pattern.isDynamicPattern(source, settings);
+}
+exports.escapePath = withPatternsInputAssert(utils.path.escape);
+exports.convertPathToPattern = withPatternsInputAssert(utils.path.convertPathToPattern);
+exports.posix = {
+    escapePath: withPatternsInputAssert(utils.path.escapePosixPath),
+    convertPathToPattern: withPatternsInputAssert(utils.path.convertPosixPathToPattern),
+};
+exports.win32 = {
+    escapePath: withPatternsInputAssert(utils.path.escapeWindowsPath),
+    convertPathToPattern: withPatternsInputAssert(utils.path.convertWindowsPathToPattern),
+};
+function getTasks(source, settings) {
+    const patterns = [].concat(source);
+    return taskManager.generate(patterns, settings);
+}
+function assertPatternsInput(input) {
+    const source = [].concat(input);
+    const isValidSource = source.every((item) => utils.string.isString(item) && !utils.string.isEmpty(item));
+    if (!isValidSource) {
+        throw new TypeError('Patterns must be a string (non empty) or an array of strings');
+    }
+}
+function withPatternsInputAssert(method) {
+    return (source) => {
+        assertPatternsInput(source);
+        return method(source);
+    };
+}

package/out/managers/tasks.d.ts

@@ -0,0 +1,22 @@
+import type Settings from '../settings';
+import type { Pattern, PatternsGroup } from '../types';
+export interface Task {
+    base: string;
+    dynamic: boolean;
+    patterns: Pattern[];
+    positive: Pattern[];
+    negative: Pattern[];
+}
+export declare function generate(input: readonly Pattern[], settings: Settings): Task[];
+/**
+ * Returns tasks grouped by basic pattern directories.
+ *
+ * Patterns that can be found inside (`./`) and outside (`../`) the current directory are handled separately.
+ * This is necessary because directory traversal starts at the base directory and goes deeper.
+ */
+export declare function convertPatternsToTasks(positive: Pattern[], negative: Pattern[], dynamic: boolean): Task[];
+export declare function getPositivePatterns(patterns: Pattern[]): Pattern[];
+export declare function getNegativePatternsAsPositive(patterns: Pattern[], ignore: Pattern[]): Pattern[];
+export declare function groupPatternsByBaseDirectory(patterns: Pattern[]): PatternsGroup;
+export declare function convertPatternGroupsToTasks(positive: PatternsGroup, negative: Pattern[], dynamic: boolean): Task[];
+export declare function convertPatternGroupToTask(base: string, positive: Pattern[], negative: Pattern[], dynamic: boolean): Task;

package/out/managers/tasks.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generate = generate;
+exports.convertPatternsToTasks = convertPatternsToTasks;
+exports.getPositivePatterns = getPositivePatterns;
+exports.getNegativePatternsAsPositive = getNegativePatternsAsPositive;
+exports.groupPatternsByBaseDirectory = groupPatternsByBaseDirectory;
+exports.convertPatternGroupsToTasks = convertPatternGroupsToTasks;
+exports.convertPatternGroupToTask = convertPatternGroupToTask;
+const utils = require("../utils");
+function generate(input, settings) {
+    const patterns = processPatterns([...input], settings);
+    const ignore = processPatterns([...settings.ignore], settings);
+    const positivePatterns = getPositivePatterns(patterns);
+    const negativePatterns = getNegativePatternsAsPositive(patterns, ignore);
+    const staticPatterns = positivePatterns.filter((pattern) => utils.pattern.isStaticPattern(pattern, settings));
+    const dynamicPatterns = positivePatterns.filter((pattern) => utils.pattern.isDynamicPattern(pattern, settings));
+    const staticTasks = convertPatternsToTasks(staticPatterns, negativePatterns, /* dynamic */ false);
+    const dynamicTasks = convertPatternsToTasks(dynamicPatterns, negativePatterns, /* dynamic */ true);
+    return staticTasks.concat(dynamicTasks);
+}
+function processPatterns(input, settings) {
+    let patterns = input;
+    /**
+     * The original pattern like `{,*,**,a/*}` can lead to problems checking the depth when matching entry
+     * and some problems with the micromatch package (see fast-glob issues: #365, #394).
+     *
+     * To solve this problem, we expand all patterns containing brace expansion. This can lead to a slight slowdown
+     * in matching in the case of a large set of patterns after expansion.
+     */
+    if (settings.braceExpansion) {
+        patterns = utils.pattern.expandPatternsWithBraceExpansion(patterns);
+    }
+    /**
+     * If the `baseNameMatch` option is enabled, we must add globstar to patterns, so that they can be used
+     * at any nesting level.
+     *
+     * We do this here, because otherwise we have to complicate the filtering logic. For example, we need to change
+     * the pattern in the filter before creating a regular expression. There is no need to change the patterns
+     * in the application. Only on the input.
+     */
+    if (settings.baseNameMatch) {
+        patterns = patterns.map((pattern) => pattern.includes('/') ? pattern : `**/${pattern}`);
+    }
+    /**
+     * This method also removes duplicate slashes that may have been in the pattern or formed as a result of expansion.
+     */
+    return patterns.map((pattern) => utils.pattern.removeDuplicateSlashes(pattern));
+}
+/**
+ * Returns tasks grouped by basic pattern directories.
+ *
+ * Patterns that can be found inside (`./`) and outside (`../`) the current directory are handled separately.
+ * This is necessary because directory traversal starts at the base directory and goes deeper.
+ */
+function convertPatternsToTasks(positive, negative, dynamic) {
+    const tasks = [];
+    const patternsOutsideCurrentDirectory = utils.pattern.getPatternsOutsideCurrentDirectory(positive);
+    const patternsInsideCurrentDirectory = utils.pattern.getPatternsInsideCurrentDirectory(positive);
+    const outsideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsOutsideCurrentDirectory);
+    const insideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsInsideCurrentDirectory);
+    tasks.push(...convertPatternGroupsToTasks(outsideCurrentDirectoryGroup, negative, dynamic));
+    /*
+     * For the sake of reducing future accesses to the file system, we merge all tasks within the current directory
+     * into a global task, if at least one pattern refers to the root (`.`). In this case, the global task covers the rest.
+     */
+    if ('.' in insideCurrentDirectoryGroup) {
+        tasks.push(convertPatternGroupToTask('.', patternsInsideCurrentDirectory, negative, dynamic));
+    }
+    else {
+        tasks.push(...convertPatternGroupsToTasks(insideCurrentDirectoryGroup, negative, dynamic));
+    }
+    return tasks;
+}
+function getPositivePatterns(patterns) {
+    return utils.pattern.getPositivePatterns(patterns);
+}
+function getNegativePatternsAsPositive(patterns, ignore) {
+    const negative = utils.pattern.getNegativePatterns(patterns).concat(ignore);
+    const positive = negative.map((pattern) => utils.pattern.convertToPositivePattern(pattern));
+    return positive;
+}
+function groupPatternsByBaseDirectory(patterns) {
+    const group = {};
+    return patterns.reduce((collection, pattern) => {
+        let base = utils.pattern.getBaseDirectory(pattern);
+        /**
+         * After extracting the basic static part of the pattern, it becomes a path,
+         * so escaping leads to referencing non-existent paths.
+         */
+        base = utils.path.removeBackslashes(base);
+        if (base in collection) {
+            collection[base].push(pattern);
+        }
+        else {
+            collection[base] = [pattern];
+        }
+        return collection;
+    }, group);
+}
+function convertPatternGroupsToTasks(positive, negative, dynamic) {
+    return Object.keys(positive).map((base) => {
+        return convertPatternGroupToTask(base, positive[base], negative, dynamic);
+    });
+}
+function convertPatternGroupToTask(base, positive, negative, dynamic) {
+    return {
+        dynamic,
+        positive,
+        negative,
+        base,
+        patterns: [].concat(positive, negative.map((pattern) => utils.pattern.convertToNegativePattern(pattern))),
+    };
+}

package/out/providers/async.d.ts

@@ -0,0 +1,11 @@
+import { Provider } from './provider';
+import type { IReaderAsync } from '../readers';
+import type Settings from '../settings';
+import type { Task } from '../managers/tasks';
+import type { Entry, EntryItem, ReaderOptions } from '../types';
+export declare class ProviderAsync extends Provider<Promise<EntryItem[]>> {
+    #private;
+    constructor(reader: IReaderAsync, settings: Settings);
+    read(task: Task): Promise<EntryItem[]>;
+    api(root: string, task: Task, options: ReaderOptions): Promise<Entry[]>;
+}

package/out/providers/async.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderAsync = void 0;
+const provider_1 = require("./provider");
+class ProviderAsync extends provider_1.Provider {
+    #reader;
+    constructor(reader, settings) {
+        super(settings);
+        this.#reader = reader;
+    }
+    async read(task) {
+        const root = this._getRootDirectory(task);
+        const options = this._getReaderOptions(task);
+        const entries = await this.api(root, task, options);
+        return entries.map((entry) => options.transform(entry));
+    }
+    api(root, task, options) {
+        if (task.dynamic) {
+            return this.#reader.dynamic(root, options);
+        }
+        return this.#reader.static(task.patterns, options);
+    }
+}
+exports.ProviderAsync = ProviderAsync;

package/out/providers/filters/deep.d.ts

@@ -0,0 +1,7 @@
+import type { MicromatchOptions, EntryFilterFunction, Pattern } from '../../types';
+import type Settings from '../../settings';
+export default class DeepFilter {
+    #private;
+    constructor(settings: Settings, micromatchOptions: MicromatchOptions);
+    getFilter(basePath: string, positive: Pattern[], negative: Pattern[]): EntryFilterFunction;
+}

package/out/providers/filters/deep.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils = require("../../utils");
+const partial_1 = require("../matchers/partial");
+class DeepFilter {
+    #settings;
+    #micromatchOptions;
+    constructor(settings, micromatchOptions) {
+        this.#settings = settings;
+        this.#micromatchOptions = micromatchOptions;
+    }
+    getFilter(basePath, positive, negative) {
+        const matcher = this.#getMatcher(positive);
+        const negativeRe = this.#getNegativePatternsRe(negative);
+        return (entry) => this.#filter(basePath, entry, matcher, negativeRe);
+    }
+    #getMatcher(patterns) {
+        return new partial_1.default(patterns, this.#settings, this.#micromatchOptions);
+    }
+    #getNegativePatternsRe(patterns) {
+        const affectDepthOfReadingPatterns = patterns.filter((pattern) => utils.pattern.isAffectDepthOfReadingPattern(pattern));
+        return utils.pattern.convertPatternsToRe(affectDepthOfReadingPatterns, this.#micromatchOptions);
+    }
+    #filter(basePath, entry, matcher, negativeRe) {
+        if (this.#isSkippedByDeep(basePath, entry.path)) {
+            return false;
+        }
+        if (this.#isSkippedSymbolicLink(entry)) {
+            return false;
+        }
+        const filepath = utils.path.removeLeadingDotSegment(entry.path);
+        if (this.#isSkippedByPositivePatterns(filepath, matcher)) {
+            return false;
+        }
+        return this.#isSkippedByNegativePatterns(filepath, negativeRe);
+    }
+    #isSkippedByDeep(basePath, entryPath) {
+        /**
+         * Avoid unnecessary depth calculations when it doesn't matter.
+         */
+        if (this.#settings.deep === Number.POSITIVE_INFINITY) {
+            return false;
+        }
+        return this.#getEntryLevel(basePath, entryPath) >= this.#settings.deep;
+    }
+    #getEntryLevel(basePath, entryPath) {
+        const entryPathDepth = entryPath.split('/').length;
+        if (basePath === '') {
+            return entryPathDepth;
+        }
+        const basePathDepth = basePath.split('/').length;
+        return entryPathDepth - basePathDepth;
+    }
+    #isSkippedSymbolicLink(entry) {
+        return !this.#settings.followSymbolicLinks && entry.dirent.isSymbolicLink();
+    }
+    #isSkippedByPositivePatterns(entryPath, matcher) {
+        return !this.#settings.baseNameMatch && !matcher.match(entryPath);
+    }
+    #isSkippedByNegativePatterns(entryPath, patternsRe) {
+        return !utils.pattern.matchAny(entryPath, patternsRe);
+    }
+}
+exports.default = DeepFilter;

package/out/providers/filters/entry.d.ts

@@ -0,0 +1,8 @@
+import type Settings from '../../settings';
+import type { MicromatchOptions, EntryFilterFunction, Pattern } from '../../types';
+export default class EntryFilter {
+    #private;
+    readonly index: Map<string, undefined>;
+    constructor(settings: Settings, micromatchOptions: MicromatchOptions);
+    getFilter(positive: Pattern[], negative: Pattern[]): EntryFilterFunction;
+}

package/out/providers/filters/entry.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils = require("../../utils");
+class EntryFilter {
+    index = new Map();
+    #settings;
+    #micromatchOptions;
+    constructor(settings, micromatchOptions) {
+        this.#settings = settings;
+        this.#micromatchOptions = micromatchOptions;
+    }
+    getFilter(positive, negative) {
+        const [absoluteNegative, relativeNegative] = utils.pattern.partitionAbsoluteAndRelative(negative);
+        const patterns = {
+            positive: {
+                all: utils.pattern.convertPatternsToRe(positive, this.#micromatchOptions),
+            },
+            negative: {
+                absolute: utils.pattern.convertPatternsToRe(absoluteNegative, { ...this.#micromatchOptions, dot: true }),
+                relative: utils.pattern.convertPatternsToRe(relativeNegative, { ...this.#micromatchOptions, dot: true }),
+            },
+        };
+        return (entry) => this.#filter(entry, patterns);
+    }
+    #filter(entry, pattens) {
+        const filepath = utils.path.removeLeadingDotSegment(entry.path);
+        if (this.#settings.unique && this.#isDuplicateEntry(filepath)) {
+            return false;
+        }
+        const isDirectory = entry.dirent.isDirectory();
+        if (this.#onlyFileFilter(isDirectory) || this.#onlyDirectoryFilter(isDirectory)) {
+            return false;
+        }
+        const isMatched = this.#isMatchToPatternsSet(filepath, pattens, isDirectory);
+        if (this.#settings.unique && isMatched) {
+            this.#createIndexRecord(filepath);
+        }
+        return isMatched;
+    }
+    #isDuplicateEntry(filepath) {
+        return this.index.has(filepath);
+    }
+    #createIndexRecord(filepath) {
+        this.index.set(filepath, undefined);
+    }
+    #onlyFileFilter(isDirectory) {
+        return this.#settings.onlyFiles && isDirectory;
+    }
+    #onlyDirectoryFilter(isDirectory) {
+        return this.#settings.onlyDirectories && !isDirectory;
+    }
+    #isMatchToPatternsSet(filepath, patterns, isDirectory) {
+        const isMatched = this.#isMatchToPatterns(filepath, patterns.positive.all, isDirectory);
+        if (!isMatched) {
+            return false;
+        }
+        const isMatchedByRelativeNegative = this.#isMatchToPatterns(filepath, patterns.negative.relative, isDirectory);
+        if (isMatchedByRelativeNegative) {
+            return false;
+        }
+        const isMatchedByAbsoluteNegative = this.#isMatchToAbsoluteNegative(filepath, patterns.negative.absolute, isDirectory);
+        if (isMatchedByAbsoluteNegative) {
+            return false;
+        }
+        return true;
+    }
+    #isMatchToAbsoluteNegative(filepath, patternsRe, isDirectory) {
+        if (patternsRe.length === 0) {
+            return false;
+        }
+        const fullpath = utils.path.makeAbsolute(this.#settings.cwd, filepath);
+        return this.#isMatchToPatterns(fullpath, patternsRe, isDirectory);
+    }
+    #isMatchToPatterns(filepath, patternsRe, isDirectory) {
+        if (patternsRe.length === 0) {
+            return false;
+        }
+        // Trying to match files and directories by patterns.
+        const isMatched = utils.pattern.matchAny(filepath, patternsRe);
+        // A pattern with a trailling slash can be used for directory matching.
+        // To apply such pattern, we need to add a tralling slash to the path.
+        if (!isMatched && isDirectory) {
+            return utils.pattern.matchAny(`${filepath}/`, patternsRe);
+        }
+        return isMatched;
+    }
+}
+exports.default = EntryFilter;

package/out/providers/filters/error.d.ts

@@ -0,0 +1,7 @@
+import type Settings from '../../settings';
+import type { ErrorFilterFunction } from '../../types';
+export default class ErrorFilter {
+    #private;
+    constructor(settings: Settings);
+    getFilter(): ErrorFilterFunction;
+}

package/out/providers/filters/error.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils = require("../../utils");
+class ErrorFilter {
+    #settings;
+    constructor(settings) {
+        this.#settings = settings;
+    }
+    getFilter() {
+        return (error) => this.#isNonFatalError(error);
+    }
+    #isNonFatalError(error) {
+        return utils.errno.isEnoentCodeError(error) || this.#settings.suppressErrors;
+    }
+}
+exports.default = ErrorFilter;

package/out/providers/index.d.ts

@@ -0,0 +1,3 @@
+export * from './async';
+export * from './stream';
+export * from './sync';

package/out/providers/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./async"), exports);
+__exportStar(require("./stream"), exports);
+__exportStar(require("./sync"), exports);

package/out/providers/matchers/matcher.d.ts

@@ -0,0 +1,28 @@
+import type { MicromatchOptions, Pattern, PatternRe } from '../../types';
+import type Settings from '../../settings';
+export type PatternSegment = DynamicPatternSegment | StaticPatternSegment;
+interface StaticPatternSegment {
+    dynamic: false;
+    pattern: Pattern;
+}
+interface DynamicPatternSegment {
+    dynamic: true;
+    pattern: Pattern;
+    patternRe: PatternRe;
+}
+export type PatternSection = PatternSegment[];
+export interface PatternInfo {
+    /**
+     * Indicates that the pattern has a globstar (more than a single section).
+     */
+    complete: boolean;
+    pattern: Pattern;
+    segments: PatternSegment[];
+    sections: PatternSection[];
+}
+export default abstract class Matcher {
+    #private;
+    protected readonly _storage: PatternInfo[];
+    constructor(patterns: Pattern[], settings: Settings, micromatchOptions: MicromatchOptions);
+}
+export {};

package/out/providers/matchers/matcher.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils = require("../../utils");
+class Matcher {
+    _storage = [];
+    #patterns;
+    #settings;
+    #micromatchOptions;
+    constructor(patterns, settings, micromatchOptions) {
+        this.#patterns = patterns;
+        this.#settings = settings;
+        this.#micromatchOptions = micromatchOptions;
+        this.#fillStorage();
+    }
+    #fillStorage() {
+        for (const pattern of this.#patterns) {
+            const segments = this.#getPatternSegments(pattern);
+            const sections = this.#splitSegmentsIntoSections(segments);
+            this._storage.push({
+                complete: sections.length <= 1,
+                pattern,
+                segments,
+                sections,
+            });
+        }
+    }
+    #getPatternSegments(pattern) {
+        const parts = utils.pattern.getPatternParts(pattern, this.#micromatchOptions);
+        return parts.map((part) => {
+            const dynamic = utils.pattern.isDynamicPattern(part, this.#settings);
+            if (!dynamic) {
+                return {
+                    dynamic: false,
+                    pattern: part,
+                };
+            }
+            return {
+                dynamic: true,
+                pattern: part,
+                patternRe: utils.pattern.makeRe(part, this.#micromatchOptions),
+            };
+        });
+    }
+    #splitSegmentsIntoSections(segments) {
+        return utils.array.splitWhen(segments, (segment) => segment.dynamic && utils.pattern.hasGlobStar(segment.pattern));
+    }
+}
+exports.default = Matcher;

package/out/providers/matchers/partial.d.ts

@@ -0,0 +1,4 @@
+import Matcher from './matcher';
+export default class PartialMatcher extends Matcher {
+    match(filepath: string): boolean;
+}

package/out/providers/matchers/partial.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const matcher_1 = require("./matcher");
+class PartialMatcher extends matcher_1.default {
+    match(filepath) {
+        const parts = filepath.split('/');
+        const levels = parts.length;
+        const patterns = this._storage.filter((info) => !info.complete || info.segments.length > levels);
+        for (const pattern of patterns) {
+            const section = pattern.sections[0];
+            /**
+             * In this case, the pattern has a globstar and we must read all directories unconditionally,
+             * but only if the level has reached the end of the first group.
+             *
+             * fixtures/{a,b}/**
+             *  ^ true/false  ^ always true
+            */
+            if (!pattern.complete && levels > section.length) {
+                return true;
+            }
+            const match = parts.every((part, index) => {
+                const segment = pattern.segments[index];
+                if (segment.dynamic && segment.patternRe.test(part)) {
+                    return true;
+                }
+                if (!segment.dynamic && segment.pattern === part) {
+                    return true;
+                }
+                return false;
+            });
+            if (match) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+exports.default = PartialMatcher;