text: # minimatch
  
  A minimal matching utility.
  
  [![Build Status](https://secure.travis-ci.org/isaacs/minimatch.png)](http://travis-ci.org/isaacs/minimatch)
  
  
  This is the matching library used internally by npm.
  
  Eventually, it will replace the C binding in node-glob.
  
  It works by converting glob expressions into JavaScript `RegExp`
  objects.
  
  ## Usage
  
  ```javascript
  var minimatch = require("minimatch")
  
  minimatch("bar.foo", "*.foo") // true!
  minimatch("bar.foo", "*.bar") // false!
  minimatch("bar.foo", "*.+(bar|foo)", { debug: true }) // true, and noisy!
  ```
  
  ## Features
  
  Supports these glob features:
  
  * Brace Expansion
  * Extended glob matching
  * "Globstar" `**` matching
  
  See:
  
  * `man sh`
  * `man bash`
  * `man 3 fnmatch`
  * `man 5 gitignore`
  
  ## Minimatch Class
  
  Create a minimatch object by instanting the `minimatch.Minimatch` class.
  
  ```javascript
  var Minimatch = require("minimatch").Minimatch
  var mm = new Minimatch(pattern, options)
  ```
  
  ### 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 `""`.
  
  ### 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.
  
  All other methods are internal, and will be called as necessary.
  
  ## Functions
  
  The top-level exported function has a `cache` property, which is an LRU
  cache set to store 100 items.  So, calling these methods repeatedly
  with the same pattern and options will use the same Minimatch object,
  saving the cost of parsing it multiple times.
  
  ### minimatch(path, pattern, options)
  
  Main export.  Tests a path against the pattern using the options.
  
  ```javascript
  var isJS = minimatch(file, "*.js", { matchBase: true })
  ```
  
  ### minimatch.filter(pattern, options)
  
  Returns a function that tests its
  supplied argument, suitable for use with `Array.filter`.  Example:
  
  ```javascript
  var javascripts = fileList.filter(minimatch.filter("*.js", {matchBase: true}))
  ```
  
  ### minimatch.match(list, pattern, options)
  
  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.
  
  ```javascript
  var javascripts = minimatch.match(fileList, "*.js", {matchBase: true}))
  ```
  
  ### minimatch.makeRe(pattern, options)
  
  Make a regular expression object from the pattern.
  
  ## 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.
  
  ### nonull
  
  When a match is not found by `minimatch.match`, return a list containing
  the pattern itself.  When set, an empty list is returned if there are
  no matches.
  
  ### matchBase
  
  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`.
  
  ### nocomment
  
  Suppress the behavior of treating `#` at the start of a pattern as a
  comment.
  
  ### nonegate
  
  Suppress the behavior of treating a leading `!` character as negation.
  
  ### flipNegate
  
  Returns from negate expressions the same as if they were not negated.
  (Ie, true on a hit, false on a miss.)
  
  
  ## Comparisons to other fnmatch/glob implementations
  
  While strict compliance with the existing standards is a worthwhile
  goal, some discrepancies exist between minimatch and other
  implementations, and are intentional.
  
  If the pattern starts with a `!` character, then it is negated.  Set the
  `nonegate` flag to suppress this behavior, and treat leading `!`
  characters normally.  This is perhaps relevant if you wish to start the
  pattern with a negative extglob pattern like `!(a|B)`.  Multiple `!`
  characters at the start of a pattern will negate the pattern multiple
  times.
  
  If a pattern starts with `#`, then it is treated as a comment, and
  will not match anything.  Use `\#` to match a literal `#` at the
  start of a line, or set the `nocomment` flag to suppress this behavior.
  
  The double-star character `**` is supported by default, unless the
  `noglobstar` flag is set.  This is supported in the manner of bsdglob
  and bash 4.1, where `**` only has special significance if it is the only
  thing in a path part.  That is, `a/**/b` will match `a/x/y/b`, but
  `a/**b` will not.
  
  If an escaped pattern has no matches, and the `nonull` flag is set,
  then minimatch.match returns the pattern as-provided, rather than
  interpreting the character escapes.  For example,
  `minimatch.match([], "\\*a\\?")` will return `"\\*a\\?"` rather than
  `"*a?"`.  This is akin to setting the `nullglob` option in bash, except
  that it does not resolve escaped pattern characters.
  
  If brace expansion is not disabled, then it is performed before any
  other interpretation of the glob pattern.  Thus, a pattern like
  `+(a|{b),c)}`, which would not be valid in bash or zsh, is expanded
  **first** into the set of `+(a|b)` and `+(a|c)`, and those patterns are
  checked for validity.  Since those two are valid, matching proceeds.
  