Minimatch

https://www.npmjs.com/package/minimatch
Admin
Minimatch is a minimal matching utility that converts glob expressions into JavaScript regular...
Tokens:17,561
Snippets:241
Trust Score:9.6
Update:6 months ago
Show doc for...
Tokens:
Raw
### Example of minimatch set property

Source: https://www.npmjs.com/package/minimatch

Illustrates the structure of the `set` property for brace-expanded patterns.

```plaintext
[ [ a,
  d ]
,
  [ b, c, d ] ]
```

--------------------------------

### Perform glob matching with minimatch

Source: https://www.npmjs.com/package/minimatch?activeTab=versions

Demonstrates basic usage of the minimatch function using both ESM and CommonJS imports, including an example with debug options enabled.

```javascript
// hybrid module, load with require() or import
import { minimatch } from 'minimatch'
// or:
const { minimatch } = require('minimatch')

minimatch('bar.foo', '*.foo') // true!
minimatch('bar.foo', '*.bar') // false!
minimatch('bar.foo', '*.+(bar|foo)', { debug: true }) // true, and noisy!
```

--------------------------------

### Representing a brace-expanded pattern

Source: https://www.npmjs.com/package/minimatch?activeTab=versions

Example of how a brace-expanded pattern is represented in the set property.

```javascript
  [ [ a, d ]
  , [ b, c, d ] ]
```

--------------------------------

### matchBase Option

Source: https://www.npmjs.com/package/minimatch?activeTab=code

If set, patterns without slashes are matched against the basename of the path if it contains slashes. For example, `a?b` would match the path `/xyz/123/acb`.

```APIDOC
## matchBase Option

### Description
If set, then patterns without slashes will be matched against the basename of the path if it contains slashes. For example, `a?b` would match the path `/xyz/123/acb`, but not `/xyz/acb/123`.

### Parameters
#### Request Body
- **matchBase** (boolean) - Optional - If true, matches patterns without slashes against the basename of the path.
```

--------------------------------

### matchBase Option

Source: https://www.npmjs.com/package/minimatch?activeTab=dependencies

If set, patterns without slashes will be matched against the basename of the path if it contains slashes. For example, `a?b` would match the path `/xyz/123/acb`, but not `/xyz/acb/123`.

```APIDOC
## matchBase Option

### Description
If set, then patterns without slashes will be matched against the basename of the path if it contains slashes. For example, `a?b` would match the path `/xyz/123/acb`, but not `/xyz/acb/123`.

### Usage
```javascript
minimatch('/xyz/123/acb', 'a?b', { matchBase: true })
```
```

--------------------------------

### windowsNoMagicRoot Option

Source: https://www.npmjs.com/package/minimatch?activeTab=dependencies

When a pattern starts with a UNC path or drive letter, and in `nocase:true` mode, this option prevents the root portions of the pattern from being converted into a case-insensitive regular expression, leaving them as strings instead. This is the default behavior on Windows when `nocase:true` is set.

```APIDOC
## windowsNoMagicRoot Option

### Description
When a pattern starts with a UNC path or drive letter, and in `nocase:true` mode, do not convert the root portions of the pattern into a case-insensitive regular expression, and instead leave them as strings. This is the default when the platform is `win32` and `nocase:true` is set.

### Usage
```javascript
minimatch('C:\\path\\to\\file', 'C:\\path\\*', { nocase: true, windowsNoMagicRoot: true })
```
```

--------------------------------

### Instantiate the Minimatch class

Source: https://www.npmjs.com/package/minimatch?activeTab=versions

Shows how to create a reusable Minimatch object by instantiating the Minimatch class.

```javascript
var Minimatch = require('minimatch').Minimatch
var mm = new Minimatch(pattern, options)
```

--------------------------------

### platform

Source: https://www.npmjs.com/package/minimatch?activeTab=versions

Enables Windows-specific behaviors, such as special handling for UNC paths and treating `\` as separators.

```APIDOC
## platform

