the most correct and second fastest glob implementation in JavaScript

isaacs

glob

exports.childrenIgnored = childrenIgnored

  return Object.prototype.hasOwnProperty.call(obj, field)

var isAbsolute = require("path-is-absolute")

  return a.toLowerCase().localeCompare(b.toLowerCase())

    self.ignore = self.ignore.map(ignoreMap)

// ignore patterns are always in dot:true mode.

    var gpattern = pattern.replace(/(\/\*\*)+$/, '')

    gmatcher = new Minimatch(gpattern, { dot: true })

    matcher: new Minimatch(pattern, { dot: true }),

function setopts (self, pattern, options) {

  // base-matching: just use globstar for that.

  if (options.matchBase && -1 === pattern.indexOf("/")) {

      throw new Error("base matching requires globstar")

  self.realpathCache = options.realpathCache || Object.create(null)

  self.maxLength = options.maxLength || Infinity

  self.cache = options.cache || Object.create(null)

  self.statCache = options.statCache || Object.create(null)

  self.symlinks = options.symlinks || Object.create(null)

  self.root = options.root || path.resolve(self.cwd, "/")

    self.root = self.root.replace(/\\/g, "/")

  // TODO: is an absolute `cwd` supposed to be resolved against `root`?

  // e.g. { cwd: '/test', root: __dirname } === path.join(__dirname, '/test')

  self.cwdAbs = isAbsolute(self.cwd) ? self.cwd : makeAbs(self, self.cwd)

    self.cwdAbs = self.cwdAbs.replace(/\\/g, "/")

  // disable comments and negation in Minimatch.

  // Note that they are not supported in Glob itself anyway.

  self.minimatch = new Minimatch(pattern, options)

  var all = nou ? [] : Object.create(null)

  for (var i = 0, l = self.matches.length; i < l; i ++) {

    all = all.sort(self.nocase ? alphasorti : alphasort)

  // at *some* point we statted all of these

    for (var i = 0; i < all.length; i++) {

        var c = self.cache[e] || self.cache[makeAbs(self, e)]

          notDir = c !== 'DIR' && !Array.isArray(c)

    var isDir = c === 'DIR' || Array.isArray(c)

      self.statCache[mabs] = self.statCache[abs]

  } else if (isAbsolute(f) || f === '') {

// Return true, if pattern ends with globstar '**', for the accompanying parent directory.

// Ex:- If node_modules/** is the pattern, add 'node_modules' to ignore list along with it's contents

  return self.ignore.some(function(item) {

    return item.matcher.match(path) || !!(item.gmatcher && item.gmatcher.match(path))

    return !!(item.gmatcher && item.gmatcher.match(path))

// 2. For each pattern in the set, PROCESS(pattern, false)

// 3. Store matches per-set, then uniq them

// Get the first [n] items from pattern that are all strings

//   If there is no more remaining, then stat(PREFIX) and

//   add to matches if it succeeds.  END.

// If inGlobStar and PREFIX is symlink and points to dir

//     // handle the case where the globstar match is empty

//     // by pruning it out, and testing the resulting pattern

//     PROCESS(pattern[0..n] + pattern[n+1 .. $], false)

//     for ENTRY in ENTRIES (not dotfiles)

//       // attach globstar + tail onto the entry

//       // Mark that this entry is a globstar match

//       PROCESS(pattern[0..n] + ENTRY + pattern[n .. $], true)

//     for ENTRY in ENTRIES (not dotfiles, unless pattern[n] is dot)

//       If passes, PROCESS(pattern[0..n] + item + pattern[n+1 .. $])

//   Cache all stats and readdirs results to minimize syscall.  Since all

//   we ever care about is existence and directory-ness, we can just keep

//   `true` for files, and [children,...] for directories, or `false` for

var isAbsolute = require('path-is-absolute')

var childrenIgnored = common.childrenIgnored

  if (typeof options === 'function') cb = options, options = {}

      throw new TypeError('callback provided to sync glob')

var GlobSync = glob.GlobSync = globSync.GlobSync

  if (add === null || typeof add !== 'object') {

glob.hasMagic = function (pattern, options_) {

  for (var j = 0; j < set[0].length; j++) {

    return new GlobSync(pattern, options)

    return new Glob(pattern, options, cb)

  // process each pattern in the minimatch set

  // The matches are stored as {<filename>: true,...} so that

  // duplicates are automagically pruned.

  // Later, we do an Object.keys() on these.

  // Keep them as a list so we can fill in when nonull is set.

  "author": "Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me/)",

    "url": "git://github.com/isaacs/node-glob.git"

    "profclean": "rm -f v8.log profile.txt",

    "test-regen": "npm run profclean && TEST_REGEN=1 node test/00-setup.js",

    "prof": "bash prof.sh && cat profile.txt",

    "url": "https://github.com/sponsors/isaacs"

Match files using the patterns the shell uses, like stars and stuff.

[![Build Status](https://travis-ci.org/isaacs/node-glob.svg?branch=master)](https://travis-ci.org/isaacs/node-glob/) [![Build Status](https://ci.appveyor.com/api/projects/status/kd7f3yftf7unxlsx?svg=true)](https://ci.appveyor.com/project/isaacs/node-glob) [![Coverage Status](https://coveralls.io/repos/isaacs/node-glob/badge.svg?branch=master&service=github)](https://coveralls.io/github/isaacs/node-glob?branch=master)

This is a glob implementation in JavaScript.  It uses the `minimatch`

![a fun cartoon logo made of glob characters](logo/glob.png)

glob("**/*.js", options, function (er, files) {

  // If the `nonull` option is set, and nothing

  // was found, then files is ["**/*.js"]

"Globs" are the patterns you type when you do stuff like `ls *.js` on

the command line, or put `build/*` in a `.gitignore` file.

Before parsing the path part patterns, braced sections are expanded

into a set.  Braced sections start with `{` and end with `}`, with any

number of comma-delimited sections within.  Braced sections may contain

slash characters, so `a{/b/c,bcd}` would expand into `a/b/c` and `abcd`.

The following characters have special magic meaning when used in a

* `*` Matches 0 or more characters in a single path portion

* `[...]` Matches a range of characters, similar to a RegExp range.

  If the first character of the range is `!` or `^` then it matches

* `!(pattern|pattern|pattern)` Matches anything that does not match

* `?(pattern|pattern|pattern)` Matches zero or one occurrence of the

* `+(pattern|pattern|pattern)` Matches one or more occurrences of the

* `*(a|b|c)` Matches zero or more occurrences of the patterns provided

* `@(pattern|pat*|pat?erN)` Matches exactly one of the patterns

* `**` If a "globstar" is alone in a path portion, then it matches

  zero or more directories and subdirectories searching for matches.

  It does not crawl symlinked directories.

If a file or directory path portion has a `.` as the first character,

then it will not match any glob pattern unless that pattern's

corresponding path part also has a `.` as its first character.

For example, the pattern `a/.*/c` would match the file at `a/.b/c`.

However the pattern `a/*/c` would not, because `*` does not start with

You can make glob treat dots as normal characters by setting

If you set `matchBase:true` in the options, and the pattern has no

slashes in it, then it will seek for any file anywhere in the tree

with a matching basename.  For example, `*.js` would match

If no matching files are found, then an empty array is returned.  This

differs from the shell, where the pattern itself is returned.  For

To get the bash-style behavior, set the `nonull:true` in the options.

* `man bash` (Search for "Pattern Matching")

* [minimatch documentation](https://github.com/isaacs/minimatch)

Returns `true` if there are any special characters in the pattern, and

Note that the options affect the results.  If `noext:true` is set in

the options object, then `+(a|b)` will not be considered a magic

pattern.  If the pattern has a brace expansion, like `a/{b/c,x/y}`

then that is considered magical, unless `nobrace:true` is set in the

  if (typeof options === 'function' || arguments.length === 3)

    throw new TypeError('callback provided to sync glob\n'+

                        'See: https://github.com/isaacs/node-glob/issues/167')

  return new GlobSync(pattern, options).found

    throw new Error('must provide pattern')

    this._process(this.minimatch.set[i], i, false)

GlobSync.prototype._finish = function () {

    this.matches.forEach(function (matchset, index) {

      var set = self.matches[index] = Object.create(null)

          var real = rp.realpathSync(p, self.realpathCache)

GlobSync.prototype._process = function (pattern, index, inGlobStar) {

  // Get the first [n] parts of pattern that are all strings.

  while (typeof pattern[n] === 'string') {

  // now n is the index of the first one that is *not* a string.

    // if not, then this is rather simple

      this._processSimple(pattern.join('/'), index)

      // pattern *starts* with some non-trivial item.

      // going to readdir(cwd), but not include the prefix in matches.

      // pattern has some string bits in the front.

      // whatever it starts with, whether that's 'absolute' like /foo/bar,

      prefix = pattern.slice(0, n).join('/')

  else if (isAbsolute(prefix) || isAbsolute(pattern.join('/'))) {

		@@ -1,3 +0,1 @@
		exports.alphasort = alphasort
		exports.alphasorti = alphasorti
		exports.setopts = setopts
		@@ -20,8 +18,4 @@ exports.ownProp = ownProp

		function alphasorti (a, b) {
		return a.toLowerCase().localeCompare(b.toLowerCase())
		}

		function alphasort (a, b) {
		return a.localeCompare(b)
		return a.localeCompare(b, 'en')
		}
		@@ -154,3 +148,3 @@
		if (!self.nosort)
		all = all.sort(self.nocase ? alphasorti : alphasort)
		all = all.sort(alphasort)

		@@ -157,0 +151,0 @@ // at some point we statted all of these

		@@ -54,4 +54,2 @@ // Approach:
		var common = require('./common.js')
		var alphasort = common.alphasort
		var alphasorti = common.alphasorti
		var setopts = common.setopts
		@@ -58,0 +56,0 @@ var ownProp = common.ownProp

		@@ -5,3 +5,3 @@ {
		"description": "a little globber",
		"version": "7.1.6",
		"version": "7.1.7",
		"repository": {
		@@ -31,9 +31,14 @@ "type": "git",
		"rimraf": "^2.2.8",
		"tap": "^12.0.1",
		"tap": "^15.0.6",
		"tick": "0.0.6"
		},
		"tap": {
		"before": "test/00-setup.js",
		"after": "test/zz-cleanup.js",
		"jobs": 1
		},
		"scripts": {
		"prepublish": "npm run benchclean",
		"profclean": "rm -f v8.log profile.txt",
		"test": "tap test/*.js --cov",
		"test": "tap",
		"test-regen": "npm run profclean && TEST_REGEN=1 node test/00-setup.js",
		@@ -40,0 +45,0 @@ "bench": "bash benchmark.sh",

		@@ -10,3 +10,3 @@ # Glob

		![](logo/glob.png)
		![a fun cartoon logo made of glob characters](logo/glob.png)

		@@ -13,0 +13,0 @@ ## Usage

		@@ -14,4 +14,2 @@ module.exports = globSync
		var common = require('./common.js')
		var alphasort = common.alphasort
		var alphasorti = common.alphasorti
		var setopts = common.setopts
		@@ -18,0 +16,0 @@ var ownProp = common.ownProp

Worsened metrics