minimatch 0.2.10 → 0.2.14

package/.npmignore

@@ -0,0 +1 @@
+node_modules

package/README.md

@@ -19,6 +19,7 @@ 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
@@ -36,44 +37,6 @@ See:
 * `man 3 fnmatch`
 * `man 5 gitignore`
 
-### 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.  **Note that this is different from the way that `**` is
-handled by ruby's `Dir` class.**
-
-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.
-
-
 ## Minimatch Class
 
 Create a minimatch object by instanting the `minimatch.Minimatch` class.
@@ -216,3 +179,40 @@ Suppress the behavior of treating a leading `!` character as negation.
 
 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.

package/minimatch.js

@@ -68,17 +68,6 @@ function charSet (s) {
 // normalizes slashes.
 var slashSplit = /\/+/
 
-minimatch.monkeyPatch = monkeyPatch
-function monkeyPatch () {
-  var desc = Object.getOwnPropertyDescriptor(String.prototype, "match")
-  var orig = desc.value
-  desc.value = function (p) {
-    if (p instanceof Minimatch) return p.match(this)
-    return orig.call(this, p)
-  }
-  Object.defineProperty(String.prototype, desc)
-}
-
 minimatch.filter = filter
 function filter (pattern, options) {
   options = options || {}
@@ -178,6 +167,8 @@ function Minimatch (pattern, options) {
   this.make()
 }
 
+Minimatch.prototype.debug = function() {}
+
 Minimatch.prototype.make = make
 function make () {
   // don't do it more than once.
@@ -202,7 +193,9 @@ function make () {
   // step 2: expand braces
   var set = this.globSet = this.braceExpand()
 
-  if (options.debug) console.error(this.pattern, set)
+  if (options.debug) this.debug = console.error
+
+  this.debug(this.pattern, set)
 
   // step 3: now we have a set, so turn each one into a series of path-portion
   // matching patterns.
@@ -213,21 +206,21 @@ function make () {
     return s.split(slashSplit)
   })
 
-  if (options.debug) console.error(this.pattern, set)
+  this.debug(this.pattern, set)
 
   // glob --> regexps
   set = set.map(function (s, si, set) {
     return s.map(this.parse, this)
   }, this)
 
-  if (options.debug) console.error(this.pattern, set)
+  this.debug(this.pattern, set)
 
   // filter out everything that didn't compile properly.
   set = set.filter(function (s) {
     return -1 === s.indexOf(false)
   })
 
-  if (options.debug) console.error(this.pattern, set)
+  this.debug(this.pattern, set)
 
   this.set = set
 }
@@ -302,11 +295,11 @@ function braceExpand (pattern, options) {
   // So, we pluck that off, and work with the rest,
   // and then prepend it to everything we find.
   if (pattern.charAt(0) !== "{") {
-    // console.error(pattern)
+    this.debug(pattern)
     var prefix = null
     for (var i = 0, l = pattern.length; i < l; i ++) {
       var c = pattern.charAt(i)
-      // console.error(i, c)
+      this.debug(i, c)
       if (c === "\\") {
         escaping = !escaping
       } else if (c === "{" && !escaping) {
@@ -317,11 +310,11 @@ function braceExpand (pattern, options) {
 
     // actually no sets, all { were escaped.
     if (prefix === null) {
-      // console.error("no sets")
+      this.debug("no sets")
       return [pattern]
     }
 
-    var tail = braceExpand(pattern.substr(i), options)
+   var tail = braceExpand.call(this, pattern.substr(i), options)
     return tail.map(function (t) {
       return prefix + t
     })
@@ -336,8 +329,8 @@ function braceExpand (pattern, options) {
   // first, handle numeric sets, since they're easier
   var numset = pattern.match(/^\{(-?[0-9]+)\.\.(-?[0-9]+)\}/)
   if (numset) {
-    // console.error("numset", numset[1], numset[2])
-    var suf = braceExpand(pattern.substr(numset[0].length), options)
+    this.debug("numset", numset[1], numset[2])
+    var suf = braceExpand.call(this, pattern.substr(numset[0].length), options)
       , start = +numset[1]
       , end = +numset[2]
       , inc = start > end ? -1 : 1
@@ -369,10 +362,10 @@ function braceExpand (pattern, options) {
     member = ""
   }
 
-  // console.error("Entering for")
+  this.debug("Entering for")
   FOR: for (i = 1, l = pattern.length; i < l; i ++) {
     var c = pattern.charAt(i)
-    // console.error("", i, c)
+    this.debug("", i, c)
 
     if (escaping) {
       escaping = false
@@ -420,22 +413,22 @@ function braceExpand (pattern, options) {
   // pattern.substr(i), or we have *not* closed the set,
   // and need to escape the leading brace
   if (depth !== 0) {
-    // console.error("didn't close", pattern)
-    return braceExpand("\\" + pattern, options)
+    this.debug("didn't close", pattern)
+    return braceExpand.call(this, "\\" + pattern, options)
   }
 
   // x{y,z} -> ["xy", "xz"]
-  // console.error("set", set)
-  // console.error("suffix", pattern.substr(i))
-  var suf = braceExpand(pattern.substr(i), options)
+  this.debug("set", set)
+  this.debug("suffix", pattern.substr(i))
+  var suf = braceExpand.call(this, pattern.substr(i), options)
   // ["b", "c{d,e}","{f,g}h"] ->
   //   [["b"], ["cd", "ce"], ["fh", "gh"]]
   var addBraces = set.length === 1
-  // console.error("set pre-expanded", set)
+  this.debug("set pre-expanded", set)
   set = set.map(function (p) {
-    return braceExpand(p, options)
-  })
-  // console.error("set expanded", set)
+    return braceExpand.call(this, p, options)
+  }, this)
+  this.debug("set expanded", set)
 
 
   // [["b"], ["cd", "ce"], ["fh", "gh"]] ->
@@ -496,6 +489,7 @@ function parse (pattern, isSub) {
       // not (start or / followed by . or .. followed by / or end)
       : options.dot ? "(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))"
       : "(?!\\.)"
+    , self = this
 
   function clearStateChar () {
     if (stateChar) {
@@ -514,6 +508,7 @@ function parse (pattern, isSub) {
           re += "\\"+stateChar
           break
       }
+      self.debug('clearStateChar %j %j', stateChar, re)
       stateChar = false
     }
   }
@@ -522,9 +517,7 @@ function parse (pattern, isSub) {
       ; (i < len) && (c = pattern.charAt(i))
       ; i ++ ) {
 
-    if (options.debug) {
-      console.error("%s\t%s %s %j", pattern, i, re, c)
-    }
+    this.debug("%s\t%s %s %j", pattern, i, re, c)
 
     // skip over any that are escaped.
     if (escaping && reSpecials[c]) {
@@ -551,13 +544,12 @@ function parse (pattern, isSub) {
       case "+":
       case "@":
       case "!":
-        if (options.debug) {
-          console.error("%s\t%s %s %j <-- stateChar", pattern, i, re, c)
-        }
+        this.debug("%s\t%s %s %j <-- stateChar", pattern, i, re, c)
 
         // all of those are literals inside a class, except that
         // the glob [!a] means [^a] in regexp
         if (inClass) {
+          this.debug('  in class')
           if (c === "!" && i === classStart + 1) c = "^"
           re += c
           continue
@@ -566,6 +558,7 @@ function parse (pattern, isSub) {
         // if we already have a stateChar, then it means
         // that there was something like ** or +? in there.
         // Handle the stateChar, then proceed with this one.
+        self.debug('call clearStateChar %j', stateChar)
         clearStateChar()
         stateChar = c
         // if extglob is disabled, then +(asdf|foo) isn't a thing.
@@ -591,6 +584,7 @@ function parse (pattern, isSub) {
                               , reStart: re.length })
         // negation is (?:(?!js)[^/]*)
         re += stateChar === "!" ? "(?:(?!" : "(?:"
+        this.debug('plType %j %j', stateChar, re)
         stateChar = false
         continue
 
@@ -600,6 +594,7 @@ function parse (pattern, isSub) {
           continue
         }
 
+        clearStateChar()
         hasMagic = true
         re += ")"
         plType = patternListStack.pop().type
@@ -623,6 +618,7 @@ function parse (pattern, isSub) {
           continue
         }
 
+        clearStateChar()
         re += "|"
         continue
 
@@ -715,7 +711,7 @@ function parse (pattern, isSub) {
       return $1 + $1 + $2 + "|"
     })
 
-    // console.error("tail=%j\n   %s", tail, tail)
+    this.debug("tail=%j\n   %s", tail, tail)
     var t = pl.type === "*" ? star
           : pl.type === "?" ? qmark
           : "\\" + pl.type
@@ -804,7 +800,7 @@ function makeRe () {
 
   // must match entire pattern
   // ending in a * or ** will make it less strict.
-  re = "^" + re + "$"
+  re = "^(?:" + re + ")$"
 
   // can match anything, as long as it's not this.
   if (this.negate) re = "^(?!" + re + ").*$"
@@ -829,7 +825,7 @@ minimatch.match = function (list, pattern, options) {
 
 Minimatch.prototype.match = match
 function match (f, partial) {
-  // console.error("match", f, this.pattern)
+  this.debug("match", f, this.pattern)
   // short-circuit in the case of busted things.
   // comments, etc.
   if (this.comment) return false
@@ -847,9 +843,7 @@ function match (f, partial) {
 
   // treat the test path as a set of pathparts.
   f = f.split(slashSplit)
-  if (options.debug) {
-    console.error(this.pattern, "split", f)
-  }
+  this.debug(this.pattern, "split", f)
 
   // just ONE of the pattern sets in this.set needs to match
   // in order for it to be valid.  If negating, then just one
@@ -857,11 +851,16 @@ function match (f, partial) {
   // Either way, return on the first hit.
 
   var set = this.set
-  // console.error(this.pattern, "set", set)
+  this.debug(this.pattern, "set", set)
+
+  var splitFile = path.basename(f.join("/")).split("/")
 
   for (var i = 0, l = set.length; i < l; i ++) {
-    var pattern = set[i]
-    var hit = this.matchOne(f, pattern, partial)
+    var pattern = set[i], file = f
+    if (options.matchBase && pattern.length === 1) {
+      file = splitFile
+    }
+    var hit = this.matchOne(file, pattern, partial)
     if (hit) {
       if (options.flipNegate) return true
       return !this.negate
@@ -882,20 +881,12 @@ function match (f, partial) {
 Minimatch.prototype.matchOne = function (file, pattern, partial) {
   var options = this.options
 
-  if (options.debug) {
-    console.error("matchOne",
-                  { "this": this
-                  , file: file
-                  , pattern: pattern })
-  }
-
-  if (options.matchBase && pattern.length === 1) {
-    file = path.basename(file.join("/")).split("/")
-  }
+  this.debug("matchOne",
+              { "this": this
+              , file: file
+              , pattern: pattern })
 
-  if (options.debug) {
-    console.error("matchOne", file.length, pattern.length)
-  }
+  this.debug("matchOne", file.length, pattern.length)
 
   for ( var fi = 0
           , pi = 0
@@ -904,23 +895,18 @@ Minimatch.prototype.matchOne = function (file, pattern, partial) {
       ; (fi < fl) && (pi < pl)
       ; fi ++, pi ++ ) {
 
-    if (options.debug) {
-      console.error("matchOne loop")
-    }
+    this.debug("matchOne loop")
     var p = pattern[pi]
       , f = file[fi]
 
-    if (options.debug) {
-      console.error(pattern, p, f)
-    }
+    this.debug(pattern, p, f)
 
     // should be impossible.
     // some invalid regexp stuff in the set.
     if (p === false) return false
 
     if (p === GLOBSTAR) {
-      if (options.debug)
-        console.error('GLOBSTAR', [pattern, p, f])
+      this.debug('GLOBSTAR', [pattern, p, f])
 
       // "**"
       // a/**/b/**/c would match the following:
@@ -947,8 +933,7 @@ Minimatch.prototype.matchOne = function (file, pattern, partial) {
       var fr = fi
         , pr = pi + 1
       if (pr === pl) {
-        if (options.debug)
-          console.error('** at the end')
+        this.debug('** at the end')
         // a ** at the end will just swallow the rest.
         // We have found a match.
         // however, it will not swallow /.x, unless
@@ -966,15 +951,12 @@ Minimatch.prototype.matchOne = function (file, pattern, partial) {
       WHILE: while (fr < fl) {
         var swallowee = file[fr]
 
-        if (options.debug) {
-          console.error('\nglobstar while',
-                        file, fr, pattern, pr, swallowee)
-        }
+        this.debug('\nglobstar while',
+                    file, fr, pattern, pr, swallowee)
 
         // XXX remove this slice.  Just pass the start index.
         if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
-          if (options.debug)
-            console.error('globstar found match!', fr, fl, swallowee)
+          this.debug('globstar found match!', fr, fl, swallowee)
           // found a match.
           return true
         } else {
@@ -982,14 +964,12 @@ Minimatch.prototype.matchOne = function (file, pattern, partial) {
           // can only swallow ".foo" when explicitly asked.
           if (swallowee === "." || swallowee === ".." ||
               (!options.dot && swallowee.charAt(0) === ".")) {
-            if (options.debug)
-              console.error("dot detected!", file, fr, pattern, pr)
+            this.debug("dot detected!", file, fr, pattern, pr)
             break WHILE
           }
 
           // ** swallows a segment, and continue.
-          if (options.debug)
-            console.error('globstar swallow a segment, and continue')
+          this.debug('globstar swallow a segment, and continue')
           fr ++
         }
       }
@@ -998,7 +978,7 @@ Minimatch.prototype.matchOne = function (file, pattern, partial) {
       // If there's more *pattern* left, then 
       if (partial) {
         // ran out of file
-        // console.error("\n>>> no match, partial?", file, fr, pattern, pr)
+        this.debug("\n>>> no match, partial?", file, fr, pattern, pr)
         if (fr === fl) return true
       }
       return false
@@ -1014,14 +994,10 @@ Minimatch.prototype.matchOne = function (file, pattern, partial) {
       } else {
         hit = f === p
       }
-      if (options.debug) {
-        console.error("string match", p, f, hit)
-      }
+      this.debug("string match", p, f, hit)
     } else {
       hit = f.match(p)
-      if (options.debug) {
-        console.error("pattern match", p, f, hit)
-      }
+      this.debug("pattern match", p, f, hit)
     }
 
     if (!hit) return false

package/package.json

@@ -2,20 +2,20 @@
   "author": "Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me)",
   "name": "minimatch",
   "description": "a glob matcher in javascript",
-  "version": "0.2.10",
+  "version": "0.2.14",
   "repository": {
     "type": "git",
     "url": "git://github.com/isaacs/minimatch.git"
   },
   "main": "minimatch.js",
   "scripts": {
-    "test": "tap test"
+    "test": "tap test/*.js"
   },
   "engines": {
     "node": "*"
   },
   "dependencies": {
-    "lru-cache": "~2.0.0",
+    "lru-cache": "2",
     "sigmund": "~1.0.0"
   },
   "devDependencies": {

package/test/basic.js

@@ -13,274 +13,376 @@ var tap = require("tap")
   , next = files.concat([ "a-b", "aXb"
                         , ".x", ".y" ])
 
+
+var patterns =
+  [ "http://www.bashcookbook.com/bashinfo/source/bash-1.14.7/tests/glob-test"
+  , ["a*", ["a", "abc", "abd", "abe"]]
+  , ["X*", ["X*"], {nonull: true}]
+
+  // allow null glob expansion
+  , ["X*", []]
+
+  // isaacs: Slightly different than bash/sh/ksh
+  // \\* is not un-escaped to literal "*" in a failed match,
+  // but it does make it get treated as a literal star
+  , ["\\*", ["\\*"], {nonull: true}]
+  , ["\\**", ["\\**"], {nonull: true}]
+  , ["\\*\\*", ["\\*\\*"], {nonull: true}]
+
+  , ["b*/", ["bdir/"]]
+  , ["c*", ["c", "ca", "cb"]]
+  , ["**", files]
+
+  , ["\\.\\./*/", ["\\.\\./*/"], {nonull: true}]
+  , ["s/\\..*//", ["s/\\..*//"], {nonull: true}]
+
+  , "legendary larry crashes bashes"
+  , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\\1/"
+    , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\\1/"], {nonull: true}]
+  , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\1/"
+    , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\1/"], {nonull: true}]
+
+  , "character classes"
+  , ["[a-c]b*", ["abc", "abd", "abe", "bb", "cb"]]
+  , ["[a-y]*[^c]", ["abd", "abe", "bb", "bcd",
+     "bdir/", "ca", "cb", "dd", "de"]]
+  , ["a*[^c]", ["abd", "abe"]]
+  , function () { files.push("a-b", "aXb") }
+  , ["a[X-]b", ["a-b", "aXb"]]
+  , function () { files.push(".x", ".y") }
+  , ["[^a-c]*", ["d", "dd", "de"]]
+  , function () { files.push("a*b/", "a*b/ooo") }
+  , ["a\\*b/*", ["a*b/ooo"]]
+  , ["a\\*?/*", ["a*b/ooo"]]
+  , ["*\\\\!*", [], {null: true}, ["echo !7"]]
+  , ["*\\!*", ["echo !7"], null, ["echo !7"]]
+  , ["*.\\*", ["r.*"], null, ["r.*"]]
+  , ["a[b]c", ["abc"]]
+  , ["a[\\b]c", ["abc"]]
+  , ["a?c", ["abc"]]
+  , ["a\\*c", [], {null: true}, ["abc"]]
+  , ["", [""], { null: true }, [""]]
+
+  , "http://www.opensource.apple.com/source/bash/bash-23/" +
+    "bash/tests/glob-test"
+  , function () { files.push("man/", "man/man1/", "man/man1/bash.1") }
+  , ["*/man*/bash.*", ["man/man1/bash.1"]]
+  , ["man/man1/bash.1", ["man/man1/bash.1"]]
+  , ["a***c", ["abc"], null, ["abc"]]
+  , ["a*****?c", ["abc"], null, ["abc"]]
+  , ["?*****??", ["abc"], null, ["abc"]]
+  , ["*****??", ["abc"], null, ["abc"]]
+  , ["?*****?c", ["abc"], null, ["abc"]]
+  , ["?***?****c", ["abc"], null, ["abc"]]
+  , ["?***?****?", ["abc"], null, ["abc"]]
+  , ["?***?****", ["abc"], null, ["abc"]]
+  , ["*******c", ["abc"], null, ["abc"]]
+  , ["*******?", ["abc"], null, ["abc"]]
+  , ["a*cd**?**??k", ["abcdecdhjk"], null, ["abcdecdhjk"]]
+  , ["a**?**cd**?**??k", ["abcdecdhjk"], null, ["abcdecdhjk"]]
+  , ["a**?**cd**?**??k***", ["abcdecdhjk"], null, ["abcdecdhjk"]]
+  , ["a**?**cd**?**??***k", ["abcdecdhjk"], null, ["abcdecdhjk"]]
+  , ["a**?**cd**?**??***k**", ["abcdecdhjk"], null, ["abcdecdhjk"]]
+  , ["a****c**?**??*****", ["abcdecdhjk"], null, ["abcdecdhjk"]]
+  , ["[-abc]", ["-"], null, ["-"]]
+  , ["[abc-]", ["-"], null, ["-"]]
+  , ["\\", ["\\"], null, ["\\"]]
+  , ["[\\\\]", ["\\"], null, ["\\"]]
+  , ["[[]", ["["], null, ["["]]
+  , ["[", ["["], null, ["["]]
+  , ["[*", ["[abc"], null, ["[abc"]]
+  , "a right bracket shall lose its special meaning and\n" +
+    "represent itself in a bracket expression if it occurs\n" +
+    "first in the list.  -- POSIX.2 2.8.3.2"
+  , ["[]]", ["]"], null, ["]"]]
+  , ["[]-]", ["]"], null, ["]"]]
+  , ["[a-\z]", ["p"], null, ["p"]]
+  , ["??**********?****?", [], { null: true }, ["abc"]]
+  , ["??**********?****c", [], { null: true }, ["abc"]]
+  , ["?************c****?****", [], { null: true }, ["abc"]]
+  , ["*c*?**", [], { null: true }, ["abc"]]
+  , ["a*****c*?**", [], { null: true }, ["abc"]]
+  , ["a********???*******", [], { null: true }, ["abc"]]
+  , ["[]", [], { null: true }, ["a"]]
+  , ["[abc", [], { null: true }, ["["]]
+
+  , "nocase tests"
+  , ["XYZ", ["xYz"], { nocase: true, null: true }
+    , ["xYz", "ABC", "IjK"]]
+  , ["ab*", ["ABC"], { nocase: true, null: true }
+    , ["xYz", "ABC", "IjK"]]
+  , ["[ia]?[ck]", ["ABC", "IjK"], { nocase: true, null: true }
+    , ["xYz", "ABC", "IjK"]]
+
+  // [ pattern, [matches], MM opts, files, TAP opts]
+  , "onestar/twostar"
+  , ["{/*,*}", [], {null: true}, ["/asdf/asdf/asdf"]]
+  , ["{/?,*}", ["/a", "bb"], {null: true}
+    , ["/a", "/b/b", "/a/b/c", "bb"]]
+
+  , "dots should not match unless requested"
+  , ["**", ["a/b"], {}, ["a/b", "a/.d", ".a/.d"]]
+
+  // .. and . can only match patterns starting with .,
+  // even when options.dot is set.
+  , function () {
+      files = ["a/./b", "a/../b", "a/c/b", "a/.d/b"]
+    }
+  , ["a/*/b", ["a/c/b", "a/.d/b"], {dot: true}]
+  , ["a/.*/b", ["a/./b", "a/../b", "a/.d/b"], {dot: true}]
+  , ["a/*/b", ["a/c/b"], {dot:false}]
+  , ["a/.*/b", ["a/./b", "a/../b", "a/.d/b"], {dot: false}]
+
+
+  // this also tests that changing the options needs
+  // to change the cache key, even if the pattern is
+  // the same!
+  , ["**", ["a/b","a/.d",".a/.d"], { dot: true }
+    , [ ".a/.d", "a/.d", "a/b"]]
+
+  , "paren sets cannot contain slashes"
+  , ["*(a/b)", ["*(a/b)"], {nonull: true}, ["a/b"]]
+
+  // brace sets trump all else.
+  //
+  // invalid glob pattern.  fails on bash4 and bsdglob.
+  // however, in this implementation, it's easier just
+  // to do the intuitive thing, and let brace-expansion
+  // actually come before parsing any extglob patterns,
+  // like the documentation seems to say.
+  //
+  // XXX: if anyone complains about this, either fix it
+  // or tell them to grow up and stop complaining.
+  //
+  // bash/bsdglob says this:
+  // , ["*(a|{b),c)}", ["*(a|{b),c)}"], {}, ["a", "ab", "ac", "ad"]]
+  // but we do this instead:
+  , ["*(a|{b),c)}", ["a", "ab", "ac"], {}, ["a", "ab", "ac", "ad"]]
+
+  // test partial parsing in the presence of comment/negation chars
+  , ["[!a*", ["[!ab"], {}, ["[!ab", "[ab"]]
+  , ["[#a*", ["[#ab"], {}, ["[#ab", "[ab"]]
+
+  // like: {a,b|c\\,d\\\|e} except it's unclosed, so it has to be escaped.
+  , ["+(a|*\\|c\\\\|d\\\\\\|e\\\\\\\\|f\\\\\\\\\\|g"
+    , ["+(a|b\\|c\\\\|d\\\\|e\\\\\\\\|f\\\\\\\\|g"]
+    , {}
+    , ["+(a|b\\|c\\\\|d\\\\|e\\\\\\\\|f\\\\\\\\|g", "a", "b\\c"]]
+
+
+  // crazy nested {,,} and *(||) tests.
+  , function () {
+      files = [ "a", "b", "c", "d"
+              , "ab", "ac", "ad"
+              , "bc", "cb"
+              , "bc,d", "c,db", "c,d"
+              , "d)", "(b|c", "*(b|c"
+              , "b|c", "b|cc", "cb|c"
+              , "x(a|b|c)", "x(a|c)"
+              , "(a|b|c)", "(a|c)"]
+    }
+  , ["*(a|{b,c})", ["a", "b", "c", "ab", "ac"]]
+  , ["{a,*(b|c,d)}", ["a","(b|c", "*(b|c", "d)"]]
+  // a
+  // *(b|c)
+  // *(b|d)
+  , ["{a,*(b|{c,d})}", ["a","b", "bc", "cb", "c", "d"]]
+  , ["*(a|{b|c,c})", ["a", "b", "c", "ab", "ac", "bc", "cb"]]
+
+
+  // test various flag settings.
+  , [ "*(a|{b|c,c})", ["x(a|b|c)", "x(a|c)", "(a|b|c)", "(a|c)"]
+    , { noext: true } ]
+  , ["a?b", ["x/y/acb", "acb/"], {matchBase: true}
+    , ["x/y/acb", "acb/", "acb/d/e", "x/y/acb/d"] ]
+  , ["#*", ["#a", "#b"], {nocomment: true}, ["#a", "#b", "c#d"]]
+
+
+  // begin channelling Boole and deMorgan...
+  , "negation tests"
+  , function () {
+      files = ["d", "e", "!ab", "!abc", "a!b", "\\!a"]
+    }
+
+  // anything that is NOT a* matches.
+  , ["!a*", ["\\!a", "d", "e", "!ab", "!abc"]]
+
+  // anything that IS !a* matches.
+  , ["!a*", ["!ab", "!abc"], {nonegate: true}]
+
+  // anything that IS a* matches
+  , ["!!a*", ["a!b"]]
+
+  // anything that is NOT !a* matches
+  , ["!\\!a*", ["a!b", "d", "e", "\\!a"]]
+
+  // negation nestled within a pattern
+  , function () {
+      files = [ "foo.js"
+              , "foo.bar"
+              // can't match this one without negative lookbehind.
+              , "foo.js.js"
+              , "blar.js"
+              , "foo."
+              , "boo.js.boo" ]
+    }
+  , ["*.!(js)", ["foo.bar", "foo.", "boo.js.boo"] ]
+
+  // https://github.com/isaacs/minimatch/issues/5
+  , function () {
+      files = [ 'a/b/.x/c'
+              , 'a/b/.x/c/d'
+              , 'a/b/.x/c/d/e'
+              , 'a/b/.x'
+              , 'a/b/.x/'
+              , 'a/.x/b'
+              , '.x'
+              , '.x/'
+              , '.x/a'
+              , '.x/a/b'
+              , 'a/.x/b/.x/c'
+              , '.x/.x' ]
+  }
+  , ["**/.x/**", [ '.x/'
+                 , '.x/a'
+                 , '.x/a/b'
+                 , 'a/.x/b'
+                 , 'a/b/.x/'
+                 , 'a/b/.x/c'
+                 , 'a/b/.x/c/d'
+                 , 'a/b/.x/c/d/e' ] ]
+
+  ]
+
+var regexps =
+  [ '/^(?:(?=.)a[^/]*?)$/',
+    '/^(?:(?=.)X[^/]*?)$/',
+    '/^(?:(?=.)X[^/]*?)$/',
+    '/^(?:\\*)$/',
+    '/^(?:(?=.)\\*[^/]*?)$/',
+    '/^(?:\\*\\*)$/',
+    '/^(?:(?=.)b[^/]*?\\/)$/',
+    '/^(?:(?=.)c[^/]*?)$/',
+    '/^(?:(?:(?!(?:\\/|^)\\.).)*?)$/',
+    '/^(?:\\.\\.\\/(?!\\.)(?=.)[^/]*?\\/)$/',
+    '/^(?:s\\/(?=.)\\.\\.[^/]*?\\/)$/',
+    '/^(?:\\/\\^root:\\/\\{s\\/(?=.)\\^[^:][^/]*?:[^:][^/]*?:\\([^:]\\)[^/]*?\\.[^/]*?\\$\\/1\\/)$/',
+    '/^(?:\\/\\^root:\\/\\{s\\/(?=.)\\^[^:][^/]*?:[^:][^/]*?:\\([^:]\\)[^/]*?\\.[^/]*?\\$\\/\u0001\\/)$/',
+    '/^(?:(?!\\.)(?=.)[a-c]b[^/]*?)$/',
+    '/^(?:(?!\\.)(?=.)[a-y][^/]*?[^c])$/',
+    '/^(?:(?=.)a[^/]*?[^c])$/',
+    '/^(?:(?=.)a[X-]b)$/',
+    '/^(?:(?!\\.)(?=.)[^a-c][^/]*?)$/',
+    '/^(?:a\\*b\\/(?!\\.)(?=.)[^/]*?)$/',
+    '/^(?:(?=.)a\\*[^/]\\/(?!\\.)(?=.)[^/]*?)$/',
+    '/^(?:(?!\\.)(?=.)[^/]*?\\\\\\![^/]*?)$/',
+    '/^(?:(?!\\.)(?=.)[^/]*?\\![^/]*?)$/',
+    '/^(?:(?!\\.)(?=.)[^/]*?\\.\\*)$/',
+    '/^(?:(?=.)a[b]c)$/',
+    '/^(?:(?=.)a[b]c)$/',
+    '/^(?:(?=.)a[^/]c)$/',
+    '/^(?:a\\*c)$/',
+    'false',
+    '/^(?:(?!\\.)(?=.)[^/]*?\\/(?=.)man[^/]*?\\/(?=.)bash\\.[^/]*?)$/',
+    '/^(?:man\\/man1\\/bash\\.1)$/',
+    '/^(?:(?=.)a[^/]*?[^/]*?[^/]*?c)$/',
+    '/^(?:(?=.)a[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]c)$/',
+    '/^(?:(?!\\.)(?=.)[^/][^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/][^/])$/',
+    '/^(?:(?!\\.)(?=.)[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/][^/])$/',
+    '/^(?:(?!\\.)(?=.)[^/][^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]c)$/',
+    '/^(?:(?!\\.)(?=.)[^/][^/]*?[^/]*?[^/]*?[^/][^/]*?[^/]*?[^/]*?[^/]*?c)$/',
+    '/^(?:(?!\\.)(?=.)[^/][^/]*?[^/]*?[^/]*?[^/][^/]*?[^/]*?[^/]*?[^/]*?[^/])$/',
+    '/^(?:(?!\\.)(?=.)[^/][^/]*?[^/]*?[^/]*?[^/][^/]*?[^/]*?[^/]*?[^/]*?)$/',
+    '/^(?:(?!\\.)(?=.)[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?c)$/',
+    '/^(?:(?!\\.)(?=.)[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/])$/',
+    '/^(?:(?=.)a[^/]*?cd[^/]*?[^/]*?[^/][^/]*?[^/]*?[^/][^/]k)$/',
+    '/^(?:(?=.)a[^/]*?[^/]*?[^/][^/]*?[^/]*?cd[^/]*?[^/]*?[^/][^/]*?[^/]*?[^/][^/]k)$/',
+    '/^(?:(?=.)a[^/]*?[^/]*?[^/][^/]*?[^/]*?cd[^/]*?[^/]*?[^/][^/]*?[^/]*?[^/][^/]k[^/]*?[^/]*?[^/]*?)$/',
+    '/^(?:(?=.)a[^/]*?[^/]*?[^/][^/]*?[^/]*?cd[^/]*?[^/]*?[^/][^/]*?[^/]*?[^/][^/][^/]*?[^/]*?[^/]*?k)$/',
+    '/^(?:(?=.)a[^/]*?[^/]*?[^/][^/]*?[^/]*?cd[^/]*?[^/]*?[^/][^/]*?[^/]*?[^/][^/][^/]*?[^/]*?[^/]*?k[^/]*?[^/]*?)$/',
+    '/^(?:(?=.)a[^/]*?[^/]*?[^/]*?[^/]*?c[^/]*?[^/]*?[^/][^/]*?[^/]*?[^/][^/][^/]*?[^/]*?[^/]*?[^/]*?[^/]*?)$/',
+    '/^(?:(?!\\.)(?=.)[-abc])$/',
+    '/^(?:(?!\\.)(?=.)[abc-])$/',
+    '/^(?:\\\\)$/',
+    '/^(?:(?!\\.)(?=.)[\\\\])$/',
+    '/^(?:(?!\\.)(?=.)[\\[])$/',
+    '/^(?:\\[)$/',
+    '/^(?:(?=.)\\[(?!\\.)(?=.)[^/]*?)$/',
+    '/^(?:(?!\\.)(?=.)[\\]])$/',
+    '/^(?:(?!\\.)(?=.)[\\]-])$/',
+    '/^(?:(?!\\.)(?=.)[a-z])$/',
+    '/^(?:(?!\\.)(?=.)[^/][^/][^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/][^/]*?[^/]*?[^/]*?[^/]*?[^/])$/',
+    '/^(?:(?!\\.)(?=.)[^/][^/][^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/][^/]*?[^/]*?[^/]*?[^/]*?c)$/',
+    '/^(?:(?!\\.)(?=.)[^/][^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?c[^/]*?[^/]*?[^/]*?[^/]*?[^/][^/]*?[^/]*?[^/]*?[^/]*?)$/',
+    '/^(?:(?!\\.)(?=.)[^/]*?c[^/]*?[^/][^/]*?[^/]*?)$/',
+    '/^(?:(?=.)a[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?c[^/]*?[^/][^/]*?[^/]*?)$/',
+    '/^(?:(?=.)a[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/][^/][^/][^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?[^/]*?)$/',
+    '/^(?:\\[\\])$/',
+    '/^(?:\\[abc)$/',
+    '/^(?:(?=.)XYZ)$/i',
+    '/^(?:(?=.)ab[^/]*?)$/i',
+    '/^(?:(?!\\.)(?=.)[ia][^/][ck])$/i',
+    '/^(?:\\/(?!\\.)(?=.)[^/]*?|(?!\\.)(?=.)[^/]*?)$/',
+    '/^(?:\\/(?!\\.)(?=.)[^/]|(?!\\.)(?=.)[^/]*?)$/',
+    '/^(?:(?:(?!(?:\\/|^)\\.).)*?)$/',
+    '/^(?:a\\/(?!(?:^|\\/)\\.{1,2}(?:$|\\/))(?=.)[^/]*?\\/b)$/',
+    '/^(?:a\\/(?=.)\\.[^/]*?\\/b)$/',
+    '/^(?:a\\/(?!\\.)(?=.)[^/]*?\\/b)$/',
+    '/^(?:a\\/(?=.)\\.[^/]*?\\/b)$/',
+    '/^(?:(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?)$/',
+    '/^(?:(?!\\.)(?=.)[^/]*?\\(a\\/b\\))$/',
+    '/^(?:(?!\\.)(?=.)(?:a|b)*|(?!\\.)(?=.)(?:a|c)*)$/',
+    '/^(?:(?=.)\\[(?=.)\\!a[^/]*?)$/',
+    '/^(?:(?=.)\\[(?=.)#a[^/]*?)$/',
+    '/^(?:(?=.)\\+\\(a\\|[^/]*?\\|c\\\\\\\\\\|d\\\\\\\\\\|e\\\\\\\\\\\\\\\\\\|f\\\\\\\\\\\\\\\\\\|g)$/',
+    '/^(?:(?!\\.)(?=.)(?:a|b)*|(?!\\.)(?=.)(?:a|c)*)$/',
+    '/^(?:a|(?!\\.)(?=.)[^/]*?\\(b\\|c|d\\))$/',
+    '/^(?:a|(?!\\.)(?=.)(?:b|c)*|(?!\\.)(?=.)(?:b|d)*)$/',
+    '/^(?:(?!\\.)(?=.)(?:a|b|c)*|(?!\\.)(?=.)(?:a|c)*)$/',
+    '/^(?:(?!\\.)(?=.)[^/]*?\\(a\\|b\\|c\\)|(?!\\.)(?=.)[^/]*?\\(a\\|c\\))$/',
+    '/^(?:(?=.)a[^/]b)$/',
+    '/^(?:(?=.)#[^/]*?)$/',
+    '/^(?!^(?:(?=.)a[^/]*?)$).*$/',
+    '/^(?:(?=.)\\!a[^/]*?)$/',
+    '/^(?:(?=.)a[^/]*?)$/',
+    '/^(?!^(?:(?=.)\\!a[^/]*?)$).*$/',
+    '/^(?:(?!\\.)(?=.)[^/]*?\\.(?:(?!js)[^/]*?))$/',
+    '/^(?:(?:(?!(?:\\/|^)\\.).)*?\\/\\.x\\/(?:(?!(?:\\/|^)\\.).)*?)$/' ]
+var re = 0;
+
 tap.test("basic tests", function (t) {
   var start = Date.now()
 
   // [ pattern, [matches], MM opts, files, TAP opts]
-  ; [ "http://www.bashcookbook.com/bashinfo" +
-      "/source/bash-1.14.7/tests/glob-test"
-    , ["a*", ["a", "abc", "abd", "abe"]]
-    , ["X*", ["X*"], {nonull: true}]
-
-    // allow null glob expansion
-    , ["X*", []]
-
-    // isaacs: Slightly different than bash/sh/ksh
-    // \\* is not un-escaped to literal "*" in a failed match,
-    // but it does make it get treated as a literal star
-    , ["\\*", ["\\*"], {nonull: true}]
-    , ["\\**", ["\\**"], {nonull: true}]
-    , ["\\*\\*", ["\\*\\*"], {nonull: true}]
-
-    , ["b*/", ["bdir/"]]
-    , ["c*", ["c", "ca", "cb"]]
-    , ["**", files]
-
-    , ["\\.\\./*/", ["\\.\\./*/"], {nonull: true}]
-    , ["s/\\..*//", ["s/\\..*//"], {nonull: true}]
-
-    , "legendary larry crashes bashes"
-    , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\\1/"
-      , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\\1/"], {nonull: true}]
-    , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\1/"
-      , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\1/"], {nonull: true}]
-
-    , "character classes"
-    , ["[a-c]b*", ["abc", "abd", "abe", "bb", "cb"]]
-    , ["[a-y]*[^c]", ["abd", "abe", "bb", "bcd",
-       "bdir/", "ca", "cb", "dd", "de"]]
-    , ["a*[^c]", ["abd", "abe"]]
-    , function () { files.push("a-b", "aXb") }
-    , ["a[X-]b", ["a-b", "aXb"]]
-    , function () { files.push(".x", ".y") }
-    , ["[^a-c]*", ["d", "dd", "de"]]
-    , function () { files.push("a*b/", "a*b/ooo") }
-    , ["a\\*b/*", ["a*b/ooo"]]
-    , ["a\\*?/*", ["a*b/ooo"]]
-    , ["*\\\\!*", [], {null: true}, ["echo !7"]]
-    , ["*\\!*", ["echo !7"], null, ["echo !7"]]
-    , ["*.\\*", ["r.*"], null, ["r.*"]]
-    , ["a[b]c", ["abc"]]
-    , ["a[\\b]c", ["abc"]]
-    , ["a?c", ["abc"]]
-    , ["a\\*c", [], {null: true}, ["abc"]]
-    , ["", [""], { null: true }, [""]]
-
-    , "http://www.opensource.apple.com/source/bash/bash-23/" +
-      "bash/tests/glob-test"
-    , function () { files.push("man/", "man/man1/", "man/man1/bash.1") }
-    , ["*/man*/bash.*", ["man/man1/bash.1"]]
-    , ["man/man1/bash.1", ["man/man1/bash.1"]]
-    , ["a***c", ["abc"], null, ["abc"]]
-    , ["a*****?c", ["abc"], null, ["abc"]]
-    , ["?*****??", ["abc"], null, ["abc"]]
-    , ["*****??", ["abc"], null, ["abc"]]
-    , ["?*****?c", ["abc"], null, ["abc"]]
-    , ["?***?****c", ["abc"], null, ["abc"]]
-    , ["?***?****?", ["abc"], null, ["abc"]]
-    , ["?***?****", ["abc"], null, ["abc"]]
-    , ["*******c", ["abc"], null, ["abc"]]
-    , ["*******?", ["abc"], null, ["abc"]]
-    , ["a*cd**?**??k", ["abcdecdhjk"], null, ["abcdecdhjk"]]
-    , ["a**?**cd**?**??k", ["abcdecdhjk"], null, ["abcdecdhjk"]]
-    , ["a**?**cd**?**??k***", ["abcdecdhjk"], null, ["abcdecdhjk"]]
-    , ["a**?**cd**?**??***k", ["abcdecdhjk"], null, ["abcdecdhjk"]]
-    , ["a**?**cd**?**??***k**", ["abcdecdhjk"], null, ["abcdecdhjk"]]
-    , ["a****c**?**??*****", ["abcdecdhjk"], null, ["abcdecdhjk"]]
-    , ["[-abc]", ["-"], null, ["-"]]
-    , ["[abc-]", ["-"], null, ["-"]]
-    , ["\\", ["\\"], null, ["\\"]]
-    , ["[\\\\]", ["\\"], null, ["\\"]]
-    , ["[[]", ["["], null, ["["]]
-    , ["[", ["["], null, ["["]]
-    , ["[*", ["[abc"], null, ["[abc"]]
-    , "a right bracket shall lose its special meaning and\n" +
-      "represent itself in a bracket expression if it occurs\n" +
-      "first in the list.  -- POSIX.2 2.8.3.2"
-    , ["[]]", ["]"], null, ["]"]]
-    , ["[]-]", ["]"], null, ["]"]]
-    , ["[a-\z]", ["p"], null, ["p"]]
-    , ["??**********?****?", [], { null: true }, ["abc"]]
-    , ["??**********?****c", [], { null: true }, ["abc"]]
-    , ["?************c****?****", [], { null: true }, ["abc"]]
-    , ["*c*?**", [], { null: true }, ["abc"]]
-    , ["a*****c*?**", [], { null: true }, ["abc"]]
-    , ["a********???*******", [], { null: true }, ["abc"]]
-    , ["[]", [], { null: true }, ["a"]]
-    , ["[abc", [], { null: true }, ["["]]
-
-    , "nocase tests"
-    , ["XYZ", ["xYz"], { nocase: true, null: true }
-      , ["xYz", "ABC", "IjK"]]
-    , ["ab*", ["ABC"], { nocase: true, null: true }
-      , ["xYz", "ABC", "IjK"]]
-    , ["[ia]?[ck]", ["ABC", "IjK"], { nocase: true, null: true }
-      , ["xYz", "ABC", "IjK"]]
-
-    // [ pattern, [matches], MM opts, files, TAP opts]
-    , "onestar/twostar"
-    , ["{/*,*}", [], {null: true}, ["/asdf/asdf/asdf"]]
-    , ["{/?,*}", ["/a", "bb"], {null: true}
-      , ["/a", "/b/b", "/a/b/c", "bb"]]
-
-    , "dots should not match unless requested"
-    , ["**", ["a/b"], {}, ["a/b", "a/.d", ".a/.d"]]
-
-    // .. and . can only match patterns starting with .,
-    // even when options.dot is set.
-    , function () {
-        files = ["a/./b", "a/../b", "a/c/b", "a/.d/b"]
-      }
-    , ["a/*/b", ["a/c/b", "a/.d/b"], {dot: true}]
-    , ["a/.*/b", ["a/./b", "a/../b", "a/.d/b"], {dot: true}]
-    , ["a/*/b", ["a/c/b"], {dot:false}]
-    , ["a/.*/b", ["a/./b", "a/../b", "a/.d/b"], {dot: false}]
-
-
-    // this also tests that changing the options needs
-    // to change the cache key, even if the pattern is
-    // the same!
-    , ["**", ["a/b","a/.d",".a/.d"], { dot: true }
-      , [ ".a/.d", "a/.d", "a/b"]]
-
-    , "paren sets cannot contain slashes"
-    , ["*(a/b)", ["*(a/b)"], {nonull: true}, ["a/b"]]
-
-    // brace sets trump all else.
-    //
-    // invalid glob pattern.  fails on bash4 and bsdglob.
-    // however, in this implementation, it's easier just
-    // to do the intuitive thing, and let brace-expansion
-    // actually come before parsing any extglob patterns,
-    // like the documentation seems to say.
-    //
-    // XXX: if anyone complains about this, either fix it
-    // or tell them to grow up and stop complaining.
-    //
-    // bash/bsdglob says this:
-    // , ["*(a|{b),c)}", ["*(a|{b),c)}"], {}, ["a", "ab", "ac", "ad"]]
-    // but we do this instead:
-    , ["*(a|{b),c)}", ["a", "ab", "ac"], {}, ["a", "ab", "ac", "ad"]]
-
-    // test partial parsing in the presence of comment/negation chars
-    , ["[!a*", ["[!ab"], {}, ["[!ab", "[ab"]]
-    , ["[#a*", ["[#ab"], {}, ["[#ab", "[ab"]]
-
-    // like: {a,b|c\\,d\\\|e} except it's unclosed, so it has to be escaped.
-    , ["+(a|*\\|c\\\\|d\\\\\\|e\\\\\\\\|f\\\\\\\\\\|g"
-      , ["+(a|b\\|c\\\\|d\\\\|e\\\\\\\\|f\\\\\\\\|g"]
-      , {}
-      , ["+(a|b\\|c\\\\|d\\\\|e\\\\\\\\|f\\\\\\\\|g", "a", "b\\c"]]
-
-
-    // crazy nested {,,} and *(||) tests.
-    , function () {
-        files = [ "a", "b", "c", "d"
-                , "ab", "ac", "ad"
-                , "bc", "cb"
-                , "bc,d", "c,db", "c,d"
-                , "d)", "(b|c", "*(b|c"
-                , "b|c", "b|cc", "cb|c"
-                , "x(a|b|c)", "x(a|c)"
-                , "(a|b|c)", "(a|c)"]
-      }
-    , ["*(a|{b,c})", ["a", "b", "c", "ab", "ac"]]
-    , ["{a,*(b|c,d)}", ["a","(b|c", "*(b|c", "d)"]]
-    // a
-    // *(b|c)
-    // *(b|d)
-    , ["{a,*(b|{c,d})}", ["a","b", "bc", "cb", "c", "d"]]
-    , ["*(a|{b|c,c})", ["a", "b", "c", "ab", "ac", "bc", "cb"]]
-
-
-    // test various flag settings.
-    , [ "*(a|{b|c,c})", ["x(a|b|c)", "x(a|c)", "(a|b|c)", "(a|c)"]
-      , { noext: true } ]
-    , ["a?b", ["x/y/acb", "acb/"], {matchBase: true}
-      , ["x/y/acb", "acb/", "acb/d/e", "x/y/acb/d"] ]
-    , ["#*", ["#a", "#b"], {nocomment: true}, ["#a", "#b", "c#d"]]
-
-
-    // begin channelling Boole and deMorgan...
-    , "negation tests"
-    , function () {
-        files = ["d", "e", "!ab", "!abc", "a!b", "\\!a"]
-      }
-
-    // anything that is NOT a* matches.
-    , ["!a*", ["\\!a", "d", "e", "!ab", "!abc"]]
-
-    // anything that IS !a* matches.
-    , ["!a*", ["!ab", "!abc"], {nonegate: true}]
-
-    // anything that IS a* matches
-    , ["!!a*", ["a!b"]]
-
-    // anything that is NOT !a* matches
-    , ["!\\!a*", ["a!b", "d", "e", "\\!a"]]
-
-    // negation nestled within a pattern
-    , function () {
-        files = [ "foo.js"
-                , "foo.bar"
-                // can't match this one without negative lookbehind.
-                , "foo.js.js"
-                , "blar.js"
-                , "foo."
-                , "boo.js.boo" ]
-      }
-    , ["*.!(js)", ["foo.bar", "foo.", "boo.js.boo"] ]
-
-    // https://github.com/isaacs/minimatch/issues/5
-    , function () {
-        files = [ 'a/b/.x/c'
-                , 'a/b/.x/c/d'
-                , 'a/b/.x/c/d/e'
-                , 'a/b/.x'
-                , 'a/b/.x/'
-                , 'a/.x/b'
-                , '.x'
-                , '.x/'
-                , '.x/a'
-                , '.x/a/b'
-                , 'a/.x/b/.x/c'
-                , '.x/.x' ]
-    }
-    , ["**/.x/**", [ '.x/'
-                   , '.x/a'
-                   , '.x/a/b'
-                   , 'a/.x/b'
-                   , 'a/b/.x/'
-                   , 'a/b/.x/c'
-                   , 'a/b/.x/c/d'
-                   , 'a/b/.x/c/d/e' ] ]
-
-    ].forEach(function (c) {
-      if (typeof c === "function") return c()
-      if (typeof c === "string") return t.comment(c)
-
-      var pattern = c[0]
-        , expect = c[1].sort(alpha)
-        , options = c[2] || {}
-        , f = c[3] || files
-        , tapOpts = c[4] || {}
-
-      // options.debug = true
-      var m = new mm.Minimatch(pattern, options)
-      var r = m.makeRe()
-      tapOpts.re = String(r) || JSON.stringify(r)
-      tapOpts.files = JSON.stringify(f)
-      tapOpts.pattern = pattern
-      tapOpts.set = m.set
-      tapOpts.negated = m.negate
-
-      var actual = mm.match(f, pattern, options)
-      actual.sort(alpha)
-
-      t.equivalent( actual, expect
-                  , JSON.stringify(pattern) + " " + JSON.stringify(expect)
-                  , tapOpts )
-    })
+  patterns.forEach(function (c) {
+    if (typeof c === "function") return c()
+    if (typeof c === "string") return t.comment(c)
+
+    var pattern = c[0]
+      , expect = c[1].sort(alpha)
+      , options = c[2] || {}
+      , f = c[3] || files
+      , tapOpts = c[4] || {}
+
+    // options.debug = true
+    var m = new mm.Minimatch(pattern, options)
+    var r = m.makeRe()
+    var expectRe = regexps[re++]
+    tapOpts.re = String(r) || JSON.stringify(r)
+    tapOpts.files = JSON.stringify(f)
+    tapOpts.pattern = pattern
+    tapOpts.set = m.set
+    tapOpts.negated = m.negate
+
+    var actual = mm.match(f, pattern, options)
+    actual.sort(alpha)
+
+    t.equivalent( actual, expect
+                , JSON.stringify(pattern) + " " + JSON.stringify(expect)
+                , tapOpts )
+
+    t.equal(tapOpts.re, expectRe, tapOpts)
+  })
 
   t.comment("time=" + (Date.now() - start) + "ms")
   t.end()

package/test/extglob-ending-with-state-char.js

@@ -0,0 +1,8 @@
+var test = require('tap').test
+var minimatch = require('../')
+
+test('extglob ending with statechar', function(t) {
+  t.notOk(minimatch('ax', 'a?(b*)'))
+  t.ok(minimatch('ax', '?(a*|b)'))
+  t.end()
+})

package/.travis.yml

@@ -1,4 +0,0 @@
-language: node_js
-node_js:
-  - 0.4
-  - 0.6