Index: frontend/node_modules/fast-glob/LICENSE
===================================================================
--- frontend/node_modules/fast-glob/LICENSE (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/LICENSE (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Denis Malinochkin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
Index: frontend/node_modules/fast-glob/README.md
===================================================================
--- frontend/node_modules/fast-glob/README.md (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/README.md (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,830 @@
+# fast-glob
+
+> It's a very fast and efficient [glob][glob_definition] library for [Node.js][node_js].
+
+This package provides methods for traversing the file system and returning pathnames that matched a defined set of a specified pattern according to the rules used by the Unix Bash shell with some simplifications, meanwhile results are returned in **arbitrary order**. Quick, simple, effective.
+
+## Table of Contents
+
+
+Details
+
+* [Highlights](#highlights)
+* [Old and modern mode](#old-and-modern-mode)
+* [Pattern syntax](#pattern-syntax)
+ * [Basic syntax](#basic-syntax)
+ * [Advanced syntax](#advanced-syntax)
+* [Installation](#installation)
+* [API](#api)
+ * [Asynchronous](#asynchronous)
+ * [Synchronous](#synchronous)
+ * [Stream](#stream)
+ * [patterns](#patterns)
+ * [[options]](#options)
+ * [Helpers](#helpers)
+ * [generateTasks](#generatetaskspatterns-options)
+ * [isDynamicPattern](#isdynamicpatternpattern-options)
+ * [escapePath](#escapepathpath)
+ * [convertPathToPattern](#convertpathtopatternpath)
+* [Options](#options-3)
+ * [Common](#common)
+ * [concurrency](#concurrency)
+ * [cwd](#cwd)
+ * [deep](#deep)
+ * [followSymbolicLinks](#followsymboliclinks)
+ * [fs](#fs)
+ * [ignore](#ignore)
+ * [suppressErrors](#suppresserrors)
+ * [throwErrorOnBrokenSymbolicLink](#throwerroronbrokensymboliclink)
+ * [Output control](#output-control)
+ * [absolute](#absolute)
+ * [markDirectories](#markdirectories)
+ * [objectMode](#objectmode)
+ * [onlyDirectories](#onlydirectories)
+ * [onlyFiles](#onlyfiles)
+ * [stats](#stats)
+ * [unique](#unique)
+ * [Matching control](#matching-control)
+ * [braceExpansion](#braceexpansion)
+ * [caseSensitiveMatch](#casesensitivematch)
+ * [dot](#dot)
+ * [extglob](#extglob)
+ * [globstar](#globstar)
+ * [baseNameMatch](#basenamematch)
+* [FAQ](#faq)
+ * [What is a static or dynamic pattern?](#what-is-a-static-or-dynamic-pattern)
+ * [How to write patterns on Windows?](#how-to-write-patterns-on-windows)
+ * [Why are parentheses match wrong?](#why-are-parentheses-match-wrong)
+ * [How to exclude directory from reading?](#how-to-exclude-directory-from-reading)
+ * [How to use UNC path?](#how-to-use-unc-path)
+ * [Compatible with `node-glob`?](#compatible-with-node-glob)
+* [Benchmarks](#benchmarks)
+ * [Server](#server)
+ * [Nettop](#nettop)
+* [Changelog](#changelog)
+* [License](#license)
+
+
+
+## Highlights
+
+* Fast. Probably the fastest.
+* Supports multiple and negative patterns.
+* Synchronous, Promise and Stream API.
+* Object mode. Can return more than just strings.
+* Error-tolerant.
+
+## Old and modern mode
+
+This package works in two modes, depending on the environment in which it is used.
+
+* **Old mode**. Node.js below 10.10 or when the [`stats`](#stats) option is *enabled*.
+* **Modern mode**. Node.js 10.10+ and the [`stats`](#stats) option is *disabled*.
+
+The modern mode is faster. Learn more about the [internal mechanism][nodelib_fs_scandir_old_and_modern_modern].
+
+## Pattern syntax
+
+> :warning: Always use forward-slashes in glob expressions (patterns and [`ignore`](#ignore) option). Use backslashes for escaping characters.
+
+There is more than one form of syntax: basic and advanced. Below is a brief overview of the supported features. Also pay attention to our [FAQ](#faq).
+
+> :book: This package uses [`micromatch`][micromatch] as a library for pattern matching.
+
+### Basic syntax
+
+* An asterisk (`*`) — matches everything except slashes (path separators), hidden files (names starting with `.`).
+* A double star or globstar (`**`) — matches zero or more directories.
+* Question mark (`?`) – matches any single character except slashes (path separators).
+* Sequence (`[seq]`) — matches any character in sequence.
+
+> :book: A few additional words about the [basic matching behavior][picomatch_matching_behavior].
+
+Some examples:
+
+* `src/**/*.js` — matches all files in the `src` directory (any level of nesting) that have the `.js` extension.
+* `src/*.??` — matches all files in the `src` directory (only first level of nesting) that have a two-character extension.
+* `file-[01].js` — matches files: `file-0.js`, `file-1.js`.
+
+### Advanced syntax
+
+* [Escapes characters][micromatch_backslashes] (`\\`) — matching special characters (`$^*+?()[]`) as literals.
+* [POSIX character classes][picomatch_posix_brackets] (`[[:digit:]]`).
+* [Extended globs][micromatch_extglobs] (`?(pattern-list)`).
+* [Bash style brace expansions][micromatch_braces] (`{}`).
+* [Regexp character classes][micromatch_regex_character_classes] (`[1-5]`).
+* [Regex groups][regular_expressions_brackets] (`(a|b)`).
+
+> :book: A few additional words about the [advanced matching behavior][micromatch_extended_globbing].
+
+Some examples:
+
+* `src/**/*.{css,scss}` — matches all files in the `src` directory (any level of nesting) that have the `.css` or `.scss` extension.
+* `file-[[:digit:]].js` — matches files: `file-0.js`, `file-1.js`, …, `file-9.js`.
+* `file-{1..3}.js` — matches files: `file-1.js`, `file-2.js`, `file-3.js`.
+* `file-(1|2)` — matches files: `file-1.js`, `file-2.js`.
+
+## Installation
+
+```console
+npm install fast-glob
+```
+
+## API
+
+### Asynchronous
+
+```js
+fg(patterns, [options])
+fg.async(patterns, [options])
+fg.glob(patterns, [options])
+```
+
+Returns a `Promise` with an array of matching entries.
+
+```js
+const fg = require('fast-glob');
+
+const entries = await fg(['.editorconfig', '**/index.js'], { dot: true });
+
+// ['.editorconfig', 'services/index.js']
+```
+
+### Synchronous
+
+```js
+fg.sync(patterns, [options])
+fg.globSync(patterns, [options])
+```
+
+Returns an array of matching entries.
+
+```js
+const fg = require('fast-glob');
+
+const entries = fg.sync(['.editorconfig', '**/index.js'], { dot: true });
+
+// ['.editorconfig', 'services/index.js']
+```
+
+### Stream
+
+```js
+fg.stream(patterns, [options])
+fg.globStream(patterns, [options])
+```
+
+Returns a [`ReadableStream`][node_js_stream_readable_streams] when the `data` event will be emitted with matching entry.
+
+```js
+const fg = require('fast-glob');
+
+const stream = fg.stream(['.editorconfig', '**/index.js'], { dot: true });
+
+for await (const entry of stream) {
+ // .editorconfig
+ // services/index.js
+}
+```
+
+#### patterns
+
+* Required: `true`
+* Type: `string | string[]`
+
+Any correct pattern(s).
+
+> :1234: [Pattern syntax](#pattern-syntax)
+>
+> :warning: This package does not respect the order of patterns. First, all the negative patterns are applied, and only then the positive patterns. If you want to get a certain order of records, use sorting or split calls.
+
+#### [options]
+
+* Required: `false`
+* Type: [`Options`](#options-3)
+
+See [Options](#options-3) section.
+
+### Helpers
+
+#### `generateTasks(patterns, [options])`
+
+Returns the internal representation of patterns ([`Task`](./src/managers/tasks.ts) is a combining patterns by base directory).
+
+```js
+fg.generateTasks('*');
+
+[{
+ base: '.', // Parent directory for all patterns inside this task
+ dynamic: true, // Dynamic or static patterns are in this task
+ patterns: ['*'],
+ positive: ['*'],
+ negative: []
+}]
+```
+
+##### patterns
+
+* Required: `true`
+* Type: `string | string[]`
+
+Any correct pattern(s).
+
+##### [options]
+
+* Required: `false`
+* Type: [`Options`](#options-3)
+
+See [Options](#options-3) section.
+
+#### `isDynamicPattern(pattern, [options])`
+
+Returns `true` if the passed pattern is a dynamic pattern.
+
+> :1234: [What is a static or dynamic pattern?](#what-is-a-static-or-dynamic-pattern)
+
+```js
+fg.isDynamicPattern('*'); // true
+fg.isDynamicPattern('abc'); // false
+```
+
+##### pattern
+
+* Required: `true`
+* Type: `string`
+
+Any correct pattern.
+
+##### [options]
+
+* Required: `false`
+* Type: [`Options`](#options-3)
+
+See [Options](#options-3) section.
+
+#### `escapePath(path)`
+
+Returns the path with escaped special characters depending on the platform.
+
+* Posix:
+ * `*?|(){}[]`;
+ * `!` at the beginning of line;
+ * `@+!` before the opening parenthesis;
+ * `\\` before non-special characters;
+* Windows:
+ * `(){}[]`
+ * `!` at the beginning of line;
+ * `@+!` before the opening parenthesis;
+ * Characters like `*?|` cannot be used in the path ([windows_naming_conventions][windows_naming_conventions]), so they will not be escaped;
+
+```js
+fg.escapePath('!abc');
+// \\!abc
+fg.escapePath('[OpenSource] mrmlnc – fast-glob (Deluxe Edition) 2014') + '/*.flac'
+// \\[OpenSource\\] mrmlnc – fast-glob \\(Deluxe Edition\\) 2014/*.flac
+
+fg.posix.escapePath('C:\\Program Files (x86)\\**\\*');
+// C:\\\\Program Files \\(x86\\)\\*\\*\\*
+fg.win32.escapePath('C:\\Program Files (x86)\\**\\*');
+// Windows: C:\\Program Files \\(x86\\)\\**\\*
+```
+
+#### `convertPathToPattern(path)`
+
+Converts a path to a pattern depending on the platform, including special character escaping.
+
+* Posix. Works similarly to the `fg.posix.escapePath` method.
+* Windows. Works similarly to the `fg.win32.escapePath` method, additionally converting backslashes to forward slashes in cases where they are not escape characters (`!()+@{}[]`).
+
+```js
+fg.convertPathToPattern('[OpenSource] mrmlnc – fast-glob (Deluxe Edition) 2014') + '/*.flac';
+// \\[OpenSource\\] mrmlnc – fast-glob \\(Deluxe Edition\\) 2014/*.flac
+
+fg.convertPathToPattern('C:/Program Files (x86)/**/*');
+// Posix: C:/Program Files \\(x86\\)/\\*\\*/\\*
+// Windows: C:/Program Files \\(x86\\)/**/*
+
+fg.convertPathToPattern('C:\\Program Files (x86)\\**\\*');
+// Posix: C:\\\\Program Files \\(x86\\)\\*\\*\\*
+// Windows: C:/Program Files \\(x86\\)/**/*
+
+fg.posix.convertPathToPattern('\\\\?\\c:\\Program Files (x86)') + '/**/*';
+// Posix: \\\\\\?\\\\c:\\\\Program Files \\(x86\\)/**/* (broken pattern)
+fg.win32.convertPathToPattern('\\\\?\\c:\\Program Files (x86)') + '/**/*';
+// Windows: //?/c:/Program Files \\(x86\\)/**/*
+```
+
+## Options
+
+### Common options
+
+#### concurrency
+
+* Type: `number`
+* Default: `os.cpus().length`
+
+Specifies the maximum number of concurrent requests from a reader to read directories.
+
+> :book: The higher the number, the higher the performance and load on the file system. If you want to read in quiet mode, set the value to a comfortable number or `1`.
+
+
+
+More details
+
+In Node, there are [two types of threads][nodejs_thread_pool]: Event Loop (code) and a Thread Pool (fs, dns, …). The thread pool size controlled by the `UV_THREADPOOL_SIZE` environment variable. Its default size is 4 ([documentation][libuv_thread_pool]). The pool is one for all tasks within a single Node process.
+
+Any code can make 4 real concurrent accesses to the file system. The rest of the FS requests will wait in the queue.
+
+> :book: Each new instance of FG in the same Node process will use the same Thread pool.
+
+But this package also has the `concurrency` option. This option allows you to control the number of concurrent accesses to the FS at the package level. By default, this package has a value equal to the number of cores available for the current Node process. This allows you to set a value smaller than the pool size (`concurrency: 1`) or, conversely, to prepare tasks for the pool queue more quickly (`concurrency: Number.POSITIVE_INFINITY`).
+
+So, in fact, this package can **only make 4 concurrent requests to the FS**. You can increase this value by using an environment variable (`UV_THREADPOOL_SIZE`), but in practice this does not give a multiple advantage.
+
+
+
+#### cwd
+
+* Type: `string`
+* Default: `process.cwd()`
+
+The current working directory in which to search.
+
+#### deep
+
+* Type: `number`
+* Default: `Infinity`
+
+Specifies the maximum depth of a read directory relative to the start directory.
+
+For example, you have the following tree:
+
+```js
+dir/
+└── one/ // 1
+ └── two/ // 2
+ └── file.js // 3
+```
+
+```js
+// With base directory
+fg.sync('dir/**', { onlyFiles: false, deep: 1 }); // ['dir/one']
+fg.sync('dir/**', { onlyFiles: false, deep: 2 }); // ['dir/one', 'dir/one/two']
+
+// With cwd option
+fg.sync('**', { onlyFiles: false, cwd: 'dir', deep: 1 }); // ['one']
+fg.sync('**', { onlyFiles: false, cwd: 'dir', deep: 2 }); // ['one', 'one/two']
+```
+
+> :book: If you specify a pattern with some base directory, this directory will not participate in the calculation of the depth of the found directories. Think of it as a [`cwd`](#cwd) option.
+
+#### followSymbolicLinks
+
+* Type: `boolean`
+* Default: `true`
+
+Indicates whether to traverse descendants of symbolic link directories when expanding `**` patterns.
+
+> :book: Note that this option does not affect the base directory of the pattern. For example, if `./a` is a symlink to directory `./b` and you specified `['./a**', './b/**']` patterns, then directory `./a` will still be read.
+
+> :book: If the [`stats`](#stats) option is specified, the information about the symbolic link (`fs.lstat`) will be replaced with information about the entry (`fs.stat`) behind it.
+
+#### fs
+
+* Type: `FileSystemAdapter`
+* Default: `fs.*`
+
+Custom implementation of methods for working with the file system. Supports objects with enumerable properties only.
+
+```ts
+export interface FileSystemAdapter {
+ lstat?: typeof fs.lstat;
+ stat?: typeof fs.stat;
+ lstatSync?: typeof fs.lstatSync;
+ statSync?: typeof fs.statSync;
+ readdir?: typeof fs.readdir;
+ readdirSync?: typeof fs.readdirSync;
+}
+```
+
+#### ignore
+
+* Type: `string[]`
+* Default: `[]`
+
+An array of glob patterns to exclude matches. This is an alternative way to use negative patterns.
+
+```js
+dir/
+├── package-lock.json
+└── package.json
+```
+
+```js
+fg.sync(['*.json', '!package-lock.json']); // ['package.json']
+fg.sync('*.json', { ignore: ['package-lock.json'] }); // ['package.json']
+```
+
+#### suppressErrors
+
+* Type: `boolean`
+* Default: `false`
+
+By default this package suppress only `ENOENT` errors. Set to `true` to suppress any error.
+
+> :book: Can be useful when the directory has entries with a special level of access.
+
+#### throwErrorOnBrokenSymbolicLink
+
+* Type: `boolean`
+* Default: `false`
+
+Throw an error when symbolic link is broken if `true` or safely return `lstat` call if `false`.
+
+> :book: This option has no effect on errors when reading the symbolic link directory.
+
+### Output control
+
+#### absolute
+
+* Type: `boolean`
+* Default: `false`
+
+Return the absolute path for entries.
+
+```js
+fg.sync('*.js', { absolute: false }); // ['index.js']
+fg.sync('*.js', { absolute: true }); // ['/home/user/index.js']
+```
+
+> :book: This option is required if you want to use negative patterns with absolute path, for example, `!${__dirname}/*.js`.
+
+#### markDirectories
+
+* Type: `boolean`
+* Default: `false`
+
+Mark the directory path with the final slash.
+
+```js
+fg.sync('*', { onlyFiles: false, markDirectories: false }); // ['index.js', 'controllers']
+fg.sync('*', { onlyFiles: false, markDirectories: true }); // ['index.js', 'controllers/']
+```
+
+#### objectMode
+
+* Type: `boolean`
+* Default: `false`
+
+Returns objects (instead of strings) describing entries.
+
+```js
+fg.sync('*', { objectMode: false }); // ['src/index.js']
+fg.sync('*', { objectMode: true }); // [{ name: 'index.js', path: 'src/index.js', dirent: }]
+```
+
+The object has the following fields:
+
+* name (`string`) — the last part of the path (basename)
+* path (`string`) — full path relative to the pattern base directory
+* dirent ([`fs.Dirent`][node_js_fs_class_fs_dirent]) — instance of `fs.Dirent`
+
+> :book: An object is an internal representation of entry, so getting it does not affect performance.
+
+#### onlyDirectories
+
+* Type: `boolean`
+* Default: `false`
+
+Return only directories.
+
+```js
+fg.sync('*', { onlyDirectories: false }); // ['index.js', 'src']
+fg.sync('*', { onlyDirectories: true }); // ['src']
+```
+
+> :book: If `true`, the [`onlyFiles`](#onlyfiles) option is automatically `false`.
+
+#### onlyFiles
+
+* Type: `boolean`
+* Default: `true`
+
+Return only files.
+
+```js
+fg.sync('*', { onlyFiles: false }); // ['index.js', 'src']
+fg.sync('*', { onlyFiles: true }); // ['index.js']
+```
+
+#### stats
+
+* Type: `boolean`
+* Default: `false`
+
+Enables an [object mode](#objectmode) with an additional field:
+
+* stats ([`fs.Stats`][node_js_fs_class_fs_stats]) — instance of `fs.Stats`
+
+```js
+fg.sync('*', { stats: false }); // ['src/index.js']
+fg.sync('*', { stats: true }); // [{ name: 'index.js', path: 'src/index.js', dirent: , stats: }]
+```
+
+> :book: Returns `fs.stat` instead of `fs.lstat` for symbolic links when the [`followSymbolicLinks`](#followsymboliclinks) option is specified.
+>
+> :warning: Unlike [object mode](#objectmode) this mode requires additional calls to the file system. On average, this mode is slower at least twice. See [old and modern mode](#old-and-modern-mode) for more details.
+
+#### unique
+
+* Type: `boolean`
+* Default: `true`
+
+Ensures that the returned entries are unique.
+
+```js
+fg.sync(['*.json', 'package.json'], { unique: false }); // ['package.json', 'package.json']
+fg.sync(['*.json', 'package.json'], { unique: true }); // ['package.json']
+```
+
+If `true` and similar entries are found, the result is the first found.
+
+### Matching control
+
+#### braceExpansion
+
+* Type: `boolean`
+* Default: `true`
+
+Enables Bash-like brace expansion.
+
+> :1234: [Syntax description][bash_hackers_syntax_expansion_brace] or more [detailed description][micromatch_braces].
+
+```js
+dir/
+├── abd
+├── acd
+└── a{b,c}d
+```
+
+```js
+fg.sync('a{b,c}d', { braceExpansion: false }); // ['a{b,c}d']
+fg.sync('a{b,c}d', { braceExpansion: true }); // ['abd', 'acd']
+```
+
+#### caseSensitiveMatch
+
+* Type: `boolean`
+* Default: `true`
+
+Enables a [case-sensitive][wikipedia_case_sensitivity] mode for matching files.
+
+```js
+dir/
+├── file.txt
+└── File.txt
+```
+
+```js
+fg.sync('file.txt', { caseSensitiveMatch: false }); // ['file.txt', 'File.txt']
+fg.sync('file.txt', { caseSensitiveMatch: true }); // ['file.txt']
+```
+
+#### dot
+
+* Type: `boolean`
+* Default: `false`
+
+Allow patterns to match entries that begin with a period (`.`).
+
+> :book: Note that an explicit dot in a portion of the pattern will always match dot files.
+
+```js
+dir/
+├── .editorconfig
+└── package.json
+```
+
+```js
+fg.sync('*', { dot: false }); // ['package.json']
+fg.sync('*', { dot: true }); // ['.editorconfig', 'package.json']
+```
+
+#### extglob
+
+* Type: `boolean`
+* Default: `true`
+
+Enables Bash-like `extglob` functionality.
+
+> :1234: [Syntax description][micromatch_extglobs].
+
+```js
+dir/
+├── README.md
+└── package.json
+```
+
+```js
+fg.sync('*.+(json|md)', { extglob: false }); // []
+fg.sync('*.+(json|md)', { extglob: true }); // ['README.md', 'package.json']
+```
+
+#### globstar
+
+* Type: `boolean`
+* Default: `true`
+
+Enables recursively repeats a pattern containing `**`. If `false`, `**` behaves exactly like `*`.
+
+```js
+dir/
+└── a
+ └── b
+```
+
+```js
+fg.sync('**', { onlyFiles: false, globstar: false }); // ['a']
+fg.sync('**', { onlyFiles: false, globstar: true }); // ['a', 'a/b']
+```
+
+#### baseNameMatch
+
+* Type: `boolean`
+* Default: `false`
+
+If set to `true`, then patterns without slashes will be matched against the basename of the path if it contains slashes.
+
+```js
+dir/
+└── one/
+ └── file.md
+```
+
+```js
+fg.sync('*.md', { baseNameMatch: false }); // []
+fg.sync('*.md', { baseNameMatch: true }); // ['one/file.md']
+```
+
+## FAQ
+
+## What is a static or dynamic pattern?
+
+All patterns can be divided into two types:
+
+* **static**. A pattern is considered static if it can be used to get an entry on the file system without using matching mechanisms. For example, the `file.js` pattern is a static pattern because we can just verify that it exists on the file system.
+* **dynamic**. A pattern is considered dynamic if it cannot be used directly to find occurrences without using a matching mechanisms. For example, the `*` pattern is a dynamic pattern because we cannot use this pattern directly.
+
+A pattern is considered dynamic if it contains the following characters (`…` — any characters or their absence) or options:
+
+* The [`caseSensitiveMatch`](#casesensitivematch) option is disabled
+* `\\` (the escape character)
+* `*`, `?`, `!` (at the beginning of line)
+* `[…]`
+* `(…|…)`
+* `@(…)`, `!(…)`, `*(…)`, `?(…)`, `+(…)` (respects the [`extglob`](#extglob) option)
+* `{…,…}`, `{…..…}` (respects the [`braceExpansion`](#braceexpansion) option)
+
+## How to write patterns on Windows?
+
+Always use forward-slashes in glob expressions (patterns and [`ignore`](#ignore) option). Use backslashes for escaping characters. With the [`cwd`](#cwd) option use a convenient format.
+
+**Bad**
+
+```ts
+[
+ 'directory\\*',
+ path.join(process.cwd(), '**')
+]
+```
+
+**Good**
+
+```ts
+[
+ 'directory/*',
+ fg.convertPathToPattern(process.cwd()) + '/**'
+]
+```
+
+> :book: Use the [`.convertPathToPattern`](#convertpathtopatternpath) package to convert Windows-style path to a Unix-style path.
+
+Read more about [matching with backslashes][micromatch_backslashes].
+
+## Why are parentheses match wrong?
+
+```js
+dir/
+└── (special-*file).txt
+```
+
+```js
+fg.sync(['(special-*file).txt']) // []
+```
+
+Refers to Bash. You need to escape special characters:
+
+```js
+fg.sync(['\\(special-*file\\).txt']) // ['(special-*file).txt']
+```
+
+Read more about [matching special characters as literals][picomatch_matching_special_characters_as_literals]. Or use the [`.escapePath`](#escapepathpath).
+
+## How to exclude directory from reading?
+
+You can use a negative pattern like this: `!**/node_modules` or `!**/node_modules/**`. Also you can use [`ignore`](#ignore) option. Just look at the example below.
+
+```js
+first/
+├── file.md
+└── second/
+ └── file.txt
+```
+
+If you don't want to read the `second` directory, you must write the following pattern: `!**/second` or `!**/second/**`.
+
+```js
+fg.sync(['**/*.md', '!**/second']); // ['first/file.md']
+fg.sync(['**/*.md'], { ignore: ['**/second/**'] }); // ['first/file.md']
+```
+
+> :warning: When you write `!**/second/**/*` it means that the directory will be **read**, but all the entries will not be included in the results.
+
+You have to understand that if you write the pattern to exclude directories, then the directory will not be read under any circumstances.
+
+## How to use UNC path?
+
+You cannot use [Uniform Naming Convention (UNC)][unc_path] paths as patterns (due to syntax) directly, but you can use them as [`cwd`](#cwd) directory or use the `fg.convertPathToPattern` method.
+
+```ts
+// cwd
+fg.sync('*', { cwd: '\\\\?\\C:\\Python27' /* or //?/C:/Python27 */ });
+fg.sync('Python27/*', { cwd: '\\\\?\\C:\\' /* or //?/C:/ */ });
+
+// .convertPathToPattern
+fg.sync(fg.convertPathToPattern('\\\\?\\c:\\Python27') + '/*');
+```
+
+## Compatible with `node-glob`?
+
+| node-glob | fast-glob |
+| :----------: | :-------: |
+| `cwd` | [`cwd`](#cwd) |
+| `root` | – |
+| `dot` | [`dot`](#dot) |
+| `nomount` | – |
+| `mark` | [`markDirectories`](#markdirectories) |
+| `nosort` | – |
+| `nounique` | [`unique`](#unique) |
+| `nobrace` | [`braceExpansion`](#braceexpansion) |
+| `noglobstar` | [`globstar`](#globstar) |
+| `noext` | [`extglob`](#extglob) |
+| `nocase` | [`caseSensitiveMatch`](#casesensitivematch) |
+| `matchBase` | [`baseNameMatch`](#basenamematch) |
+| `nodir` | [`onlyFiles`](#onlyfiles) |
+| `ignore` | [`ignore`](#ignore) |
+| `follow` | [`followSymbolicLinks`](#followsymboliclinks) |
+| `realpath` | – |
+| `absolute` | [`absolute`](#absolute) |
+
+## Benchmarks
+
+You can see results [here](https://github.com/mrmlnc/fast-glob/actions/workflows/benchmark.yml?query=branch%3Amaster) for every commit into the `main` branch.
+
+* **Product benchmark** – comparison with the main competitors.
+* **Regress benchmark** – regression between the current version and the version from the npm registry.
+
+## Changelog
+
+See the [Releases section of our GitHub project][github_releases] for changelog for each release version.
+
+## License
+
+This software is released under the terms of the MIT license.
+
+[bash_hackers_syntax_expansion_brace]: https://wiki.bash-hackers.org/syntax/expansion/brace
+[github_releases]: https://github.com/mrmlnc/fast-glob/releases
+[glob_definition]: https://en.wikipedia.org/wiki/Glob_(programming)
+[glob_linux_man]: http://man7.org/linux/man-pages/man3/glob.3.html
+[micromatch_backslashes]: https://github.com/micromatch/micromatch#backslashes
+[micromatch_braces]: https://github.com/micromatch/braces
+[micromatch_extended_globbing]: https://github.com/micromatch/micromatch#extended-globbing
+[micromatch_extglobs]: https://github.com/micromatch/micromatch#extglobs
+[micromatch_regex_character_classes]: https://github.com/micromatch/micromatch#regex-character-classes
+[micromatch]: https://github.com/micromatch/micromatch
+[node_js_fs_class_fs_dirent]: https://nodejs.org/api/fs.html#fs_class_fs_dirent
+[node_js_fs_class_fs_stats]: https://nodejs.org/api/fs.html#fs_class_fs_stats
+[node_js_stream_readable_streams]: https://nodejs.org/api/stream.html#stream_readable_streams
+[node_js]: https://nodejs.org/en
+[nodelib_fs_scandir_old_and_modern_modern]: https://github.com/nodelib/nodelib/blob/master/packages/fs/fs.scandir/README.md#old-and-modern-mode
+[npm_normalize_path]: https://www.npmjs.com/package/normalize-path
+[npm_unixify]: https://www.npmjs.com/package/unixify
+[picomatch_matching_behavior]: https://github.com/micromatch/picomatch#matching-behavior-vs-bash
+[picomatch_matching_special_characters_as_literals]: https://github.com/micromatch/picomatch#matching-special-characters-as-literals
+[picomatch_posix_brackets]: https://github.com/micromatch/picomatch#posix-brackets
+[regular_expressions_brackets]: https://www.regular-expressions.info/brackets.html
+[unc_path]: https://learn.microsoft.com/openspecs/windows_protocols/ms-dtyp/62e862f4-2a51-452e-8eeb-dc4ff5ee33cc
+[wikipedia_case_sensitivity]: https://en.wikipedia.org/wiki/Case_sensitivity
+[nodejs_thread_pool]: https://nodejs.org/en/docs/guides/dont-block-the-event-loop
+[libuv_thread_pool]: http://docs.libuv.org/en/v1.x/threadpool.html
+[windows_naming_conventions]: https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file#naming-conventions
Index: frontend/node_modules/fast-glob/node_modules/glob-parent/CHANGELOG.md
===================================================================
--- frontend/node_modules/fast-glob/node_modules/glob-parent/CHANGELOG.md (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/node_modules/glob-parent/CHANGELOG.md (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,110 @@
+### [5.1.2](https://github.com/gulpjs/glob-parent/compare/v5.1.1...v5.1.2) (2021-03-06)
+
+
+### Bug Fixes
+
+* eliminate ReDoS ([#36](https://github.com/gulpjs/glob-parent/issues/36)) ([f923116](https://github.com/gulpjs/glob-parent/commit/f9231168b0041fea3f8f954b3cceb56269fc6366))
+
+### [5.1.1](https://github.com/gulpjs/glob-parent/compare/v5.1.0...v5.1.1) (2021-01-27)
+
+
+### Bug Fixes
+
+* unescape exclamation mark ([#26](https://github.com/gulpjs/glob-parent/issues/26)) ([a98874f](https://github.com/gulpjs/glob-parent/commit/a98874f1a59e407f4fb1beb0db4efa8392da60bb))
+
+## [5.1.0](https://github.com/gulpjs/glob-parent/compare/v5.0.0...v5.1.0) (2021-01-27)
+
+
+### Features
+
+* add `flipBackslashes` option to disable auto conversion of slashes (closes [#24](https://github.com/gulpjs/glob-parent/issues/24)) ([#25](https://github.com/gulpjs/glob-parent/issues/25)) ([eecf91d](https://github.com/gulpjs/glob-parent/commit/eecf91d5e3834ed78aee39c4eaaae654d76b87b3))
+
+## [5.0.0](https://github.com/gulpjs/glob-parent/compare/v4.0.0...v5.0.0) (2021-01-27)
+
+
+### ⚠ BREAKING CHANGES
+
+* Drop support for node <6 & bump dependencies
+
+### Miscellaneous Chores
+
+* Drop support for node <6 & bump dependencies ([896c0c0](https://github.com/gulpjs/glob-parent/commit/896c0c00b4e7362f60b96e7fc295ae929245255a))
+
+## [4.0.0](https://github.com/gulpjs/glob-parent/compare/v3.1.0...v4.0.0) (2021-01-27)
+
+
+### ⚠ BREAKING CHANGES
+
+* question marks are valid path characters on Windows so avoid flagging as a glob when alone
+* Update is-glob dependency
+
+### Features
+
+* hoist regexps and strings for performance gains ([4a80667](https://github.com/gulpjs/glob-parent/commit/4a80667c69355c76a572a5892b0f133c8e1f457e))
+* question marks are valid path characters on Windows so avoid flagging as a glob when alone ([2a551dd](https://github.com/gulpjs/glob-parent/commit/2a551dd0dc3235e78bf3c94843d4107072d17841))
+* Update is-glob dependency ([e41fcd8](https://github.com/gulpjs/glob-parent/commit/e41fcd895d1f7bc617dba45c9d935a7949b9c281))
+
+## [3.1.0](https://github.com/gulpjs/glob-parent/compare/v3.0.1...v3.1.0) (2021-01-27)
+
+
+### Features
+
+* allow basic win32 backslash use ([272afa5](https://github.com/gulpjs/glob-parent/commit/272afa5fd070fc0f796386a5993d4ee4a846988b))
+* handle extglobs (parentheses) containing separators ([7db1bdb](https://github.com/gulpjs/glob-parent/commit/7db1bdb0756e55fd14619e8ce31aa31b17b117fd))
+* new approach to braces/brackets handling ([8269bd8](https://github.com/gulpjs/glob-parent/commit/8269bd89290d99fac9395a354fb56fdcdb80f0be))
+* pre-process braces/brackets sections ([9ef8a87](https://github.com/gulpjs/glob-parent/commit/9ef8a87f66b1a43d0591e7a8e4fc5a18415ee388))
+* preserve escaped brace/bracket at end of string ([8cfb0ba](https://github.com/gulpjs/glob-parent/commit/8cfb0ba84202d51571340dcbaf61b79d16a26c76))
+
+
+### Bug Fixes
+
+* trailing escaped square brackets ([99ec9fe](https://github.com/gulpjs/glob-parent/commit/99ec9fecc60ee488ded20a94dd4f18b4f55c4ccf))
+
+### [3.0.1](https://github.com/gulpjs/glob-parent/compare/v3.0.0...v3.0.1) (2021-01-27)
+
+
+### Features
+
+* use path-dirname ponyfill ([cdbea5f](https://github.com/gulpjs/glob-parent/commit/cdbea5f32a58a54e001a75ddd7c0fccd4776aacc))
+
+
+### Bug Fixes
+
+* unescape glob-escaped dirnames on output ([598c533](https://github.com/gulpjs/glob-parent/commit/598c533bdf49c1428bc063aa9b8db40c5a86b030))
+
+## [3.0.0](https://github.com/gulpjs/glob-parent/compare/v2.0.0...v3.0.0) (2021-01-27)
+
+
+### ⚠ BREAKING CHANGES
+
+* update is-glob dependency
+
+### Features
+
+* update is-glob dependency ([5c5f8ef](https://github.com/gulpjs/glob-parent/commit/5c5f8efcee362a8e7638cf8220666acd8784f6bd))
+
+## [2.0.0](https://github.com/gulpjs/glob-parent/compare/v1.3.0...v2.0.0) (2021-01-27)
+
+
+### Features
+
+* move up to dirname regardless of glob characters ([f97fb83](https://github.com/gulpjs/glob-parent/commit/f97fb83be2e0a9fc8d3b760e789d2ecadd6aa0c2))
+
+## [1.3.0](https://github.com/gulpjs/glob-parent/compare/v1.2.0...v1.3.0) (2021-01-27)
+
+## [1.2.0](https://github.com/gulpjs/glob-parent/compare/v1.1.0...v1.2.0) (2021-01-27)
+
+
+### Reverts
+
+* feat: make regex test strings smaller ([dc80fa9](https://github.com/gulpjs/glob-parent/commit/dc80fa9658dca20549cfeba44bbd37d5246fcce0))
+
+## [1.1.0](https://github.com/gulpjs/glob-parent/compare/v1.0.0...v1.1.0) (2021-01-27)
+
+
+### Features
+
+* make regex test strings smaller ([cd83220](https://github.com/gulpjs/glob-parent/commit/cd832208638f45169f986d80fcf66e401f35d233))
+
+## 1.0.0 (2021-01-27)
+
Index: frontend/node_modules/fast-glob/node_modules/glob-parent/LICENSE
===================================================================
--- frontend/node_modules/fast-glob/node_modules/glob-parent/LICENSE (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/node_modules/glob-parent/LICENSE (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) 2015, 2019 Elan Shanker
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
Index: frontend/node_modules/fast-glob/node_modules/glob-parent/README.md
===================================================================
--- frontend/node_modules/fast-glob/node_modules/glob-parent/README.md (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/node_modules/glob-parent/README.md (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,137 @@
+
+
+ 
+
+
+
+# glob-parent
+
+[![NPM version][npm-image]][npm-url] [![Downloads][downloads-image]][npm-url] [![Azure Pipelines Build Status][azure-pipelines-image]][azure-pipelines-url] [![Travis Build Status][travis-image]][travis-url] [![AppVeyor Build Status][appveyor-image]][appveyor-url] [![Coveralls Status][coveralls-image]][coveralls-url] [![Gitter chat][gitter-image]][gitter-url]
+
+Extract the non-magic parent path from a glob string.
+
+## Usage
+
+```js
+var globParent = require('glob-parent');
+
+globParent('path/to/*.js'); // 'path/to'
+globParent('/root/path/to/*.js'); // '/root/path/to'
+globParent('/*.js'); // '/'
+globParent('*.js'); // '.'
+globParent('**/*.js'); // '.'
+globParent('path/{to,from}'); // 'path'
+globParent('path/!(to|from)'); // 'path'
+globParent('path/?(to|from)'); // 'path'
+globParent('path/+(to|from)'); // 'path'
+globParent('path/*(to|from)'); // 'path'
+globParent('path/@(to|from)'); // 'path'
+globParent('path/**/*'); // 'path'
+
+// if provided a non-glob path, returns the nearest dir
+globParent('path/foo/bar.js'); // 'path/foo'
+globParent('path/foo/'); // 'path/foo'
+globParent('path/foo'); // 'path' (see issue #3 for details)
+```
+
+## API
+
+### `globParent(maybeGlobString, [options])`
+
+Takes a string and returns the part of the path before the glob begins. Be aware of Escaping rules and Limitations below.
+
+#### options
+
+```js
+{
+ // Disables the automatic conversion of slashes for Windows
+ flipBackslashes: true
+}
+```
+
+## Escaping
+
+The following characters have special significance in glob patterns and must be escaped if you want them to be treated as regular path characters:
+
+- `?` (question mark) unless used as a path segment alone
+- `*` (asterisk)
+- `|` (pipe)
+- `(` (opening parenthesis)
+- `)` (closing parenthesis)
+- `{` (opening curly brace)
+- `}` (closing curly brace)
+- `[` (opening bracket)
+- `]` (closing bracket)
+
+**Example**
+
+```js
+globParent('foo/[bar]/') // 'foo'
+globParent('foo/\\[bar]/') // 'foo/[bar]'
+```
+
+## Limitations
+
+### Braces & Brackets
+This library attempts a quick and imperfect method of determining which path
+parts have glob magic without fully parsing/lexing the pattern. There are some
+advanced use cases that can trip it up, such as nested braces where the outer
+pair is escaped and the inner one contains a path separator. If you find
+yourself in the unlikely circumstance of being affected by this or need to
+ensure higher-fidelity glob handling in your library, it is recommended that you
+pre-process your input with [expand-braces] and/or [expand-brackets].
+
+### Windows
+Backslashes are not valid path separators for globs. If a path with backslashes
+is provided anyway, for simple cases, glob-parent will replace the path
+separator for you and return the non-glob parent path (now with
+forward-slashes, which are still valid as Windows path separators).
+
+This cannot be used in conjunction with escape characters.
+
+```js
+// BAD
+globParent('C:\\Program Files \\(x86\\)\\*.ext') // 'C:/Program Files /(x86/)'
+
+// GOOD
+globParent('C:/Program Files\\(x86\\)/*.ext') // 'C:/Program Files (x86)'
+```
+
+If you are using escape characters for a pattern without path parts (i.e.
+relative to `cwd`), prefix with `./` to avoid confusing glob-parent.
+
+```js
+// BAD
+globParent('foo \\[bar]') // 'foo '
+globParent('foo \\[bar]*') // 'foo '
+
+// GOOD
+globParent('./foo \\[bar]') // 'foo [bar]'
+globParent('./foo \\[bar]*') // '.'
+```
+
+## License
+
+ISC
+
+[expand-braces]: https://github.com/jonschlinkert/expand-braces
+[expand-brackets]: https://github.com/jonschlinkert/expand-brackets
+
+[downloads-image]: https://img.shields.io/npm/dm/glob-parent.svg
+[npm-url]: https://www.npmjs.com/package/glob-parent
+[npm-image]: https://img.shields.io/npm/v/glob-parent.svg
+
+[azure-pipelines-url]: https://dev.azure.com/gulpjs/gulp/_build/latest?definitionId=2&branchName=master
+[azure-pipelines-image]: https://dev.azure.com/gulpjs/gulp/_apis/build/status/glob-parent?branchName=master
+
+[travis-url]: https://travis-ci.org/gulpjs/glob-parent
+[travis-image]: https://img.shields.io/travis/gulpjs/glob-parent.svg?label=travis-ci
+
+[appveyor-url]: https://ci.appveyor.com/project/gulpjs/glob-parent
+[appveyor-image]: https://img.shields.io/appveyor/ci/gulpjs/glob-parent.svg?label=appveyor
+
+[coveralls-url]: https://coveralls.io/r/gulpjs/glob-parent
+[coveralls-image]: https://img.shields.io/coveralls/gulpjs/glob-parent/master.svg
+
+[gitter-url]: https://gitter.im/gulpjs/gulp
+[gitter-image]: https://badges.gitter.im/gulpjs/gulp.svg
Index: frontend/node_modules/fast-glob/node_modules/glob-parent/index.js
===================================================================
--- frontend/node_modules/fast-glob/node_modules/glob-parent/index.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/node_modules/glob-parent/index.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,42 @@
+'use strict';
+
+var isGlob = require('is-glob');
+var pathPosixDirname = require('path').posix.dirname;
+var isWin32 = require('os').platform() === 'win32';
+
+var slash = '/';
+var backslash = /\\/g;
+var enclosure = /[\{\[].*[\}\]]$/;
+var globby = /(^|[^\\])([\{\[]|\([^\)]+$)/;
+var escaped = /\\([\!\*\?\|\[\]\(\)\{\}])/g;
+
+/**
+ * @param {string} str
+ * @param {Object} opts
+ * @param {boolean} [opts.flipBackslashes=true]
+ * @returns {string}
+ */
+module.exports = function globParent(str, opts) {
+ var options = Object.assign({ flipBackslashes: true }, opts);
+
+ // flip windows path separators
+ if (options.flipBackslashes && isWin32 && str.indexOf(slash) < 0) {
+ str = str.replace(backslash, slash);
+ }
+
+ // special case for strings ending in enclosure containing path separator
+ if (enclosure.test(str)) {
+ str += slash;
+ }
+
+ // preserves full path in case of trailing path separator
+ str += 'a';
+
+ // remove path parts that are globby
+ do {
+ str = pathPosixDirname(str);
+ } while (isGlob(str) || globby.test(str));
+
+ // remove escape chars and return result
+ return str.replace(escaped, '$1');
+};
Index: frontend/node_modules/fast-glob/node_modules/glob-parent/package.json
===================================================================
--- frontend/node_modules/fast-glob/node_modules/glob-parent/package.json (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/node_modules/glob-parent/package.json (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,48 @@
+{
+ "name": "glob-parent",
+ "version": "5.1.2",
+ "description": "Extract the non-magic parent path from a glob string.",
+ "author": "Gulp Team (https://gulpjs.com/)",
+ "contributors": [
+ "Elan Shanker (https://github.com/es128)",
+ "Blaine Bublitz "
+ ],
+ "repository": "gulpjs/glob-parent",
+ "license": "ISC",
+ "engines": {
+ "node": ">= 6"
+ },
+ "main": "index.js",
+ "files": [
+ "LICENSE",
+ "index.js"
+ ],
+ "scripts": {
+ "lint": "eslint .",
+ "pretest": "npm run lint",
+ "test": "nyc mocha --async-only",
+ "azure-pipelines": "nyc mocha --async-only --reporter xunit -O output=test.xunit",
+ "coveralls": "nyc report --reporter=text-lcov | coveralls"
+ },
+ "dependencies": {
+ "is-glob": "^4.0.1"
+ },
+ "devDependencies": {
+ "coveralls": "^3.0.11",
+ "eslint": "^2.13.1",
+ "eslint-config-gulp": "^3.0.1",
+ "expect": "^1.20.2",
+ "mocha": "^6.0.2",
+ "nyc": "^13.3.0"
+ },
+ "keywords": [
+ "glob",
+ "parent",
+ "strip",
+ "path",
+ "dirname",
+ "directory",
+ "base",
+ "wildcard"
+ ]
+}
Index: frontend/node_modules/fast-glob/out/index.d.ts
===================================================================
--- frontend/node_modules/fast-glob/out/index.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/index.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,40 @@
+///
+import * as taskManager from './managers/tasks';
+import { Options as OptionsInternal } from './settings';
+import { Entry as EntryInternal, FileSystemAdapter as FileSystemAdapterInternal, Pattern as PatternInternal } from './types';
+type EntryObjectModePredicate = {
+ [TKey in keyof Pick]-?: true;
+};
+type EntryStatsPredicate = {
+ [TKey in keyof Pick]-?: true;
+};
+type EntryObjectPredicate = EntryObjectModePredicate | EntryStatsPredicate;
+declare function FastGlob(source: PatternInternal | PatternInternal[], options: OptionsInternal & EntryObjectPredicate): Promise;
+declare function FastGlob(source: PatternInternal | PatternInternal[], options?: OptionsInternal): Promise;
+declare namespace FastGlob {
+ type Options = OptionsInternal;
+ type Entry = EntryInternal;
+ 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: 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;
Index: frontend/node_modules/fast-glob/out/index.js
===================================================================
--- frontend/node_modules/fast-glob/out/index.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/index.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,102 @@
+"use strict";
+const taskManager = require("./managers/tasks");
+const async_1 = require("./providers/async");
+const stream_1 = require("./providers/stream");
+const sync_1 = require("./providers/sync");
+const settings_1 = require("./settings");
+const utils = require("./utils");
+async function FastGlob(source, options) {
+ assertPatternsInput(source);
+ const works = getWorks(source, async_1.default, options);
+ const result = await Promise.all(works);
+ return utils.array.flatten(result);
+}
+// 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);
+ return utils.array.flatten(works);
+ }
+ FastGlob.sync = sync;
+ function stream(source, options) {
+ assertPatternsInput(source);
+ const works = getWorks(source, stream_1.default, options);
+ /**
+ * The stream returned by the provider cannot work with an asynchronous iterator.
+ * To support asynchronous iterators, regardless of the number of tasks, we always multiplex streams.
+ * This affects performance (+25%). I don't see best solution right now.
+ */
+ return utils.stream.merge(works);
+ }
+ FastGlob.stream = stream;
+ function generateTasks(source, options) {
+ assertPatternsInput(source);
+ const patterns = [].concat(source);
+ const settings = new settings_1.default(options);
+ return taskManager.generate(patterns, settings);
+ }
+ FastGlob.generateTasks = generateTasks;
+ function isDynamicPattern(source, options) {
+ assertPatternsInput(source);
+ const settings = new settings_1.default(options);
+ return utils.pattern.isDynamicPattern(source, settings);
+ }
+ FastGlob.isDynamicPattern = isDynamicPattern;
+ function escapePath(source) {
+ assertPatternsInput(source);
+ 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 = [].concat(source);
+ const settings = new settings_1.default(options);
+ const tasks = taskManager.generate(patterns, settings);
+ const provider = new _Provider(settings);
+ return tasks.map(provider.read, provider);
+}
+function assertPatternsInput(input) {
+ const source = [].concat(input);
+ const isValidSource = source.every((item) => utils.string.isString(item) && !utils.string.isEmpty(item));
+ if (!isValidSource) {
+ throw new TypeError('Patterns must be a string (non empty) or an array of strings');
+ }
+}
+module.exports = FastGlob;
Index: frontend/node_modules/fast-glob/out/managers/tasks.d.ts
===================================================================
--- frontend/node_modules/fast-glob/out/managers/tasks.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/managers/tasks.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,22 @@
+import Settings from '../settings';
+import { Pattern, PatternsGroup } from '../types';
+export type Task = {
+ base: string;
+ dynamic: boolean;
+ patterns: Pattern[];
+ positive: Pattern[];
+ negative: Pattern[];
+};
+export declare function generate(input: Pattern[], settings: Settings): Task[];
+/**
+ * Returns tasks grouped by basic pattern directories.
+ *
+ * Patterns that can be found inside (`./`) and outside (`../`) the current directory are handled separately.
+ * This is necessary because directory traversal starts at the base directory and goes deeper.
+ */
+export declare function convertPatternsToTasks(positive: Pattern[], negative: Pattern[], dynamic: boolean): Task[];
+export declare function getPositivePatterns(patterns: Pattern[]): Pattern[];
+export declare function getNegativePatternsAsPositive(patterns: Pattern[], ignore: Pattern[]): Pattern[];
+export declare function groupPatternsByBaseDirectory(patterns: Pattern[]): PatternsGroup;
+export declare function convertPatternGroupsToTasks(positive: PatternsGroup, negative: Pattern[], dynamic: boolean): Task[];
+export declare function convertPatternGroupToTask(base: string, positive: Pattern[], negative: Pattern[], dynamic: boolean): Task;
Index: frontend/node_modules/fast-glob/out/managers/tasks.js
===================================================================
--- frontend/node_modules/fast-glob/out/managers/tasks.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/managers/tasks.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,110 @@
+"use strict";
+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(input, settings) {
+ const patterns = processPatterns(input, settings);
+ const ignore = processPatterns(settings.ignore, settings);
+ const positivePatterns = getPositivePatterns(patterns);
+ const negativePatterns = getNegativePatternsAsPositive(patterns, ignore);
+ const staticPatterns = positivePatterns.filter((pattern) => utils.pattern.isStaticPattern(pattern, settings));
+ const dynamicPatterns = positivePatterns.filter((pattern) => utils.pattern.isDynamicPattern(pattern, settings));
+ const staticTasks = convertPatternsToTasks(staticPatterns, negativePatterns, /* dynamic */ false);
+ const dynamicTasks = convertPatternsToTasks(dynamicPatterns, negativePatterns, /* dynamic */ true);
+ return staticTasks.concat(dynamicTasks);
+}
+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.
+ *
+ * Patterns that can be found inside (`./`) and outside (`../`) the current directory are handled separately.
+ * This is necessary because directory traversal starts at the base directory and goes deeper.
+ */
+function convertPatternsToTasks(positive, negative, dynamic) {
+ const tasks = [];
+ const patternsOutsideCurrentDirectory = utils.pattern.getPatternsOutsideCurrentDirectory(positive);
+ const patternsInsideCurrentDirectory = utils.pattern.getPatternsInsideCurrentDirectory(positive);
+ const outsideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsOutsideCurrentDirectory);
+ const insideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsInsideCurrentDirectory);
+ tasks.push(...convertPatternGroupsToTasks(outsideCurrentDirectoryGroup, negative, dynamic));
+ /*
+ * For the sake of reducing future accesses to the file system, we merge all tasks within the current directory
+ * into a global task, if at least one pattern refers to the root (`.`). In this case, the global task covers the rest.
+ */
+ if ('.' in insideCurrentDirectoryGroup) {
+ tasks.push(convertPatternGroupToTask('.', patternsInsideCurrentDirectory, negative, dynamic));
+ }
+ else {
+ tasks.push(...convertPatternGroupsToTasks(insideCurrentDirectoryGroup, negative, dynamic));
+ }
+ return tasks;
+}
+exports.convertPatternsToTasks = convertPatternsToTasks;
+function getPositivePatterns(patterns) {
+ return utils.pattern.getPositivePatterns(patterns);
+}
+exports.getPositivePatterns = getPositivePatterns;
+function getNegativePatternsAsPositive(patterns, ignore) {
+ const negative = utils.pattern.getNegativePatterns(patterns).concat(ignore);
+ const positive = negative.map(utils.pattern.convertToPositivePattern);
+ return positive;
+}
+exports.getNegativePatternsAsPositive = getNegativePatternsAsPositive;
+function groupPatternsByBaseDirectory(patterns) {
+ const group = {};
+ return patterns.reduce((collection, pattern) => {
+ const base = utils.pattern.getBaseDirectory(pattern);
+ if (base in collection) {
+ collection[base].push(pattern);
+ }
+ else {
+ collection[base] = [pattern];
+ }
+ return collection;
+ }, group);
+}
+exports.groupPatternsByBaseDirectory = groupPatternsByBaseDirectory;
+function convertPatternGroupsToTasks(positive, negative, dynamic) {
+ return Object.keys(positive).map((base) => {
+ return convertPatternGroupToTask(base, positive[base], negative, dynamic);
+ });
+}
+exports.convertPatternGroupsToTasks = convertPatternGroupsToTasks;
+function convertPatternGroupToTask(base, positive, negative, dynamic) {
+ return {
+ dynamic,
+ positive,
+ negative,
+ base,
+ patterns: [].concat(positive, negative.map(utils.pattern.convertToNegativePattern))
+ };
+}
+exports.convertPatternGroupToTask = convertPatternGroupToTask;
Index: frontend/node_modules/fast-glob/out/providers/async.d.ts
===================================================================
--- frontend/node_modules/fast-glob/out/providers/async.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/providers/async.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,9 @@
+import { Task } from '../managers/tasks';
+import { Entry, EntryItem, ReaderOptions } from '../types';
+import ReaderAsync from '../readers/async';
+import Provider from './provider';
+export default class ProviderAsync extends Provider> {
+ protected _reader: ReaderAsync;
+ read(task: Task): Promise;
+ api(root: string, task: Task, options: ReaderOptions): Promise;
+}
Index: frontend/node_modules/fast-glob/out/providers/async.js
===================================================================
--- frontend/node_modules/fast-glob/out/providers/async.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/providers/async.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const async_1 = require("../readers/async");
+const provider_1 = require("./provider");
+class ProviderAsync extends provider_1.default {
+ constructor() {
+ super(...arguments);
+ this._reader = new async_1.default(this._settings);
+ }
+ async read(task) {
+ const root = this._getRootDirectory(task);
+ const options = this._getReaderOptions(task);
+ const entries = await this.api(root, task, options);
+ return entries.map((entry) => options.transform(entry));
+ }
+ api(root, task, options) {
+ if (task.dynamic) {
+ return this._reader.dynamic(root, options);
+ }
+ return this._reader.static(task.patterns, options);
+ }
+}
+exports.default = ProviderAsync;
Index: frontend/node_modules/fast-glob/out/providers/filters/deep.d.ts
===================================================================
--- frontend/node_modules/fast-glob/out/providers/filters/deep.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/providers/filters/deep.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,16 @@
+import { MicromatchOptions, EntryFilterFunction, Pattern } from '../../types';
+import Settings from '../../settings';
+export default class DeepFilter {
+ private readonly _settings;
+ private readonly _micromatchOptions;
+ constructor(_settings: Settings, _micromatchOptions: MicromatchOptions);
+ getFilter(basePath: string, positive: Pattern[], negative: Pattern[]): EntryFilterFunction;
+ private _getMatcher;
+ private _getNegativePatternsRe;
+ private _filter;
+ private _isSkippedByDeep;
+ private _getEntryLevel;
+ private _isSkippedSymbolicLink;
+ private _isSkippedByPositivePatterns;
+ private _isSkippedByNegativePatterns;
+}
Index: frontend/node_modules/fast-glob/out/providers/filters/deep.js
===================================================================
--- frontend/node_modules/fast-glob/out/providers/filters/deep.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/providers/filters/deep.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils = require("../../utils");
+const partial_1 = require("../matchers/partial");
+class DeepFilter {
+ constructor(_settings, _micromatchOptions) {
+ this._settings = _settings;
+ this._micromatchOptions = _micromatchOptions;
+ }
+ getFilter(basePath, positive, negative) {
+ const matcher = this._getMatcher(positive);
+ const negativeRe = this._getNegativePatternsRe(negative);
+ return (entry) => this._filter(basePath, entry, matcher, negativeRe);
+ }
+ _getMatcher(patterns) {
+ return new partial_1.default(patterns, this._settings, this._micromatchOptions);
+ }
+ _getNegativePatternsRe(patterns) {
+ const affectDepthOfReadingPatterns = patterns.filter(utils.pattern.isAffectDepthOfReadingPattern);
+ return utils.pattern.convertPatternsToRe(affectDepthOfReadingPatterns, this._micromatchOptions);
+ }
+ _filter(basePath, entry, matcher, negativeRe) {
+ if (this._isSkippedByDeep(basePath, entry.path)) {
+ return false;
+ }
+ if (this._isSkippedSymbolicLink(entry)) {
+ return false;
+ }
+ const filepath = utils.path.removeLeadingDotSegment(entry.path);
+ if (this._isSkippedByPositivePatterns(filepath, matcher)) {
+ return false;
+ }
+ return this._isSkippedByNegativePatterns(filepath, negativeRe);
+ }
+ _isSkippedByDeep(basePath, entryPath) {
+ /**
+ * Avoid unnecessary depth calculations when it doesn't matter.
+ */
+ if (this._settings.deep === Infinity) {
+ return false;
+ }
+ return this._getEntryLevel(basePath, entryPath) >= this._settings.deep;
+ }
+ _getEntryLevel(basePath, entryPath) {
+ const entryPathDepth = entryPath.split('/').length;
+ if (basePath === '') {
+ return entryPathDepth;
+ }
+ const basePathDepth = basePath.split('/').length;
+ return entryPathDepth - basePathDepth;
+ }
+ _isSkippedSymbolicLink(entry) {
+ return !this._settings.followSymbolicLinks && entry.dirent.isSymbolicLink();
+ }
+ _isSkippedByPositivePatterns(entryPath, matcher) {
+ return !this._settings.baseNameMatch && !matcher.match(entryPath);
+ }
+ _isSkippedByNegativePatterns(entryPath, patternsRe) {
+ return !utils.pattern.matchAny(entryPath, patternsRe);
+ }
+}
+exports.default = DeepFilter;
Index: frontend/node_modules/fast-glob/out/providers/filters/entry.d.ts
===================================================================
--- frontend/node_modules/fast-glob/out/providers/filters/entry.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/providers/filters/entry.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,17 @@
+import Settings from '../../settings';
+import { EntryFilterFunction, MicromatchOptions, Pattern } from '../../types';
+export default class EntryFilter {
+ private readonly _settings;
+ private readonly _micromatchOptions;
+ readonly index: Map;
+ constructor(_settings: Settings, _micromatchOptions: MicromatchOptions);
+ getFilter(positive: Pattern[], negative: Pattern[]): EntryFilterFunction;
+ private _filter;
+ private _isDuplicateEntry;
+ private _createIndexRecord;
+ private _onlyFileFilter;
+ private _onlyDirectoryFilter;
+ private _isMatchToPatternsSet;
+ private _isMatchToAbsoluteNegative;
+ private _isMatchToPatterns;
+}
Index: frontend/node_modules/fast-glob/out/providers/filters/entry.js
===================================================================
--- frontend/node_modules/fast-glob/out/providers/filters/entry.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/providers/filters/entry.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils = require("../../utils");
+class EntryFilter {
+ constructor(_settings, _micromatchOptions) {
+ this._settings = _settings;
+ this._micromatchOptions = _micromatchOptions;
+ this.index = new Map();
+ }
+ getFilter(positive, negative) {
+ const [absoluteNegative, relativeNegative] = utils.pattern.partitionAbsoluteAndRelative(negative);
+ const patterns = {
+ positive: {
+ all: utils.pattern.convertPatternsToRe(positive, this._micromatchOptions)
+ },
+ negative: {
+ absolute: utils.pattern.convertPatternsToRe(absoluteNegative, Object.assign(Object.assign({}, this._micromatchOptions), { dot: true })),
+ relative: utils.pattern.convertPatternsToRe(relativeNegative, Object.assign(Object.assign({}, this._micromatchOptions), { dot: true }))
+ }
+ };
+ return (entry) => this._filter(entry, patterns);
+ }
+ _filter(entry, patterns) {
+ 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;
+ }
+ const isMatched = this._isMatchToPatternsSet(filepath, patterns, entry.dirent.isDirectory());
+ if (this._settings.unique && isMatched) {
+ this._createIndexRecord(filepath);
+ }
+ return isMatched;
+ }
+ _isDuplicateEntry(filepath) {
+ return this.index.has(filepath);
+ }
+ _createIndexRecord(filepath) {
+ this.index.set(filepath, undefined);
+ }
+ _onlyFileFilter(entry) {
+ return this._settings.onlyFiles && !entry.dirent.isFile();
+ }
+ _onlyDirectoryFilter(entry) {
+ return this._settings.onlyDirectories && !entry.dirent.isDirectory();
+ }
+ _isMatchToPatternsSet(filepath, patterns, isDirectory) {
+ const isMatched = this._isMatchToPatterns(filepath, patterns.positive.all, isDirectory);
+ if (!isMatched) {
+ return false;
+ }
+ const isMatchedByRelativeNegative = this._isMatchToPatterns(filepath, patterns.negative.relative, isDirectory);
+ if (isMatchedByRelativeNegative) {
+ return false;
+ }
+ const isMatchedByAbsoluteNegative = this._isMatchToAbsoluteNegative(filepath, patterns.negative.absolute, isDirectory);
+ if (isMatchedByAbsoluteNegative) {
+ return false;
+ }
+ return true;
+ }
+ _isMatchToAbsoluteNegative(filepath, patternsRe, isDirectory) {
+ if (patternsRe.length === 0) {
+ return false;
+ }
+ const fullpath = utils.path.makeAbsolute(this._settings.cwd, filepath);
+ return this._isMatchToPatterns(fullpath, patternsRe, isDirectory);
+ }
+ _isMatchToPatterns(filepath, patternsRe, isDirectory) {
+ if (patternsRe.length === 0) {
+ return false;
+ }
+ // Trying to match files and directories by patterns.
+ const isMatched = utils.pattern.matchAny(filepath, patternsRe);
+ // A pattern with a trailling slash can be used for directory matching.
+ // To apply such pattern, we need to add a tralling slash to the path.
+ if (!isMatched && isDirectory) {
+ return utils.pattern.matchAny(filepath + '/', patternsRe);
+ }
+ return isMatched;
+ }
+}
+exports.default = EntryFilter;
Index: frontend/node_modules/fast-glob/out/providers/filters/error.d.ts
===================================================================
--- frontend/node_modules/fast-glob/out/providers/filters/error.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/providers/filters/error.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,8 @@
+import Settings from '../../settings';
+import { ErrorFilterFunction } from '../../types';
+export default class ErrorFilter {
+ private readonly _settings;
+ constructor(_settings: Settings);
+ getFilter(): ErrorFilterFunction;
+ private _isNonFatalError;
+}
Index: frontend/node_modules/fast-glob/out/providers/filters/error.js
===================================================================
--- frontend/node_modules/fast-glob/out/providers/filters/error.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/providers/filters/error.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils = require("../../utils");
+class ErrorFilter {
+ constructor(_settings) {
+ this._settings = _settings;
+ }
+ getFilter() {
+ return (error) => this._isNonFatalError(error);
+ }
+ _isNonFatalError(error) {
+ return utils.errno.isEnoentCodeError(error) || this._settings.suppressErrors;
+ }
+}
+exports.default = ErrorFilter;
Index: frontend/node_modules/fast-glob/out/providers/matchers/matcher.d.ts
===================================================================
--- frontend/node_modules/fast-glob/out/providers/matchers/matcher.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/providers/matchers/matcher.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,33 @@
+import { Pattern, MicromatchOptions, PatternRe } from '../../types';
+import Settings from '../../settings';
+export type PatternSegment = StaticPatternSegment | DynamicPatternSegment;
+type StaticPatternSegment = {
+ dynamic: false;
+ pattern: Pattern;
+};
+type DynamicPatternSegment = {
+ dynamic: true;
+ pattern: Pattern;
+ patternRe: PatternRe;
+};
+export type PatternSection = PatternSegment[];
+export type PatternInfo = {
+ /**
+ * Indicates that the pattern has a globstar (more than a single section).
+ */
+ complete: boolean;
+ pattern: Pattern;
+ segments: PatternSegment[];
+ sections: PatternSection[];
+};
+export default abstract class Matcher {
+ private readonly _patterns;
+ private readonly _settings;
+ private readonly _micromatchOptions;
+ protected readonly _storage: PatternInfo[];
+ constructor(_patterns: Pattern[], _settings: Settings, _micromatchOptions: MicromatchOptions);
+ private _fillStorage;
+ private _getPatternSegments;
+ private _splitSegmentsIntoSections;
+}
+export {};
Index: frontend/node_modules/fast-glob/out/providers/matchers/matcher.js
===================================================================
--- frontend/node_modules/fast-glob/out/providers/matchers/matcher.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/providers/matchers/matcher.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils = require("../../utils");
+class Matcher {
+ constructor(_patterns, _settings, _micromatchOptions) {
+ this._patterns = _patterns;
+ this._settings = _settings;
+ this._micromatchOptions = _micromatchOptions;
+ this._storage = [];
+ this._fillStorage();
+ }
+ _fillStorage() {
+ for (const pattern of this._patterns) {
+ const segments = this._getPatternSegments(pattern);
+ const sections = this._splitSegmentsIntoSections(segments);
+ this._storage.push({
+ complete: sections.length <= 1,
+ pattern,
+ segments,
+ sections
+ });
+ }
+ }
+ _getPatternSegments(pattern) {
+ const parts = utils.pattern.getPatternParts(pattern, this._micromatchOptions);
+ return parts.map((part) => {
+ const dynamic = utils.pattern.isDynamicPattern(part, this._settings);
+ if (!dynamic) {
+ return {
+ dynamic: false,
+ pattern: part
+ };
+ }
+ return {
+ dynamic: true,
+ pattern: part,
+ patternRe: utils.pattern.makeRe(part, this._micromatchOptions)
+ };
+ });
+ }
+ _splitSegmentsIntoSections(segments) {
+ return utils.array.splitWhen(segments, (segment) => segment.dynamic && utils.pattern.hasGlobStar(segment.pattern));
+ }
+}
+exports.default = Matcher;
Index: frontend/node_modules/fast-glob/out/providers/matchers/partial.d.ts
===================================================================
--- frontend/node_modules/fast-glob/out/providers/matchers/partial.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/providers/matchers/partial.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,4 @@
+import Matcher from './matcher';
+export default class PartialMatcher extends Matcher {
+ match(filepath: string): boolean;
+}
Index: frontend/node_modules/fast-glob/out/providers/matchers/partial.js
===================================================================
--- frontend/node_modules/fast-glob/out/providers/matchers/partial.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/providers/matchers/partial.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const matcher_1 = require("./matcher");
+class PartialMatcher extends matcher_1.default {
+ match(filepath) {
+ const parts = filepath.split('/');
+ const levels = parts.length;
+ const patterns = this._storage.filter((info) => !info.complete || info.segments.length > levels);
+ for (const pattern of patterns) {
+ const section = pattern.sections[0];
+ /**
+ * In this case, the pattern has a globstar and we must read all directories unconditionally,
+ * but only if the level has reached the end of the first group.
+ *
+ * fixtures/{a,b}/**
+ * ^ true/false ^ always true
+ */
+ if (!pattern.complete && levels > section.length) {
+ return true;
+ }
+ const match = parts.every((part, index) => {
+ const segment = pattern.segments[index];
+ if (segment.dynamic && segment.patternRe.test(part)) {
+ return true;
+ }
+ if (!segment.dynamic && segment.pattern === part) {
+ return true;
+ }
+ return false;
+ });
+ if (match) {
+ return true;
+ }
+ }
+ return false;
+ }
+}
+exports.default = PartialMatcher;
Index: frontend/node_modules/fast-glob/out/providers/provider.d.ts
===================================================================
--- frontend/node_modules/fast-glob/out/providers/provider.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/providers/provider.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,19 @@
+import { Task } from '../managers/tasks';
+import Settings from '../settings';
+import { MicromatchOptions, ReaderOptions } from '../types';
+import DeepFilter from './filters/deep';
+import EntryFilter from './filters/entry';
+import ErrorFilter from './filters/error';
+import EntryTransformer from './transformers/entry';
+export default abstract class Provider {
+ protected readonly _settings: Settings;
+ readonly errorFilter: ErrorFilter;
+ readonly entryFilter: EntryFilter;
+ readonly deepFilter: DeepFilter;
+ readonly entryTransformer: EntryTransformer;
+ constructor(_settings: Settings);
+ abstract read(_task: Task): T;
+ protected _getRootDirectory(task: Task): string;
+ protected _getReaderOptions(task: Task): ReaderOptions;
+ protected _getMicromatchOptions(): MicromatchOptions;
+}
Index: frontend/node_modules/fast-glob/out/providers/provider.js
===================================================================
--- frontend/node_modules/fast-glob/out/providers/provider.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/providers/provider.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const deep_1 = require("./filters/deep");
+const entry_1 = require("./filters/entry");
+const error_1 = require("./filters/error");
+const entry_2 = require("./transformers/entry");
+class Provider {
+ constructor(_settings) {
+ this._settings = _settings;
+ this.errorFilter = new error_1.default(this._settings);
+ this.entryFilter = new entry_1.default(this._settings, this._getMicromatchOptions());
+ this.deepFilter = new deep_1.default(this._settings, this._getMicromatchOptions());
+ this.entryTransformer = new entry_2.default(this._settings);
+ }
+ _getRootDirectory(task) {
+ return path.resolve(this._settings.cwd, task.base);
+ }
+ _getReaderOptions(task) {
+ const basePath = task.base === '.' ? '' : task.base;
+ return {
+ basePath,
+ pathSegmentSeparator: '/',
+ concurrency: this._settings.concurrency,
+ deepFilter: this.deepFilter.getFilter(basePath, task.positive, task.negative),
+ entryFilter: this.entryFilter.getFilter(task.positive, task.negative),
+ errorFilter: this.errorFilter.getFilter(),
+ followSymbolicLinks: this._settings.followSymbolicLinks,
+ fs: this._settings.fs,
+ stats: this._settings.stats,
+ throwErrorOnBrokenSymbolicLink: this._settings.throwErrorOnBrokenSymbolicLink,
+ transform: this.entryTransformer.getTransformer()
+ };
+ }
+ _getMicromatchOptions() {
+ return {
+ dot: this._settings.dot,
+ matchBase: this._settings.baseNameMatch,
+ nobrace: !this._settings.braceExpansion,
+ nocase: !this._settings.caseSensitiveMatch,
+ noext: !this._settings.extglob,
+ noglobstar: !this._settings.globstar,
+ posix: true,
+ strictSlashes: false
+ };
+ }
+}
+exports.default = Provider;
Index: frontend/node_modules/fast-glob/out/providers/stream.d.ts
===================================================================
--- frontend/node_modules/fast-glob/out/providers/stream.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/providers/stream.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,11 @@
+///
+import { Readable } from 'stream';
+import { Task } from '../managers/tasks';
+import ReaderStream from '../readers/stream';
+import { ReaderOptions } from '../types';
+import Provider from './provider';
+export default class ProviderStream extends Provider {
+ protected _reader: ReaderStream;
+ read(task: Task): Readable;
+ api(root: string, task: Task, options: ReaderOptions): Readable;
+}
Index: frontend/node_modules/fast-glob/out/providers/stream.js
===================================================================
--- frontend/node_modules/fast-glob/out/providers/stream.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/providers/stream.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const stream_1 = require("stream");
+const stream_2 = require("../readers/stream");
+const provider_1 = require("./provider");
+class ProviderStream extends provider_1.default {
+ constructor() {
+ super(...arguments);
+ this._reader = new stream_2.default(this._settings);
+ }
+ read(task) {
+ const root = this._getRootDirectory(task);
+ const options = this._getReaderOptions(task);
+ const source = this.api(root, task, options);
+ const destination = new stream_1.Readable({ objectMode: true, read: () => { } });
+ source
+ .once('error', (error) => destination.emit('error', error))
+ .on('data', (entry) => destination.emit('data', options.transform(entry)))
+ .once('end', () => destination.emit('end'));
+ destination
+ .once('close', () => source.destroy());
+ return destination;
+ }
+ api(root, task, options) {
+ if (task.dynamic) {
+ return this._reader.dynamic(root, options);
+ }
+ return this._reader.static(task.patterns, options);
+ }
+}
+exports.default = ProviderStream;
Index: frontend/node_modules/fast-glob/out/providers/sync.d.ts
===================================================================
--- frontend/node_modules/fast-glob/out/providers/sync.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/providers/sync.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,9 @@
+import { Task } from '../managers/tasks';
+import ReaderSync from '../readers/sync';
+import { Entry, EntryItem, ReaderOptions } from '../types';
+import Provider from './provider';
+export default class ProviderSync extends Provider {
+ protected _reader: ReaderSync;
+ read(task: Task): EntryItem[];
+ api(root: string, task: Task, options: ReaderOptions): Entry[];
+}
Index: frontend/node_modules/fast-glob/out/providers/sync.js
===================================================================
--- frontend/node_modules/fast-glob/out/providers/sync.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/providers/sync.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sync_1 = require("../readers/sync");
+const provider_1 = require("./provider");
+class ProviderSync extends provider_1.default {
+ constructor() {
+ super(...arguments);
+ this._reader = new sync_1.default(this._settings);
+ }
+ read(task) {
+ const root = this._getRootDirectory(task);
+ const options = this._getReaderOptions(task);
+ const entries = this.api(root, task, options);
+ return entries.map(options.transform);
+ }
+ api(root, task, options) {
+ if (task.dynamic) {
+ return this._reader.dynamic(root, options);
+ }
+ return this._reader.static(task.patterns, options);
+ }
+}
+exports.default = ProviderSync;
Index: frontend/node_modules/fast-glob/out/providers/transformers/entry.d.ts
===================================================================
--- frontend/node_modules/fast-glob/out/providers/transformers/entry.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/providers/transformers/entry.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,8 @@
+import Settings from '../../settings';
+import { EntryTransformerFunction } from '../../types';
+export default class EntryTransformer {
+ private readonly _settings;
+ constructor(_settings: Settings);
+ getTransformer(): EntryTransformerFunction;
+ private _transform;
+}
Index: frontend/node_modules/fast-glob/out/providers/transformers/entry.js
===================================================================
--- frontend/node_modules/fast-glob/out/providers/transformers/entry.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/providers/transformers/entry.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils = require("../../utils");
+class EntryTransformer {
+ constructor(_settings) {
+ this._settings = _settings;
+ }
+ getTransformer() {
+ return (entry) => this._transform(entry);
+ }
+ _transform(entry) {
+ let filepath = entry.path;
+ if (this._settings.absolute) {
+ filepath = utils.path.makeAbsolute(this._settings.cwd, filepath);
+ filepath = utils.path.unixify(filepath);
+ }
+ if (this._settings.markDirectories && entry.dirent.isDirectory()) {
+ filepath += '/';
+ }
+ if (!this._settings.objectMode) {
+ return filepath;
+ }
+ return Object.assign(Object.assign({}, entry), { path: filepath });
+ }
+}
+exports.default = EntryTransformer;
Index: frontend/node_modules/fast-glob/out/readers/async.d.ts
===================================================================
--- frontend/node_modules/fast-glob/out/readers/async.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/readers/async.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -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> {
+ protected _walkAsync: typeof fsWalk.walk;
+ protected _readerStream: ReaderStream;
+ dynamic(root: string, options: ReaderOptions): Promise;
+ static(patterns: Pattern[], options: ReaderOptions): Promise;
+}
Index: frontend/node_modules/fast-glob/out/readers/async.js
===================================================================
--- frontend/node_modules/fast-glob/out/readers/async.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/readers/async.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -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;
Index: frontend/node_modules/fast-glob/out/readers/reader.d.ts
===================================================================
--- frontend/node_modules/fast-glob/out/readers/reader.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/readers/reader.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,15 @@
+///
+import * as fs from 'fs';
+import * as fsStat from '@nodelib/fs.stat';
+import Settings from '../settings';
+import { Entry, ErrnoException, Pattern, ReaderOptions } from '../types';
+export default abstract class Reader {
+ protected readonly _settings: Settings;
+ protected readonly _fsStatSettings: fsStat.Settings;
+ constructor(_settings: Settings);
+ abstract dynamic(root: string, options: ReaderOptions): T;
+ abstract static(patterns: Pattern[], options: ReaderOptions): T;
+ protected _getFullEntryPath(filepath: string): string;
+ protected _makeEntry(stats: fs.Stats, pattern: Pattern): Entry;
+ protected _isFatalError(error: ErrnoException): boolean;
+}
Index: frontend/node_modules/fast-glob/out/readers/reader.js
===================================================================
--- frontend/node_modules/fast-glob/out/readers/reader.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/readers/reader.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const fsStat = require("@nodelib/fs.stat");
+const utils = require("../utils");
+class Reader {
+ constructor(_settings) {
+ this._settings = _settings;
+ this._fsStatSettings = new fsStat.Settings({
+ followSymbolicLink: this._settings.followSymbolicLinks,
+ fs: this._settings.fs,
+ throwErrorOnBrokenSymbolicLink: this._settings.followSymbolicLinks
+ });
+ }
+ _getFullEntryPath(filepath) {
+ return path.resolve(this._settings.cwd, filepath);
+ }
+ _makeEntry(stats, pattern) {
+ const entry = {
+ name: pattern,
+ path: pattern,
+ dirent: utils.fs.createDirentFromStats(pattern, stats)
+ };
+ if (this._settings.stats) {
+ entry.stats = stats;
+ }
+ return entry;
+ }
+ _isFatalError(error) {
+ return !utils.errno.isEnoentCodeError(error) && !this._settings.suppressErrors;
+ }
+}
+exports.default = Reader;
Index: frontend/node_modules/fast-glob/out/readers/stream.d.ts
===================================================================
--- frontend/node_modules/fast-glob/out/readers/stream.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/readers/stream.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,14 @@
+///
+import { Readable } from 'stream';
+import * as fsStat from '@nodelib/fs.stat';
+import * as fsWalk from '@nodelib/fs.walk';
+import { Pattern, ReaderOptions } from '../types';
+import Reader from './reader';
+export default class ReaderStream extends Reader {
+ protected _walkStream: typeof fsWalk.walkStream;
+ protected _stat: typeof fsStat.stat;
+ dynamic(root: string, options: ReaderOptions): Readable;
+ static(patterns: Pattern[], options: ReaderOptions): Readable;
+ private _getEntry;
+ private _getStat;
+}
Index: frontend/node_modules/fast-glob/out/readers/stream.js
===================================================================
--- frontend/node_modules/fast-glob/out/readers/stream.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/readers/stream.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const stream_1 = require("stream");
+const fsStat = require("@nodelib/fs.stat");
+const fsWalk = require("@nodelib/fs.walk");
+const reader_1 = require("./reader");
+class ReaderStream extends reader_1.default {
+ constructor() {
+ super(...arguments);
+ this._walkStream = fsWalk.walkStream;
+ this._stat = fsStat.stat;
+ }
+ dynamic(root, options) {
+ return this._walkStream(root, options);
+ }
+ static(patterns, options) {
+ const filepaths = patterns.map(this._getFullEntryPath, this);
+ const stream = new stream_1.PassThrough({ objectMode: true });
+ stream._write = (index, _enc, done) => {
+ return this._getEntry(filepaths[index], patterns[index], options)
+ .then((entry) => {
+ if (entry !== null && options.entryFilter(entry)) {
+ stream.push(entry);
+ }
+ if (index === filepaths.length - 1) {
+ stream.end();
+ }
+ done();
+ })
+ .catch(done);
+ };
+ for (let i = 0; i < filepaths.length; i++) {
+ stream.write(i);
+ }
+ return stream;
+ }
+ _getEntry(filepath, pattern, options) {
+ return this._getStat(filepath)
+ .then((stats) => this._makeEntry(stats, pattern))
+ .catch((error) => {
+ if (options.errorFilter(error)) {
+ return null;
+ }
+ throw error;
+ });
+ }
+ _getStat(filepath) {
+ return new Promise((resolve, reject) => {
+ this._stat(filepath, this._fsStatSettings, (error, stats) => {
+ return error === null ? resolve(stats) : reject(error);
+ });
+ });
+ }
+}
+exports.default = ReaderStream;
Index: frontend/node_modules/fast-glob/out/readers/sync.d.ts
===================================================================
--- frontend/node_modules/fast-glob/out/readers/sync.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/readers/sync.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,12 @@
+import * as fsStat from '@nodelib/fs.stat';
+import * as fsWalk from '@nodelib/fs.walk';
+import { Entry, Pattern, ReaderOptions } from '../types';
+import Reader from './reader';
+export default class ReaderSync extends Reader {
+ protected _walkSync: typeof fsWalk.walkSync;
+ protected _statSync: typeof fsStat.statSync;
+ dynamic(root: string, options: ReaderOptions): Entry[];
+ static(patterns: Pattern[], options: ReaderOptions): Entry[];
+ private _getEntry;
+ private _getStat;
+}
Index: frontend/node_modules/fast-glob/out/readers/sync.js
===================================================================
--- frontend/node_modules/fast-glob/out/readers/sync.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/readers/sync.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fsStat = require("@nodelib/fs.stat");
+const fsWalk = require("@nodelib/fs.walk");
+const reader_1 = require("./reader");
+class ReaderSync extends reader_1.default {
+ constructor() {
+ super(...arguments);
+ this._walkSync = fsWalk.walkSync;
+ this._statSync = fsStat.statSync;
+ }
+ dynamic(root, options) {
+ return this._walkSync(root, options);
+ }
+ static(patterns, options) {
+ const entries = [];
+ for (const pattern of patterns) {
+ const filepath = this._getFullEntryPath(pattern);
+ const entry = this._getEntry(filepath, pattern, options);
+ if (entry === null || !options.entryFilter(entry)) {
+ continue;
+ }
+ entries.push(entry);
+ }
+ return entries;
+ }
+ _getEntry(filepath, pattern, options) {
+ try {
+ const stats = this._getStat(filepath);
+ return this._makeEntry(stats, pattern);
+ }
+ catch (error) {
+ if (options.errorFilter(error)) {
+ return null;
+ }
+ throw error;
+ }
+ }
+ _getStat(filepath) {
+ return this._statSync(filepath, this._fsStatSettings);
+ }
+}
+exports.default = ReaderSync;
Index: frontend/node_modules/fast-glob/out/settings.d.ts
===================================================================
--- frontend/node_modules/fast-glob/out/settings.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/settings.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,164 @@
+import { FileSystemAdapter, Pattern } from './types';
+export declare const DEFAULT_FILE_SYSTEM_ADAPTER: FileSystemAdapter;
+export type Options = {
+ /**
+ * Return the absolute path for entries.
+ *
+ * @default false
+ */
+ absolute?: boolean;
+ /**
+ * If set to `true`, then patterns without slashes will be matched against
+ * the basename of the path if it contains slashes.
+ *
+ * @default false
+ */
+ baseNameMatch?: boolean;
+ /**
+ * Enables Bash-like brace expansion.
+ *
+ * @default true
+ */
+ braceExpansion?: boolean;
+ /**
+ * Enables a case-sensitive mode for matching files.
+ *
+ * @default true
+ */
+ caseSensitiveMatch?: boolean;
+ /**
+ * Specifies the maximum number of concurrent requests from a reader to read
+ * directories.
+ *
+ * @default os.cpus().length
+ */
+ concurrency?: number;
+ /**
+ * The current working directory in which to search.
+ *
+ * @default process.cwd()
+ */
+ cwd?: string;
+ /**
+ * Specifies the maximum depth of a read directory relative to the start
+ * directory.
+ *
+ * @default Infinity
+ */
+ deep?: number;
+ /**
+ * Allow patterns to match entries that begin with a period (`.`).
+ *
+ * @default false
+ */
+ dot?: boolean;
+ /**
+ * Enables Bash-like `extglob` functionality.
+ *
+ * @default true
+ */
+ extglob?: boolean;
+ /**
+ * Indicates whether to traverse descendants of symbolic link directories.
+ *
+ * @default true
+ */
+ followSymbolicLinks?: boolean;
+ /**
+ * Custom implementation of methods for working with the file system.
+ *
+ * @default fs.*
+ */
+ fs?: Partial;
+ /**
+ * Enables recursively repeats a pattern containing `**`.
+ * If `false`, `**` behaves exactly like `*`.
+ *
+ * @default true
+ */
+ globstar?: boolean;
+ /**
+ * An array of glob patterns to exclude matches.
+ * This is an alternative way to use negative patterns.
+ *
+ * @default []
+ */
+ ignore?: Pattern[];
+ /**
+ * Mark the directory path with the final slash.
+ *
+ * @default false
+ */
+ markDirectories?: boolean;
+ /**
+ * Returns objects (instead of strings) describing entries.
+ *
+ * @default false
+ */
+ objectMode?: boolean;
+ /**
+ * Return only directories.
+ *
+ * @default false
+ */
+ onlyDirectories?: boolean;
+ /**
+ * Return only files.
+ *
+ * @default true
+ */
+ onlyFiles?: boolean;
+ /**
+ * Enables an object mode (`objectMode`) with an additional `stats` field.
+ *
+ * @default false
+ */
+ stats?: boolean;
+ /**
+ * By default this package suppress only `ENOENT` errors.
+ * Set to `true` to suppress any error.
+ *
+ * @default false
+ */
+ suppressErrors?: boolean;
+ /**
+ * Throw an error when symbolic link is broken if `true` or safely
+ * return `lstat` call if `false`.
+ *
+ * @default false
+ */
+ throwErrorOnBrokenSymbolicLink?: boolean;
+ /**
+ * Ensures that the returned entries are unique.
+ *
+ * @default true
+ */
+ unique?: boolean;
+};
+export default class Settings {
+ private readonly _options;
+ readonly absolute: boolean;
+ readonly baseNameMatch: boolean;
+ readonly braceExpansion: boolean;
+ readonly caseSensitiveMatch: boolean;
+ readonly concurrency: number;
+ readonly cwd: string;
+ readonly deep: number;
+ readonly dot: boolean;
+ readonly extglob: boolean;
+ readonly followSymbolicLinks: boolean;
+ readonly fs: FileSystemAdapter;
+ readonly globstar: boolean;
+ readonly ignore: Pattern[];
+ readonly markDirectories: boolean;
+ readonly objectMode: boolean;
+ readonly onlyDirectories: boolean;
+ readonly onlyFiles: boolean;
+ readonly stats: boolean;
+ readonly suppressErrors: boolean;
+ readonly throwErrorOnBrokenSymbolicLink: boolean;
+ readonly unique: boolean;
+ constructor(_options?: Options);
+ private _getValue;
+ private _getFileSystemMethods;
+}
Index: frontend/node_modules/fast-glob/out/settings.js
===================================================================
--- frontend/node_modules/fast-glob/out/settings.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/settings.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
+const fs = require("fs");
+const os = require("os");
+/**
+ * The `os.cpus` method can return zero. We expect the number of cores to be greater than zero.
+ * https://github.com/nodejs/node/blob/7faeddf23a98c53896f8b574a6e66589e8fb1eb8/lib/os.js#L106-L107
+ */
+const CPU_COUNT = Math.max(os.cpus().length, 1);
+exports.DEFAULT_FILE_SYSTEM_ADAPTER = {
+ lstat: fs.lstat,
+ lstatSync: fs.lstatSync,
+ stat: fs.stat,
+ statSync: fs.statSync,
+ readdir: fs.readdir,
+ readdirSync: fs.readdirSync
+};
+class Settings {
+ constructor(_options = {}) {
+ this._options = _options;
+ this.absolute = this._getValue(this._options.absolute, false);
+ this.baseNameMatch = this._getValue(this._options.baseNameMatch, false);
+ this.braceExpansion = this._getValue(this._options.braceExpansion, true);
+ this.caseSensitiveMatch = this._getValue(this._options.caseSensitiveMatch, true);
+ this.concurrency = this._getValue(this._options.concurrency, CPU_COUNT);
+ this.cwd = this._getValue(this._options.cwd, process.cwd());
+ this.deep = this._getValue(this._options.deep, Infinity);
+ this.dot = this._getValue(this._options.dot, false);
+ this.extglob = this._getValue(this._options.extglob, true);
+ this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, true);
+ this.fs = this._getFileSystemMethods(this._options.fs);
+ this.globstar = this._getValue(this._options.globstar, true);
+ this.ignore = this._getValue(this._options.ignore, []);
+ this.markDirectories = this._getValue(this._options.markDirectories, false);
+ this.objectMode = this._getValue(this._options.objectMode, false);
+ this.onlyDirectories = this._getValue(this._options.onlyDirectories, false);
+ this.onlyFiles = this._getValue(this._options.onlyFiles, true);
+ this.stats = this._getValue(this._options.stats, false);
+ this.suppressErrors = this._getValue(this._options.suppressErrors, false);
+ this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, false);
+ this.unique = this._getValue(this._options.unique, true);
+ if (this.onlyDirectories) {
+ this.onlyFiles = false;
+ }
+ if (this.stats) {
+ this.objectMode = true;
+ }
+ // Remove the cast to the array in the next major (#404).
+ this.ignore = [].concat(this.ignore);
+ }
+ _getValue(option, value) {
+ return option === undefined ? value : option;
+ }
+ _getFileSystemMethods(methods = {}) {
+ return Object.assign(Object.assign({}, exports.DEFAULT_FILE_SYSTEM_ADAPTER), methods);
+ }
+}
+exports.default = Settings;
Index: frontend/node_modules/fast-glob/out/types/index.d.ts
===================================================================
--- frontend/node_modules/fast-glob/out/types/index.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/types/index.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,31 @@
+///
+import * as fsWalk from '@nodelib/fs.walk';
+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;
+export type ReaderOptions = fsWalk.Options & {
+ transform(entry: Entry): EntryItem;
+ deepFilter: DeepFilterFunction;
+ entryFilter: EntryFilterFunction;
+ errorFilter: ErrorFilterFunction;
+ fs: FileSystemAdapter;
+ stats: boolean;
+};
+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;
+ nocase?: boolean;
+ noext?: boolean;
+ noglobstar?: boolean;
+ posix?: boolean;
+ strictSlashes?: boolean;
+};
+export type FileSystemAdapter = fsWalk.FileSystemAdapter;
Index: frontend/node_modules/fast-glob/out/types/index.js
===================================================================
--- frontend/node_modules/fast-glob/out/types/index.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/types/index.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
Index: frontend/node_modules/fast-glob/out/utils/array.d.ts
===================================================================
--- frontend/node_modules/fast-glob/out/utils/array.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/utils/array.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,2 @@
+export declare function flatten(items: T[][]): T[];
+export declare function splitWhen(items: T[], predicate: (item: T) => boolean): T[][];
Index: frontend/node_modules/fast-glob/out/utils/array.js
===================================================================
--- frontend/node_modules/fast-glob/out/utils/array.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/utils/array.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitWhen = exports.flatten = void 0;
+function flatten(items) {
+ return items.reduce((collection, item) => [].concat(collection, item), []);
+}
+exports.flatten = flatten;
+function splitWhen(items, predicate) {
+ const result = [[]];
+ let groupIndex = 0;
+ for (const item of items) {
+ if (predicate(item)) {
+ groupIndex++;
+ result[groupIndex] = [];
+ }
+ else {
+ result[groupIndex].push(item);
+ }
+ }
+ return result;
+}
+exports.splitWhen = splitWhen;
Index: frontend/node_modules/fast-glob/out/utils/errno.d.ts
===================================================================
--- frontend/node_modules/fast-glob/out/utils/errno.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/utils/errno.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,2 @@
+import { ErrnoException } from '../types';
+export declare function isEnoentCodeError(error: ErrnoException): boolean;
Index: frontend/node_modules/fast-glob/out/utils/errno.js
===================================================================
--- frontend/node_modules/fast-glob/out/utils/errno.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/utils/errno.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEnoentCodeError = void 0;
+function isEnoentCodeError(error) {
+ return error.code === 'ENOENT';
+}
+exports.isEnoentCodeError = isEnoentCodeError;
Index: frontend/node_modules/fast-glob/out/utils/fs.d.ts
===================================================================
--- frontend/node_modules/fast-glob/out/utils/fs.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/utils/fs.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,4 @@
+///
+import * as fs from 'fs';
+import { Dirent } from '@nodelib/fs.walk';
+export declare function createDirentFromStats(name: string, stats: fs.Stats): Dirent;
Index: frontend/node_modules/fast-glob/out/utils/fs.js
===================================================================
--- frontend/node_modules/fast-glob/out/utils/fs.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/utils/fs.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDirentFromStats = void 0;
+class DirentFromStats {
+ constructor(name, stats) {
+ this.name = name;
+ this.isBlockDevice = stats.isBlockDevice.bind(stats);
+ this.isCharacterDevice = stats.isCharacterDevice.bind(stats);
+ this.isDirectory = stats.isDirectory.bind(stats);
+ this.isFIFO = stats.isFIFO.bind(stats);
+ this.isFile = stats.isFile.bind(stats);
+ this.isSocket = stats.isSocket.bind(stats);
+ this.isSymbolicLink = stats.isSymbolicLink.bind(stats);
+ }
+}
+function createDirentFromStats(name, stats) {
+ return new DirentFromStats(name, stats);
+}
+exports.createDirentFromStats = createDirentFromStats;
Index: frontend/node_modules/fast-glob/out/utils/index.d.ts
===================================================================
--- frontend/node_modules/fast-glob/out/utils/index.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/utils/index.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,8 @@
+import * as array from './array';
+import * as errno from './errno';
+import * as fs from './fs';
+import * as path from './path';
+import * as pattern from './pattern';
+import * as stream from './stream';
+import * as string from './string';
+export { array, errno, fs, path, pattern, stream, string };
Index: frontend/node_modules/fast-glob/out/utils/index.js
===================================================================
--- frontend/node_modules/fast-glob/out/utils/index.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/utils/index.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.string = exports.stream = exports.pattern = exports.path = exports.fs = exports.errno = exports.array = void 0;
+const array = require("./array");
+exports.array = array;
+const errno = require("./errno");
+exports.errno = errno;
+const fs = require("./fs");
+exports.fs = fs;
+const path = require("./path");
+exports.path = path;
+const pattern = require("./pattern");
+exports.pattern = pattern;
+const stream = require("./stream");
+exports.stream = stream;
+const string = require("./string");
+exports.string = string;
Index: frontend/node_modules/fast-glob/out/utils/path.d.ts
===================================================================
--- frontend/node_modules/fast-glob/out/utils/path.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/utils/path.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,13 @@
+import { Pattern } from '../types';
+/**
+ * Designed to work only with simple paths: `dir\\file`.
+ */
+export declare function unixify(filepath: string): string;
+export declare function makeAbsolute(cwd: string, filepath: string): string;
+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;
Index: frontend/node_modules/fast-glob/out/utils/path.js
===================================================================
--- frontend/node_modules/fast-glob/out/utils/path.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/utils/path.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 .\\
+/**
+ * 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`.
+ */
+function unixify(filepath) {
+ return filepath.replace(/\\/g, '/');
+}
+exports.unixify = unixify;
+function makeAbsolute(cwd, filepath) {
+ return path.resolve(cwd, filepath);
+}
+exports.makeAbsolute = makeAbsolute;
+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
+ if (entry.charAt(0) === '.') {
+ const secondCharactery = entry.charAt(1);
+ if (secondCharactery === '/' || secondCharactery === '\\') {
+ return entry.slice(LEADING_DOT_SEGMENT_CHARACTERS_COUNT);
+ }
+ }
+ 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;
Index: frontend/node_modules/fast-glob/out/utils/pattern.d.ts
===================================================================
--- frontend/node_modules/fast-glob/out/utils/pattern.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/utils/pattern.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,49 @@
+import { MicromatchOptions, Pattern, PatternRe } from '../types';
+type PatternTypeOptions = {
+ braceExpansion?: boolean;
+ caseSensitiveMatch?: boolean;
+ extglob?: boolean;
+};
+export declare function isStaticPattern(pattern: Pattern, options?: PatternTypeOptions): boolean;
+export declare function isDynamicPattern(pattern: Pattern, options?: PatternTypeOptions): boolean;
+export declare function convertToPositivePattern(pattern: Pattern): Pattern;
+export declare function convertToNegativePattern(pattern: Pattern): Pattern;
+export declare function isNegativePattern(pattern: Pattern): boolean;
+export declare function isPositivePattern(pattern: Pattern): boolean;
+export declare function getNegativePatterns(patterns: Pattern[]): Pattern[];
+export declare function getPositivePatterns(patterns: Pattern[]): Pattern[];
+/**
+ * Returns patterns that can be applied inside the current directory.
+ *
+ * @example
+ * // ['./*', '*', 'a/*']
+ * getPatternsInsideCurrentDirectory(['./*', '*', 'a/*', '../*', './../*'])
+ */
+export declare function getPatternsInsideCurrentDirectory(patterns: Pattern[]): Pattern[];
+/**
+ * Returns patterns to be expanded relative to (outside) the current directory.
+ *
+ * @example
+ * // ['../*', './../*']
+ * getPatternsInsideCurrentDirectory(['./*', '*', 'a/*', '../*', './../*'])
+ */
+export declare function getPatternsOutsideCurrentDirectory(patterns: Pattern[]): Pattern[];
+export declare function isPatternRelatedToParentDirectory(pattern: Pattern): boolean;
+export declare function getBaseDirectory(pattern: Pattern): string;
+export declare function hasGlobStar(pattern: Pattern): boolean;
+export declare function endsWithSlashGlobStar(pattern: Pattern): boolean;
+export declare function isAffectDepthOfReadingPattern(pattern: Pattern): boolean;
+export declare function expandPatternsWithBraceExpansion(patterns: Pattern[]): Pattern[];
+export declare function expandBraceExpansion(pattern: Pattern): Pattern[];
+export declare function getPatternParts(pattern: Pattern, options: MicromatchOptions): Pattern[];
+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 declare function partitionAbsoluteAndRelative(patterns: Pattern[]): Pattern[][];
+export declare function isAbsolute(pattern: string): boolean;
+export {};
Index: frontend/node_modules/fast-glob/out/utils/pattern.js
===================================================================
--- frontend/node_modules/fast-glob/out/utils/pattern.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/utils/pattern.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAbsolute = exports.partitionAbsoluteAndRelative = 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");
+const GLOBSTAR = '**';
+const ESCAPE_SYMBOL = '\\';
+const COMMON_GLOB_SYMBOLS_RE = /[*?]|^!/;
+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);
+}
+exports.isStaticPattern = isStaticPattern;
+function isDynamicPattern(pattern, options = {}) {
+ /**
+ * A special case with an empty string is necessary for matching patterns that start with a forward slash.
+ * An empty string cannot be a dynamic pattern.
+ * For example, the pattern `/lib/*` will be spread into parts: '', 'lib', '*'.
+ */
+ if (pattern === '') {
+ return false;
+ }
+ /**
+ * When the `caseSensitiveMatch` option is disabled, all patterns must be marked as dynamic, because we cannot check
+ * filepath directly (without read directory).
+ */
+ if (options.caseSensitiveMatch === false || pattern.includes(ESCAPE_SYMBOL)) {
+ return true;
+ }
+ if (COMMON_GLOB_SYMBOLS_RE.test(pattern) || REGEX_CHARACTER_CLASS_SYMBOLS_RE.test(pattern) || REGEX_GROUP_SYMBOLS_RE.test(pattern)) {
+ return true;
+ }
+ if (options.extglob !== false && GLOB_EXTENSION_SYMBOLS_RE.test(pattern)) {
+ return true;
+ }
+ if (options.braceExpansion !== false && hasBraceExpansion(pattern)) {
+ return true;
+ }
+ return false;
+}
+exports.isDynamicPattern = isDynamicPattern;
+function hasBraceExpansion(pattern) {
+ const openingBraceIndex = pattern.indexOf('{');
+ if (openingBraceIndex === -1) {
+ return false;
+ }
+ const closingBraceIndex = pattern.indexOf('}', openingBraceIndex + 1);
+ if (closingBraceIndex === -1) {
+ return false;
+ }
+ const braceContent = pattern.slice(openingBraceIndex, closingBraceIndex);
+ return BRACE_EXPANSION_SEPARATORS_RE.test(braceContent);
+}
+function convertToPositivePattern(pattern) {
+ return isNegativePattern(pattern) ? pattern.slice(1) : pattern;
+}
+exports.convertToPositivePattern = convertToPositivePattern;
+function convertToNegativePattern(pattern) {
+ return '!' + pattern;
+}
+exports.convertToNegativePattern = convertToNegativePattern;
+function isNegativePattern(pattern) {
+ return pattern.startsWith('!') && pattern[1] !== '(';
+}
+exports.isNegativePattern = isNegativePattern;
+function isPositivePattern(pattern) {
+ return !isNegativePattern(pattern);
+}
+exports.isPositivePattern = isPositivePattern;
+function getNegativePatterns(patterns) {
+ return patterns.filter(isNegativePattern);
+}
+exports.getNegativePatterns = getNegativePatterns;
+function getPositivePatterns(patterns) {
+ return patterns.filter(isPositivePattern);
+}
+exports.getPositivePatterns = getPositivePatterns;
+/**
+ * Returns patterns that can be applied inside the current directory.
+ *
+ * @example
+ * // ['./*', '*', 'a/*']
+ * getPatternsInsideCurrentDirectory(['./*', '*', 'a/*', '../*', './../*'])
+ */
+function getPatternsInsideCurrentDirectory(patterns) {
+ return patterns.filter((pattern) => !isPatternRelatedToParentDirectory(pattern));
+}
+exports.getPatternsInsideCurrentDirectory = getPatternsInsideCurrentDirectory;
+/**
+ * Returns patterns to be expanded relative to (outside) the current directory.
+ *
+ * @example
+ * // ['../*', './../*']
+ * getPatternsInsideCurrentDirectory(['./*', '*', 'a/*', '../*', './../*'])
+ */
+function getPatternsOutsideCurrentDirectory(patterns) {
+ return patterns.filter(isPatternRelatedToParentDirectory);
+}
+exports.getPatternsOutsideCurrentDirectory = getPatternsOutsideCurrentDirectory;
+function isPatternRelatedToParentDirectory(pattern) {
+ return pattern.startsWith('..') || pattern.startsWith('./..');
+}
+exports.isPatternRelatedToParentDirectory = isPatternRelatedToParentDirectory;
+function getBaseDirectory(pattern) {
+ return globParent(pattern, { flipBackslashes: false });
+}
+exports.getBaseDirectory = getBaseDirectory;
+function hasGlobStar(pattern) {
+ return pattern.includes(GLOBSTAR);
+}
+exports.hasGlobStar = hasGlobStar;
+function endsWithSlashGlobStar(pattern) {
+ return pattern.endsWith('/' + GLOBSTAR);
+}
+exports.endsWithSlashGlobStar = endsWithSlashGlobStar;
+function isAffectDepthOfReadingPattern(pattern) {
+ const basename = path.basename(pattern);
+ return endsWithSlashGlobStar(pattern) || isStaticPattern(basename);
+}
+exports.isAffectDepthOfReadingPattern = isAffectDepthOfReadingPattern;
+function expandPatternsWithBraceExpansion(patterns) {
+ return patterns.reduce((collection, pattern) => {
+ return collection.concat(expandBraceExpansion(pattern));
+ }, []);
+}
+exports.expandPatternsWithBraceExpansion = expandPatternsWithBraceExpansion;
+function expandBraceExpansion(pattern) {
+ const patterns = micromatch.braces(pattern, { expand: true, nodupes: true, keepEscaping: 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) {
+ let { parts } = micromatch.scan(pattern, Object.assign(Object.assign({}, options), { parts: true }));
+ /**
+ * The scan method returns an empty array in some cases.
+ * See micromatch/picomatch#58 for more details.
+ */
+ if (parts.length === 0) {
+ parts = [pattern];
+ }
+ /**
+ * The scan method does not return an empty part for the pattern with a forward slash.
+ * This is another part of micromatch/picomatch#58.
+ */
+ if (parts[0].startsWith('/')) {
+ parts[0] = parts[0].slice(1);
+ parts.unshift('');
+ }
+ return parts;
+}
+exports.getPatternParts = getPatternParts;
+function makeRe(pattern, options) {
+ return micromatch.makeRe(pattern, options);
+}
+exports.makeRe = makeRe;
+function convertPatternsToRe(patterns, options) {
+ return patterns.map((pattern) => makeRe(pattern, options));
+}
+exports.convertPatternsToRe = convertPatternsToRe;
+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;
+function partitionAbsoluteAndRelative(patterns) {
+ const absolute = [];
+ const relative = [];
+ for (const pattern of patterns) {
+ if (isAbsolute(pattern)) {
+ absolute.push(pattern);
+ }
+ else {
+ relative.push(pattern);
+ }
+ }
+ return [absolute, relative];
+}
+exports.partitionAbsoluteAndRelative = partitionAbsoluteAndRelative;
+function isAbsolute(pattern) {
+ return path.isAbsolute(pattern);
+}
+exports.isAbsolute = isAbsolute;
Index: frontend/node_modules/fast-glob/out/utils/stream.d.ts
===================================================================
--- frontend/node_modules/fast-glob/out/utils/stream.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/utils/stream.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,4 @@
+///
+///
+import { Readable } from 'stream';
+export declare function merge(streams: Readable[]): NodeJS.ReadableStream;
Index: frontend/node_modules/fast-glob/out/utils/stream.js
===================================================================
--- frontend/node_modules/fast-glob/out/utils/stream.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/utils/stream.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.merge = void 0;
+const merge2 = require("merge2");
+function merge(streams) {
+ const mergedStream = merge2(streams);
+ streams.forEach((stream) => {
+ stream.once('error', (error) => mergedStream.emit('error', error));
+ });
+ mergedStream.once('close', () => propagateCloseEventToSources(streams));
+ mergedStream.once('end', () => propagateCloseEventToSources(streams));
+ return mergedStream;
+}
+exports.merge = merge;
+function propagateCloseEventToSources(streams) {
+ streams.forEach((stream) => stream.emit('close'));
+}
Index: frontend/node_modules/fast-glob/out/utils/string.d.ts
===================================================================
--- frontend/node_modules/fast-glob/out/utils/string.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/utils/string.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,2 @@
+export declare function isString(input: unknown): input is string;
+export declare function isEmpty(input: string): boolean;
Index: frontend/node_modules/fast-glob/out/utils/string.js
===================================================================
--- frontend/node_modules/fast-glob/out/utils/string.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/out/utils/string.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEmpty = exports.isString = void 0;
+function isString(input) {
+ return typeof input === 'string';
+}
+exports.isString = isString;
+function isEmpty(input) {
+ return input === '';
+}
+exports.isEmpty = isEmpty;
Index: frontend/node_modules/fast-glob/package.json
===================================================================
--- frontend/node_modules/fast-glob/package.json (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/fast-glob/package.json (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,81 @@
+{
+ "name": "fast-glob",
+ "version": "3.3.3",
+ "description": "It's a very fast and efficient glob library for Node.js",
+ "license": "MIT",
+ "repository": "mrmlnc/fast-glob",
+ "author": {
+ "name": "Denis Malinochkin",
+ "url": "https://mrmlnc.com"
+ },
+ "engines": {
+ "node": ">=8.6.0"
+ },
+ "main": "out/index.js",
+ "typings": "out/index.d.ts",
+ "files": [
+ "out",
+ "!out/{benchmark,tests}",
+ "!out/**/*.map",
+ "!out/**/*.spec.*"
+ ],
+ "keywords": [
+ "glob",
+ "patterns",
+ "fast",
+ "implementation"
+ ],
+ "devDependencies": {
+ "@nodelib/fs.macchiato": "^1.0.1",
+ "@types/glob-parent": "^5.1.0",
+ "@types/merge2": "^1.1.4",
+ "@types/micromatch": "^4.0.0",
+ "@types/mocha": "^5.2.7",
+ "@types/node": "^14.18.53",
+ "@types/picomatch": "^2.3.0",
+ "@types/sinon": "^7.5.0",
+ "bencho": "^0.1.1",
+ "eslint": "^6.5.1",
+ "eslint-config-mrmlnc": "^1.1.0",
+ "execa": "^7.1.1",
+ "fast-glob": "^3.0.4",
+ "fdir": "6.0.1",
+ "glob": "^10.0.0",
+ "hereby": "^1.8.1",
+ "mocha": "^6.2.1",
+ "rimraf": "^5.0.0",
+ "sinon": "^7.5.0",
+ "snap-shot-it": "^7.9.10",
+ "typescript": "^4.9.5"
+ },
+ "dependencies": {
+ "@nodelib/fs.stat": "^2.0.2",
+ "@nodelib/fs.walk": "^1.2.3",
+ "glob-parent": "^5.1.2",
+ "merge2": "^1.3.0",
+ "micromatch": "^4.0.8"
+ },
+ "scripts": {
+ "clean": "rimraf out",
+ "lint": "eslint \"src/**/*.ts\" --cache",
+ "compile": "tsc",
+ "test": "mocha \"out/**/*.spec.js\" -s 0",
+ "test:e2e": "mocha \"out/**/*.e2e.js\" -s 0",
+ "test:e2e:sync": "mocha \"out/**/*.e2e.js\" -s 0 --grep \"\\(sync\\)\"",
+ "test:e2e:async": "mocha \"out/**/*.e2e.js\" -s 0 --grep \"\\(async\\)\"",
+ "test:e2e:stream": "mocha \"out/**/*.e2e.js\" -s 0 --grep \"\\(stream\\)\"",
+ "build": "npm run clean && npm run compile && npm run lint && npm test",
+ "watch": "npm run clean && npm run compile -- -- --sourceMap --watch",
+ "bench:async": "npm run bench:product:async && npm run bench:regression:async",
+ "bench:stream": "npm run bench:product:stream && npm run bench:regression:stream",
+ "bench:sync": "npm run bench:product:sync && npm run bench:regression:sync",
+ "bench:product": "npm run bench:product:async && npm run bench:product:sync && npm run bench:product:stream",
+ "bench:product:async": "hereby bench:product:async",
+ "bench:product:sync": "hereby bench:product:sync",
+ "bench:product:stream": "hereby bench:product:stream",
+ "bench:regression": "npm run bench:regression:async && npm run bench:regression:sync && npm run bench:regression:stream",
+ "bench:regression:async": "hereby bench:regression:async",
+ "bench:regression:sync": "hereby bench:regression:sync",
+ "bench:regression:stream": "hereby bench:regression:stream"
+ }
+}