When set to `win32`, this will trigger all windows-specific behaviors (special handling for UNC paths, and treating `\` as separators in file paths for comparison.)

Defaults to the value of `process.platform`.
```

--------------------------------

### nocomment Option

Source: https://www.npmjs.com/package/minimatch?activeTab=dependencies

Suppresses the behavior of treating the `#` character at the start of a pattern as a comment.

```APIDOC
## nocomment Option

### Description
Suppress the behavior of treating `#` at the start of a pattern as a comment.

### Usage
```javascript
minimatch(path, '#commented/pattern', { nocomment: true })
```
```

--------------------------------

### Matching a list of files

Source: https://www.npmjs.com/package/minimatch?activeTab=versions

Matches a list of files against a pattern, returning the matched subset.

```javascript
var javascripts = minimatch.match(fileList, '*.js', { matchBase: true })
```

--------------------------------

### Minimatch Configuration Options

Source: https://www.npmjs.com/package/minimatch

Configuration settings for controlling the behavior of the minimatch pattern matcher.

```APIDOC
## Configuration Options

### optimizationLevel
- **Type**: number
- **Description**: Indicates the level of optimization applied to the pattern. 
  - `0`: No further changes.
  - `1`: (Default) Removes cases where `..` follows a pattern portion that is not `**`, `.`, `..`, or empty.
  - `2` or higher: Aggressive optimizations for file-walking, including deduping and path simplification.

### platform
- **Type**: string
- **Description**: Triggers platform-specific behaviors. Set to `win32` for Windows-specific handling (UNC paths, `\` as separators). Defaults to `process.platform`.

### maxGlobstarRecursion
- **Type**: number
- **Description**: Max number of non-adjacent `**` patterns to recursively walk. Default is `200`. Exceeding this results in a non-match for security and performance.

### maxExtglobRecursion
- **Type**: number
- **Description**: Max depth to traverse for nested extglobs. Default is `2`. If exceeded, the pattern switches to `noextglob: true` mode for that sub-pattern.
```

--------------------------------

### Import and Use minimatch Function

Source: https://www.npmjs.com/package/minimatch

Import the minimatch function using either require or import syntax. Use it to test if a string matches a glob pattern.

```javascript
import { minimatch } from 'minimatch'
// or:
const { minimatch } = require('minimatch')

minimatch('bar.foo', '*.foo') // true!
minimatch('bar.foo', '*.bar') // false!
minimatch('bar.foo', '*.+(bar|foo)', { debug: true }) // true, and noisy!
```

--------------------------------

### Minimatch object properties

Source: https://www.npmjs.com/package/minimatch?activeTab=code

Illustrates the structure of a minimatch object, showing properties like original pattern, options, and parsed expressions.

```plaintext
[ [ a, d ]
, [ b, c, d ] ]
```

--------------------------------

### minimatch(path, pattern, options)

Source: https://www.npmjs.com/package/minimatch?activeTab=dependents

The main export function that tests a path against a glob pattern.

```APIDOC
## minimatch(path, pattern, options)

### Description
Tests a path against the pattern using the provided options.

### Parameters
- **path** (string) - Required - The file path to test.
- **pattern** (string) - Required - The glob pattern to match against.
- **options** (object) - Optional - Configuration options for the matching process.

### Request Example
```javascript
var isJS = minimatch(file, '*.js', { matchBase: true })
```
```

--------------------------------

### partial Option

Source: https://www.npmjs.com/package/minimatch?activeTab=dependencies

Allows comparing a partial path to a pattern. As long as the parts of the path that are present are not contradicted by the pattern, it will be treated as a match. This is useful for applications walking through a folder structure where the full path is not yet known.

```APIDOC
## partial Option

### Description
Compare a partial path to a pattern. As long as the parts of the path that are present are not contradicted by the pattern, it will be treated as a match. This is useful in applications where you're walking through a folder structure, and don't yet have the full path, but want to ensure that you do not walk down paths that can never be a match.

### Examples
```javascript
minimatch('/a/b', '/a/*/c/d', { partial: true }) // true, might be /a/b/c/d
minimatch('/a/b', '/**/d', { partial: true }) // true, might be /a/b/.../d
minimatch('/x/y/z', '/a/**/z', { partial: true }) // false, because x !== a
```
```

--------------------------------

### Testing a path against a pattern

Source: https://www.npmjs.com/package/minimatch?activeTab=versions

Tests a path against a pattern using the specified options.

```javascript
var isJS = minimatch(file, '*.js', { matchBase: true })
```

--------------------------------

### Minimatch Options

Source: https://www.npmjs.com/package/minimatch?activeTab=versions

Configuration options that can be passed to minimatch functions to customize matching behavior.

```APIDOC
## Options
All options are `false` by default.

### debug
Dump a ton of stuff to stderr.

### nobrace
Do not expand `{a,b}` and `{1..3}` brace sets.

### noglobstar
Disable `**` matching against multiple folder names.

### dot
Allow patterns to match filenames starting with a period, even if the pattern does not explicitly have a period in that spot. Note that by default, `a/**/b` will **not** match `a/.d/b`, unless `dot` is set.

### noext
Disable "extglob" style patterns like `+(a|b)`.

### nocase
Perform a case-insensitive match.
```

--------------------------------

### Minimatch Methods

Source: https://www.npmjs.com/package/minimatch?activeTab=dependencies

Methods available on a minimatch object instance.

```APIDOC
## Methods

### `makeRe()`
Generate the `regexp` member if necessary, and return it. Will return `false` if the pattern is invalid.

### `match(fname)`
Return true if the filename matches the pattern, or false otherwise.

### `matchOne(fileArray, patternArray, partial)`
Take a `/`-split filename, and match it against a single row in the `regExpSet`. This method is mainly for internal use, but is exposed so that it can be used by a glob-walker that needs to avoid excessive filesystem calls.

### `hasMagic()`
Returns true if the parsed pattern contains any magic characters. Returns false if all comparator parts are string literals. If the `magicalBraces` option is set on the constructor, then it will consider brace expansions which are not otherwise magical to be magic. If not set, then a pattern like `a{b,c}d` will return `false`, because neither `abd` nor `acd` contain any special glob characters.
This does **not** mean that the pattern string can be used as a literal filename, as it may contain magic glob characters that are escaped. For example, the pattern `\*` or `[*]` would not be considered to have magic, as the matching portion parses to the literal string `'*'` and would match a path named `'*'`, not `'\*'` or `'[*]'`. The `minimatch.unescape()` method may be used to remove escape characters.
```

--------------------------------

### Minimatch Match List

Source: https://www.npmjs.com/package/minimatch

Matches a list of files against a pattern, similar to fnmatch or glob.

```APIDOC
## minimatch.match(list, pattern, options)

### Description
Match against the list of files, in the style of fnmatch or glob. If nothing is matched, and options.nonull is set, then return a list containing the pattern itself.

### Parameters
#### Path Parameters
- **list** (array) - Required - An array of file paths to match against.
- **pattern** (string) - Required - The glob pattern to match.
- **options** (object) - Optional - Configuration options.

### Request Example
```javascript
var javascripts = minimatch.match(fileList, '*.js', { matchBase: true })
```
```

--------------------------------

### Perform partial path matching with minimatch

Source: https://www.npmjs.com/package/minimatch?activeTab=versions

Use the partial option to match path segments against a pattern before the full path is available. This is useful for directory traversal validation.

```javascript
minimatch('/a/b', '/a/*/c/d', { partial: true }) // true, might be /a/b/c/d
minimatch('/a/b', '/**/d', { partial: true }) // true, might be /a/b/.../d
minimatch('/x/y/z', '/a/**/z', { partial: true }) // false, because x !== a
```

--------------------------------

### windowsPathsNoEscape Option

Source: https://www.npmjs.com/package/minimatch?activeTab=dependencies

Uses `\` as a path separator only, and never as an escape character. If set, all `\` characters are replaced with `/` in the pattern. This makes it impossible to match paths containing literal glob pattern characters but allows matching with patterns constructed using `path.join()` and `path.resolve()` on Windows platforms, mimicking earlier buggy behavior. For legacy reasons, this is also set if `options.allowWindowsEscape` is set to the exact value `false`.

```APIDOC
## windowsPathsNoEscape Option

### Description
Use `\` as a path separator _only_ , and _never_ as an escape character. If set, all `\` characters are replaced with `/` in the pattern. Note that this makes it **impossible** to match against paths containing literal glob pattern characters, but allows matching with patterns constructed using `path.join()` and `path.resolve()` on Windows platforms, mimicking the (buggy!) behavior of earlier versions on Windows. Please use with caution, and be mindful of the caveat about Windows paths. For legacy reasons, this is also set if `options.allowWindowsEscape` is set to the exact value `false`.

### Usage
```javascript
minimatch(path, 'C:\\Users\\file.txt', { windowsPathsNoEscape: true })
```
```

--------------------------------

### Minimatch Match Function

Source: https://www.npmjs.com/package/minimatch?activeTab=versions

Matches a list of files against a pattern, similar to fnmatch or glob.

```APIDOC
## minimatch.match(list, pattern, options)

### Description
Match against the list of files, in the style of fnmatch or glob. If nothing is matched, and options.nonull is set, then return a list containing the pattern itself.

### Parameters
#### Path Parameters
- **list** (array) - Required - An array of file paths to match against.
- **pattern** (string) - Required - The glob pattern to match.
- **options** (object) - Optional - Configuration options for matching.

### Request Example
```javascript
var javascripts = minimatch.match(fileList, '*.js', { matchBase: true })
```
```

--------------------------------

### Minimatch Main Export

Source: https://www.npmjs.com/package/minimatch?activeTab=versions

The main export of the minimatch library. It tests a given path against a pattern using specified options.

```APIDOC
## minimatch(path, pattern, options)

### Description
Tests a path against the pattern using the options.

### Parameters
#### Path Parameters
- **path** (string) - Required - The file path to test.
- **pattern** (string) - Required - The glob pattern to match against.
- **options** (object) - Optional - Configuration options for matching.

### Request Example
```javascript
var isJS = minimatch(file, '*.js', { matchBase: true })
```
```

--------------------------------

### windowsPathsNoEscape Option

Source: https://www.npmjs.com/package/minimatch?activeTab=code

Uses `\` as a path separator only, and never as an escape character. If set, all `\` characters are replaced with `/` in the pattern. This mimics the behavior of earlier versions on Windows but makes it impossible to match paths with literal glob pattern characters.

```APIDOC
## windowsPathsNoEscape Option

### Description
Use `\` as a path separator _only_ , and _never_ as an escape character. If set, all `\` characters are replaced with `/` in the pattern. Note that this makes it **impossible** to match against paths containing literal glob pattern characters, but allows matching with patterns constructed using `path.join()` and `path.resolve()` on Windows platforms, mimicking the (buggy!) behavior of earlier versions on Windows. Please use with caution, and be mindful of the caveat about Windows paths.
For legacy reasons, this is also set if `options.allowWindowsEscape` is set to the exact value `false`.

### Parameters
#### Request Body
- **windowsPathsNoEscape** (boolean) - Optional - If true, uses `\` as a path separator only and never as an escape character.
```

--------------------------------

### Minimatch Properties

Source: https://www.npmjs.com/package/minimatch?activeTab=dependencies

Properties available on a minimatch object instance.

```APIDOC
## Properties

### `pattern`
The original pattern the minimatch object represents.

### `options`
The options supplied to the constructor.

### `set`
A 2-dimensional array of regexp or string expressions. Each row in the array corresponds to a brace-expanded pattern. Each item in the row corresponds to a single path-part. For example, the pattern `{a,b/c}/d` would expand to a set of patterns like:
```
  [ [ a, d ]
  , [ b, c, d ] ]
```
If a portion of the pattern doesn't have any "magic" in it (that is, it's something like `"foo"` rather than `fo*o?`), then it will be left as a string rather than converted to a regular expression.

### `regexp`
Created by the `makeRe` method. A single regular expression expressing the entire pattern. This is useful in cases where you wish to use the pattern somewhat like `fnmatch(3)` with `FNM_PATH` enabled.

### `negate`
True if the pattern is negated.

### `comment`
True if the pattern is a comment.

### `empty`
True if the pattern is `""`.
```

--------------------------------

### Minimatch MakeRe Function

Source: https://www.npmjs.com/package/minimatch?activeTab=versions

Creates a regular expression object from a glob pattern.

```APIDOC
## minimatch.makeRe(pattern, options)

### Description
Make a regular expression object from the pattern.

### Parameters
#### Path Parameters
- **pattern** (string) - Required - The glob pattern to convert to a regular expression.
- **options** (object) - Optional - Configuration options for creating the regular expression.

### Request Example
```javascript
var regex = minimatch.makeRe('*.js');
```
```

--------------------------------

### minimatch.unescape(pattern, options)

Source: https://www.npmjs.com/package/minimatch?activeTab=code

Un-escapes a glob string.

```APIDOC
## minimatch.unescape(pattern, options)

### Description
Un-escape a glob string that may contain some escaped characters.
```

--------------------------------

### Filtering an array of files

Source: https://www.npmjs.com/package/minimatch?activeTab=versions

Creates a filter function for use with Array.prototype.filter to match files against a pattern.

```javascript
var javascripts = fileList.filter(
  minimatch.filter('*.js', { matchBase: true }),
)
```

--------------------------------

### Minimatch Make Regular Expression

Source: https://www.npmjs.com/package/minimatch

Creates a regular expression object from a glob pattern.

```APIDOC
## minimatch.makeRe(pattern, options)

### Description
Make a regular expression object from the pattern.

### Parameters
#### Path Parameters
- **pattern** (string) - Required - The glob pattern to convert to a regular expression.
- **options** (object) - Optional - Configuration options.

### Request Example
```javascript
var regex = minimatch.makeRe('*.js');
```
```

--------------------------------

### Create a regular expression from a pattern

Source: https://www.npmjs.com/package/minimatch

Use minimatch.makeRe to generate a regular expression object from a glob pattern.

```javascript
minimatch.makeRe(pattern, options)
```

--------------------------------

### nonull Option

Source: https://www.npmjs.com/package/minimatch?activeTab=dependencies

When a match is not found by `minimatch.match`, this option determines the return value. If set, it returns a list containing the pattern itself. Otherwise, an empty list is returned.

```APIDOC
## nonull Option

### Description
When a match is not found by `minimatch.match`, return a list containing the pattern itself if this option is set. When not set, an empty list is returned if there are no matches.

### Usage
```javascript
minimatch.match(list, pattern, { nonull: true })
```
```

--------------------------------

### flipNegate Option

Source: https://www.npmjs.com/package/minimatch?activeTab=dependencies

Returns from negate expressions the same as if they were not negated. This means it returns `true` on a hit and `false` on a miss for negated patterns.

```APIDOC
## flipNegate Option

### Description
Returns from negate expressions the same as if they were not negated. (Ie, true on a hit, false on a miss.)

### Usage
```javascript
minimatch(path, '!negated/pattern', { flipNegate: true })
```
```

--------------------------------

### minimatch.escape(pattern, options)

Source: https://www.npmjs.com/package/minimatch?activeTab=code

Escapes magic characters in a glob pattern.

```APIDOC
## minimatch.escape(pattern, options)

### Description
Escape all magic characters in a glob pattern, so that it will only ever match literal strings.
```

--------------------------------

### minimatch.filter(pattern, options)

Source: https://www.npmjs.com/package/minimatch?activeTab=dependents

Returns a function that tests its supplied argument, suitable for use with Array.filter.

```APIDOC
## minimatch.filter(pattern, options)

### Description
Returns a filter function that can be used with Array.prototype.filter to test a list of paths.

### Parameters
- **pattern** (string) - Required - The glob pattern.
- **options** (object) - Optional - Configuration options.

### Request Example
```javascript
var javascripts = fileList.filter(minimatch.filter('*.js', { matchBase: true }));
```
```

--------------------------------

### optimizationLevel

Source: https://www.npmjs.com/package/minimatch?activeTab=versions

Controls the level of optimization applied to patterns before matching. Higher levels offer more aggressive optimizations for performance, especially in file-walking scenarios, but may affect literal string matching.

```APIDOC
## optimizationLevel

A number indicating the level of optimization that should be done to the pattern prior to parsing and using it for matches.

* `0` - Make no further changes. `.` and `..` are maintained in the pattern.
* `1` - (default) Remove cases where a double-dot `..` follows a pattern portion that is not `**`, `.`, `..`, or empty `''`.
* `2` (or higher) - More aggressive optimizations: removes `.` and empty portions, converts specific `**` patterns, and deduplicates patterns.
```

--------------------------------

### maxGlobstarRecursion

Source: https://www.npmjs.com/package/minimatch?activeTab=versions

Sets the maximum number of non-adjacent `**` patterns to recursively walk down. Exceeding this limit results in a non-match for security and performance.

```APIDOC
## maxGlobstarRecursion

Max number of non-adjacent `**` patterns to recursively walk down.

The default of `200` is almost certainly high enough for most purposes.
If the limit is exceeded, then it is treated as non-matching, even if the path would normally match the pattern provided.
```

--------------------------------

### Minimatch Escape Function

Source: https://www.npmjs.com/package/minimatch?activeTab=versions

Escapes all magic characters in a glob pattern, ensuring it matches only literal strings.

```APIDOC
## minimatch.escape(pattern, options = {})

### Description
Escape all magic characters in a glob pattern, so that it will only ever match literal strings.
If the `windowsPathsNoEscape` option is used, then characters are escaped by wrapping in `[]`, because a magic character wrapped in a character class can only be satisfied by that exact character. Slashes (and backslashes in `windowsPathsNoEscape` mode) cannot be escaped or unescaped.

### Parameters
#### Path Parameters
- **pattern** (string) - Required - The glob pattern to escape.
- **options** (object) - Optional - Configuration options for escaping.

### Request Example
```javascript
var escapedPattern = minimatch.escape('*.js');
```
```

--------------------------------

### nocase Option

Source: https://www.npmjs.com/package/minimatch?activeTab=dependencies

When used with `{nocase: true}`, creates case-insensitive regular expressions for matching, while leaving string match portions untouched. This option has no effect when used without `{nocase: true}`.

```APIDOC
## nocase Option

### Description
Creates regular expressions that are case-insensitive when used with `{nocase: true}`, but leaves string match portions untouched. Has no effect when used without `{nocase: true}`.

Useful when some other form of case-insensitive matching is used, or if the original string representation is useful in some other way.

### Usage
```javascript
minimatch(path, pattern, { nocase: true })
```
```

--------------------------------

### nonegate Option

Source: https://www.npmjs.com/package/minimatch?activeTab=dependencies

Suppresses the behavior of treating a leading `!` character as negation.

```APIDOC
## nonegate Option

### Description
Suppress the behavior of treating a leading `!` character as negation.

### Usage
```javascript
minimatch(path, '!negated/pattern', { nonegate: true })
```
```

--------------------------------

### Windows Path Handling in Minimatch

Source: https://www.npmjs.com/package/minimatch?activeTab=code

The `windowsPathsNoEscape` option treats `\` as a path separator only and never as an escape character. It replaces all `\` with `/` in the pattern. This is useful for matching paths constructed with `path.join()` on Windows but makes it impossible to match literal glob pattern characters.

```javascript
// Example usage would involve setting this option when creating a Minimatch instance or calling match functions.
```

--------------------------------

### optimizationLevel

Source: https://www.npmjs.com/package/minimatch?activeTab=code

Controls the level of optimization applied to patterns before matching. Higher levels offer more aggressive optimizations but may lead to fewer matches in certain edge cases.

```APIDOC
## optimizationLevel
A number indicating the level of optimization that should be done to the pattern prior to parsing and using it for matches.

### Levels:
* `0` - No further changes. `.` and `..` are maintained in the pattern.
* `1` - (default) Removes `..` where it follows a non-`**` portion, unless it's at the beginning or end. Preserves dots and empty path portions.
* `2` (or higher) - More aggressive optimizations:
    * Removes `..` and empty/`.` portions safely.
    * Converts patterns like `/**/../` to `/{..,**}/`.
    * Deduplicates patterns with `**` and equivalent patterns without `**`.
    * Deduplicates patterns with `*` and equivalent patterns with non-dot strings.

**Note:** Higher optimization levels might fail to match literal strings that lower levels would match. `Minimatch.match()` optimizes paths, but `Minimatch.makeRe()` requires pre-processing for level 2 optimizations.
```

--------------------------------

### Minimatch Escape

Source: https://www.npmjs.com/package/minimatch

Escapes all magic characters in a glob pattern, ensuring it only matches literal strings.

```APIDOC
## minimatch.escape(pattern, options = {})

### Description
Escape all magic characters in a glob pattern, so that it will only ever match literal strings.
If the `windowsPathsNoEscape` option is used, then characters are escaped by wrapping in `[]`, because a magic character wrapped in a character class can only be satisfied by that exact character. Slashes (and backslashes in `windowsPathsNoEscape` mode) cannot be escaped or unescaped.

### Parameters
#### Path Parameters
- **pattern** (string) - Required - The glob pattern to escape.
- **options** (object) - Optional - Configuration options.

### Request Example
```javascript
var escapedPattern = minimatch.escape('*.js');
```
```

--------------------------------

### magicalBraces Option

Source: https://www.npmjs.com/package/minimatch?activeTab=dependencies

This option affects the results of the `Minimatch.hasMagic` method. By default, `Minimatch.hasMagic()` returns `false` for patterns with only brace expansions (e.g., `a{b,c}d`). When this option is set, it returns `true` for brace expansions as well as other magic glob characters.

```APIDOC
## magicalBraces Option

### Description
This only affects the results of the `Minimatch.hasMagic` method. If the pattern contains brace expansions, such as `a{b,c}d`, but no other magic characters, then the `Minimatch.hasMagic()` method will return `false` by default. When this option is set, it will return `true` for brace expansion as well as other magic glob characters.

### Usage
```javascript
const mm = new Minimatch('a{b,c}d', { magicalBraces: true });
mm.hasMagic()
```
```

--------------------------------

### Minimatch Unescape

Source: https://www.npmjs.com/package/minimatch

Un-escapes characters in a glob string that may have been escaped.

```APIDOC
## minimatch.unescape(pattern, options = {})

### Description
Un-escape a glob string that may contain some escaped characters. If the `windowsPathsNoEscape` option is used, then square-brace escapes are removed, but not backslash escapes. For example, it will turn the string `'[*]'` into `*`, but it will not turn `'\*'` into `'*'`, because `\` is a path separator in `windowsPathsNoEscape` mode. When `windowsPathsNoEscape` is not set, then both brace escapes and backslash escapes are removed. Slashes (and backslashes in `windowsPathsNoEscape` mode) cannot be escaped or unescaped.

### Parameters
#### Path Parameters
- **pattern** (string) - Required - The glob pattern to unescape.
- **options** (object) - Optional - Configuration options.

### Request Example
```javascript
var unescapedPattern = minimatch.unescape('[*]');
```
```

--------------------------------

### Escape magic characters in a glob pattern

Source: https://www.npmjs.com/package/minimatch

Use minimatch.escape to ensure a pattern only matches literal strings. Magic characters are escaped by wrapping in `[]` if `windowsPathsNoEscape` is used.

```javascript
minimatch.escape(pattern, options = {})
```

--------------------------------

### Minimatch Unescape Function

Source: https://www.npmjs.com/package/minimatch?activeTab=versions

Un-escapes characters in a glob string that may have been escaped.

```APIDOC
## minimatch.unescape(pattern, options = {})

### Description
Un-escape a glob string that may contain some escaped characters. If the `windowsPathsNoEscape` option is used, then square-brace escapes are removed, but not backslash escapes. When `windowsPathsNoEscape` is not set, then both brace escapes and backslash escapes are removed. Slashes (and backslashes in `windowsPathsNoEscape` mode) cannot be escaped or unescaped.

### Parameters
#### Path Parameters
- **pattern** (string) - Required - The glob pattern to unescape.
- **options** (object) - Optional - Configuration options for unescaping.

### Request Example
```javascript
var unescapedPattern = minimatch.unescape('\*.js');
```
```

--------------------------------

### maxGlobstarRecursion

Source: https://www.npmjs.com/package/minimatch?activeTab=code

Sets the maximum number of non-adjacent `**` patterns to recursively traverse. Exceeding this limit results in a non-match for security and performance reasons.

```APIDOC
### maxGlobstarRecursion
Max number of non-adjacent `**` patterns to recursively walk down.
The default of `200` is almost certainly high enough for most purposes, and can handle absurdly excessive patterns.
If the limit is exceeded (which would require very excessively long patterns and paths containing lots of `**` patterns!), then it is treated as non-matching, even if the path would normally match the pattern provided.
That is, this is an intentional false negative, deemed an acceptable break in correctness for security and performance.
```
Tokens:
Raw