Update checked-in dependencies

node_modules/fast-glob/out/index.d.ts

@@ -2,13 +2,13 @@
 import * as taskManager from './managers/tasks';
 import { Options as OptionsInternal } from './settings';
 import { Entry as EntryInternal, FileSystemAdapter as FileSystemAdapterInternal, Pattern as PatternInternal } from './types';
-declare type EntryObjectModePredicate = {
+type EntryObjectModePredicate = {
     [TKey in keyof Pick<OptionsInternal, 'objectMode'>]-?: true;
 };
-declare type EntryStatsPredicate = {
+type EntryStatsPredicate = {
     [TKey in keyof Pick<OptionsInternal, 'stats'>]-?: true;
 };
-declare type EntryObjectPredicate = EntryObjectModePredicate | EntryStatsPredicate;
+type EntryObjectPredicate = EntryObjectModePredicate | EntryStatsPredicate;
 declare function FastGlob(source: PatternInternal | PatternInternal[], options: OptionsInternal & EntryObjectPredicate): Promise<EntryInternal[]>;
 declare function FastGlob(source: PatternInternal | PatternInternal[], options?: OptionsInternal): Promise<string[]>;
 declare namespace FastGlob {
@@ -17,11 +17,24 @@ declare namespace FastGlob {
     type Task = taskManager.Task;
     type Pattern = PatternInternal;
     type FileSystemAdapter = FileSystemAdapterInternal;
+    const glob: typeof FastGlob;
+    const globSync: typeof sync;
+    const globStream: typeof stream;
+    const async: typeof FastGlob;
     function sync(source: PatternInternal | PatternInternal[], options: OptionsInternal & EntryObjectPredicate): EntryInternal[];
     function sync(source: PatternInternal | PatternInternal[], options?: OptionsInternal): string[];
     function stream(source: PatternInternal | PatternInternal[], options?: OptionsInternal): NodeJS.ReadableStream;
     function generateTasks(source: PatternInternal | PatternInternal[], options?: OptionsInternal): Task[];
     function isDynamicPattern(source: PatternInternal, options?: OptionsInternal): boolean;
-    function escapePath(source: PatternInternal): PatternInternal;
+    function escapePath(source: string): PatternInternal;
+    function convertPathToPattern(source: string): PatternInternal;
+    namespace posix {
+        function escapePath(source: string): PatternInternal;
+        function convertPathToPattern(source: string): PatternInternal;
+    }
+    namespace win32 {
+        function escapePath(source: string): PatternInternal;
+        function convertPathToPattern(source: string): PatternInternal;
+    }
 }
 export = FastGlob;

node_modules/fast-glob/out/index.js

@@ -1,6 +1,5 @@
 "use strict";
 const taskManager = require("./managers/tasks");
-const patternManager = require("./managers/patterns");
 const async_1 = require("./providers/async");
 const stream_1 = require("./providers/stream");
 const sync_1 = require("./providers/sync");
@@ -15,6 +14,10 @@ async function FastGlob(source, options) {
 // https://github.com/typescript-eslint/typescript-eslint/issues/60
 // eslint-disable-next-line no-redeclare
 (function (FastGlob) {
+    FastGlob.glob = FastGlob;
+    FastGlob.globSync = sync;
+    FastGlob.globStream = stream;
+    FastGlob.async = FastGlob;
     function sync(source, options) {
         assertPatternsInput(source);
         const works = getWorks(source, sync_1.default, options);
@@ -34,7 +37,7 @@ async function FastGlob(source, options) {
     FastGlob.stream = stream;
     function generateTasks(source, options) {
         assertPatternsInput(source);
-        const patterns = patternManager.transform([].concat(source));
+        const patterns = [].concat(source);
         const settings = new settings_1.default(options);
         return taskManager.generate(patterns, settings);
     }
@@ -50,9 +53,40 @@ async function FastGlob(source, options) {
         return utils.path.escape(source);
     }
     FastGlob.escapePath = escapePath;
+    function convertPathToPattern(source) {
+        assertPatternsInput(source);
+        return utils.path.convertPathToPattern(source);
+    }
+    FastGlob.convertPathToPattern = convertPathToPattern;
+    let posix;
+    (function (posix) {
+        function escapePath(source) {
+            assertPatternsInput(source);
+            return utils.path.escapePosixPath(source);
+        }
+        posix.escapePath = escapePath;
+        function convertPathToPattern(source) {
+            assertPatternsInput(source);
+            return utils.path.convertPosixPathToPattern(source);
+        }
+        posix.convertPathToPattern = convertPathToPattern;
+    })(posix = FastGlob.posix || (FastGlob.posix = {}));
+    let win32;
+    (function (win32) {
+        function escapePath(source) {
+            assertPatternsInput(source);
+            return utils.path.escapeWindowsPath(source);
+        }
+        win32.escapePath = escapePath;
+        function convertPathToPattern(source) {
+            assertPatternsInput(source);
+            return utils.path.convertWindowsPathToPattern(source);
+        }
+        win32.convertPathToPattern = convertPathToPattern;
+    })(win32 = FastGlob.win32 || (FastGlob.win32 = {}));
 })(FastGlob || (FastGlob = {}));
 function getWorks(source, _Provider, options) {
-    const patterns = patternManager.transform([].concat(source));
+    const patterns = [].concat(source);
     const settings = new settings_1.default(options);
     const tasks = taskManager.generate(patterns, settings);
     const provider = new _Provider(settings);

node_modules/fast-glob/out/managers/patterns.d.ts

@@ -1,6 +0,0 @@
-export declare function transform(patterns: string[]): string[];
-/**
- * This package only works with forward slashes as a path separator.
- * Because of this, we cannot use the standard `path.normalize` method, because on Windows platform it will use of backslashes.
- */
-export declare function removeDuplicateSlashes(pattern: string): string;

node_modules/fast-glob/out/managers/patterns.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.removeDuplicateSlashes = exports.transform = void 0;
-/**
- * Matches a sequence of two or more consecutive slashes, excluding the first two slashes at the beginning of the string.
- * The latter is due to the presence of the device path at the beginning of the UNC path.
- * @todo rewrite to negative lookbehind with the next major release.
- */
-const DOUBLE_SLASH_RE = /(?!^)\/{2,}/g;
-function transform(patterns) {
-    return patterns.map((pattern) => removeDuplicateSlashes(pattern));
-}
-exports.transform = transform;
-/**
- * This package only works with forward slashes as a path separator.
- * Because of this, we cannot use the standard `path.normalize` method, because on Windows platform it will use of backslashes.
- */
-function removeDuplicateSlashes(pattern) {
-    return pattern.replace(DOUBLE_SLASH_RE, '/');
-}
-exports.removeDuplicateSlashes = removeDuplicateSlashes;

node_modules/fast-glob/out/managers/tasks.d.ts

@@ -1,13 +1,13 @@
 import Settings from '../settings';
 import { Pattern, PatternsGroup } from '../types';
-export declare type Task = {
+export type Task = {
     base: string;
     dynamic: boolean;
     patterns: Pattern[];
     positive: Pattern[];
     negative: Pattern[];
 };
-export declare function generate(patterns: Pattern[], settings: Settings): Task[];
+export declare function generate(input: Pattern[], settings: Settings): Task[];
 /**
  * Returns tasks grouped by basic pattern directories.
  *

node_modules/fast-glob/out/managers/tasks.js

@@ -2,9 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertPatternGroupToTask = exports.convertPatternGroupsToTasks = exports.groupPatternsByBaseDirectory = exports.getNegativePatternsAsPositive = exports.getPositivePatterns = exports.convertPatternsToTasks = exports.generate = void 0;
 const utils = require("../utils");
-function generate(patterns, settings) {
+function generate(input, settings) {
+    const patterns = processPatterns(input, settings);
+    const ignore = processPatterns(settings.ignore, settings);
     const positivePatterns = getPositivePatterns(patterns);
-    const negativePatterns = getNegativePatternsAsPositive(patterns, settings.ignore);
+    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);
@@ -12,6 +14,34 @@ function generate(patterns, settings) {
     return staticTasks.concat(dynamicTasks);
 }
 exports.generate = generate;
+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.
  *

node_modules/fast-glob/out/providers/async.d.ts

@@ -1,11 +1,9 @@
-/// <reference types="node" />
-import { Readable } from 'stream';
 import { Task } from '../managers/tasks';
-import ReaderStream from '../readers/stream';
-import { EntryItem, ReaderOptions } from '../types';
+import { Entry, EntryItem, ReaderOptions } from '../types';
+import ReaderAsync from '../readers/async';
 import Provider from './provider';
 export default class ProviderAsync extends Provider<Promise<EntryItem[]>> {
-    protected _reader: ReaderStream;
+    protected _reader: ReaderAsync;
     read(task: Task): Promise<EntryItem[]>;
-    api(root: string, task: Task, options: ReaderOptions): Readable;
+    api(root: string, task: Task, options: ReaderOptions): Promise<Entry[]>;
 }

node_modules/fast-glob/out/providers/async.js

@@ -1,22 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const stream_1 = require("../readers/stream");
+const async_1 = require("../readers/async");
 const provider_1 = require("./provider");
 class ProviderAsync extends provider_1.default {
     constructor() {
         super(...arguments);
-        this._reader = new stream_1.default(this._settings);
+        this._reader = new async_1.default(this._settings);
     }
-    read(task) {
+    async read(task) {
         const root = this._getRootDirectory(task);
         const options = this._getReaderOptions(task);
-        const entries = [];
-        return new Promise((resolve, reject) => {
-            const stream = this.api(root, task, options);
-            stream.once('error', reject);
-            stream.on('data', (entry) => entries.push(options.transform(entry)));
-            stream.once('end', () => resolve(entries));
-        });
+        const entries = await this.api(root, task, options);
+        return entries.map((entry) => options.transform(entry));
     }
     api(root, task, options) {
         if (task.dynamic) {

node_modules/fast-glob/out/providers/filters/entry.d.ts

@@ -12,9 +12,5 @@ export default class EntryFilter {
     private _onlyFileFilter;
     private _onlyDirectoryFilter;
     private _isSkippedByAbsoluteNegativePatterns;
-    /**
-     * First, just trying to apply patterns to the path.
-     * Second, trying to apply patterns to the path with final slash.
-     */
     private _isMatchToPatterns;
 }

node_modules/fast-glob/out/providers/filters/entry.js

@@ -9,31 +9,32 @@ class EntryFilter {
     }
     getFilter(positive, negative) {
         const positiveRe = utils.pattern.convertPatternsToRe(positive, this._micromatchOptions);
-        const negativeRe = utils.pattern.convertPatternsToRe(negative, this._micromatchOptions);
+        const negativeRe = utils.pattern.convertPatternsToRe(negative, Object.assign(Object.assign({}, this._micromatchOptions), { dot: true }));
         return (entry) => this._filter(entry, positiveRe, negativeRe);
     }
     _filter(entry, positiveRe, negativeRe) {
-        if (this._settings.unique && this._isDuplicateEntry(entry)) {
+        const filepath = utils.path.removeLeadingDotSegment(entry.path);
+        if (this._settings.unique && this._isDuplicateEntry(filepath)) {
             return false;
         }
         if (this._onlyFileFilter(entry) || this._onlyDirectoryFilter(entry)) {
             return false;
         }
-        if (this._isSkippedByAbsoluteNegativePatterns(entry.path, negativeRe)) {
+        if (this._isSkippedByAbsoluteNegativePatterns(filepath, negativeRe)) {
             return false;
         }
-        const filepath = this._settings.baseNameMatch ? entry.name : entry.path;
-        const isMatched = this._isMatchToPatterns(filepath, positiveRe) && !this._isMatchToPatterns(entry.path, negativeRe);
+        const isDirectory = entry.dirent.isDirectory();
+        const isMatched = this._isMatchToPatterns(filepath, positiveRe, isDirectory) && !this._isMatchToPatterns(filepath, negativeRe, isDirectory);
         if (this._settings.unique && isMatched) {
-            this._createIndexRecord(entry);
+            this._createIndexRecord(filepath);
         }
         return isMatched;
     }
-    _isDuplicateEntry(entry) {
-        return this.index.has(entry.path);
+    _isDuplicateEntry(filepath) {
+        return this.index.has(filepath);
     }
-    _createIndexRecord(entry) {
-        this.index.set(entry.path, undefined);
+    _createIndexRecord(filepath) {
+        this.index.set(filepath, undefined);
     }
     _onlyFileFilter(entry) {
         return this._settings.onlyFiles && !entry.dirent.isFile();
@@ -48,13 +49,15 @@ class EntryFilter {
         const fullpath = utils.path.makeAbsolute(this._settings.cwd, entryPath);
         return utils.pattern.matchAny(fullpath, patternsRe);
     }
-    /**
-     * First, just trying to apply patterns to the path.
-     * Second, trying to apply patterns to the path with final slash.
-     */
-    _isMatchToPatterns(entryPath, patternsRe) {
-        const filepath = utils.path.removeLeadingDotSegment(entryPath);
-        return utils.pattern.matchAny(filepath, patternsRe) || utils.pattern.matchAny(filepath + '/', patternsRe);
+    _isMatchToPatterns(filepath, patternsRe, isDirectory) {
+        // 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;

node_modules/fast-glob/out/providers/matchers/matcher.d.ts

@@ -1,17 +1,17 @@
 import { Pattern, MicromatchOptions, PatternRe } from '../../types';
 import Settings from '../../settings';
-export declare type PatternSegment = StaticPatternSegment | DynamicPatternSegment;
-declare type StaticPatternSegment = {
+export type PatternSegment = StaticPatternSegment | DynamicPatternSegment;
+type StaticPatternSegment = {
     dynamic: false;
     pattern: Pattern;
 };
-declare type DynamicPatternSegment = {
+type DynamicPatternSegment = {
     dynamic: true;
     pattern: Pattern;
     patternRe: PatternRe;
 };
-export declare type PatternSection = PatternSegment[];
-export declare type PatternInfo = {
+export type PatternSection = PatternSegment[];
+export type PatternInfo = {
     /**
      * Indicates that the pattern has a globstar (more than a single section).
      */

node_modules/fast-glob/out/providers/matchers/matcher.js

@@ -10,12 +10,7 @@ class Matcher {
         this._fillStorage();
     }
     _fillStorage() {
-        /**
-         * The original pattern may include `{,*,**,a/*}`, which will lead to problems with matching (unresolved level).
-         * So, before expand patterns with brace expansion into separated patterns.
-         */
-        const patterns = utils.pattern.expandPatternsWithBraceExpansion(this._patterns);
-        for (const pattern of patterns) {
+        for (const pattern of this._patterns) {
             const segments = this._getPatternSegments(pattern);
             const sections = this._splitSegmentsIntoSections(segments);
             this._storage.push({

node_modules/fast-glob/out/readers/async.d.ts

@@ -0,0 +1,10 @@
+import * as fsWalk from '@nodelib/fs.walk';
+import { Entry, ReaderOptions, Pattern } from '../types';
+import Reader from './reader';
+import ReaderStream from './stream';
+export default class ReaderAsync extends Reader<Promise<Entry[]>> {
+    protected _walkAsync: typeof fsWalk.walk;
+    protected _readerStream: ReaderStream;
+    dynamic(root: string, options: ReaderOptions): Promise<Entry[]>;
+    static(patterns: Pattern[], options: ReaderOptions): Promise<Entry[]>;
+}

node_modules/fast-glob/out/readers/async.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fsWalk = require("@nodelib/fs.walk");
+const reader_1 = require("./reader");
+const stream_1 = require("./stream");
+class ReaderAsync extends reader_1.default {
+    constructor() {
+        super(...arguments);
+        this._walkAsync = fsWalk.walk;
+        this._readerStream = new stream_1.default(this._settings);
+    }
+    dynamic(root, options) {
+        return new Promise((resolve, reject) => {
+            this._walkAsync(root, options, (error, entries) => {
+                if (error === null) {
+                    resolve(entries);
+                }
+                else {
+                    reject(error);
+                }
+            });
+        });
+    }
+    async static(patterns, options) {
+        const entries = [];
+        const stream = this._readerStream.static(patterns, options);
+        // After #235, replace it with an asynchronous iterator.
+        return new Promise((resolve, reject) => {
+            stream.once('error', reject);
+            stream.on('data', (entry) => entries.push(entry));
+            stream.once('end', () => resolve(entries));
+        });
+    }
+}
+exports.default = ReaderAsync;

node_modules/fast-glob/out/settings.d.ts

@@ -1,6 +1,6 @@
 import { FileSystemAdapter, Pattern } from './types';
 export declare const DEFAULT_FILE_SYSTEM_ADAPTER: FileSystemAdapter;
-export declare type Options = {
+export type Options = {
     /**
      * Return the absolute path for entries.
      *

node_modules/fast-glob/out/types/index.d.ts

@@ -1,12 +1,12 @@
 /// <reference types="node" />
 import * as fsWalk from '@nodelib/fs.walk';
-export declare type ErrnoException = NodeJS.ErrnoException;
-export declare type Entry = fsWalk.Entry;
-export declare type EntryItem = string | Entry;
-export declare type Pattern = string;
-export declare type PatternRe = RegExp;
-export declare type PatternsGroup = Record<string, Pattern[]>;
-export declare type ReaderOptions = fsWalk.Options & {
+export type ErrnoException = NodeJS.ErrnoException;
+export type Entry = fsWalk.Entry;
+export type EntryItem = string | Entry;
+export type Pattern = string;
+export type PatternRe = RegExp;
+export type PatternsGroup = Record<string, Pattern[]>;
+export type ReaderOptions = fsWalk.Options & {
     transform(entry: Entry): EntryItem;
     deepFilter: DeepFilterFunction;
     entryFilter: EntryFilterFunction;
@@ -14,11 +14,11 @@ export declare type ReaderOptions = fsWalk.Options & {
     fs: FileSystemAdapter;
     stats: boolean;
 };
-export declare type ErrorFilterFunction = fsWalk.ErrorFilterFunction;
-export declare type EntryFilterFunction = fsWalk.EntryFilterFunction;
-export declare type DeepFilterFunction = fsWalk.DeepFilterFunction;
-export declare type EntryTransformerFunction = (entry: Entry) => EntryItem;
-export declare type MicromatchOptions = {
+export type ErrorFilterFunction = fsWalk.ErrorFilterFunction;
+export type EntryFilterFunction = fsWalk.EntryFilterFunction;
+export type DeepFilterFunction = fsWalk.DeepFilterFunction;
+export type EntryTransformerFunction = (entry: Entry) => EntryItem;
+export type MicromatchOptions = {
     dot?: boolean;
     matchBase?: boolean;
     nobrace?: boolean;
@@ -28,4 +28,4 @@ export declare type MicromatchOptions = {
     posix?: boolean;
     strictSlashes?: boolean;
 };
-export declare type FileSystemAdapter = fsWalk.FileSystemAdapter;
+export type FileSystemAdapter = fsWalk.FileSystemAdapter;

node_modules/fast-glob/out/utils/path.d.ts

@@ -4,5 +4,10 @@ import { Pattern } from '../types';
  */
 export declare function unixify(filepath: string): string;
 export declare function makeAbsolute(cwd: string, filepath: string): string;
-export declare function escape(pattern: Pattern): Pattern;
 export declare function removeLeadingDotSegment(entry: string): string;
+export declare const escape: typeof escapeWindowsPath;
+export declare function escapeWindowsPath(pattern: Pattern): Pattern;
+export declare function escapePosixPath(pattern: Pattern): Pattern;
+export declare const convertPathToPattern: typeof convertWindowsPathToPattern;
+export declare function convertWindowsPathToPattern(filepath: string): Pattern;
+export declare function convertPosixPathToPattern(filepath: string): Pattern;

node_modules/fast-glob/out/utils/path.js

@@ -1,9 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.removeLeadingDotSegment = exports.escape = exports.makeAbsolute = exports.unixify = void 0;
+exports.convertPosixPathToPattern = exports.convertWindowsPathToPattern = exports.convertPathToPattern = exports.escapePosixPath = exports.escapeWindowsPath = exports.escape = exports.removeLeadingDotSegment = exports.makeAbsolute = exports.unixify = void 0;
+const os = require("os");
 const path = require("path");
+const IS_WINDOWS_PLATFORM = os.platform() === 'win32';
 const LEADING_DOT_SEGMENT_CHARACTERS_COUNT = 2; // ./ or .\\
-const UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()*?[\]{|}]|^!|[!+@](?=\())/g;
+/**
+ * All non-escaped special characters.
+ * Posix: ()*?[\]{|}, !+@ before (, ! at the beginning, \\ before non-special characters.
+ * Windows: (){}, !+@ before (, ! at the beginning.
+ */
+const POSIX_UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()*?[\]{|}]|^!|[!+@](?=\()|\\(?![!()*+?@[\]{|}]))/g;
+const WINDOWS_UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([(){}]|^!|[!+@](?=\())/g;
+/**
+ * The device path (\\.\ or \\?\).
+ * https://learn.microsoft.com/en-us/dotnet/standard/io/file-path-formats#dos-device-paths
+ */
+const DOS_DEVICE_PATH_RE = /^\\\\([.?])/;
+/**
+ * All backslashes except those escaping special characters.
+ * Windows: !()+@{}
+ * https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file#naming-conventions
+ */
+const WINDOWS_BACKSLASHES_RE = /\\(?![!()+@{}])/g;
 /**
  * Designed to work only with simple paths: `dir\\file`.
  */
@@ -15,10 +34,6 @@ function makeAbsolute(cwd, filepath) {
     return path.resolve(cwd, filepath);
 }
 exports.makeAbsolute = makeAbsolute;
-function escape(pattern) {
-    return pattern.replace(UNESCAPED_GLOB_SYMBOLS_RE, '\\$2');
-}
-exports.escape = escape;
 function removeLeadingDotSegment(entry) {
     // We do not use `startsWith` because this is 10x slower than current implementation for some cases.
     // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
@@ -31,3 +46,23 @@ function removeLeadingDotSegment(entry) {
     return entry;
 }
 exports.removeLeadingDotSegment = removeLeadingDotSegment;
+exports.escape = IS_WINDOWS_PLATFORM ? escapeWindowsPath : escapePosixPath;
+function escapeWindowsPath(pattern) {
+    return pattern.replace(WINDOWS_UNESCAPED_GLOB_SYMBOLS_RE, '\\$2');
+}
+exports.escapeWindowsPath = escapeWindowsPath;
+function escapePosixPath(pattern) {
+    return pattern.replace(POSIX_UNESCAPED_GLOB_SYMBOLS_RE, '\\$2');
+}
+exports.escapePosixPath = escapePosixPath;
+exports.convertPathToPattern = IS_WINDOWS_PLATFORM ? convertWindowsPathToPattern : convertPosixPathToPattern;
+function convertWindowsPathToPattern(filepath) {
+    return escapeWindowsPath(filepath)
+        .replace(DOS_DEVICE_PATH_RE, '//$1')
+        .replace(WINDOWS_BACKSLASHES_RE, '/');
+}
+exports.convertWindowsPathToPattern = convertWindowsPathToPattern;
+function convertPosixPathToPattern(filepath) {
+    return escapePosixPath(filepath);
+}
+exports.convertPosixPathToPattern = convertPosixPathToPattern;

node_modules/fast-glob/out/utils/pattern.d.ts

@@ -1,5 +1,5 @@
 import { MicromatchOptions, Pattern, PatternRe } from '../types';
-declare type PatternTypeOptions = {
+type PatternTypeOptions = {
     braceExpansion?: boolean;
     caseSensitiveMatch?: boolean;
     extglob?: boolean;
@@ -39,4 +39,9 @@ export declare function getPatternParts(pattern: Pattern, options: MicromatchOpt
 export declare function makeRe(pattern: Pattern, options: MicromatchOptions): PatternRe;
 export declare function convertPatternsToRe(patterns: Pattern[], options: MicromatchOptions): PatternRe[];
 export declare function matchAny(entry: string, patternsRe: PatternRe[]): boolean;
+/**
+ * This package only works with forward slashes as a path separator.
+ * Because of this, we cannot use the standard `path.normalize` method, because on Windows platform it will use of backslashes.
+ */
+export declare function removeDuplicateSlashes(pattern: string): string;
 export {};

node_modules/fast-glob/out/utils/pattern.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.matchAny = exports.convertPatternsToRe = exports.makeRe = exports.getPatternParts = exports.expandBraceExpansion = exports.expandPatternsWithBraceExpansion = exports.isAffectDepthOfReadingPattern = exports.endsWithSlashGlobStar = exports.hasGlobStar = exports.getBaseDirectory = exports.isPatternRelatedToParentDirectory = exports.getPatternsOutsideCurrentDirectory = exports.getPatternsInsideCurrentDirectory = exports.getPositivePatterns = exports.getNegativePatterns = exports.isPositivePattern = exports.isNegativePattern = exports.convertToNegativePattern = exports.convertToPositivePattern = exports.isDynamicPattern = exports.isStaticPattern = void 0;
+exports.removeDuplicateSlashes = exports.matchAny = exports.convertPatternsToRe = exports.makeRe = exports.getPatternParts = exports.expandBraceExpansion = exports.expandPatternsWithBraceExpansion = exports.isAffectDepthOfReadingPattern = exports.endsWithSlashGlobStar = exports.hasGlobStar = exports.getBaseDirectory = exports.isPatternRelatedToParentDirectory = exports.getPatternsOutsideCurrentDirectory = exports.getPatternsInsideCurrentDirectory = exports.getPositivePatterns = exports.getNegativePatterns = exports.isPositivePattern = exports.isNegativePattern = exports.convertToNegativePattern = exports.convertToPositivePattern = exports.isDynamicPattern = exports.isStaticPattern = void 0;
 const path = require("path");
 const globParent = require("glob-parent");
 const micromatch = require("micromatch");
@@ -11,6 +11,11 @@ const REGEX_CHARACTER_CLASS_SYMBOLS_RE = /\[[^[]*]/;
 const REGEX_GROUP_SYMBOLS_RE = /(?:^|[^!*+?@])\([^(]*\|[^|]*\)/;
 const GLOB_EXTENSION_SYMBOLS_RE = /[!*+?@]\([^(]*\)/;
 const BRACE_EXPANSION_SEPARATORS_RE = /,|\.\./;
+/**
+ * Matches a sequence of two or more consecutive slashes, excluding the first two slashes at the beginning of the string.
+ * The latter is due to the presence of the device path at the beginning of the UNC path.
+ */
+const DOUBLE_SLASH_RE = /(?!^)\/{2,}/g;
 function isStaticPattern(pattern, options = {}) {
     return !isDynamicPattern(pattern, options);
 }
@@ -129,10 +134,16 @@ function expandPatternsWithBraceExpansion(patterns) {
 }
 exports.expandPatternsWithBraceExpansion = expandPatternsWithBraceExpansion;
 function expandBraceExpansion(pattern) {
-    return micromatch.braces(pattern, {
-        expand: true,
-        nodupes: true
-    });
+    const patterns = micromatch.braces(pattern, { expand: true, nodupes: true });
+    /**
+     * Sort the patterns by length so that the same depth patterns are processed side by side.
+     * `a/{b,}/{c,}/*` – `['a///*', 'a/b//*', 'a//c/*', 'a/b/c/*']`
+     */
+    patterns.sort((a, b) => a.length - b.length);
+    /**
+     * Micromatch can return an empty string in the case of patterns like `{a,}`.
+     */
+    return patterns.filter((pattern) => pattern !== '');
 }
 exports.expandBraceExpansion = expandBraceExpansion;
 function getPatternParts(pattern, options) {
@@ -167,3 +178,11 @@ function matchAny(entry, patternsRe) {
     return patternsRe.some((patternRe) => patternRe.test(entry));
 }
 exports.matchAny = matchAny;
+/**
+ * This package only works with forward slashes as a path separator.
+ * Because of this, we cannot use the standard `path.normalize` method, because on Windows platform it will use of backslashes.
+ */
+function removeDuplicateSlashes(pattern) {
+    return pattern.replace(DOUBLE_SLASH_RE, '/');
+}
+exports.removeDuplicateSlashes = removeDuplicateSlashes;

node_modules/fast-glob/out/utils/stream.d.ts

@@ -1,3 +1,4 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { Readable } from 'stream';
 export declare function merge(streams: Readable[]): NodeJS.ReadableStream;