1  # micromatch [![NPM version](https://img.shields.io/npm/v/micromatch.svg?style=flat)](https://www.npmjs.com/package/micromatch) [![NPM monthly downloads](https://img.shields.io/npm/dm/micromatch.svg?style=flat)](https://npmjs.org/package/micromatch) [![NPM total downloads](https://img.shields.io/npm/dt/micromatch.svg?style=flat)](https://npmjs.org/package/micromatch) [![Linux Build Status](https://img.shields.io/travis/micromatch/micromatch.svg?style=flat&label=Travis)](https://travis-ci.org/micromatch/micromatch)
   2  
   3  > Glob matching for javascript/node.js. A replacement and faster alternative to minimatch and multimatch.
   4  
   5  Please consider following this project's author, [Jon Schlinkert](https://github.com/jonschlinkert), and consider starring the project to show your :heart: and support.
   6  
   7  ## Table of Contents
   8  
   9  <details>
  10  <summary><strong>Details</strong></summary>
  11  
  12  - [Install](#install)
  13  - [Quickstart](#quickstart)
  14  - [Why use micromatch?](#why-use-micromatch)
  15    * [Matching features](#matching-features)
  16  - [Switching to micromatch](#switching-to-micromatch)
  17    * [From minimatch](#from-minimatch)
  18    * [From multimatch](#from-multimatch)
  19  - [API](#api)
  20  - [Options](#options)
  21  - [Options Examples](#options-examples)
  22    * [options.basename](#optionsbasename)
  23    * [options.bash](#optionsbash)
  24    * [options.expandRange](#optionsexpandrange)
  25    * [options.format](#optionsformat)
  26    * [options.ignore](#optionsignore)
  27    * [options.matchBase](#optionsmatchbase)
  28    * [options.noextglob](#optionsnoextglob)
  29    * [options.nonegate](#optionsnonegate)
  30    * [options.noglobstar](#optionsnoglobstar)
  31    * [options.nonull](#optionsnonull)
  32    * [options.nullglob](#optionsnullglob)
  33    * [options.onIgnore](#optionsonignore)
  34    * [options.onMatch](#optionsonmatch)
  35    * [options.onResult](#optionsonresult)
  36    * [options.posixSlashes](#optionsposixslashes)
  37    * [options.unescape](#optionsunescape)
  38  - [Extended globbing](#extended-globbing)
  39    * [Extglobs](#extglobs)
  40    * [Braces](#braces)
  41    * [Regex character classes](#regex-character-classes)
  42    * [Regex groups](#regex-groups)
  43    * [POSIX bracket expressions](#posix-bracket-expressions)
  44  - [Notes](#notes)
  45    * [Bash 4.3 parity](#bash-43-parity)
  46    * [Backslashes](#backslashes)
  47  - [Benchmarks](#benchmarks)
  48    * [Running benchmarks](#running-benchmarks)
  49    * [Latest results](#latest-results)
  50  - [Contributing](#contributing)
  51  - [About](#about)
  52  
  53  </details>
  54  
  55  ## Install
  56  
  57  Install with [npm](https://www.npmjs.com/):
  58  
  59  ```sh
  60  $ npm install --save micromatch
  61  ```
  62  
  63  ## Quickstart
  64  
  65  ```js
  66  const micromatch = require('micromatch');
  67  // micromatch(list, patterns[, options]);
  68  ```
  69  
  70  The [main export](#micromatch) takes a list of strings and one or more glob patterns:
  71  
  72  ```js
  73  console.log(micromatch(['foo', 'bar', 'baz', 'qux'], ['f*', 'b*'])) //=> ['foo', 'bar', 'baz']
  74  console.log(micromatch(['foo', 'bar', 'baz', 'qux'], ['*', '!b*'])) //=> ['foo', 'qux']
  75  ```
  76  
  77  Use [.isMatch()](#ismatch) to for boolean matching:
  78  
  79  ```js
  80  console.log(micromatch.isMatch('foo', 'f*')) //=> true
  81  console.log(micromatch.isMatch('foo', ['b*', 'f*'])) //=> true
  82  ```
  83  
  84  [Switching](#switching-to-micromatch) from minimatch and multimatch is easy!
  85  
  86  <br>
  87  
  88  ## Why use micromatch?
  89  
  90  > micromatch is a [replacement](#switching-to-micromatch) for minimatch and multimatch
  91  
  92  * Supports all of the same matching features as [minimatch](https://github.com/isaacs/minimatch) and [multimatch](https://github.com/sindresorhus/multimatch)
  93  * More complete support for the Bash 4.3 specification than minimatch and multimatch. Micromatch passes _all of the spec tests_ from bash, including some that bash still fails.
  94  * **Fast & Performant** - Loads in about 5ms and performs [fast matches](#benchmarks).
  95  * **Glob matching** - Using wildcards (`*` and `?`), globstars (`**`) for nested directories
  96  * **[Advanced globbing](#extended-globbing)** - Supports [extglobs](#extglobs), [braces](#braces-1), and [POSIX brackets](#posix-bracket-expressions), and support for escaping special characters with `\` or quotes.
  97  * **Accurate** - Covers more scenarios [than minimatch](https://github.com/yarnpkg/yarn/pull/3339)
  98  * **Well tested** - More than 5,000 [test assertions](./test)
  99  * **Windows support** - More reliable windows support than minimatch and multimatch.
 100  * **[Safe](https://github.com/micromatch/braces#braces-is-safe)** - Micromatch is not subject to DoS with brace patterns like minimatch and multimatch.
 101  
 102  ### Matching features
 103  
 104  * Support for multiple glob patterns (no need for wrappers like multimatch)
 105  * Wildcards (`**`, `*.js`)
 106  * Negation (`'!a/*.js'`, `'*!(b).js']`)
 107  * [extglobs](#extglobs) (`+(x|y)`, `!(a|b)`)
 108  * [POSIX character classes](#posix-bracket-expressions) (`[[:alpha:][:digit:]]`)
 109  * [brace expansion](https://github.com/micromatch/braces) (`foo/{1..5}.md`, `bar/{a,b,c}.js`)
 110  * regex character classes (`foo-[1-5].js`)
 111  * regex logical "or" (`foo/(abc|xyz).js`)
 112  
 113  You can mix and match these features to create whatever patterns you need!
 114  
 115  ## Switching to micromatch
 116  
 117  _(There is one notable difference between micromatch and minimatch in regards to how backslashes are handled. See [the notes about backslashes](#backslashes) for more information.)_
 118  
 119  ### From minimatch
 120  
 121  Use [micromatch.isMatch()](#ismatch) instead of `minimatch()`:
 122  
 123  ```js
 124  console.log(micromatch.isMatch('foo', 'b*')); //=> false
 125  ```
 126  
 127  Use [micromatch.match()](#match) instead of `minimatch.match()`:
 128  
 129  ```js
 130  console.log(micromatch.match(['foo', 'bar'], 'b*')); //=> 'bar'
 131  ```
 132  
 133  ### From multimatch
 134  
 135  Same signature:
 136  
 137  ```js
 138  console.log(micromatch(['foo', 'bar', 'baz'], ['f*', '*z'])); //=> ['foo', 'baz']
 139  ```
 140  
 141  ## API
 142  
 143  **Params**
 144  
 145  * `list` **{String|Array<string>}**: List of strings to match.
 146  * `patterns` **{String|Array<string>}**: One or more glob patterns to use for matching.
 147  * `options` **{Object}**: See available [options](#options)
 148  * `returns` **{Array}**: Returns an array of matches
 149  
 150  **Example**
 151  
 152  ```js
 153  const mm = require('micromatch');
 154  // mm(list, patterns[, options]);
 155  
 156  console.log(mm(['a.js', 'a.txt'], ['*.js']));
 157  //=> [ 'a.js' ]
 158  ```
 159  
 160  ### [.matcher](index.js#L104)
 161  
 162  Returns a matcher function from the given glob `pattern` and `options`. The returned function takes a string to match as its only argument and returns true if the string is a match.
 163  
 164  **Params**
 165  
 166  * `pattern` **{String}**: Glob pattern
 167  * `options` **{Object}**
 168  * `returns` **{Function}**: Returns a matcher function.
 169  
 170  **Example**
 171  
 172  ```js
 173  const mm = require('micromatch');
 174  // mm.matcher(pattern[, options]);
 175  
 176  const isMatch = mm.matcher('*.!(*a)');
 177  console.log(isMatch('a.a')); //=> false
 178  console.log(isMatch('a.b')); //=> true
 179  ```
 180  
 181  ### [.isMatch](index.js#L123)
 182  
 183  Returns true if **any** of the given glob `patterns` match the specified `string`.
 184  
 185  **Params**
 186  
 187  * `str` **{String}**: The string to test.
 188  * `patterns` **{String|Array}**: One or more glob patterns to use for matching.
 189  * `[options]` **{Object}**: See available [options](#options).
 190  * `returns` **{Boolean}**: Returns true if any patterns match `str`
 191  
 192  **Example**
 193  
 194  ```js
 195  const mm = require('micromatch');
 196  // mm.isMatch(string, patterns[, options]);
 197  
 198  console.log(mm.isMatch('a.a', ['b.*', '*.a'])); //=> true
 199  console.log(mm.isMatch('a.a', 'b.*')); //=> false
 200  ```
 201  
 202  ### [.not](index.js#L148)
 203  
 204  Returns a list of strings that _**do not match any**_ of the given `patterns`.
 205  
 206  **Params**
 207  
 208  * `list` **{Array}**: Array of strings to match.
 209  * `patterns` **{String|Array}**: One or more glob pattern to use for matching.
 210  * `options` **{Object}**: See available [options](#options) for changing how matches are performed
 211  * `returns` **{Array}**: Returns an array of strings that **do not match** the given patterns.
 212  
 213  **Example**
 214  
 215  ```js
 216  const mm = require('micromatch');
 217  // mm.not(list, patterns[, options]);
 218  
 219  console.log(mm.not(['a.a', 'b.b', 'c.c'], '*.a'));
 220  //=> ['b.b', 'c.c']
 221  ```
 222  
 223  ### [.contains](index.js#L188)
 224  
 225  Returns true if the given `string` contains the given pattern. Similar to [.isMatch](#isMatch) but the pattern can match any part of the string.
 226  
 227  **Params**
 228  
 229  * `str` **{String}**: The string to match.
 230  * `patterns` **{String|Array}**: Glob pattern to use for matching.
 231  * `options` **{Object}**: See available [options](#options) for changing how matches are performed
 232  * `returns` **{Boolean}**: Returns true if any of the patterns matches any part of `str`.
 233  
 234  **Example**
 235  
 236  ```js
 237  var mm = require('micromatch');
 238  // mm.contains(string, pattern[, options]);
 239  
 240  console.log(mm.contains('aa/bb/cc', '*b'));
 241  //=> true
 242  console.log(mm.contains('aa/bb/cc', '*d'));
 243  //=> false
 244  ```
 245  
 246  ### [.matchKeys](index.js#L230)
 247  
 248  Filter the keys of the given object with the given `glob` pattern and `options`. Does not attempt to match nested keys. If you need this feature, use [glob-object](https://github.com/jonschlinkert/glob-object) instead.
 249  
 250  **Params**
 251  
 252  * `object` **{Object}**: The object with keys to filter.
 253  * `patterns` **{String|Array}**: One or more glob patterns to use for matching.
 254  * `options` **{Object}**: See available [options](#options) for changing how matches are performed
 255  * `returns` **{Object}**: Returns an object with only keys that match the given patterns.
 256  
 257  **Example**
 258  
 259  ```js
 260  const mm = require('micromatch');
 261  // mm.matchKeys(object, patterns[, options]);
 262  
 263  const obj = { aa: 'a', ab: 'b', ac: 'c' };
 264  console.log(mm.matchKeys(obj, '*b'));
 265  //=> { ab: 'b' }
 266  ```
 267  
 268  ### [.some](index.js#L259)
 269  
 270  Returns true if some of the strings in the given `list` match any of the given glob `patterns`.
 271  
 272  **Params**
 273  
 274  * `list` **{String|Array}**: The string or array of strings to test. Returns as soon as the first match is found.
 275  * `patterns` **{String|Array}**: One or more glob patterns to use for matching.
 276  * `options` **{Object}**: See available [options](#options) for changing how matches are performed
 277  * `returns` **{Boolean}**: Returns true if any `patterns` matches any of the strings in `list`
 278  
 279  **Example**
 280  
 281  ```js
 282  const mm = require('micromatch');
 283  // mm.some(list, patterns[, options]);
 284  
 285  console.log(mm.some(['foo.js', 'bar.js'], ['*.js', '!foo.js']));
 286  // true
 287  console.log(mm.some(['foo.js'], ['*.js', '!foo.js']));
 288  // false
 289  ```
 290  
 291  ### [.every](index.js#L295)
 292  
 293  Returns true if every string in the given `list` matches any of the given glob `patterns`.
 294  
 295  **Params**
 296  
 297  * `list` **{String|Array}**: The string or array of strings to test.
 298  * `patterns` **{String|Array}**: One or more glob patterns to use for matching.
 299  * `options` **{Object}**: See available [options](#options) for changing how matches are performed
 300  * `returns` **{Boolean}**: Returns true if all `patterns` matches all of the strings in `list`
 301  
 302  **Example**
 303  
 304  ```js
 305  const mm = require('micromatch');
 306  // mm.every(list, patterns[, options]);
 307  
 308  console.log(mm.every('foo.js', ['foo.js']));
 309  // true
 310  console.log(mm.every(['foo.js', 'bar.js'], ['*.js']));
 311  // true
 312  console.log(mm.every(['foo.js', 'bar.js'], ['*.js', '!foo.js']));
 313  // false
 314  console.log(mm.every(['foo.js'], ['*.js', '!foo.js']));
 315  // false
 316  ```
 317  
 318  ### [.all](index.js#L334)
 319  
 320  Returns true if **all** of the given `patterns` match the specified string.
 321  
 322  **Params**
 323  
 324  * `str` **{String|Array}**: The string to test.
 325  * `patterns` **{String|Array}**: One or more glob patterns to use for matching.
 326  * `options` **{Object}**: See available [options](#options) for changing how matches are performed
 327  * `returns` **{Boolean}**: Returns true if any patterns match `str`
 328  
 329  **Example**
 330  
 331  ```js
 332  const mm = require('micromatch');
 333  // mm.all(string, patterns[, options]);
 334  
 335  console.log(mm.all('foo.js', ['foo.js']));
 336  // true
 337  
 338  console.log(mm.all('foo.js', ['*.js', '!foo.js']));
 339  // false
 340  
 341  console.log(mm.all('foo.js', ['*.js', 'foo.js']));
 342  // true
 343  
 344  console.log(mm.all('foo.js', ['*.js', 'f*', '*o*', '*o.js']));
 345  // true
 346  ```
 347  
 348  ### [.capture](index.js#L361)
 349  
 350  Returns an array of matches captured by `pattern` in `string, or`null` if the pattern did not match.
 351  
 352  **Params**
 353  
 354  * `glob` **{String}**: Glob pattern to use for matching.
 355  * `input` **{String}**: String to match
 356  * `options` **{Object}**: See available [options](#options) for changing how matches are performed
 357  * `returns` **{Array|null}**: Returns an array of captures if the input matches the glob pattern, otherwise `null`.
 358  
 359  **Example**
 360  
 361  ```js
 362  const mm = require('micromatch');
 363  // mm.capture(pattern, string[, options]);
 364  
 365  console.log(mm.capture('test/*.js', 'test/foo.js'));
 366  //=> ['foo']
 367  console.log(mm.capture('test/*.js', 'foo/bar.css'));
 368  //=> null
 369  ```
 370  
 371  ### [.makeRe](index.js#L387)
 372  
 373  Create a regular expression from the given glob `pattern`.
 374  
 375  **Params**
 376  
 377  * `pattern` **{String}**: A glob pattern to convert to regex.
 378  * `options` **{Object}**
 379  * `returns` **{RegExp}**: Returns a regex created from the given pattern.
 380  
 381  **Example**
 382  
 383  ```js
 384  const mm = require('micromatch');
 385  // mm.makeRe(pattern[, options]);
 386  
 387  console.log(mm.makeRe('*.js'));
 388  //=> /^(?:(\.[\\\/])?(?!\.)(?=.)[^\/]*?\.js)$/
 389  ```
 390  
 391  ### [.scan](index.js#L403)
 392  
 393  Scan a glob pattern to separate the pattern into segments. Used by the [split](#split) method.
 394  
 395  **Params**
 396  
 397  * `pattern` **{String}**
 398  * `options` **{Object}**
 399  * `returns` **{Object}**: Returns an object with
 400  
 401  **Example**
 402  
 403  ```js
 404  const mm = require('micromatch');
 405  const state = mm.scan(pattern[, options]);
 406  ```
 407  
 408  ### [.parse](index.js#L419)
 409  
 410  Parse a glob pattern to create the source string for a regular expression.
 411  
 412  **Params**
 413  
 414  * `glob` **{String}**
 415  * `options` **{Object}**
 416  * `returns` **{Object}**: Returns an object with useful properties and output to be used as regex source string.
 417  
 418  **Example**
 419  
 420  ```js
 421  const mm = require('micromatch');
 422  const state = mm(pattern[, options]);
 423  ```
 424  
 425  ### [.braces](index.js#L446)
 426  
 427  Process the given brace `pattern`.
 428  
 429  **Params**
 430  
 431  * `pattern` **{String}**: String with brace pattern to process.
 432  * `options` **{Object}**: Any [options](#options) to change how expansion is performed. See the [braces](https://github.com/micromatch/braces) library for all available options.
 433  * `returns` **{Array}**
 434  
 435  **Example**
 436  
 437  ```js
 438  const { braces } = require('micromatch');
 439  console.log(braces('foo/{a,b,c}/bar'));
 440  //=> [ 'foo/(a|b|c)/bar' ]
 441  
 442  console.log(braces('foo/{a,b,c}/bar', { expand: true }));
 443  //=> [ 'foo/a/bar', 'foo/b/bar', 'foo/c/bar' ]
 444  ```
 445  
 446  ## Options
 447  
 448  | **Option** | **Type** | **Default value** | **Description** |
 449  | --- | --- | --- | --- |
 450  | `basename`            | `boolean`      | `false`     | 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`. |
 451  | `bash`                | `boolean`      | `false`     | Follow bash matching rules more strictly - disallows backslashes as escape characters, and treats single stars as globstars (`**`). |
 452  | `capture`             | `boolean`      | `undefined` | Return regex matches in supporting methods. |
 453  | `contains`            | `boolean`      | `undefined` | Allows glob to match any part of the given string(s). |
 454  | `cwd`                 | `string`       | `process.cwd()` | Current working directory. Used by `picomatch.split()` |
 455  | `debug`               | `boolean`      | `undefined` | Debug regular expressions when an error is thrown. |
 456  | `dot`                 | `boolean`      | `false`     | Match dotfiles. Otherwise dotfiles are ignored unless a `.` is explicitly defined in the pattern. |
 457  | `expandRange`         | `function`     | `undefined` | Custom function for expanding ranges in brace patterns, such as `{a..z}`. The function receives the range values as two arguments, and it must return a string to be used in the generated regex. It's recommended that returned strings be wrapped in parentheses. This option is overridden by the `expandBrace` option. |
 458  | `failglob`            | `boolean`      | `false`     | Similar to the `failglob` behavior in Bash, throws an error when no matches are found. Based on the bash option of the same name. |
 459  | `fastpaths`           | `boolean`      | `true`      | To speed up processing, full parsing is skipped for a handful common glob patterns. Disable this behavior by setting this option to `false`. |
 460  | `flags`               | `boolean`      | `undefined` | Regex flags to use in the generated regex. If defined, the `nocase` option will be overridden. |
 461  | [format](#optionsformat) | `function` | `undefined` | Custom function for formatting the returned string. This is useful for removing leading slashes, converting Windows paths to Posix paths, etc. |
 462  | `ignore`              | `array\|string` | `undefined` | One or more glob patterns for excluding strings that should not be matched from the result. |
 463  | `keepQuotes`          | `boolean`      | `false`     | Retain quotes in the generated regex, since quotes may also be used as an alternative to backslashes.  |
 464  | `literalBrackets`     | `boolean`      | `undefined` | When `true`, brackets in the glob pattern will be escaped so that only literal brackets will be matched. |
 465  | `lookbehinds`         | `boolean`      | `true`      | Support regex positive and negative lookbehinds. Note that you must be using Node 8.1.10 or higher to enable regex lookbehinds. |
 466  | `matchBase`           | `boolean`      | `false`     | Alias for `basename` |
 467  | `maxLength`           | `boolean`      | `65536`     | Limit the max length of the input string. An error is thrown if the input string is longer than this value. |
 468  | `nobrace`             | `boolean`      | `false`     | Disable brace matching, so that `{a,b}` and `{1..3}` would be treated as literal characters. |
 469  | `nobracket`           | `boolean`      | `undefined` | Disable matching with regex brackets. |
 470  | `nocase`              | `boolean`      | `false`     | Perform case-insensitive matching. Equivalent to the regex `i` flag. Note that this option is ignored when the `flags` option is defined. |
 471  | `nodupes`             | `boolean`      | `true`      | Deprecated, use `nounique` instead. This option will be removed in a future major release. By default duplicates are removed. Disable uniquification by setting this option to false. |
 472  | `noext`               | `boolean`      | `false`     | Alias for `noextglob` |
 473  | `noextglob`           | `boolean`      | `false`     | Disable support for matching with [extglobs](#extglobs) (like `+(a\|b)`) |
 474  | `noglobstar`          | `boolean`      | `false`     | Disable support for matching nested directories with globstars (`**`) |
 475  | `nonegate`            | `boolean`      | `false`     | Disable support for negating with leading `!` |
 476  | `noquantifiers`       | `boolean`      | `false`     | Disable support for regex quantifiers (like `a{1,2}`) and treat them as brace patterns to be expanded. |
 477  | [onIgnore](#optionsonIgnore) | `function` | `undefined` | Function to be called on ignored items. |
 478  | [onMatch](#optionsonMatch) | `function` | `undefined` | Function to be called on matched items. |
 479  | [onResult](#optionsonResult) | `function` | `undefined` | Function to be called on all items, regardless of whether or not they are matched or ignored. |
 480  | `posix`               | `boolean`      | `false`     | Support [POSIX character classes](#posix-bracket-expressions) ("posix brackets"). |
 481  | `posixSlashes`        | `boolean`      | `undefined` | Convert all slashes in file paths to forward slashes. This does not convert slashes in the glob pattern itself |
 482  | `prepend`             | `string`       | `undefined` | String to prepend to the generated regex used for matching. |
 483  | `regex`               | `boolean`      | `false`     | Use regular expression rules for `+` (instead of matching literal `+`), and for stars that follow closing parentheses or brackets (as in `)*` and `]*`). |
 484  | `strictBrackets`      | `boolean`      | `undefined` | Throw an error if brackets, braces, or parens are imbalanced. |
 485  | `strictSlashes`       | `boolean`      | `undefined` | When true, picomatch won't match trailing slashes with single stars. |
 486  | `unescape`            | `boolean`      | `undefined` | Remove preceding backslashes from escaped glob characters before creating the regular expression to perform matches. |
 487  | `unixify`             | `boolean`      | `undefined` | Alias for `posixSlashes`, for backwards compatitibility. |
 488  
 489  ## Options Examples
 490  
 491  ### options.basename
 492  
 493  Allow glob patterns without slashes to match a file path based on its basename. Same behavior as [minimatch](https://github.com/isaacs/minimatch) option `matchBase`.
 494  
 495  **Type**: `Boolean`
 496  
 497  **Default**: `false`
 498  
 499  **Example**
 500  
 501  ```js
 502  micromatch(['a/b.js', 'a/c.md'], '*.js');
 503  //=> []
 504  
 505  micromatch(['a/b.js', 'a/c.md'], '*.js', { basename: true });
 506  //=> ['a/b.js']
 507  ```
 508  
 509  ### options.bash
 510  
 511  Enabled by default, this option enforces bash-like behavior with stars immediately following a bracket expression. Bash bracket expressions are similar to regex character classes, but unlike regex, a star following a bracket expression **does not repeat the bracketed characters**. Instead, the star is treated the same as any other star.
 512  
 513  **Type**: `Boolean`
 514  
 515  **Default**: `true`
 516  
 517  **Example**
 518  
 519  ```js
 520  const files = ['abc', 'ajz'];
 521  console.log(micromatch(files, '[a-c]*'));
 522  //=> ['abc', 'ajz']
 523  
 524  console.log(micromatch(files, '[a-c]*', { bash: false }));
 525  ```
 526  
 527  ### options.expandRange
 528  
 529  **Type**: `function`
 530  
 531  **Default**: `undefined`
 532  
 533  Custom function for expanding ranges in brace patterns. The [fill-range](https://github.com/jonschlinkert/fill-range) library is ideal for this purpose, or you can use custom code to do whatever you need.
 534  
 535  **Example**
 536  
 537  The following example shows how to create a glob that matches a numeric folder name between `01` and `25`, with leading zeros.
 538  
 539  ```js
 540  const fill = require('fill-range');
 541  const regex = micromatch.makeRe('foo/{01..25}/bar', {
 542    expandRange(a, b) {
 543      return `(${fill(a, b, { toRegex: true })})`;
 544    }
 545  });
 546  
 547  console.log(regex)
 548  //=> /^(?:foo\/((?:0[1-9]|1[0-9]|2[0-5]))\/bar)$/
 549  
 550  console.log(regex.test('foo/00/bar')) // false
 551  console.log(regex.test('foo/01/bar')) // true
 552  console.log(regex.test('foo/10/bar')) // true
 553  console.log(regex.test('foo/22/bar')) // true
 554  console.log(regex.test('foo/25/bar')) // true
 555  console.log(regex.test('foo/26/bar')) // false
 556  ```
 557  
 558  ### options.format
 559  
 560  **Type**: `function`
 561  
 562  **Default**: `undefined`
 563  
 564  Custom function for formatting strings before they're matched.
 565  
 566  **Example**
 567  
 568  ```js
 569  // strip leading './' from strings
 570  const format = str => str.replace(/^\.\//, '');
 571  const isMatch = picomatch('foo/*.js', { format });
 572  console.log(isMatch('./foo/bar.js')) //=> true
 573  ```
 574  
 575  ### options.ignore
 576  
 577  String or array of glob patterns to match files to ignore.
 578  
 579  **Type**: `String|Array`
 580  
 581  **Default**: `undefined`
 582  
 583  ```js
 584  const isMatch = micromatch.matcher('*', { ignore: 'f*' });
 585  console.log(isMatch('foo')) //=> false
 586  console.log(isMatch('bar')) //=> true
 587  console.log(isMatch('baz')) //=> true
 588  ```
 589  
 590  ### options.matchBase
 591  
 592  Alias for [options.basename](#options-basename).
 593  
 594  ### options.noextglob
 595  
 596  Disable extglob support, so that [extglobs](#extglobs) are regarded as literal characters.
 597  
 598  **Type**: `Boolean`
 599  
 600  **Default**: `undefined`
 601  
 602  **Examples**
 603  
 604  ```js
 605  console.log(micromatch(['a/z', 'a/b', 'a/!(z)'], 'a/!(z)'));
 606  //=> ['a/b', 'a/!(z)']
 607  
 608  console.log(micromatch(['a/z', 'a/b', 'a/!(z)'], 'a/!(z)', { noextglob: true }));
 609  //=> ['a/!(z)'] (matches only as literal characters)
 610  ```
 611  
 612  ### options.nonegate
 613  
 614  Disallow negation (`!`) patterns, and treat leading `!` as a literal character to match.
 615  
 616  **Type**: `Boolean`
 617  
 618  **Default**: `undefined`
 619  
 620  ### options.noglobstar
 621  
 622  Disable matching with globstars (`**`).
 623  
 624  **Type**: `Boolean`
 625  
 626  **Default**: `undefined`
 627  
 628  ```js
 629  micromatch(['a/b', 'a/b/c', 'a/b/c/d'], 'a/**');
 630  //=> ['a/b', 'a/b/c', 'a/b/c/d']
 631  
 632  micromatch(['a/b', 'a/b/c', 'a/b/c/d'], 'a/**', {noglobstar: true});
 633  //=> ['a/b']
 634  ```
 635  
 636  ### options.nonull
 637  
 638  Alias for [options.nullglob](#options-nullglob).
 639  
 640  ### options.nullglob
 641  
 642  If `true`, when no matches are found the actual (arrayified) glob pattern is returned instead of an empty array. Same behavior as [minimatch](https://github.com/isaacs/minimatch) option `nonull`.
 643  
 644  **Type**: `Boolean`
 645  
 646  **Default**: `undefined`
 647  
 648  ### options.onIgnore
 649  
 650  ```js
 651  const onIgnore = ({ glob, regex, input, output }) => {
 652    console.log({ glob, regex, input, output });
 653    // { glob: '*', regex: /^(?:(?!\.)(?=.)[^\/]*?\/?)$/, input: 'foo', output: 'foo' }
 654  };
 655  
 656  const isMatch = micromatch.matcher('*', { onIgnore, ignore: 'f*' });
 657  isMatch('foo');
 658  isMatch('bar');
 659  isMatch('baz');
 660  ```
 661  
 662  ### options.onMatch
 663  
 664  ```js
 665  const onMatch = ({ glob, regex, input, output }) => {
 666    console.log({ input, output });
 667    // { input: 'some\\path', output: 'some/path' }
 668    // { input: 'some\\path', output: 'some/path' }
 669    // { input: 'some\\path', output: 'some/path' }
 670  };
 671  
 672  const isMatch = micromatch.matcher('**', { onMatch, posixSlashes: true });
 673  isMatch('some\\path');
 674  isMatch('some\\path');
 675  isMatch('some\\path');
 676  ```
 677  
 678  ### options.onResult
 679  
 680  ```js
 681  const onResult = ({ glob, regex, input, output }) => {
 682    console.log({ glob, regex, input, output });
 683  };
 684  
 685  const isMatch = micromatch('*', { onResult, ignore: 'f*' });
 686  isMatch('foo');
 687  isMatch('bar');
 688  isMatch('baz');
 689  ```
 690  
 691  ### options.posixSlashes
 692  
 693  Convert path separators on returned files to posix/unix-style forward slashes. Aliased as `unixify` for backwards compatibility.
 694  
 695  **Type**: `Boolean`
 696  
 697  **Default**: `true` on windows, `false` everywhere else.
 698  
 699  **Example**
 700  
 701  ```js
 702  console.log(micromatch.match(['a\\b\\c'], 'a/**'));
 703  //=> ['a/b/c']
 704  
 705  console.log(micromatch.match(['a\\b\\c'], { posixSlashes: false }));
 706  //=> ['a\\b\\c']
 707  ```
 708  
 709  ### options.unescape
 710  
 711  Remove backslashes from escaped glob characters before creating the regular expression to perform matches.
 712  
 713  **Type**: `Boolean`
 714  
 715  **Default**: `undefined`
 716  
 717  **Example**
 718  
 719  In this example we want to match a literal `*`:
 720  
 721  ```js
 722  console.log(micromatch.match(['abc', 'a\\*c'], 'a\\*c'));
 723  //=> ['a\\*c']
 724  
 725  console.log(micromatch.match(['abc', 'a\\*c'], 'a\\*c', { unescape: true }));
 726  //=> ['a*c']
 727  ```
 728  
 729  <br>
 730  <br>
 731  
 732  ## Extended globbing
 733  
 734  Micromatch supports the following extended globbing features.
 735  
 736  ### Extglobs
 737  
 738  Extended globbing, as described by the bash man page:
 739  
 740  | **pattern** | **regex equivalent** | **description** |
 741  | --- | --- | --- |
 742  | `?(pattern)` | `(pattern)?` | Matches zero or one occurrence of the given patterns |
 743  | `*(pattern)` | `(pattern)*` | Matches zero or more occurrences of the given patterns |
 744  | `+(pattern)` | `(pattern)+` | Matches one or more occurrences of the given patterns |
 745  | `@(pattern)` | `(pattern)` <sup>*</sup> | Matches one of the given patterns |
 746  | `!(pattern)` | N/A (equivalent regex is much more complicated) | Matches anything except one of the given patterns |
 747  
 748  <sup><strong>*</strong></sup> Note that `@` isn't a regex character.
 749  
 750  ### Braces
 751  
 752  Brace patterns can be used to match specific ranges or sets of characters.
 753  
 754  **Example**
 755  
 756  The pattern `{f,b}*/{1..3}/{b,q}*` would match any of following strings:
 757  
 758  ```
 759  foo/1/bar
 760  foo/2/bar
 761  foo/3/bar
 762  baz/1/qux
 763  baz/2/qux
 764  baz/3/qux
 765  ```
 766  
 767  Visit [braces](https://github.com/micromatch/braces) to see the full range of features and options related to brace expansion, or to create brace matching or expansion related issues.
 768  
 769  ### Regex character classes
 770  
 771  Given the list: `['a.js', 'b.js', 'c.js', 'd.js', 'E.js']`:
 772  
 773  * `[ac].js`: matches both `a` and `c`, returning `['a.js', 'c.js']`
 774  * `[b-d].js`: matches from `b` to `d`, returning `['b.js', 'c.js', 'd.js']`
 775  * `a/[A-Z].js`: matches and uppercase letter, returning `['a/E.md']`
 776  
 777  Learn about [regex character classes](http://www.regular-expressions.info/charclass.html).
 778  
 779  ### Regex groups
 780  
 781  Given `['a.js', 'b.js', 'c.js', 'd.js', 'E.js']`:
 782  
 783  * `(a|c).js`: would match either `a` or `c`, returning `['a.js', 'c.js']`
 784  * `(b|d).js`: would match either `b` or `d`, returning `['b.js', 'd.js']`
 785  * `(b|[A-Z]).js`: would match either `b` or an uppercase letter, returning `['b.js', 'E.js']`
 786  
 787  As with regex, parens can be nested, so patterns like `((a|b)|c)/b` will work. Although brace expansion might be friendlier to use, depending on preference.
 788  
 789  ### POSIX bracket expressions
 790  
 791  POSIX brackets are intended to be more user-friendly than regex character classes. This of course is in the eye of the beholder.
 792  
 793  **Example**
 794  
 795  ```js
 796  console.log(micromatch.isMatch('a1', '[[:alpha:][:digit:]]')) //=> true
 797  console.log(micromatch.isMatch('a1', '[[:alpha:][:alpha:]]')) //=> false
 798  ```
 799  
 800  ***
 801  
 802  ## Notes
 803  
 804  ### Bash 4.3 parity
 805  
 806  Whenever possible matching behavior is based on behavior Bash 4.3, which is mostly consistent with minimatch.
 807  
 808  However, it's suprising how many edge cases and rabbit holes there are with glob matching, and since there is no real glob specification, and micromatch is more accurate than both Bash and minimatch, there are cases where best-guesses were made for behavior. In a few cases where Bash had no answers, we used wildmatch (used by git) as a fallback.
 809  
 810  ### Backslashes
 811  
 812  There is an important, notable difference between minimatch and micromatch _in regards to how backslashes are handled_ in glob patterns.
 813  
 814  * Micromatch exclusively and explicitly reserves backslashes for escaping characters in a glob pattern, even on windows, which is consistent with bash behavior. _More importantly, unescaping globs can result in unsafe regular expressions_.
 815  * Minimatch converts all backslashes to forward slashes, which means you can't use backslashes to escape any characters in your glob patterns.
 816  
 817  We made this decision for micromatch for a couple of reasons:
 818  
 819  * Consistency with bash conventions.
 820  * Glob patterns are not filepaths. They are a type of [regular language](https://en.wikipedia.org/wiki/Regular_language) that is converted to a JavaScript regular expression. Thus, when forward slashes are defined in a glob pattern, the resulting regular expression will match windows or POSIX path separators just fine.
 821  
 822  **A note about joining paths to globs**
 823  
 824  Note that when you pass something like `path.join('foo', '*')` to micromatch, you are creating a filepath and expecting it to still work as a glob pattern. This causes problems on windows, since the `path.sep` is `\\`.
 825  
 826  In other words, since `\\` is reserved as an escape character in globs, on windows `path.join('foo', '*')` would result in `foo\\*`, which tells micromatch to match `*` as a literal character. This is the same behavior as bash.
 827  
 828  To solve this, you might be inspired to do something like `'foo\\*'.replace(/\\/g, '/')`, but this causes another, potentially much more serious, problem.
 829  
 830  ## Benchmarks
 831  
 832  ### Running benchmarks
 833  
 834  Install dependencies for running benchmarks:
 835  
 836  ```sh
 837  $ cd bench && npm install
 838  ```
 839  
 840  Run the benchmarks:
 841  
 842  ```sh
 843  $ npm run bench
 844  ```
 845  
 846  ### Latest results
 847  
 848  As of April 10, 2021 (longer bars are better):
 849  
 850  ```sh
 851  # .makeRe star
 852    micromatch x 2,232,802 ops/sec ±2.34% (89 runs sampled))
 853    minimatch x 781,018 ops/sec ±6.74% (92 runs sampled))
 854  
 855  # .makeRe star; dot=true
 856    micromatch x 1,863,453 ops/sec ±0.74% (93 runs sampled)
 857    minimatch x 723,105 ops/sec ±0.75% (93 runs sampled)
 858  
 859  # .makeRe globstar
 860    micromatch x 1,624,179 ops/sec ±2.22% (91 runs sampled)
 861    minimatch x 1,117,230 ops/sec ±2.78% (86 runs sampled))
 862  
 863  # .makeRe globstars
 864    micromatch x 1,658,642 ops/sec ±0.86% (92 runs sampled)
 865    minimatch x 741,224 ops/sec ±1.24% (89 runs sampled))
 866  
 867  # .makeRe with leading star
 868    micromatch x 1,525,014 ops/sec ±1.63% (90 runs sampled)
 869    minimatch x 561,074 ops/sec ±3.07% (89 runs sampled)
 870  
 871  # .makeRe - braces
 872    micromatch x 172,478 ops/sec ±2.37% (78 runs sampled)
 873    minimatch x 96,087 ops/sec ±2.34% (88 runs sampled)))
 874  
 875  # .makeRe braces - range (expanded)
 876    micromatch x 26,973 ops/sec ±0.84% (89 runs sampled)
 877    minimatch x 3,023 ops/sec ±0.99% (90 runs sampled))
 878  
 879  # .makeRe braces - range (compiled)
 880    micromatch x 152,892 ops/sec ±1.67% (83 runs sampled)
 881    minimatch x 992 ops/sec ±3.50% (89 runs sampled)d))
 882  
 883  # .makeRe braces - nested ranges (expanded)
 884    micromatch x 15,816 ops/sec ±13.05% (80 runs sampled)
 885    minimatch x 2,953 ops/sec ±1.64% (91 runs sampled)
 886  
 887  # .makeRe braces - nested ranges (compiled)
 888    micromatch x 110,881 ops/sec ±1.85% (82 runs sampled)
 889    minimatch x 1,008 ops/sec ±1.51% (91 runs sampled)
 890  
 891  # .makeRe braces - set (compiled)
 892    micromatch x 134,930 ops/sec ±3.54% (63 runs sampled))
 893    minimatch x 43,242 ops/sec ±0.60% (93 runs sampled)
 894  
 895  # .makeRe braces - nested sets (compiled)
 896    micromatch x 94,455 ops/sec ±1.74% (69 runs sampled))
 897    minimatch x 27,720 ops/sec ±1.84% (93 runs sampled))
 898  ```
 899  
 900  ## Contributing
 901  
 902  All contributions are welcome! Please read [the contributing guide](.github/contributing.md) to get started.
 903  
 904  **Bug reports**
 905  
 906  Please create an issue if you encounter a bug or matching behavior that doesn't seem correct. If you find a matching-related issue, please:
 907  
 908  * [research existing issues first](../../issues) (open and closed)
 909  * visit the [GNU Bash documentation](https://www.gnu.org/software/bash/manual/) to see how Bash deals with the pattern
 910  * visit the [minimatch](https://github.com/isaacs/minimatch) documentation to cross-check expected behavior in node.js
 911  * if all else fails, since there is no real specification for globs we will probably need to discuss expected behavior and decide how to resolve it. which means any detail you can provide to help with this discussion would be greatly appreciated.
 912  
 913  **Platform issues**
 914  
 915  It's important to us that micromatch work consistently on all platforms. If you encounter any platform-specific matching or path related issues, please let us know (pull requests are also greatly appreciated).
 916  
 917  ## About
 918  
 919  <details>
 920  <summary><strong>Contributing</strong></summary>
 921  
 922  Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new).
 923  
 924  Please read the [contributing guide](.github/contributing.md) for advice on opening issues, pull requests, and coding standards.
 925  
 926  </details>
 927  
 928  <details>
 929  <summary><strong>Running Tests</strong></summary>
 930  
 931  Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command:
 932  
 933  ```sh
 934  $ npm install && npm test
 935  ```
 936  
 937  </details>
 938  
 939  <details>
 940  <summary><strong>Building docs</strong></summary>
 941  
 942  _(This project's readme.md is generated by [verb](https://github.com/verbose/verb-generate-readme), please don't edit the readme directly. Any changes to the readme must be made in the [.verb.md](.verb.md) readme template.)_
 943  
 944  To generate the readme, run the following command:
 945  
 946  ```sh
 947  $ npm install -g verbose/verb#dev verb-generate-readme && verb
 948  ```
 949  
 950  </details>
 951  
 952  ### Related projects
 953  
 954  You might also be interested in these projects:
 955  
 956  * [braces](https://www.npmjs.com/package/braces): Bash-like brace expansion, implemented in JavaScript. Safer than other brace expansion libs, with complete support… [more](https://github.com/micromatch/braces) | [homepage](https://github.com/micromatch/braces "Bash-like brace expansion, implemented in JavaScript. Safer than other brace expansion libs, with complete support for the Bash 4.3 braces specification, without sacrificing speed.")
 957  * [expand-brackets](https://www.npmjs.com/package/expand-brackets): Expand POSIX bracket expressions (character classes) in glob patterns. | [homepage](https://github.com/micromatch/expand-brackets "Expand POSIX bracket expressions (character classes) in glob patterns.")
 958  * [extglob](https://www.npmjs.com/package/extglob): Extended glob support for JavaScript. Adds (almost) the expressive power of regular expressions to glob… [more](https://github.com/micromatch/extglob) | [homepage](https://github.com/micromatch/extglob "Extended glob support for JavaScript. Adds (almost) the expressive power of regular expressions to glob patterns.")
 959  * [fill-range](https://www.npmjs.com/package/fill-range): Fill in a range of numbers or letters, optionally passing an increment or `step` to… [more](https://github.com/jonschlinkert/fill-range) | [homepage](https://github.com/jonschlinkert/fill-range "Fill in a range of numbers or letters, optionally passing an increment or `step` to use, or create a regex-compatible range with `options.toRegex`")
 960  * [nanomatch](https://www.npmjs.com/package/nanomatch): Fast, minimal glob matcher for node.js. Similar to micromatch, minimatch and multimatch, but complete Bash… [more](https://github.com/micromatch/nanomatch) | [homepage](https://github.com/micromatch/nanomatch "Fast, minimal glob matcher for node.js. Similar to micromatch, minimatch and multimatch, but complete Bash 4.3 wildcard support only (no support for exglobs, posix brackets or braces)")
 961  
 962  ### Contributors
 963  
 964  | **Commits** | **Contributor** |  
 965  | --- | --- |  
 966  | 508 | [jonschlinkert](https://github.com/jonschlinkert) |  
 967  | 12  | [es128](https://github.com/es128) |  
 968  | 8   | [doowb](https://github.com/doowb) |  
 969  | 6   | [paulmillr](https://github.com/paulmillr) |  
 970  | 5   | [mrmlnc](https://github.com/mrmlnc) |  
 971  | 4   | [danez](https://github.com/danez) |  
 972  | 3   | [DrPizza](https://github.com/DrPizza) |  
 973  | 2   | [TrySound](https://github.com/TrySound) |  
 974  | 2   | [mceIdo](https://github.com/mceIdo) |  
 975  | 2   | [Glazy](https://github.com/Glazy) |  
 976  | 2   | [MartinKolarik](https://github.com/MartinKolarik) |  
 977  | 2   | [Tvrqvoise](https://github.com/Tvrqvoise) |  
 978  | 1   | [amilajack](https://github.com/amilajack) |  
 979  | 1   | [Cslove](https://github.com/Cslove) |  
 980  | 1   | [devongovett](https://github.com/devongovett) |  
 981  | 1   | [DianeLooney](https://github.com/DianeLooney) |  
 982  | 1   | [UltCombo](https://github.com/UltCombo) |  
 983  | 1   | [frangio](https://github.com/frangio) |  
 984  | 1   | [juszczykjakub](https://github.com/juszczykjakub) |  
 985  | 1   | [muescha](https://github.com/muescha) |  
 986  | 1   | [sebdeckers](https://github.com/sebdeckers) |  
 987  | 1   | [tomByrer](https://github.com/tomByrer) |  
 988  | 1   | [fidian](https://github.com/fidian) |  
 989  | 1   | [simlu](https://github.com/simlu) |  
 990  | 1   | [wtgtybhertgeghgtwtg](https://github.com/wtgtybhertgeghgtwtg) |  
 991  | 1   | [yvele](https://github.com/yvele) |  
 992  
 993  ### Author
 994  
 995  **Jon Schlinkert**
 996  
 997  * [GitHub Profile](https://github.com/jonschlinkert)
 998  * [Twitter Profile](https://twitter.com/jonschlinkert)
 999  * [LinkedIn Profile](https://linkedin.com/in/jonschlinkert)
1000  
1001  ### License
1002  
1003  Copyright © 2021, [Jon Schlinkert](https://github.com/jonschlinkert).
1004  Released under the [MIT License](LICENSE).
1005  
1006  ***
1007  
1008  _This file was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme), v0.8.0, on April 10, 2021._