Diffusion Open Access Compliance Check Tool (OACCT) (issn4frontend) Browse

fast-glob
49c99f97fe9aissn4frontend

fast-glob

LICENSE
README.md
node_modules/
out/
package.json

README.md

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.

<details> <summary><strong>Details</strong></summary>

[Highlights](#highlights)
[Donation](#donation)
[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](#escapepathpattern)
[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)

</details>

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.

Donation

Do you like this project? Support it by donating, creating an issue or pull request.

![Donate][paypal_mrmlnc]

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

⚠️ 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).

📖 This package uses a [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.

📖 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)).

📖 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])

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])

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])

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).

🔢 [Pattern syntax](#pattern-syntax)

⚠️ 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.

🔢 [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(pattern)`

Returns a path with escaped special characters (*?|(){}[], ! at the beginning of line, @+! before the opening parenthesis).

js
fg.escapePath('!abc'); // \\!abc
fg.escapePath('C:/Program Files (x86)'); // C:/Program Files \\(x86\\)

pattern

Required: true
Type: string

Any string, for example, a path to a file.

Options

Common options

concurrency

Type: number
Default: os.cpus().length

Specifies the maximum number of concurrent requests from a reader to read directories.

📖 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.

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']

📖 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.

📖 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.

📖 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.

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.

📖 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.

📖 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']

📖 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: <fs.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

📖 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']

📖 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: <fs.Dirent>, stats: <fs.Stats> }]

📖 Returns fs.stat instead of fs.lstat for symbolic links when the [followSymbolicLinks](#followsymboliclinks) option is specified.

⚠️ 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.

🔢 [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 (.).

📖 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.

🔢 [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/*',
	path.join(process.cwd(), '**').replace(/\\/g, '/')
]

📖 Use the [normalize-path][npm_normalize_path] or the [unixify][npm_unixify] 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].

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']

⚠️ 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), but you can use them as [cwd](#cwd) directory.

ts
fg.sync('*', { cwd: '\\\\?\\C:\\Python27' /* or //?/C:/Python27 */ });
fg.sync('Python27/*', { cwd: '\\\\?\\C:\\' /* or //?/C:/ */ });

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

Server

Link: [Vultr Bare Metal][vultr_pricing_baremetal]

Processor: E3-1270v6 (8 CPU)
RAM: 32GB
Disk: SSD ([Intel DC S3520 SSDSC2BB240G7][intel_ssd])

You can see results [here][github_gist_benchmark_server] for latest release.

Nettop

Link: [Zotac bi323][zotac_bi323]

Processor: Intel N3150 (4 CPU)
RAM: 8GB
Disk: SSD ([Silicon Power SP060GBSS3S55S25][silicon_power_ssd])

You can see results [here][github_gist_benchmark_nettop] for latest release.

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.

rOACCT/node_modules/fast-glob49c99f97fe9aissn4frontend

fast-glob

README.md

fast-glob

Table of Contents

Highlights

Donation

Old and modern mode

Pattern syntax

Basic syntax

Advanced syntax

Installation

API

Asynchronous

Synchronous

Stream

patterns

[options]

Helpers

generateTasks(patterns, [options])

patterns

[options]

isDynamicPattern(pattern, [options])

pattern

[options]

escapePath(pattern)

pattern

Options

Common options

concurrency

cwd

deep

followSymbolicLinks

fs

ignore

suppressErrors

throwErrorOnBrokenSymbolicLink

Output control

absolute

markDirectories

objectMode

onlyDirectories

onlyFiles

stats

unique

Matching control

braceExpansion

caseSensitiveMatch

dot

extglob

globstar

baseNameMatch

FAQ

What is a static or dynamic pattern?

How to write patterns on Windows?

Why are parentheses match wrong?

How to exclude directory from reading?

How to use UNC path?

Compatible with node-glob?

Benchmarks

Server

Nettop

Changelog

License

rOACCT/node_modules/fast-glob
49c99f97fe9aissn4frontend

`generateTasks(patterns, [options])`

`isDynamicPattern(pattern, [options])`

`escapePath(pattern)`

Compatible with `node-glob`?