Demo for query storing
Change-Id: I947bcac841992c3f6cfd01ab337c265b0d01cb70
diff --git a/node_modules/fast-glob/out/adapters/fs-stream.d.ts b/node_modules/fast-glob/out/adapters/fs-stream.d.ts
new file mode 100644
index 0000000..bca4e9f
--- /dev/null
+++ b/node_modules/fast-glob/out/adapters/fs-stream.d.ts
@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import * as fs from 'fs';
+import FileSystem from './fs';
+import { FilterFunction } from '@mrmlnc/readdir-enhanced';
+import { Entry } from '../types/entries';
+import { Pattern } from '../types/patterns';
+export default class FileSystemStream extends FileSystem<NodeJS.ReadableStream> {
+ /**
+ * Use stream API to read entries for Task.
+ */
+ read(patterns: string[], filter: FilterFunction): NodeJS.ReadableStream;
+ /**
+ * Return entry for the provided path.
+ */
+ getEntry(filepath: string, pattern: Pattern): Promise<Entry | null>;
+ /**
+ * Return fs.Stats for the provided path.
+ */
+ getStat(filepath: string): Promise<fs.Stats>;
+}
diff --git a/node_modules/fast-glob/out/adapters/fs-stream.js b/node_modules/fast-glob/out/adapters/fs-stream.js
new file mode 100644
index 0000000..fcb236d
--- /dev/null
+++ b/node_modules/fast-glob/out/adapters/fs-stream.js
@@ -0,0 +1,64 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+ var extendStatics = function (d, b) {
+ extendStatics = Object.setPrototypeOf ||
+ ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+ function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+ return extendStatics(d, b);
+ };
+ return function (d, b) {
+ extendStatics(d, b);
+ function __() { this.constructor = d; }
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+ };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var stream = require("stream");
+var fsStat = require("@nodelib/fs.stat");
+var fs_1 = require("./fs");
+var FileSystemStream = /** @class */ (function (_super) {
+ __extends(FileSystemStream, _super);
+ function FileSystemStream() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ /**
+ * Use stream API to read entries for Task.
+ */
+ FileSystemStream.prototype.read = function (patterns, filter) {
+ var _this = this;
+ var filepaths = patterns.map(this.getFullEntryPath, this);
+ var transform = new stream.Transform({ objectMode: true });
+ transform._transform = function (index, _enc, done) {
+ return _this.getEntry(filepaths[index], patterns[index]).then(function (entry) {
+ if (entry !== null && filter(entry)) {
+ transform.push(entry);
+ }
+ if (index === filepaths.length - 1) {
+ transform.end();
+ }
+ done();
+ });
+ };
+ for (var i = 0; i < filepaths.length; i++) {
+ transform.write(i);
+ }
+ return transform;
+ };
+ /**
+ * Return entry for the provided path.
+ */
+ FileSystemStream.prototype.getEntry = function (filepath, pattern) {
+ var _this = this;
+ return this.getStat(filepath)
+ .then(function (stat) { return _this.makeEntry(stat, pattern); })
+ .catch(function () { return null; });
+ };
+ /**
+ * Return fs.Stats for the provided path.
+ */
+ FileSystemStream.prototype.getStat = function (filepath) {
+ return fsStat.stat(filepath, { throwErrorOnBrokenSymlinks: false });
+ };
+ return FileSystemStream;
+}(fs_1.default));
+exports.default = FileSystemStream;
diff --git a/node_modules/fast-glob/out/adapters/fs-sync.d.ts b/node_modules/fast-glob/out/adapters/fs-sync.d.ts
new file mode 100644
index 0000000..6fcc736
--- /dev/null
+++ b/node_modules/fast-glob/out/adapters/fs-sync.d.ts
@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import * as fs from 'fs';
+import FileSystem from './fs';
+import { FilterFunction } from '@mrmlnc/readdir-enhanced';
+import { Entry } from '../types/entries';
+import { Pattern } from '../types/patterns';
+export default class FileSystemSync extends FileSystem<Entry[]> {
+ /**
+ * Use sync API to read entries for Task.
+ */
+ read(patterns: string[], filter: FilterFunction): Entry[];
+ /**
+ * Return entry for the provided path.
+ */
+ getEntry(filepath: string, pattern: Pattern): Entry | null;
+ /**
+ * Return fs.Stats for the provided path.
+ */
+ getStat(filepath: string): fs.Stats;
+}
diff --git a/node_modules/fast-glob/out/adapters/fs-sync.js b/node_modules/fast-glob/out/adapters/fs-sync.js
new file mode 100644
index 0000000..41bcdef
--- /dev/null
+++ b/node_modules/fast-glob/out/adapters/fs-sync.js
@@ -0,0 +1,59 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+ var extendStatics = function (d, b) {
+ extendStatics = Object.setPrototypeOf ||
+ ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+ function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+ return extendStatics(d, b);
+ };
+ return function (d, b) {
+ extendStatics(d, b);
+ function __() { this.constructor = d; }
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+ };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var fsStat = require("@nodelib/fs.stat");
+var fs_1 = require("./fs");
+var FileSystemSync = /** @class */ (function (_super) {
+ __extends(FileSystemSync, _super);
+ function FileSystemSync() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ /**
+ * Use sync API to read entries for Task.
+ */
+ FileSystemSync.prototype.read = function (patterns, filter) {
+ var _this = this;
+ var entries = [];
+ patterns.forEach(function (pattern) {
+ var filepath = _this.getFullEntryPath(pattern);
+ var entry = _this.getEntry(filepath, pattern);
+ if (entry === null || !filter(entry)) {
+ return;
+ }
+ entries.push(entry);
+ });
+ return entries;
+ };
+ /**
+ * Return entry for the provided path.
+ */
+ FileSystemSync.prototype.getEntry = function (filepath, pattern) {
+ try {
+ var stat = this.getStat(filepath);
+ return this.makeEntry(stat, pattern);
+ }
+ catch (err) {
+ return null;
+ }
+ };
+ /**
+ * Return fs.Stats for the provided path.
+ */
+ FileSystemSync.prototype.getStat = function (filepath) {
+ return fsStat.statSync(filepath, { throwErrorOnBrokenSymlinks: false });
+ };
+ return FileSystemSync;
+}(fs_1.default));
+exports.default = FileSystemSync;
diff --git a/node_modules/fast-glob/out/adapters/fs.d.ts b/node_modules/fast-glob/out/adapters/fs.d.ts
new file mode 100644
index 0000000..abf4432
--- /dev/null
+++ b/node_modules/fast-glob/out/adapters/fs.d.ts
@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import * as fs from 'fs';
+import { FilterFunction } from '@mrmlnc/readdir-enhanced';
+import { IOptions } from '../managers/options';
+import { Entry } from '../types/entries';
+import { Pattern } from '../types/patterns';
+export default abstract class FileSystem<T> {
+ private readonly options;
+ constructor(options: IOptions);
+ /**
+ * The main logic of reading the entries that must be implemented by each adapter.
+ */
+ abstract read(filepaths: string[], filter: FilterFunction): T;
+ /**
+ * Return full path to entry.
+ */
+ getFullEntryPath(filepath: string): string;
+ /**
+ * Return an implementation of the Entry interface.
+ */
+ makeEntry(stat: fs.Stats, pattern: Pattern): Entry;
+}
diff --git a/node_modules/fast-glob/out/adapters/fs.js b/node_modules/fast-glob/out/adapters/fs.js
new file mode 100644
index 0000000..e7469ec
--- /dev/null
+++ b/node_modules/fast-glob/out/adapters/fs.js
@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var path = require("path");
+var FileSystem = /** @class */ (function () {
+ function FileSystem(options) {
+ this.options = options;
+ }
+ /**
+ * Return full path to entry.
+ */
+ FileSystem.prototype.getFullEntryPath = function (filepath) {
+ return path.resolve(this.options.cwd, filepath);
+ };
+ /**
+ * Return an implementation of the Entry interface.
+ */
+ FileSystem.prototype.makeEntry = function (stat, pattern) {
+ stat.path = pattern;
+ stat.depth = pattern.split('/').length;
+ return stat;
+ };
+ return FileSystem;
+}());
+exports.default = FileSystem;
diff --git a/node_modules/fast-glob/out/index.d.ts b/node_modules/fast-glob/out/index.d.ts
new file mode 100644
index 0000000..5072dc8
--- /dev/null
+++ b/node_modules/fast-glob/out/index.d.ts
@@ -0,0 +1,21 @@
+/// <reference types="node" />
+import { IPartialOptions } from './managers/options';
+import { ITask } from './managers/tasks';
+import { EntryItem } from './types/entries';
+import { Pattern } from './types/patterns';
+/**
+ * Synchronous API.
+ */
+export declare function sync(source: Pattern | Pattern[], opts?: IPartialOptions): EntryItem[];
+/**
+ * Asynchronous API.
+ */
+export declare function async(source: Pattern | Pattern[], opts?: IPartialOptions): Promise<EntryItem[]>;
+/**
+ * Stream API.
+ */
+export declare function stream(source: Pattern | Pattern[], opts?: IPartialOptions): NodeJS.ReadableStream;
+/**
+ * Return a set of tasks based on provided patterns.
+ */
+export declare function generateTasks(source: Pattern | Pattern[], opts?: IPartialOptions): ITask[];
diff --git a/node_modules/fast-glob/out/index.js b/node_modules/fast-glob/out/index.js
new file mode 100644
index 0000000..ce70421
--- /dev/null
+++ b/node_modules/fast-glob/out/index.js
@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var optionsManager = require("./managers/options");
+var taskManager = require("./managers/tasks");
+var reader_async_1 = require("./providers/reader-async");
+var reader_stream_1 = require("./providers/reader-stream");
+var reader_sync_1 = require("./providers/reader-sync");
+var arrayUtils = require("./utils/array");
+var streamUtils = require("./utils/stream");
+/**
+ * Synchronous API.
+ */
+function sync(source, opts) {
+ assertPatternsInput(source);
+ var works = getWorks(source, reader_sync_1.default, opts);
+ return arrayUtils.flatten(works);
+}
+exports.sync = sync;
+/**
+ * Asynchronous API.
+ */
+function async(source, opts) {
+ try {
+ assertPatternsInput(source);
+ }
+ catch (error) {
+ return Promise.reject(error);
+ }
+ var works = getWorks(source, reader_async_1.default, opts);
+ return Promise.all(works).then(arrayUtils.flatten);
+}
+exports.async = async;
+/**
+ * Stream API.
+ */
+function stream(source, opts) {
+ assertPatternsInput(source);
+ var works = getWorks(source, reader_stream_1.default, opts);
+ return streamUtils.merge(works);
+}
+exports.stream = stream;
+/**
+ * Return a set of tasks based on provided patterns.
+ */
+function generateTasks(source, opts) {
+ assertPatternsInput(source);
+ var patterns = [].concat(source);
+ var options = optionsManager.prepare(opts);
+ return taskManager.generate(patterns, options);
+}
+exports.generateTasks = generateTasks;
+/**
+ * Returns a set of works based on provided tasks and class of the reader.
+ */
+function getWorks(source, _Reader, opts) {
+ var patterns = [].concat(source);
+ var options = optionsManager.prepare(opts);
+ var tasks = taskManager.generate(patterns, options);
+ var reader = new _Reader(options);
+ return tasks.map(reader.read, reader);
+}
+function assertPatternsInput(source) {
+ if ([].concat(source).every(isString)) {
+ return;
+ }
+ throw new TypeError('Patterns must be a string or an array of strings');
+}
+function isString(source) {
+ /* tslint:disable-next-line strict-type-predicates */
+ return typeof source === 'string';
+}
diff --git a/node_modules/fast-glob/out/managers/options.d.ts b/node_modules/fast-glob/out/managers/options.d.ts
new file mode 100644
index 0000000..b9c6d5c
--- /dev/null
+++ b/node_modules/fast-glob/out/managers/options.d.ts
@@ -0,0 +1,94 @@
+import { EntryItem } from '../types/entries';
+import { Pattern } from '../types/patterns';
+export declare type TransformFunction<T> = (entry: EntryItem) => T;
+export interface IOptions<T = EntryItem> {
+ /**
+ * The current working directory in which to search.
+ */
+ cwd: string;
+ /**
+ * The deep option can be set to true to traverse the entire directory structure,
+ * or it can be set to a number to only traverse that many levels deep.
+ */
+ deep: number | boolean;
+ /**
+ * Add an array of glob patterns to exclude matches.
+ */
+ ignore: Pattern[];
+ /**
+ * Allow patterns to match filenames starting with a period (files & directories),
+ * even if the pattern does not explicitly have a period in that spot.
+ */
+ dot: boolean;
+ /**
+ * Return `fs.Stats` with `path` property instead of file path.
+ */
+ stats: boolean;
+ /**
+ * Return only files.
+ */
+ onlyFiles: boolean;
+ /**
+ * Return only directories.
+ */
+ onlyDirectories: boolean;
+ /**
+ * Follow symlinked directories when expanding `**` patterns.
+ */
+ followSymlinkedDirectories: boolean;
+ /**
+ * Prevent duplicate results.
+ */
+ unique: boolean;
+ /**
+ * Add a `/` character to directory entries.
+ */
+ markDirectories: boolean;
+ /**
+ * Return absolute paths for matched entries.
+ */
+ absolute: boolean;
+ /**
+ * Disable expansion of brace patterns.
+ */
+ nobrace: boolean;
+ /**
+ * Enable expansion of brace patterns.
+ */
+ brace: boolean;
+ /**
+ * Disable matching with globstars (`**`).
+ */
+ noglobstar: boolean;
+ /**
+ * Enable matching with globstars (`**`).
+ */
+ globstar: boolean;
+ /**
+ * Disable extglob support, so that extglobs are regarded as literal characters.
+ */
+ noext: boolean;
+ /**
+ * Enable extglob support, so that extglobs are regarded as literal characters.
+ */
+ extension: boolean;
+ /**
+ * Disable a case-insensitive regex for matching files.
+ */
+ nocase: boolean;
+ /**
+ * Enable a case-insensitive regex for matching files.
+ */
+ case: boolean;
+ /**
+ * Allow glob patterns without slashes to match a file path based on its basename.
+ * For example, `a?b` would match the path `/xyz/123/acb`, but not `/xyz/acb/123`.
+ */
+ matchBase: boolean;
+ /**
+ * Allows you to transform a path or `fs.Stats` object before sending to the array.
+ */
+ transform: TransformFunction<T> | null;
+}
+export declare type IPartialOptions<T = EntryItem> = Partial<IOptions<T>>;
+export declare function prepare(options?: IPartialOptions): IOptions;
diff --git a/node_modules/fast-glob/out/managers/options.js b/node_modules/fast-glob/out/managers/options.js
new file mode 100644
index 0000000..e912c82
--- /dev/null
+++ b/node_modules/fast-glob/out/managers/options.js
@@ -0,0 +1,31 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+ __assign = Object.assign || function(t) {
+ for (var s, i = 1, n = arguments.length; i < n; i++) {
+ s = arguments[i];
+ for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+ t[p] = s[p];
+ }
+ return t;
+ };
+ return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+function prepare(options) {
+ var opts = __assign({ cwd: process.cwd(), deep: true, ignore: [], dot: false, stats: false, onlyFiles: true, onlyDirectories: false, followSymlinkedDirectories: true, unique: true, markDirectories: false, absolute: false, nobrace: false, brace: true, noglobstar: false, globstar: true, noext: false, extension: true, nocase: false, case: true, matchBase: false, transform: null }, options);
+ if (opts.onlyDirectories) {
+ opts.onlyFiles = false;
+ }
+ opts.brace = !opts.nobrace;
+ opts.globstar = !opts.noglobstar;
+ opts.extension = !opts.noext;
+ opts.case = !opts.nocase;
+ if (options) {
+ opts.brace = ('brace' in options ? options.brace : opts.brace);
+ opts.globstar = ('globstar' in options ? options.globstar : opts.globstar);
+ opts.extension = ('extension' in options ? options.extension : opts.extension);
+ opts.case = ('case' in options ? options.case : opts.case);
+ }
+ return opts;
+}
+exports.prepare = prepare;
diff --git a/node_modules/fast-glob/out/managers/tasks.d.ts b/node_modules/fast-glob/out/managers/tasks.d.ts
new file mode 100644
index 0000000..e2cc1a9
--- /dev/null
+++ b/node_modules/fast-glob/out/managers/tasks.d.ts
@@ -0,0 +1,37 @@
+import { Pattern, PatternsGroup } from '../types/patterns';
+import { IOptions } from './options';
+export interface ITask {
+ base: string;
+ dynamic: boolean;
+ patterns: Pattern[];
+ positive: Pattern[];
+ negative: Pattern[];
+}
+/**
+ * Generate tasks based on parent directory of each pattern.
+ */
+export declare function generate(patterns: Pattern[], options: IOptions): ITask[];
+/**
+ * Convert patterns to tasks based on parent directory of each pattern.
+ */
+export declare function convertPatternsToTasks(positive: Pattern[], negative: Pattern[], dynamic: boolean): ITask[];
+/**
+ * Return only positive patterns.
+ */
+export declare function getPositivePatterns(patterns: Pattern[]): Pattern[];
+/**
+ * Return only negative patterns.
+ */
+export declare function getNegativePatternsAsPositive(patterns: Pattern[], ignore: Pattern[]): Pattern[];
+/**
+ * Group patterns by base directory of each pattern.
+ */
+export declare function groupPatternsByBaseDirectory(patterns: Pattern[]): PatternsGroup;
+/**
+ * Convert group of patterns to tasks.
+ */
+export declare function convertPatternGroupsToTasks(positive: PatternsGroup, negative: Pattern[], dynamic: boolean): ITask[];
+/**
+ * Create a task for positive and negative patterns.
+ */
+export declare function convertPatternGroupToTask(base: string, positive: Pattern[], negative: Pattern[], dynamic: boolean): ITask;
diff --git a/node_modules/fast-glob/out/managers/tasks.js b/node_modules/fast-glob/out/managers/tasks.js
new file mode 100644
index 0000000..6582ceb
--- /dev/null
+++ b/node_modules/fast-glob/out/managers/tasks.js
@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var patternUtils = require("../utils/pattern");
+/**
+ * Generate tasks based on parent directory of each pattern.
+ */
+function generate(patterns, options) {
+ var unixPatterns = patterns.map(patternUtils.unixifyPattern);
+ var unixIgnore = options.ignore.map(patternUtils.unixifyPattern);
+ var positivePatterns = getPositivePatterns(unixPatterns);
+ var negativePatterns = getNegativePatternsAsPositive(unixPatterns, unixIgnore);
+ /**
+ * When the `case` option is disabled, all patterns must be marked as dynamic, because we cannot check filepath
+ * directly (without read directory).
+ */
+ var staticPatterns = !options.case ? [] : positivePatterns.filter(patternUtils.isStaticPattern);
+ var dynamicPatterns = !options.case ? positivePatterns : positivePatterns.filter(patternUtils.isDynamicPattern);
+ var staticTasks = convertPatternsToTasks(staticPatterns, negativePatterns, /* dynamic */ false);
+ var dynamicTasks = convertPatternsToTasks(dynamicPatterns, negativePatterns, /* dynamic */ true);
+ return staticTasks.concat(dynamicTasks);
+}
+exports.generate = generate;
+/**
+ * Convert patterns to tasks based on parent directory of each pattern.
+ */
+function convertPatternsToTasks(positive, negative, dynamic) {
+ var positivePatternsGroup = groupPatternsByBaseDirectory(positive);
+ // When we have a global group – there is no reason to divide the patterns into independent tasks.
+ // In this case, the global task covers the rest.
+ if ('.' in positivePatternsGroup) {
+ var task = convertPatternGroupToTask('.', positive, negative, dynamic);
+ return [task];
+ }
+ return convertPatternGroupsToTasks(positivePatternsGroup, negative, dynamic);
+}
+exports.convertPatternsToTasks = convertPatternsToTasks;
+/**
+ * Return only positive patterns.
+ */
+function getPositivePatterns(patterns) {
+ return patternUtils.getPositivePatterns(patterns);
+}
+exports.getPositivePatterns = getPositivePatterns;
+/**
+ * Return only negative patterns.
+ */
+function getNegativePatternsAsPositive(patterns, ignore) {
+ var negative = patternUtils.getNegativePatterns(patterns).concat(ignore);
+ var positive = negative.map(patternUtils.convertToPositivePattern);
+ return positive;
+}
+exports.getNegativePatternsAsPositive = getNegativePatternsAsPositive;
+/**
+ * Group patterns by base directory of each pattern.
+ */
+function groupPatternsByBaseDirectory(patterns) {
+ return patterns.reduce(function (collection, pattern) {
+ var base = patternUtils.getBaseDirectory(pattern);
+ if (base in collection) {
+ collection[base].push(pattern);
+ }
+ else {
+ collection[base] = [pattern];
+ }
+ return collection;
+ }, {});
+}
+exports.groupPatternsByBaseDirectory = groupPatternsByBaseDirectory;
+/**
+ * Convert group of patterns to tasks.
+ */
+function convertPatternGroupsToTasks(positive, negative, dynamic) {
+ return Object.keys(positive).map(function (base) {
+ return convertPatternGroupToTask(base, positive[base], negative, dynamic);
+ });
+}
+exports.convertPatternGroupsToTasks = convertPatternGroupsToTasks;
+/**
+ * Create a task for positive and negative patterns.
+ */
+function convertPatternGroupToTask(base, positive, negative, dynamic) {
+ return {
+ base: base,
+ dynamic: dynamic,
+ positive: positive,
+ negative: negative,
+ patterns: [].concat(positive, negative.map(patternUtils.convertToNegativePattern))
+ };
+}
+exports.convertPatternGroupToTask = convertPatternGroupToTask;
diff --git a/node_modules/fast-glob/out/providers/filters/deep.d.ts b/node_modules/fast-glob/out/providers/filters/deep.d.ts
new file mode 100644
index 0000000..2cd02b6
--- /dev/null
+++ b/node_modules/fast-glob/out/providers/filters/deep.d.ts
@@ -0,0 +1,45 @@
+import micromatch = require('micromatch');
+import { IOptions } from '../../managers/options';
+import { FilterFunction } from '@mrmlnc/readdir-enhanced';
+import { Pattern } from '../../types/patterns';
+export default class DeepFilter {
+ private readonly options;
+ private readonly micromatchOptions;
+ constructor(options: IOptions, micromatchOptions: micromatch.Options);
+ /**
+ * Returns filter for directories.
+ */
+ getFilter(positive: Pattern[], negative: Pattern[]): FilterFunction;
+ /**
+ * Returns max depth of the provided patterns.
+ */
+ private getMaxPatternDepth;
+ /**
+ * Returns RegExp's for patterns that can affect the depth of reading.
+ */
+ private getNegativePatternsRe;
+ /**
+ * Returns «true» for directory that should be read.
+ */
+ private filter;
+ /**
+ * Returns «true» when the «deep» option is disabled or number and depth of the entry is greater that the option value.
+ */
+ private isSkippedByDeepOption;
+ /**
+ * Returns «true» when depth parameter is not an Infinity and entry depth greater that the parameter value.
+ */
+ private isSkippedByMaxPatternDepth;
+ /**
+ * Returns «true» for symlinked directory if the «followSymlinkedDirectories» option is disabled.
+ */
+ private isSkippedSymlinkedDirectory;
+ /**
+ * Returns «true» for a directory whose name starts with a period if «dot» option is disabled.
+ */
+ private isSkippedDotDirectory;
+ /**
+ * Returns «true» for a directory whose path math to any negative pattern.
+ */
+ private isSkippedByNegativePatterns;
+}
diff --git a/node_modules/fast-glob/out/providers/filters/deep.js b/node_modules/fast-glob/out/providers/filters/deep.js
new file mode 100644
index 0000000..19732e8
--- /dev/null
+++ b/node_modules/fast-glob/out/providers/filters/deep.js
@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var pathUtils = require("../../utils/path");
+var patternUtils = require("../../utils/pattern");
+var DeepFilter = /** @class */ (function () {
+ function DeepFilter(options, micromatchOptions) {
+ this.options = options;
+ this.micromatchOptions = micromatchOptions;
+ }
+ /**
+ * Returns filter for directories.
+ */
+ DeepFilter.prototype.getFilter = function (positive, negative) {
+ var _this = this;
+ var maxPatternDepth = this.getMaxPatternDepth(positive);
+ var negativeRe = this.getNegativePatternsRe(negative);
+ return function (entry) { return _this.filter(entry, negativeRe, maxPatternDepth); };
+ };
+ /**
+ * Returns max depth of the provided patterns.
+ */
+ DeepFilter.prototype.getMaxPatternDepth = function (patterns) {
+ var globstar = patterns.some(patternUtils.hasGlobStar);
+ return globstar ? Infinity : patternUtils.getMaxNaivePatternsDepth(patterns);
+ };
+ /**
+ * Returns RegExp's for patterns that can affect the depth of reading.
+ */
+ DeepFilter.prototype.getNegativePatternsRe = function (patterns) {
+ var affectDepthOfReadingPatterns = patterns.filter(patternUtils.isAffectDepthOfReadingPattern);
+ return patternUtils.convertPatternsToRe(affectDepthOfReadingPatterns, this.micromatchOptions);
+ };
+ /**
+ * Returns «true» for directory that should be read.
+ */
+ DeepFilter.prototype.filter = function (entry, negativeRe, maxPatternDepth) {
+ if (this.isSkippedByDeepOption(entry.depth)) {
+ return false;
+ }
+ if (this.isSkippedByMaxPatternDepth(entry.depth, maxPatternDepth)) {
+ return false;
+ }
+ if (this.isSkippedSymlinkedDirectory(entry)) {
+ return false;
+ }
+ if (this.isSkippedDotDirectory(entry)) {
+ return false;
+ }
+ return this.isSkippedByNegativePatterns(entry, negativeRe);
+ };
+ /**
+ * Returns «true» when the «deep» option is disabled or number and depth of the entry is greater that the option value.
+ */
+ DeepFilter.prototype.isSkippedByDeepOption = function (entryDepth) {
+ return !this.options.deep || (typeof this.options.deep === 'number' && entryDepth >= this.options.deep);
+ };
+ /**
+ * Returns «true» when depth parameter is not an Infinity and entry depth greater that the parameter value.
+ */
+ DeepFilter.prototype.isSkippedByMaxPatternDepth = function (entryDepth, maxPatternDepth) {
+ return maxPatternDepth !== Infinity && entryDepth >= maxPatternDepth;
+ };
+ /**
+ * Returns «true» for symlinked directory if the «followSymlinkedDirectories» option is disabled.
+ */
+ DeepFilter.prototype.isSkippedSymlinkedDirectory = function (entry) {
+ return !this.options.followSymlinkedDirectories && entry.isSymbolicLink();
+ };
+ /**
+ * Returns «true» for a directory whose name starts with a period if «dot» option is disabled.
+ */
+ DeepFilter.prototype.isSkippedDotDirectory = function (entry) {
+ return !this.options.dot && pathUtils.isDotDirectory(entry.path);
+ };
+ /**
+ * Returns «true» for a directory whose path math to any negative pattern.
+ */
+ DeepFilter.prototype.isSkippedByNegativePatterns = function (entry, negativeRe) {
+ return !patternUtils.matchAny(entry.path, negativeRe);
+ };
+ return DeepFilter;
+}());
+exports.default = DeepFilter;
diff --git a/node_modules/fast-glob/out/providers/filters/entry.d.ts b/node_modules/fast-glob/out/providers/filters/entry.d.ts
new file mode 100644
index 0000000..d926190
--- /dev/null
+++ b/node_modules/fast-glob/out/providers/filters/entry.d.ts
@@ -0,0 +1,45 @@
+import micromatch = require('micromatch');
+import { IOptions } from '../../managers/options';
+import { FilterFunction } from '@mrmlnc/readdir-enhanced';
+import { Pattern } from '../../types/patterns';
+export default class EntryFilter {
+ private readonly options;
+ private readonly micromatchOptions;
+ readonly index: Map<string, undefined>;
+ constructor(options: IOptions, micromatchOptions: micromatch.Options);
+ /**
+ * Returns filter for directories.
+ */
+ getFilter(positive: Pattern[], negative: Pattern[]): FilterFunction;
+ /**
+ * Returns true if entry must be added to result.
+ */
+ private filter;
+ /**
+ * Return true if the entry already has in the cross reader index.
+ */
+ private isDuplicateEntry;
+ /**
+ * Create record in the cross reader index.
+ */
+ private createIndexRecord;
+ /**
+ * Returns true for non-files if the «onlyFiles» option is enabled.
+ */
+ private onlyFileFilter;
+ /**
+ * Returns true for non-directories if the «onlyDirectories» option is enabled.
+ */
+ private onlyDirectoryFilter;
+ /**
+ * Return true when `absolute` option is enabled and matched to the negative patterns.
+ */
+ private isSkippedByAbsoluteNegativePatterns;
+ /**
+ * Return true when entry match to provided patterns.
+ *
+ * First, just trying to apply patterns to the path.
+ * Second, trying to apply patterns to the path with final slash (need to micromatch to support «directory/**» patterns).
+ */
+ private isMatchToPatterns;
+}
diff --git a/node_modules/fast-glob/out/providers/filters/entry.js b/node_modules/fast-glob/out/providers/filters/entry.js
new file mode 100644
index 0000000..a5ea863
--- /dev/null
+++ b/node_modules/fast-glob/out/providers/filters/entry.js
@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var pathUtils = require("../../utils/path");
+var patternUtils = require("../../utils/pattern");
+var EntryFilter = /** @class */ (function () {
+ function EntryFilter(options, micromatchOptions) {
+ this.options = options;
+ this.micromatchOptions = micromatchOptions;
+ this.index = new Map();
+ }
+ /**
+ * Returns filter for directories.
+ */
+ EntryFilter.prototype.getFilter = function (positive, negative) {
+ var _this = this;
+ var positiveRe = patternUtils.convertPatternsToRe(positive, this.micromatchOptions);
+ var negativeRe = patternUtils.convertPatternsToRe(negative, this.micromatchOptions);
+ return function (entry) { return _this.filter(entry, positiveRe, negativeRe); };
+ };
+ /**
+ * Returns true if entry must be added to result.
+ */
+ EntryFilter.prototype.filter = function (entry, positiveRe, negativeRe) {
+ // Exclude duplicate results
+ if (this.options.unique) {
+ if (this.isDuplicateEntry(entry)) {
+ return false;
+ }
+ this.createIndexRecord(entry);
+ }
+ // Filter files and directories by options
+ if (this.onlyFileFilter(entry) || this.onlyDirectoryFilter(entry)) {
+ return false;
+ }
+ if (this.isSkippedByAbsoluteNegativePatterns(entry, negativeRe)) {
+ return false;
+ }
+ return this.isMatchToPatterns(entry.path, positiveRe) && !this.isMatchToPatterns(entry.path, negativeRe);
+ };
+ /**
+ * Return true if the entry already has in the cross reader index.
+ */
+ EntryFilter.prototype.isDuplicateEntry = function (entry) {
+ return this.index.has(entry.path);
+ };
+ /**
+ * Create record in the cross reader index.
+ */
+ EntryFilter.prototype.createIndexRecord = function (entry) {
+ this.index.set(entry.path, undefined);
+ };
+ /**
+ * Returns true for non-files if the «onlyFiles» option is enabled.
+ */
+ EntryFilter.prototype.onlyFileFilter = function (entry) {
+ return this.options.onlyFiles && !entry.isFile();
+ };
+ /**
+ * Returns true for non-directories if the «onlyDirectories» option is enabled.
+ */
+ EntryFilter.prototype.onlyDirectoryFilter = function (entry) {
+ return this.options.onlyDirectories && !entry.isDirectory();
+ };
+ /**
+ * Return true when `absolute` option is enabled and matched to the negative patterns.
+ */
+ EntryFilter.prototype.isSkippedByAbsoluteNegativePatterns = function (entry, negativeRe) {
+ if (!this.options.absolute) {
+ return false;
+ }
+ var fullpath = pathUtils.makeAbsolute(this.options.cwd, entry.path);
+ return this.isMatchToPatterns(fullpath, negativeRe);
+ };
+ /**
+ * Return true when entry match to provided patterns.
+ *
+ * First, just trying to apply patterns to the path.
+ * Second, trying to apply patterns to the path with final slash (need to micromatch to support «directory/**» patterns).
+ */
+ EntryFilter.prototype.isMatchToPatterns = function (filepath, patternsRe) {
+ return patternUtils.matchAny(filepath, patternsRe) || patternUtils.matchAny(filepath + '/', patternsRe);
+ };
+ return EntryFilter;
+}());
+exports.default = EntryFilter;
diff --git a/node_modules/fast-glob/out/providers/reader-async.d.ts b/node_modules/fast-glob/out/providers/reader-async.d.ts
new file mode 100644
index 0000000..eacdee3
--- /dev/null
+++ b/node_modules/fast-glob/out/providers/reader-async.d.ts
@@ -0,0 +1,28 @@
+/// <reference types="node" />
+import * as readdir from '@mrmlnc/readdir-enhanced';
+import Reader from './reader';
+import FileSystemStream from '../adapters/fs-stream';
+import { ITask } from '../managers/tasks';
+import { EntryItem } from '../types/entries';
+export default class ReaderAsync extends Reader<Promise<EntryItem[]>> {
+ /**
+ * Returns FileSystem adapter.
+ */
+ readonly fsAdapter: FileSystemStream;
+ /**
+ * Use async API to read entries for Task.
+ */
+ read(task: ITask): Promise<EntryItem[]>;
+ /**
+ * Returns founded paths.
+ */
+ api(root: string, task: ITask, options: readdir.Options): NodeJS.ReadableStream;
+ /**
+ * Api for dynamic tasks.
+ */
+ dynamicApi(root: string, options: readdir.Options): NodeJS.ReadableStream;
+ /**
+ * Api for static tasks.
+ */
+ staticApi(task: ITask, options: readdir.Options): NodeJS.ReadableStream;
+}
diff --git a/node_modules/fast-glob/out/providers/reader-async.js b/node_modules/fast-glob/out/providers/reader-async.js
new file mode 100644
index 0000000..cdd6099
--- /dev/null
+++ b/node_modules/fast-glob/out/providers/reader-async.js
@@ -0,0 +1,75 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+ var extendStatics = function (d, b) {
+ extendStatics = Object.setPrototypeOf ||
+ ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+ function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+ return extendStatics(d, b);
+ };
+ return function (d, b) {
+ extendStatics(d, b);
+ function __() { this.constructor = d; }
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+ };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var readdir = require("@mrmlnc/readdir-enhanced");
+var reader_1 = require("./reader");
+var fs_stream_1 = require("../adapters/fs-stream");
+var ReaderAsync = /** @class */ (function (_super) {
+ __extends(ReaderAsync, _super);
+ function ReaderAsync() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ Object.defineProperty(ReaderAsync.prototype, "fsAdapter", {
+ /**
+ * Returns FileSystem adapter.
+ */
+ get: function () {
+ return new fs_stream_1.default(this.options);
+ },
+ enumerable: true,
+ configurable: true
+ });
+ /**
+ * Use async API to read entries for Task.
+ */
+ ReaderAsync.prototype.read = function (task) {
+ var _this = this;
+ var root = this.getRootDirectory(task);
+ var options = this.getReaderOptions(task);
+ var entries = [];
+ return new Promise(function (resolve, reject) {
+ var stream = _this.api(root, task, options);
+ stream.on('error', function (err) {
+ _this.isEnoentCodeError(err) ? resolve([]) : reject(err);
+ stream.pause();
+ });
+ stream.on('data', function (entry) { return entries.push(_this.transform(entry)); });
+ stream.on('end', function () { return resolve(entries); });
+ });
+ };
+ /**
+ * Returns founded paths.
+ */
+ ReaderAsync.prototype.api = function (root, task, options) {
+ if (task.dynamic) {
+ return this.dynamicApi(root, options);
+ }
+ return this.staticApi(task, options);
+ };
+ /**
+ * Api for dynamic tasks.
+ */
+ ReaderAsync.prototype.dynamicApi = function (root, options) {
+ return readdir.readdirStreamStat(root, options);
+ };
+ /**
+ * Api for static tasks.
+ */
+ ReaderAsync.prototype.staticApi = function (task, options) {
+ return this.fsAdapter.read(task.patterns, options.filter);
+ };
+ return ReaderAsync;
+}(reader_1.default));
+exports.default = ReaderAsync;
diff --git a/node_modules/fast-glob/out/providers/reader-stream.d.ts b/node_modules/fast-glob/out/providers/reader-stream.d.ts
new file mode 100644
index 0000000..ebe0d5b
--- /dev/null
+++ b/node_modules/fast-glob/out/providers/reader-stream.d.ts
@@ -0,0 +1,27 @@
+/// <reference types="node" />
+import * as readdir from '@mrmlnc/readdir-enhanced';
+import Reader from './reader';
+import FileSystemStream from '../adapters/fs-stream';
+import { ITask } from '../managers/tasks';
+export default class ReaderStream extends Reader<NodeJS.ReadableStream> {
+ /**
+ * Returns FileSystem adapter.
+ */
+ readonly fsAdapter: FileSystemStream;
+ /**
+ * Use stream API to read entries for Task.
+ */
+ read(task: ITask): NodeJS.ReadableStream;
+ /**
+ * Returns founded paths.
+ */
+ api(root: string, task: ITask, options: readdir.Options): NodeJS.ReadableStream;
+ /**
+ * Api for dynamic tasks.
+ */
+ dynamicApi(root: string, options: readdir.Options): NodeJS.ReadableStream;
+ /**
+ * Api for static tasks.
+ */
+ staticApi(task: ITask, options: readdir.Options): NodeJS.ReadableStream;
+}
diff --git a/node_modules/fast-glob/out/providers/reader-stream.js b/node_modules/fast-glob/out/providers/reader-stream.js
new file mode 100644
index 0000000..fd4493d
--- /dev/null
+++ b/node_modules/fast-glob/out/providers/reader-stream.js
@@ -0,0 +1,83 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+ var extendStatics = function (d, b) {
+ extendStatics = Object.setPrototypeOf ||
+ ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+ function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+ return extendStatics(d, b);
+ };
+ return function (d, b) {
+ extendStatics(d, b);
+ function __() { this.constructor = d; }
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+ };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var stream = require("stream");
+var readdir = require("@mrmlnc/readdir-enhanced");
+var reader_1 = require("./reader");
+var fs_stream_1 = require("../adapters/fs-stream");
+var TransformStream = /** @class */ (function (_super) {
+ __extends(TransformStream, _super);
+ function TransformStream(reader) {
+ var _this = _super.call(this, { objectMode: true }) || this;
+ _this.reader = reader;
+ return _this;
+ }
+ TransformStream.prototype._transform = function (entry, _encoding, callback) {
+ callback(null, this.reader.transform(entry));
+ };
+ return TransformStream;
+}(stream.Transform));
+var ReaderStream = /** @class */ (function (_super) {
+ __extends(ReaderStream, _super);
+ function ReaderStream() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ Object.defineProperty(ReaderStream.prototype, "fsAdapter", {
+ /**
+ * Returns FileSystem adapter.
+ */
+ get: function () {
+ return new fs_stream_1.default(this.options);
+ },
+ enumerable: true,
+ configurable: true
+ });
+ /**
+ * Use stream API to read entries for Task.
+ */
+ ReaderStream.prototype.read = function (task) {
+ var _this = this;
+ var root = this.getRootDirectory(task);
+ var options = this.getReaderOptions(task);
+ var transform = new TransformStream(this);
+ var readable = this.api(root, task, options);
+ return readable
+ .on('error', function (err) { return _this.isEnoentCodeError(err) ? null : transform.emit('error', err); })
+ .pipe(transform);
+ };
+ /**
+ * Returns founded paths.
+ */
+ ReaderStream.prototype.api = function (root, task, options) {
+ if (task.dynamic) {
+ return this.dynamicApi(root, options);
+ }
+ return this.staticApi(task, options);
+ };
+ /**
+ * Api for dynamic tasks.
+ */
+ ReaderStream.prototype.dynamicApi = function (root, options) {
+ return readdir.readdirStreamStat(root, options);
+ };
+ /**
+ * Api for static tasks.
+ */
+ ReaderStream.prototype.staticApi = function (task, options) {
+ return this.fsAdapter.read(task.patterns, options.filter);
+ };
+ return ReaderStream;
+}(reader_1.default));
+exports.default = ReaderStream;
diff --git a/node_modules/fast-glob/out/providers/reader-sync.d.ts b/node_modules/fast-glob/out/providers/reader-sync.d.ts
new file mode 100644
index 0000000..07e16ea
--- /dev/null
+++ b/node_modules/fast-glob/out/providers/reader-sync.d.ts
@@ -0,0 +1,27 @@
+import * as readdir from '@mrmlnc/readdir-enhanced';
+import Reader from './reader';
+import FileSystemSync from '../adapters/fs-sync';
+import { ITask } from '../managers/tasks';
+import { Entry, EntryItem } from '../types/entries';
+export default class ReaderSync extends Reader<EntryItem[]> {
+ /**
+ * Returns FileSystem adapter.
+ */
+ readonly fsAdapter: FileSystemSync;
+ /**
+ * Use sync API to read entries for Task.
+ */
+ read(task: ITask): EntryItem[];
+ /**
+ * Returns founded paths.
+ */
+ api(root: string, task: ITask, options: readdir.Options): Entry[];
+ /**
+ * Api for dynamic tasks.
+ */
+ dynamicApi(root: string, options: readdir.Options): Entry[];
+ /**
+ * Api for static tasks.
+ */
+ staticApi(task: ITask, options: readdir.Options): Entry[];
+}
diff --git a/node_modules/fast-glob/out/providers/reader-sync.js b/node_modules/fast-glob/out/providers/reader-sync.js
new file mode 100644
index 0000000..74b5e76
--- /dev/null
+++ b/node_modules/fast-glob/out/providers/reader-sync.js
@@ -0,0 +1,74 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+ var extendStatics = function (d, b) {
+ extendStatics = Object.setPrototypeOf ||
+ ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+ function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+ return extendStatics(d, b);
+ };
+ return function (d, b) {
+ extendStatics(d, b);
+ function __() { this.constructor = d; }
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+ };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var readdir = require("@mrmlnc/readdir-enhanced");
+var reader_1 = require("./reader");
+var fs_sync_1 = require("../adapters/fs-sync");
+var ReaderSync = /** @class */ (function (_super) {
+ __extends(ReaderSync, _super);
+ function ReaderSync() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ Object.defineProperty(ReaderSync.prototype, "fsAdapter", {
+ /**
+ * Returns FileSystem adapter.
+ */
+ get: function () {
+ return new fs_sync_1.default(this.options);
+ },
+ enumerable: true,
+ configurable: true
+ });
+ /**
+ * Use sync API to read entries for Task.
+ */
+ ReaderSync.prototype.read = function (task) {
+ var root = this.getRootDirectory(task);
+ var options = this.getReaderOptions(task);
+ try {
+ var entries = this.api(root, task, options);
+ return entries.map(this.transform, this);
+ }
+ catch (err) {
+ if (this.isEnoentCodeError(err)) {
+ return [];
+ }
+ throw err;
+ }
+ };
+ /**
+ * Returns founded paths.
+ */
+ ReaderSync.prototype.api = function (root, task, options) {
+ if (task.dynamic) {
+ return this.dynamicApi(root, options);
+ }
+ return this.staticApi(task, options);
+ };
+ /**
+ * Api for dynamic tasks.
+ */
+ ReaderSync.prototype.dynamicApi = function (root, options) {
+ return readdir.readdirSyncStat(root, options);
+ };
+ /**
+ * Api for static tasks.
+ */
+ ReaderSync.prototype.staticApi = function (task, options) {
+ return this.fsAdapter.read(task.patterns, options.filter);
+ };
+ return ReaderSync;
+}(reader_1.default));
+exports.default = ReaderSync;
diff --git a/node_modules/fast-glob/out/providers/reader.d.ts b/node_modules/fast-glob/out/providers/reader.d.ts
new file mode 100644
index 0000000..ce6ba61
--- /dev/null
+++ b/node_modules/fast-glob/out/providers/reader.d.ts
@@ -0,0 +1,39 @@
+/// <reference types="node" />
+import micromatch = require('micromatch');
+import DeepFilter from './filters/deep';
+import EntryFilter from './filters/entry';
+import { IOptions } from '../managers/options';
+import { ITask } from '../managers/tasks';
+import { Options as IReaddirOptions } from '@mrmlnc/readdir-enhanced';
+import { Entry, EntryItem } from '../types/entries';
+export default abstract class Reader<T> {
+ readonly options: IOptions;
+ readonly entryFilter: EntryFilter;
+ readonly deepFilter: DeepFilter;
+ private readonly micromatchOptions;
+ constructor(options: IOptions);
+ /**
+ * The main logic of reading the directories that must be implemented by each providers.
+ */
+ abstract read(_task: ITask): T;
+ /**
+ * Returns root path to scanner.
+ */
+ getRootDirectory(task: ITask): string;
+ /**
+ * Returns options for reader.
+ */
+ getReaderOptions(task: ITask): IReaddirOptions;
+ /**
+ * Returns options for micromatch.
+ */
+ getMicromatchOptions(): micromatch.Options;
+ /**
+ * Returns transformed entry.
+ */
+ transform(entry: Entry): EntryItem;
+ /**
+ * Returns true if error has ENOENT code.
+ */
+ isEnoentCodeError(err: NodeJS.ErrnoException): boolean;
+}
diff --git a/node_modules/fast-glob/out/providers/reader.js b/node_modules/fast-glob/out/providers/reader.js
new file mode 100644
index 0000000..b74be5d
--- /dev/null
+++ b/node_modules/fast-glob/out/providers/reader.js
@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var path = require("path");
+var deep_1 = require("./filters/deep");
+var entry_1 = require("./filters/entry");
+var pathUtil = require("../utils/path");
+var Reader = /** @class */ (function () {
+ function Reader(options) {
+ this.options = options;
+ this.micromatchOptions = this.getMicromatchOptions();
+ this.entryFilter = new entry_1.default(options, this.micromatchOptions);
+ this.deepFilter = new deep_1.default(options, this.micromatchOptions);
+ }
+ /**
+ * Returns root path to scanner.
+ */
+ Reader.prototype.getRootDirectory = function (task) {
+ return path.resolve(this.options.cwd, task.base);
+ };
+ /**
+ * Returns options for reader.
+ */
+ Reader.prototype.getReaderOptions = function (task) {
+ return {
+ basePath: task.base === '.' ? '' : task.base,
+ filter: this.entryFilter.getFilter(task.positive, task.negative),
+ deep: this.deepFilter.getFilter(task.positive, task.negative),
+ sep: '/'
+ };
+ };
+ /**
+ * Returns options for micromatch.
+ */
+ Reader.prototype.getMicromatchOptions = function () {
+ return {
+ dot: this.options.dot,
+ nobrace: !this.options.brace,
+ noglobstar: !this.options.globstar,
+ noext: !this.options.extension,
+ nocase: !this.options.case,
+ matchBase: this.options.matchBase
+ };
+ };
+ /**
+ * Returns transformed entry.
+ */
+ Reader.prototype.transform = function (entry) {
+ if (this.options.absolute) {
+ entry.path = pathUtil.makeAbsolute(this.options.cwd, entry.path);
+ }
+ if (this.options.markDirectories && entry.isDirectory()) {
+ entry.path += '/';
+ }
+ var item = this.options.stats ? entry : entry.path;
+ if (this.options.transform === null) {
+ return item;
+ }
+ return this.options.transform(item);
+ };
+ /**
+ * Returns true if error has ENOENT code.
+ */
+ Reader.prototype.isEnoentCodeError = function (err) {
+ return err.code === 'ENOENT';
+ };
+ return Reader;
+}());
+exports.default = Reader;
diff --git a/node_modules/fast-glob/out/types/entries.d.ts b/node_modules/fast-glob/out/types/entries.d.ts
new file mode 100644
index 0000000..57a17dd
--- /dev/null
+++ b/node_modules/fast-glob/out/types/entries.d.ts
@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import * as fs from 'fs';
+export interface IEntry extends fs.Stats {
+ path: string;
+ depth: number;
+}
+export declare type EntryItem = string | IEntry;
+export declare type Entry = IEntry;
diff --git a/node_modules/fast-glob/out/types/entries.js b/node_modules/fast-glob/out/types/entries.js
new file mode 100644
index 0000000..c8ad2e5
--- /dev/null
+++ b/node_modules/fast-glob/out/types/entries.js
@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
diff --git a/node_modules/fast-glob/out/types/patterns.d.ts b/node_modules/fast-glob/out/types/patterns.d.ts
new file mode 100644
index 0000000..96869fd
--- /dev/null
+++ b/node_modules/fast-glob/out/types/patterns.d.ts
@@ -0,0 +1,3 @@
+export declare type Pattern = string;
+export declare type PatternRe = RegExp;
+export declare type PatternsGroup = Record<string, Pattern[]>;
diff --git a/node_modules/fast-glob/out/types/patterns.js b/node_modules/fast-glob/out/types/patterns.js
new file mode 100644
index 0000000..c8ad2e5
--- /dev/null
+++ b/node_modules/fast-glob/out/types/patterns.js
@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
diff --git a/node_modules/fast-glob/out/utils/array.d.ts b/node_modules/fast-glob/out/utils/array.d.ts
new file mode 100644
index 0000000..60c9086
--- /dev/null
+++ b/node_modules/fast-glob/out/utils/array.d.ts
@@ -0,0 +1,4 @@
+/**
+ * Flatten nested arrays (max depth is 2) into a non-nested array of non-array items.
+ */
+export declare function flatten<T>(items: T[][]): T[];
diff --git a/node_modules/fast-glob/out/utils/array.js b/node_modules/fast-glob/out/utils/array.js
new file mode 100644
index 0000000..54c7f1b
--- /dev/null
+++ b/node_modules/fast-glob/out/utils/array.js
@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Flatten nested arrays (max depth is 2) into a non-nested array of non-array items.
+ */
+function flatten(items) {
+ return items.reduce(function (collection, item) { return [].concat(collection, item); }, []);
+}
+exports.flatten = flatten;
diff --git a/node_modules/fast-glob/out/utils/path.d.ts b/node_modules/fast-glob/out/utils/path.d.ts
new file mode 100644
index 0000000..87dfe19
--- /dev/null
+++ b/node_modules/fast-glob/out/utils/path.d.ts
@@ -0,0 +1,12 @@
+/**
+ * Returns «true» if the last partial of the path starting with a period.
+ */
+export declare function isDotDirectory(filepath: string): boolean;
+/**
+ * Convert a windows-like path to a unix-style path.
+ */
+export declare function normalize(filepath: string): string;
+/**
+ * Returns normalized absolute path of provided filepath.
+ */
+export declare function makeAbsolute(cwd: string, filepath: string): string;
diff --git a/node_modules/fast-glob/out/utils/path.js b/node_modules/fast-glob/out/utils/path.js
new file mode 100644
index 0000000..ffca3fd
--- /dev/null
+++ b/node_modules/fast-glob/out/utils/path.js
@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var path = require("path");
+/**
+ * Returns «true» if the last partial of the path starting with a period.
+ */
+function isDotDirectory(filepath) {
+ return path.basename(filepath).startsWith('.');
+}
+exports.isDotDirectory = isDotDirectory;
+/**
+ * Convert a windows-like path to a unix-style path.
+ */
+function normalize(filepath) {
+ return filepath.replace(/\\/g, '/');
+}
+exports.normalize = normalize;
+/**
+ * Returns normalized absolute path of provided filepath.
+ */
+function makeAbsolute(cwd, filepath) {
+ return normalize(path.resolve(cwd, filepath));
+}
+exports.makeAbsolute = makeAbsolute;
diff --git a/node_modules/fast-glob/out/utils/pattern.d.ts b/node_modules/fast-glob/out/utils/pattern.d.ts
new file mode 100644
index 0000000..567aefd
--- /dev/null
+++ b/node_modules/fast-glob/out/utils/pattern.d.ts
@@ -0,0 +1,74 @@
+import micromatch = require('micromatch');
+import { Pattern, PatternRe } from '../types/patterns';
+/**
+ * Return true for static pattern.
+ */
+export declare function isStaticPattern(pattern: Pattern): boolean;
+/**
+ * Return true for pattern that looks like glob.
+ */
+export declare function isDynamicPattern(pattern: Pattern): boolean;
+/**
+ * Convert a windows «path» to a unix-style «path».
+ */
+export declare function unixifyPattern(pattern: Pattern): Pattern;
+/**
+ * Returns negative pattern as positive pattern.
+ */
+export declare function convertToPositivePattern(pattern: Pattern): Pattern;
+/**
+ * Returns positive pattern as negative pattern.
+ */
+export declare function convertToNegativePattern(pattern: Pattern): Pattern;
+/**
+ * Return true if provided pattern is negative pattern.
+ */
+export declare function isNegativePattern(pattern: Pattern): boolean;
+/**
+ * Return true if provided pattern is positive pattern.
+ */
+export declare function isPositivePattern(pattern: Pattern): boolean;
+/**
+ * Extracts negative patterns from array of patterns.
+ */
+export declare function getNegativePatterns(patterns: Pattern[]): Pattern[];
+/**
+ * Extracts positive patterns from array of patterns.
+ */
+export declare function getPositivePatterns(patterns: Pattern[]): Pattern[];
+/**
+ * Extract base directory from provided pattern.
+ */
+export declare function getBaseDirectory(pattern: Pattern): string;
+/**
+ * Return true if provided pattern has globstar.
+ */
+export declare function hasGlobStar(pattern: Pattern): boolean;
+/**
+ * Return true if provided pattern ends with slash and globstar.
+ */
+export declare function endsWithSlashGlobStar(pattern: Pattern): boolean;
+/**
+ * Returns «true» when pattern ends with a slash and globstar or the last partial of the pattern is static pattern.
+ */
+export declare function isAffectDepthOfReadingPattern(pattern: Pattern): boolean;
+/**
+ * Return naive depth of provided pattern without depth of the base directory.
+ */
+export declare function getNaiveDepth(pattern: Pattern): number;
+/**
+ * Return max naive depth of provided patterns without depth of the base directory.
+ */
+export declare function getMaxNaivePatternsDepth(patterns: Pattern[]): number;
+/**
+ * Make RegExp for provided pattern.
+ */
+export declare function makeRe(pattern: Pattern, options: micromatch.Options): PatternRe;
+/**
+ * Convert patterns to regexps.
+ */
+export declare function convertPatternsToRe(patterns: Pattern[], options: micromatch.Options): PatternRe[];
+/**
+ * Returns true if the entry match any of the given RegExp's.
+ */
+export declare function matchAny(entry: string, patternsRe: PatternRe[]): boolean;
diff --git a/node_modules/fast-glob/out/utils/pattern.js b/node_modules/fast-glob/out/utils/pattern.js
new file mode 100644
index 0000000..1dca26f
--- /dev/null
+++ b/node_modules/fast-glob/out/utils/pattern.js
@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var path = require("path");
+var globParent = require("glob-parent");
+var isGlob = require("is-glob");
+var micromatch = require("micromatch");
+var GLOBSTAR = '**';
+/**
+ * Return true for static pattern.
+ */
+function isStaticPattern(pattern) {
+ return !isDynamicPattern(pattern);
+}
+exports.isStaticPattern = isStaticPattern;
+/**
+ * Return true for pattern that looks like glob.
+ */
+function isDynamicPattern(pattern) {
+ return isGlob(pattern, { strict: false });
+}
+exports.isDynamicPattern = isDynamicPattern;
+/**
+ * Convert a windows «path» to a unix-style «path».
+ */
+function unixifyPattern(pattern) {
+ return pattern.replace(/\\/g, '/');
+}
+exports.unixifyPattern = unixifyPattern;
+/**
+ * Returns negative pattern as positive pattern.
+ */
+function convertToPositivePattern(pattern) {
+ return isNegativePattern(pattern) ? pattern.slice(1) : pattern;
+}
+exports.convertToPositivePattern = convertToPositivePattern;
+/**
+ * Returns positive pattern as negative pattern.
+ */
+function convertToNegativePattern(pattern) {
+ return '!' + pattern;
+}
+exports.convertToNegativePattern = convertToNegativePattern;
+/**
+ * Return true if provided pattern is negative pattern.
+ */
+function isNegativePattern(pattern) {
+ return pattern.startsWith('!') && pattern[1] !== '(';
+}
+exports.isNegativePattern = isNegativePattern;
+/**
+ * Return true if provided pattern is positive pattern.
+ */
+function isPositivePattern(pattern) {
+ return !isNegativePattern(pattern);
+}
+exports.isPositivePattern = isPositivePattern;
+/**
+ * Extracts negative patterns from array of patterns.
+ */
+function getNegativePatterns(patterns) {
+ return patterns.filter(isNegativePattern);
+}
+exports.getNegativePatterns = getNegativePatterns;
+/**
+ * Extracts positive patterns from array of patterns.
+ */
+function getPositivePatterns(patterns) {
+ return patterns.filter(isPositivePattern);
+}
+exports.getPositivePatterns = getPositivePatterns;
+/**
+ * Extract base directory from provided pattern.
+ */
+function getBaseDirectory(pattern) {
+ return globParent(pattern);
+}
+exports.getBaseDirectory = getBaseDirectory;
+/**
+ * Return true if provided pattern has globstar.
+ */
+function hasGlobStar(pattern) {
+ return pattern.indexOf(GLOBSTAR) !== -1;
+}
+exports.hasGlobStar = hasGlobStar;
+/**
+ * Return true if provided pattern ends with slash and globstar.
+ */
+function endsWithSlashGlobStar(pattern) {
+ return pattern.endsWith('/' + GLOBSTAR);
+}
+exports.endsWithSlashGlobStar = endsWithSlashGlobStar;
+/**
+ * Returns «true» when pattern ends with a slash and globstar or the last partial of the pattern is static pattern.
+ */
+function isAffectDepthOfReadingPattern(pattern) {
+ var basename = path.basename(pattern);
+ return endsWithSlashGlobStar(pattern) || isStaticPattern(basename);
+}
+exports.isAffectDepthOfReadingPattern = isAffectDepthOfReadingPattern;
+/**
+ * Return naive depth of provided pattern without depth of the base directory.
+ */
+function getNaiveDepth(pattern) {
+ var base = getBaseDirectory(pattern);
+ var patternDepth = pattern.split('/').length;
+ var patternBaseDepth = base.split('/').length;
+ /**
+ * This is a hack for pattern that has no base directory.
+ *
+ * This is related to the `*\something\*` pattern.
+ */
+ if (base === '.') {
+ return patternDepth - patternBaseDepth;
+ }
+ return patternDepth - patternBaseDepth - 1;
+}
+exports.getNaiveDepth = getNaiveDepth;
+/**
+ * Return max naive depth of provided patterns without depth of the base directory.
+ */
+function getMaxNaivePatternsDepth(patterns) {
+ return patterns.reduce(function (max, pattern) {
+ var depth = getNaiveDepth(pattern);
+ return depth > max ? depth : max;
+ }, 0);
+}
+exports.getMaxNaivePatternsDepth = getMaxNaivePatternsDepth;
+/**
+ * Make RegExp for provided pattern.
+ */
+function makeRe(pattern, options) {
+ return micromatch.makeRe(pattern, options);
+}
+exports.makeRe = makeRe;
+/**
+ * Convert patterns to regexps.
+ */
+function convertPatternsToRe(patterns, options) {
+ return patterns.map(function (pattern) { return makeRe(pattern, options); });
+}
+exports.convertPatternsToRe = convertPatternsToRe;
+/**
+ * Returns true if the entry match any of the given RegExp's.
+ */
+function matchAny(entry, patternsRe) {
+ return patternsRe.some(function (patternRe) { return patternRe.test(entry); });
+}
+exports.matchAny = matchAny;
diff --git a/node_modules/fast-glob/out/utils/stream.d.ts b/node_modules/fast-glob/out/utils/stream.d.ts
new file mode 100644
index 0000000..af67264
--- /dev/null
+++ b/node_modules/fast-glob/out/utils/stream.d.ts
@@ -0,0 +1,5 @@
+/// <reference types="node" />
+/**
+ * Merge multiple streams and propagate their errors into one stream in parallel.
+ */
+export declare function merge(streams: NodeJS.ReadableStream[]): NodeJS.ReadableStream;
diff --git a/node_modules/fast-glob/out/utils/stream.js b/node_modules/fast-glob/out/utils/stream.js
new file mode 100644
index 0000000..03134e9
--- /dev/null
+++ b/node_modules/fast-glob/out/utils/stream.js
@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var merge2 = require("merge2");
+/**
+ * Merge multiple streams and propagate their errors into one stream in parallel.
+ */
+function merge(streams) {
+ var mergedStream = merge2(streams);
+ streams.forEach(function (stream) {
+ stream.on('error', function (err) { return mergedStream.emit('error', err); });
+ });
+ return mergedStream;
+}
+exports.merge = merge;