Update checked-in dependencies

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({