Added logging, changed some directory structure

goTorrentWebUI/node_modules/react-scripts/node_modules/recursive-readdir/.npmignore

@@ -0,0 +1,2 @@
+node_modules
+.DS_Store

goTorrentWebUI/node_modules/react-scripts/node_modules/recursive-readdir/.travis.yml

@@ -0,0 +1,15 @@
+language: node_js
+node_js:
+  - "node"
+  - "6"
+  - "5"
+  - "4"
+  - "4.4"
+  - "4.3"
+  - "4.2"
+  - "4.1"
+  - "4.0"
+  - "iojs"
+  - "0.12"
+  - "0.11"
+  - "0.10"

goTorrentWebUI/node_modules/react-scripts/node_modules/recursive-readdir/CHANGELOG.md

@@ -0,0 +1,24 @@
+v2.1.0 - Mon, 19 Sep 2016 21:55:22 GMT
+--------------------------------------
+
+- 
+
+
+v2.0.0 - Wed, 06 Apr 2016 04:31:02 GMT
+--------------------------------------
+
+- 
+
+
+v1.3.0 - Wed, 14 Oct 2015 14:35:55 GMT
+--------------------------------------
+
+- [45abf8fde380d7b1f5dc0e798d435ed50b834d9c](../../commit/45abf8fde380d7b1f5dc0e798d435ed50b834d9c) [added] added custom matcher function to determine whether to ignore a file
+- [eebc91c67abce413d6213e8f389ba4e0d32ffb63](../../commit/eebc91c67abce413d6213e8f389ba4e0d32ffb63) [fixed] allow ignoring directories
+
+v1.2.1 - Wed, 14 Jan 2015 16:49:55 GMT
+--------------------------------------
+
+- 
+
+

goTorrentWebUI/node_modules/react-scripts/node_modules/recursive-readdir/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) <year> <copyright holders>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

goTorrentWebUI/node_modules/react-scripts/node_modules/recursive-readdir/README.md

@@ -0,0 +1,69 @@
+# recursive-readdir
+
+[![Build Status](https://travis-ci.org/jergason/recursive-readdir.svg?branch=master)](https://travis-ci.org/jergason/recursive-readdir)
+
+Recursively list all files in a directory and its subdirectories. It does not list the directories themselves.
+
+Because it uses fs.readdir, which calls [readdir](http://linux.die.net/man/3/readdir) under the hood
+on OS X and Linux, the order of files inside directories is [not guaranteed](http://stackoverflow.com/questions/8977441/does-readdir-guarantee-an-order).
+
+## Installation
+
+    npm install recursive-readdir
+
+## Usage
+
+```javascript
+var recursive = require("recursive-readdir");
+
+recursive("some/path", function (err, files) {
+  // `files` is an array of absolute file paths
+  console.log(files);
+});
+```
+
+It can also take a list of files to ignore.
+
+```javascript
+var recursive = require("recursive-readdir");
+
+// ignore files named "foo.cs" or files that end in ".html".
+recursive("some/path", ["foo.cs", "*.html"], function (err, files) {
+  console.log(files);
+});
+```
+
+You can also pass functions which are called to determine whether or not to
+ignore a file:
+
+```javascript
+var recursive = require("recursive-readdir");
+
+function ignoreFunc(file, stats) {
+  // `file` is the absolute path to the file, and `stats` is an `fs.Stats`
+  // object returned from `fs.lstat()`.
+  return stats.isDirectory() && path.basename(file) == "test";
+}
+
+// Ignore files named "foo.cs" and descendants of directories named test
+recursive("some/path", ["foo.cs", ignoreFunc], function (err, files) {
+  console.log(files);
+});
+```
+
+## Promises
+You can omit the callback and return a promise instead.
+
+```javascript
+readdir("some/path").then(
+  function(files) {
+    console.log("files are", files);
+  },
+  function(error) {
+    console.error("something exploded", error);
+  }
+);
+```
+
+The ignore strings support Glob syntax via
+[minimatch](https://github.com/isaacs/minimatch).

goTorrentWebUI/node_modules/react-scripts/node_modules/recursive-readdir/index.js

@@ -0,0 +1,96 @@
+var fs = require("fs");
+var p = require("path");
+var minimatch = require("minimatch");
+
+function patternMatcher(pattern) {
+  return function(path, stats) {
+    var minimatcher = new minimatch.Minimatch(pattern, { matchBase: true });
+    return (!minimatcher.negate || stats.isFile()) && minimatcher.match(path);
+  };
+}
+
+function toMatcherFunction(ignoreEntry) {
+  if (typeof ignoreEntry == "function") {
+    return ignoreEntry;
+  } else {
+    return patternMatcher(ignoreEntry);
+  }
+}
+
+function readdir(path, ignores, callback) {
+  if (typeof ignores == "function") {
+    callback = ignores;
+    ignores = [];
+  }
+
+  if (!callback) {
+    return new Promise(function(resolve, reject) {
+      readdir(path, ignores || [], function(err, data) {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(data);
+        }
+      });
+    });
+  }
+
+  ignores = ignores.map(toMatcherFunction);
+
+  var list = [];
+
+  fs.readdir(path, function(err, files) {
+    if (err) {
+      return callback(err);
+    }
+
+    var pending = files.length;
+    if (!pending) {
+      // we are done, woop woop
+      return callback(null, list);
+    }
+
+    files.forEach(function(file) {
+      var filePath = p.join(path, file);
+      fs.stat(filePath, function(_err, stats) {
+        if (_err) {
+          return callback(_err);
+        }
+
+        if (
+          ignores.some(function(matcher) {
+            return matcher(filePath, stats);
+          })
+        ) {
+          pending -= 1;
+          if (!pending) {
+            return callback(null, list);
+          }
+          return null;
+        }
+
+        if (stats.isDirectory()) {
+          readdir(filePath, ignores, function(__err, res) {
+            if (__err) {
+              return callback(__err);
+            }
+
+            list = list.concat(res);
+            pending -= 1;
+            if (!pending) {
+              return callback(null, list);
+            }
+          });
+        } else {
+          list.push(filePath);
+          pending -= 1;
+          if (!pending) {
+            return callback(null, list);
+          }
+        }
+      });
+    });
+  });
+}
+
+module.exports = readdir;

goTorrentWebUI/node_modules/react-scripts/node_modules/recursive-readdir/node_modules/minimatch/LICENSE

@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

goTorrentWebUI/node_modules/react-scripts/node_modules/recursive-readdir/node_modules/minimatch/README.md

@@ -0,0 +1,209 @@
+# minimatch
+
+A minimal matching utility.
+
+[![Build Status](https://secure.travis-ci.org/isaacs/minimatch.svg)](http://travis-ci.org/isaacs/minimatch)
+
+
+This is the matching library used internally by npm.
+
+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 instantiating 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.
+
+### 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 if this option is set.  When not 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.

goTorrentWebUI/node_modules/react-scripts/node_modules/recursive-readdir/node_modules/minimatch/minimatch.js

@@ -0,0 +1,923 @@
+module.exports = minimatch
+minimatch.Minimatch = Minimatch
+
+var path = { sep: '/' }
+try {
+  path = require('path')
+} catch (er) {}
+
+var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {}
+var expand = require('brace-expansion')
+
+var plTypes = {
+  '!': { open: '(?:(?!(?:', close: '))[^/]*?)'},
+  '?': { open: '(?:', close: ')?' },
+  '+': { open: '(?:', close: ')+' },
+  '*': { open: '(?:', close: ')*' },
+  '@': { open: '(?:', close: ')' }
+}
+
+// any single thing other than /
+// don't need to escape / when using new RegExp()
+var qmark = '[^/]'
+
+// * => any number of characters
+var star = qmark + '*?'
+
+// ** when dots are allowed.  Anything goes, except .. and .
+// not (^ or / followed by one or two dots followed by $ or /),
+// followed by anything, any number of times.
+var twoStarDot = '(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?'
+
+// not a ^ or / followed by a dot,
+// followed by anything, any number of times.
+var twoStarNoDot = '(?:(?!(?:\\\/|^)\\.).)*?'
+
+// characters that need to be escaped in RegExp.
+var reSpecials = charSet('().*{}+?[]^$\\!')
+
+// "abc" -> { a:true, b:true, c:true }
+function charSet (s) {
+  return s.split('').reduce(function (set, c) {
+    set[c] = true
+    return set
+  }, {})
+}
+
+// normalizes slashes.
+var slashSplit = /\/+/
+
+minimatch.filter = filter
+function filter (pattern, options) {
+  options = options || {}
+  return function (p, i, list) {
+    return minimatch(p, pattern, options)
+  }
+}
+
+function ext (a, b) {
+  a = a || {}
+  b = b || {}
+  var t = {}
+  Object.keys(b).forEach(function (k) {
+    t[k] = b[k]
+  })
+  Object.keys(a).forEach(function (k) {
+    t[k] = a[k]
+  })
+  return t
+}
+
+minimatch.defaults = function (def) {
+  if (!def || !Object.keys(def).length) return minimatch
+
+  var orig = minimatch
+
+  var m = function minimatch (p, pattern, options) {
+    return orig.minimatch(p, pattern, ext(def, options))
+  }
+
+  m.Minimatch = function Minimatch (pattern, options) {
+    return new orig.Minimatch(pattern, ext(def, options))
+  }
+
+  return m
+}
+
+Minimatch.defaults = function (def) {
+  if (!def || !Object.keys(def).length) return Minimatch
+  return minimatch.defaults(def).Minimatch
+}
+
+function minimatch (p, pattern, options) {
+  if (typeof pattern !== 'string') {
+    throw new TypeError('glob pattern string required')
+  }
+
+  if (!options) options = {}
+
+  // shortcut: comments match nothing.
+  if (!options.nocomment && pattern.charAt(0) === '#') {
+    return false
+  }
+
+  // "" only matches ""
+  if (pattern.trim() === '') return p === ''
+
+  return new Minimatch(pattern, options).match(p)
+}
+
+function Minimatch (pattern, options) {
+  if (!(this instanceof Minimatch)) {
+    return new Minimatch(pattern, options)
+  }
+
+  if (typeof pattern !== 'string') {
+    throw new TypeError('glob pattern string required')
+  }
+
+  if (!options) options = {}
+  pattern = pattern.trim()
+
+  // windows support: need to use /, not \
+  if (path.sep !== '/') {
+    pattern = pattern.split(path.sep).join('/')
+  }
+
+  this.options = options
+  this.set = []
+  this.pattern = pattern
+  this.regexp = null
+  this.negate = false
+  this.comment = false
+  this.empty = false
+
+  // make the set of regexps etc.
+  this.make()
+}
+
+Minimatch.prototype.debug = function () {}
+
+Minimatch.prototype.make = make
+function make () {
+  // don't do it more than once.
+  if (this._made) return
+
+  var pattern = this.pattern
+  var options = this.options
+
+  // empty patterns and comments match nothing.
+  if (!options.nocomment && pattern.charAt(0) === '#') {
+    this.comment = true
+    return
+  }
+  if (!pattern) {
+    this.empty = true
+    return
+  }
+
+  // step 1: figure out negation, etc.
+  this.parseNegate()
+
+  // step 2: expand braces
+  var set = this.globSet = this.braceExpand()
+
+  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.
+  // These will be regexps, except in the case of "**", which is
+  // set to the GLOBSTAR object for globstar behavior,
+  // and will not contain any / characters
+  set = this.globParts = set.map(function (s) {
+    return s.split(slashSplit)
+  })
+
+  this.debug(this.pattern, set)
+
+  // glob --> regexps
+  set = set.map(function (s, si, set) {
+    return s.map(this.parse, this)
+  }, this)
+
+  this.debug(this.pattern, set)
+
+  // filter out everything that didn't compile properly.
+  set = set.filter(function (s) {
+    return s.indexOf(false) === -1
+  })
+
+  this.debug(this.pattern, set)
+
+  this.set = set
+}
+
+Minimatch.prototype.parseNegate = parseNegate
+function parseNegate () {
+  var pattern = this.pattern
+  var negate = false
+  var options = this.options
+  var negateOffset = 0
+
+  if (options.nonegate) return
+
+  for (var i = 0, l = pattern.length
+    ; i < l && pattern.charAt(i) === '!'
+    ; i++) {
+    negate = !negate
+    negateOffset++
+  }
+
+  if (negateOffset) this.pattern = pattern.substr(negateOffset)
+  this.negate = negate
+}
+
+// Brace expansion:
+// a{b,c}d -> abd acd
+// a{b,}c -> abc ac
+// a{0..3}d -> a0d a1d a2d a3d
+// a{b,c{d,e}f}g -> abg acdfg acefg
+// a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg
+//
+// Invalid sets are not expanded.
+// a{2..}b -> a{2..}b
+// a{b}c -> a{b}c
+minimatch.braceExpand = function (pattern, options) {
+  return braceExpand(pattern, options)
+}
+
+Minimatch.prototype.braceExpand = braceExpand
+
+function braceExpand (pattern, options) {
+  if (!options) {
+    if (this instanceof Minimatch) {
+      options = this.options
+    } else {
+      options = {}
+    }
+  }
+
+  pattern = typeof pattern === 'undefined'
+    ? this.pattern : pattern
+
+  if (typeof pattern === 'undefined') {
+    throw new TypeError('undefined pattern')
+  }
+
+  if (options.nobrace ||
+    !pattern.match(/\{.*\}/)) {
+    // shortcut. no need to expand.
+    return [pattern]
+  }
+
+  return expand(pattern)
+}
+
+// parse a component of the expanded set.
+// At this point, no pattern may contain "/" in it
+// so we're going to return a 2d array, where each entry is the full
+// pattern, split on '/', and then turned into a regular expression.
+// A regexp is made at the end which joins each array with an
+// escaped /, and another full one which joins each regexp with |.
+//
+// Following the lead of Bash 4.1, note that "**" only has special meaning
+// when it is the *only* thing in a path portion.  Otherwise, any series
+// of * is equivalent to a single *.  Globstar behavior is enabled by
+// default, and can be disabled by setting options.noglobstar.
+Minimatch.prototype.parse = parse
+var SUBPARSE = {}
+function parse (pattern, isSub) {
+  if (pattern.length > 1024 * 64) {
+    throw new TypeError('pattern is too long')
+  }
+
+  var options = this.options
+
+  // shortcuts
+  if (!options.noglobstar && pattern === '**') return GLOBSTAR
+  if (pattern === '') return ''
+
+  var re = ''
+  var hasMagic = !!options.nocase
+  var escaping = false
+  // ? => one single character
+  var patternListStack = []
+  var negativeLists = []
+  var stateChar
+  var inClass = false
+  var reClassStart = -1
+  var classStart = -1
+  // . and .. never match anything that doesn't start with .,
+  // even when options.dot is set.
+  var patternStart = pattern.charAt(0) === '.' ? '' // anything
+  // not (start or / followed by . or .. followed by / or end)
+  : options.dot ? '(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))'
+  : '(?!\\.)'
+  var self = this
+
+  function clearStateChar () {
+    if (stateChar) {
+      // we had some state-tracking character
+      // that wasn't consumed by this pass.
+      switch (stateChar) {
+        case '*':
+          re += star
+          hasMagic = true
+        break
+        case '?':
+          re += qmark
+          hasMagic = true
+        break
+        default:
+          re += '\\' + stateChar
+        break
+      }
+      self.debug('clearStateChar %j %j', stateChar, re)
+      stateChar = false
+    }
+  }
+
+  for (var i = 0, len = pattern.length, c
+    ; (i < len) && (c = pattern.charAt(i))
+    ; i++) {
+    this.debug('%s\t%s %s %j', pattern, i, re, c)
+
+    // skip over any that are escaped.
+    if (escaping && reSpecials[c]) {
+      re += '\\' + c
+      escaping = false
+      continue
+    }
+
+    switch (c) {
+      case '/':
+        // completely not allowed, even escaped.
+        // Should already be path-split by now.
+        return false
+
+      case '\\':
+        clearStateChar()
+        escaping = true
+      continue
+
+      // the various stateChar values
+      // for the "extglob" stuff.
+      case '?':
+      case '*':
+      case '+':
+      case '@':
+      case '!':
+        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
+        }
+
+        // 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.
+        // just clear the statechar *now*, rather than even diving into
+        // the patternList stuff.
+        if (options.noext) clearStateChar()
+      continue
+
+      case '(':
+        if (inClass) {
+          re += '('
+          continue
+        }
+
+        if (!stateChar) {
+          re += '\\('
+          continue
+        }
+
+        patternListStack.push({
+          type: stateChar,
+          start: i - 1,
+          reStart: re.length,
+          open: plTypes[stateChar].open,
+          close: plTypes[stateChar].close
+        })
+        // negation is (?:(?!js)[^/]*)
+        re += stateChar === '!' ? '(?:(?!(?:' : '(?:'
+        this.debug('plType %j %j', stateChar, re)
+        stateChar = false
+      continue
+
+      case ')':
+        if (inClass || !patternListStack.length) {
+          re += '\\)'
+          continue
+        }
+
+        clearStateChar()
+        hasMagic = true
+        var pl = patternListStack.pop()
+        // negation is (?:(?!js)[^/]*)
+        // The others are (?:<pattern>)<type>
+        re += pl.close
+        if (pl.type === '!') {
+          negativeLists.push(pl)
+        }
+        pl.reEnd = re.length
+      continue
+
+      case '|':
+        if (inClass || !patternListStack.length || escaping) {
+          re += '\\|'
+          escaping = false
+          continue
+        }
+
+        clearStateChar()
+        re += '|'
+      continue
+
+      // these are mostly the same in regexp and glob
+      case '[':
+        // swallow any state-tracking char before the [
+        clearStateChar()
+
+        if (inClass) {
+          re += '\\' + c
+          continue
+        }
+
+        inClass = true
+        classStart = i
+        reClassStart = re.length
+        re += c
+      continue
+
+      case ']':
+        //  a right bracket shall lose its special
+        //  meaning and represent itself in
+        //  a bracket expression if it occurs
+        //  first in the list.  -- POSIX.2 2.8.3.2
+        if (i === classStart + 1 || !inClass) {
+          re += '\\' + c
+          escaping = false
+          continue
+        }
+
+        // handle the case where we left a class open.
+        // "[z-a]" is valid, equivalent to "\[z-a\]"
+        if (inClass) {
+          // split where the last [ was, make sure we don't have
+          // an invalid re. if so, re-walk the contents of the
+          // would-be class to re-translate any characters that
+          // were passed through as-is
+          // TODO: It would probably be faster to determine this
+          // without a try/catch and a new RegExp, but it's tricky
+          // to do safely.  For now, this is safe and works.
+          var cs = pattern.substring(classStart + 1, i)
+          try {
+            RegExp('[' + cs + ']')
+          } catch (er) {
+            // not a valid class!
+            var sp = this.parse(cs, SUBPARSE)
+            re = re.substr(0, reClassStart) + '\\[' + sp[0] + '\\]'
+            hasMagic = hasMagic || sp[1]
+            inClass = false
+            continue
+          }
+        }
+
+        // finish up the class.
+        hasMagic = true
+        inClass = false
+        re += c
+      continue
+
+      default:
+        // swallow any state char that wasn't consumed
+        clearStateChar()
+
+        if (escaping) {
+          // no need
+          escaping = false
+        } else if (reSpecials[c]
+          && !(c === '^' && inClass)) {
+          re += '\\'
+        }
+
+        re += c
+
+    } // switch
+  } // for
+
+  // handle the case where we left a class open.
+  // "[abc" is valid, equivalent to "\[abc"
+  if (inClass) {
+    // split where the last [ was, and escape it
+    // this is a huge pita.  We now have to re-walk
+    // the contents of the would-be class to re-translate
+    // any characters that were passed through as-is
+    cs = pattern.substr(classStart + 1)
+    sp = this.parse(cs, SUBPARSE)
+    re = re.substr(0, reClassStart) + '\\[' + sp[0]
+    hasMagic = hasMagic || sp[1]
+  }
+
+  // handle the case where we had a +( thing at the *end*
+  // of the pattern.
+  // each pattern list stack adds 3 chars, and we need to go through
+  // and escape any | chars that were passed through as-is for the regexp.
+  // Go through and escape them, taking care not to double-escape any
+  // | chars that were already escaped.
+  for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {
+    var tail = re.slice(pl.reStart + pl.open.length)
+    this.debug('setting tail', re, pl)
+    // maybe some even number of \, then maybe 1 \, followed by a |
+    tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, function (_, $1, $2) {
+      if (!$2) {
+        // the | isn't already escaped, so escape it.
+        $2 = '\\'
+      }
+
+      // need to escape all those slashes *again*, without escaping the
+      // one that we need for escaping the | character.  As it works out,
+      // escaping an even number of slashes can be done by simply repeating
+      // it exactly after itself.  That's why this trick works.
+      //
+      // I am sorry that you have to see this.
+      return $1 + $1 + $2 + '|'
+    })
+
+    this.debug('tail=%j\n   %s', tail, tail, pl, re)
+    var t = pl.type === '*' ? star
+      : pl.type === '?' ? qmark
+      : '\\' + pl.type
+
+    hasMagic = true
+    re = re.slice(0, pl.reStart) + t + '\\(' + tail
+  }
+
+  // handle trailing things that only matter at the very end.
+  clearStateChar()
+  if (escaping) {
+    // trailing \\
+    re += '\\\\'
+  }
+
+  // only need to apply the nodot start if the re starts with
+  // something that could conceivably capture a dot
+  var addPatternStart = false
+  switch (re.charAt(0)) {
+    case '.':
+    case '[':
+    case '(': addPatternStart = true
+  }
+
+  // Hack to work around lack of negative lookbehind in JS
+  // A pattern like: *.!(x).!(y|z) needs to ensure that a name
+  // like 'a.xyz.yz' doesn't match.  So, the first negative
+  // lookahead, has to look ALL the way ahead, to the end of
+  // the pattern.
+  for (var n = negativeLists.length - 1; n > -1; n--) {
+    var nl = negativeLists[n]
+
+    var nlBefore = re.slice(0, nl.reStart)
+    var nlFirst = re.slice(nl.reStart, nl.reEnd - 8)
+    var nlLast = re.slice(nl.reEnd - 8, nl.reEnd)
+    var nlAfter = re.slice(nl.reEnd)
+
+    nlLast += nlAfter
+
+    // Handle nested stuff like *(*.js|!(*.json)), where open parens
+    // mean that we should *not* include the ) in the bit that is considered
+    // "after" the negated section.
+    var openParensBefore = nlBefore.split('(').length - 1
+    var cleanAfter = nlAfter
+    for (i = 0; i < openParensBefore; i++) {
+      cleanAfter = cleanAfter.replace(/\)[+*?]?/, '')
+    }
+    nlAfter = cleanAfter
+
+    var dollar = ''
+    if (nlAfter === '' && isSub !== SUBPARSE) {
+      dollar = '$'
+    }
+    var newRe = nlBefore + nlFirst + nlAfter + dollar + nlLast
+    re = newRe
+  }
+
+  // if the re is not "" at this point, then we need to make sure
+  // it doesn't match against an empty path part.
+  // Otherwise a/* will match a/, which it should not.
+  if (re !== '' && hasMagic) {
+    re = '(?=.)' + re
+  }
+
+  if (addPatternStart) {
+    re = patternStart + re
+  }
+
+  // parsing just a piece of a larger pattern.
+  if (isSub === SUBPARSE) {
+    return [re, hasMagic]
+  }
+
+  // skip the regexp for non-magical patterns
+  // unescape anything in it, though, so that it'll be
+  // an exact match against a file etc.
+  if (!hasMagic) {
+    return globUnescape(pattern)
+  }
+
+  var flags = options.nocase ? 'i' : ''
+  try {
+    var regExp = new RegExp('^' + re + '$', flags)
+  } catch (er) {
+    // If it was an invalid regular expression, then it can't match
+    // anything.  This trick looks for a character after the end of
+    // the string, which is of course impossible, except in multi-line
+    // mode, but it's not a /m regex.
+    return new RegExp('$.')
+  }
+
+  regExp._glob = pattern
+  regExp._src = re
+
+  return regExp
+}
+
+minimatch.makeRe = function (pattern, options) {
+  return new Minimatch(pattern, options || {}).makeRe()
+}
+
+Minimatch.prototype.makeRe = makeRe
+function makeRe () {
+  if (this.regexp || this.regexp === false) return this.regexp
+
+  // at this point, this.set is a 2d array of partial
+  // pattern strings, or "**".
+  //
+  // It's better to use .match().  This function shouldn't
+  // be used, really, but it's pretty convenient sometimes,
+  // when you just want to work with a regex.
+  var set = this.set
+
+  if (!set.length) {
+    this.regexp = false
+    return this.regexp
+  }
+  var options = this.options
+
+  var twoStar = options.noglobstar ? star
+    : options.dot ? twoStarDot
+    : twoStarNoDot
+  var flags = options.nocase ? 'i' : ''
+
+  var re = set.map(function (pattern) {
+    return pattern.map(function (p) {
+      return (p === GLOBSTAR) ? twoStar
+      : (typeof p === 'string') ? regExpEscape(p)
+      : p._src
+    }).join('\\\/')
+  }).join('|')
+
+  // must match entire pattern
+  // ending in a * or ** will make it less strict.
+  re = '^(?:' + re + ')$'
+
+  // can match anything, as long as it's not this.
+  if (this.negate) re = '^(?!' + re + ').*$'
+
+  try {
+    this.regexp = new RegExp(re, flags)
+  } catch (ex) {
+    this.regexp = false
+  }
+  return this.regexp
+}
+
+minimatch.match = function (list, pattern, options) {
+  options = options || {}
+  var mm = new Minimatch(pattern, options)
+  list = list.filter(function (f) {
+    return mm.match(f)
+  })
+  if (mm.options.nonull && !list.length) {
+    list.push(pattern)
+  }
+  return list
+}
+
+Minimatch.prototype.match = match
+function match (f, partial) {
+  this.debug('match', f, this.pattern)
+  // short-circuit in the case of busted things.
+  // comments, etc.
+  if (this.comment) return false
+  if (this.empty) return f === ''
+
+  if (f === '/' && partial) return true
+
+  var options = this.options
+
+  // windows: need to use /, not \
+  if (path.sep !== '/') {
+    f = f.split(path.sep).join('/')
+  }
+
+  // treat the test path as a set of pathparts.
+  f = f.split(slashSplit)
+  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
+  // match means that we have failed.
+  // Either way, return on the first hit.
+
+  var set = this.set
+  this.debug(this.pattern, 'set', set)
+
+  // Find the basename of the path by looking for the last non-empty segment
+  var filename
+  var i
+  for (i = f.length - 1; i >= 0; i--) {
+    filename = f[i]
+    if (filename) break
+  }
+
+  for (i = 0; i < set.length; i++) {
+    var pattern = set[i]
+    var file = f
+    if (options.matchBase && pattern.length === 1) {
+      file = [filename]
+    }
+    var hit = this.matchOne(file, pattern, partial)
+    if (hit) {
+      if (options.flipNegate) return true
+      return !this.negate
+    }
+  }
+
+  // didn't get any hits.  this is success if it's a negative
+  // pattern, failure otherwise.
+  if (options.flipNegate) return false
+  return this.negate
+}
+
+// set partial to true to test if, for example,
+// "/a/b" matches the start of "/*/b/*/d"
+// Partial means, if you run out of file before you run
+// out of pattern, then that's fine, as long as all
+// the parts match.
+Minimatch.prototype.matchOne = function (file, pattern, partial) {
+  var options = this.options
+
+  this.debug('matchOne',
+    { 'this': this, file: file, pattern: pattern })
+
+  this.debug('matchOne', file.length, pattern.length)
+
+  for (var fi = 0,
+      pi = 0,
+      fl = file.length,
+      pl = pattern.length
+      ; (fi < fl) && (pi < pl)
+      ; fi++, pi++) {
+    this.debug('matchOne loop')
+    var p = pattern[pi]
+    var f = file[fi]
+
+    this.debug(pattern, p, f)
+
+    // should be impossible.
+    // some invalid regexp stuff in the set.
+    if (p === false) return false
+
+    if (p === GLOBSTAR) {
+      this.debug('GLOBSTAR', [pattern, p, f])
+
+      // "**"
+      // a/**/b/**/c would match the following:
+      // a/b/x/y/z/c
+      // a/x/y/z/b/c
+      // a/b/x/b/x/c
+      // a/b/c
+      // To do this, take the rest of the pattern after
+      // the **, and see if it would match the file remainder.
+      // If so, return success.
+      // If not, the ** "swallows" a segment, and try again.
+      // This is recursively awful.
+      //
+      // a/**/b/**/c matching a/b/x/y/z/c
+      // - a matches a
+      // - doublestar
+      //   - matchOne(b/x/y/z/c, b/**/c)
+      //     - b matches b
+      //     - doublestar
+      //       - matchOne(x/y/z/c, c) -> no
+      //       - matchOne(y/z/c, c) -> no
+      //       - matchOne(z/c, c) -> no
+      //       - matchOne(c, c) yes, hit
+      var fr = fi
+      var pr = pi + 1
+      if (pr === pl) {
+        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
+        // options.dot is set.
+        // . and .. are *never* matched by **, for explosively
+        // exponential reasons.
+        for (; fi < fl; fi++) {
+          if (file[fi] === '.' || file[fi] === '..' ||
+            (!options.dot && file[fi].charAt(0) === '.')) return false
+        }
+        return true
+      }
+
+      // ok, let's see if we can swallow whatever we can.
+      while (fr < fl) {
+        var swallowee = file[fr]
+
+        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)) {
+          this.debug('globstar found match!', fr, fl, swallowee)
+          // found a match.
+          return true
+        } else {
+          // can't swallow "." or ".." ever.
+          // can only swallow ".foo" when explicitly asked.
+          if (swallowee === '.' || swallowee === '..' ||
+            (!options.dot && swallowee.charAt(0) === '.')) {
+            this.debug('dot detected!', file, fr, pattern, pr)
+            break
+          }
+
+          // ** swallows a segment, and continue.
+          this.debug('globstar swallow a segment, and continue')
+          fr++
+        }
+      }
+
+      // no match was found.
+      // However, in partial mode, we can't say this is necessarily over.
+      // If there's more *pattern* left, then
+      if (partial) {
+        // ran out of file
+        this.debug('\n>>> no match, partial?', file, fr, pattern, pr)
+        if (fr === fl) return true
+      }
+      return false
+    }
+
+    // something other than **
+    // non-magic patterns just have to match exactly
+    // patterns with magic have been turned into regexps.
+    var hit
+    if (typeof p === 'string') {
+      if (options.nocase) {
+        hit = f.toLowerCase() === p.toLowerCase()
+      } else {
+        hit = f === p
+      }
+      this.debug('string match', p, f, hit)
+    } else {
+      hit = f.match(p)
+      this.debug('pattern match', p, f, hit)
+    }
+
+    if (!hit) return false
+  }
+
+  // Note: ending in / means that we'll get a final ""
+  // at the end of the pattern.  This can only match a
+  // corresponding "" at the end of the file.
+  // If the file ends in /, then it can only match a
+  // a pattern that ends in /, unless the pattern just
+  // doesn't have any more for it. But, a/b/ should *not*
+  // match "a/b/*", even though "" matches against the
+  // [^/]*? pattern, except in partial mode, where it might
+  // simply not be reached yet.
+  // However, a/b/ should still satisfy a/*
+
+  // now either we fell off the end of the pattern, or we're done.
+  if (fi === fl && pi === pl) {
+    // ran out of pattern and filename at the same time.
+    // an exact hit!
+    return true
+  } else if (fi === fl) {
+    // ran out of file, but still had pattern left.
+    // this is ok if we're doing the match as part of
+    // a glob fs traversal.
+    return partial
+  } else if (pi === pl) {
+    // ran out of pattern, still have file left.
+    // this is only acceptable if we're on the very last
+    // empty segment of a file with a trailing slash.
+    // a/* should match a/b/
+    var emptyFileEnd = (fi === fl - 1) && (file[fi] === '')
+    return emptyFileEnd
+  }
+
+  // should be unreachable.
+  throw new Error('wtf?')
+}
+
+// replace stuff like \* with *
+function globUnescape (s) {
+  return s.replace(/\\(.)/g, '$1')
+}
+
+function regExpEscape (s) {
+  return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&')
+}

goTorrentWebUI/node_modules/react-scripts/node_modules/recursive-readdir/node_modules/minimatch/package.json

@@ -0,0 +1,65 @@
+{
+  "_args": [
+    [
+      "minimatch@3.0.3",
+      "C:\\Users\\deranjer\\go\\src\\github.com\\deranjer\\goTorrent\\torrent-project"
+    ]
+  ],
+  "_from": "minimatch@3.0.3",
+  "_id": "minimatch@3.0.3",
+  "_inBundle": false,
+  "_integrity": "sha1-Kk5AkLlrLbBqnX3wEFWmKnfJt3Q=",
+  "_location": "/react-scripts/recursive-readdir/minimatch",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "minimatch@3.0.3",
+    "name": "minimatch",
+    "escapedName": "minimatch",
+    "rawSpec": "3.0.3",
+    "saveSpec": null,
+    "fetchSpec": "3.0.3"
+  },
+  "_requiredBy": [
+    "/react-scripts/recursive-readdir"
+  ],
+  "_resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.3.tgz",
+  "_spec": "3.0.3",
+  "_where": "C:\\Users\\deranjer\\go\\src\\github.com\\deranjer\\goTorrent\\torrent-project",
+  "author": {
+    "name": "Isaac Z. Schlueter",
+    "email": "i@izs.me",
+    "url": "http://blog.izs.me"
+  },
+  "bugs": {
+    "url": "https://github.com/isaacs/minimatch/issues"
+  },
+  "dependencies": {
+    "brace-expansion": "^1.0.0"
+  },
+  "description": "a glob matcher in javascript",
+  "devDependencies": {
+    "standard": "^3.7.2",
+    "tap": "^5.6.0"
+  },
+  "engines": {
+    "node": "*"
+  },
+  "files": [
+    "minimatch.js"
+  ],
+  "homepage": "https://github.com/isaacs/minimatch#readme",
+  "license": "ISC",
+  "main": "minimatch.js",
+  "name": "minimatch",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/isaacs/minimatch.git"
+  },
+  "scripts": {
+    "posttest": "standard minimatch.js test/*.js",
+    "test": "tap test/*.js"
+  },
+  "version": "3.0.3"
+}

goTorrentWebUI/node_modules/react-scripts/node_modules/recursive-readdir/package.json

@@ -0,0 +1,66 @@
+{
+  "_args": [
+    [
+      "recursive-readdir@2.2.1",
+      "C:\\Users\\deranjer\\go\\src\\github.com\\deranjer\\goTorrent\\torrent-project"
+    ]
+  ],
+  "_from": "recursive-readdir@2.2.1",
+  "_id": "recursive-readdir@2.2.1",
+  "_inBundle": false,
+  "_integrity": "sha1-kO8jHQd4xc4JPJpI105cVCLROpk=",
+  "_location": "/react-scripts/recursive-readdir",
+  "_phantomChildren": {
+    "brace-expansion": "1.1.8"
+  },
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "recursive-readdir@2.2.1",
+    "name": "recursive-readdir",
+    "escapedName": "recursive-readdir",
+    "rawSpec": "2.2.1",
+    "saveSpec": null,
+    "fetchSpec": "2.2.1"
+  },
+  "_requiredBy": [
+    "/react-scripts/react-dev-utils"
+  ],
+  "_resolved": "https://registry.npmjs.org/recursive-readdir/-/recursive-readdir-2.2.1.tgz",
+  "_spec": "2.2.1",
+  "_where": "C:\\Users\\deranjer\\go\\src\\github.com\\deranjer\\goTorrent\\torrent-project",
+  "author": {
+    "name": "Jamison Dance",
+    "email": "jergason@gmail.com",
+    "url": "http://jamisondance.com/"
+  },
+  "bugs": {
+    "url": "https://github.com/jergason/recursive-readdir/issues"
+  },
+  "dependencies": {
+    "minimatch": "3.0.3"
+  },
+  "description": "Get an array of all files in a directory and subdirectories.",
+  "devDependencies": {
+    "mocha": "1.14.0"
+  },
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "homepage": "https://github.com/jergason/recursive-readdir#readme",
+  "keywords": [
+    "directory",
+    "lister"
+  ],
+  "license": "MIT",
+  "main": "./index.js",
+  "name": "recursive-readdir",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/jergason/recursive-readdir.git"
+  },
+  "scripts": {
+    "test": "mocha test/"
+  },
+  "version": "2.2.1"
+}

goTorrentWebUI/node_modules/react-scripts/node_modules/recursive-readdir/test/recursive-readdir-test.js

@@ -0,0 +1,401 @@
+/* eslint-env mocha */
+var assert = require("assert");
+var p = require("path");
+var readdir = require("../index");
+
+function getAbsolutePath(file) {
+  return p.join(__dirname, file);
+}
+
+function getAbsolutePaths(files) {
+  return files.map(getAbsolutePath);
+}
+
+describe("readdir", function() {
+  it("correctly lists all files in nested directories", function(done) {
+    var expectedFiles = getAbsolutePaths([
+      "/testdir/a/a",
+      "/testdir/a/beans",
+      "/testdir/b/123",
+      "/testdir/b/b/hurp-durp",
+      "/testdir/c.txt",
+      "/testdir/d.txt"
+    ]);
+
+    readdir(p.join(__dirname, "testdir"), function(err, list) {
+      assert.ifError(err);
+      assert.deepEqual(list.sort(), expectedFiles.sort());
+      done();
+    });
+  });
+
+  it("ignores the files listed in the ignores array", function(done) {
+    var notExpectedFiles = getAbsolutePaths([
+      "/testdir/d.txt",
+      "/testdir/a/beans"
+    ]);
+
+    readdir(p.join(__dirname, "testdir"), ["d.txt", "beans"], function(
+      err,
+      list
+    ) {
+      assert.ifError(err);
+      list.forEach(function(file) {
+        assert.equal(
+          notExpectedFiles.indexOf(file),
+          -1,
+          'Failed to ignore file "' + file + '".'
+        );
+      });
+      done();
+    });
+  });
+
+  it("ignores the directories listed in the ignores array", function(done) {
+    var notExpectedFiles = getAbsolutePaths([
+      "/testdir/a/a",
+      "/testdir/a/beans"
+    ]);
+
+    readdir(p.join(__dirname, "testdir"), ["**/testdir/a"], function(
+      err,
+      list
+    ) {
+      assert.ifError(err);
+      list.forEach(function(file) {
+        assert.equal(
+          notExpectedFiles.indexOf(file),
+          -1,
+          'Failed to ignore file "' + file + '".'
+        );
+      });
+      done();
+    });
+  });
+
+  it("ignores symlinked files and directories listed in the ignores array", function(
+    done
+  ) {
+    var notExpectedFiles = getAbsolutePaths([
+      "/testsymlinks/testdir/linkeddir/hi.docx",
+      "/testsymlinks/testdir/linkedfile.wmf"
+    ]);
+    readdir(
+      p.join(__dirname, "testsymlinks/testdir"),
+      ["linkeddir", "linkedfile.wmf"],
+      function(err, list) {
+        assert.ifError(err);
+        list.forEach(function(file) {
+          assert.equal(
+            notExpectedFiles.indexOf(file),
+            -1,
+            'Failed to ignore file "' + file + '".'
+          );
+        });
+        done();
+      }
+    );
+  });
+
+  it("supports ignoring files with just basename globbing", function(done) {
+    var notExpectedFiles = getAbsolutePaths([
+      "/testdir/d.txt",
+      "/testdir/a/beans"
+    ]);
+
+    readdir(p.join(__dirname, "testdir"), ["*.txt", "beans"], function(
+      err,
+      list
+    ) {
+      assert.ifError(err);
+      list.forEach(function(file) {
+        assert.equal(
+          notExpectedFiles.indexOf(file),
+          -1,
+          'Failed to ignore file "' + file + '".'
+        );
+      });
+      done();
+    });
+  });
+
+  it("supports ignoring files with the globstar syntax", function(done) {
+    var notExpectedFiles = getAbsolutePaths([
+      "/testdir/d.txt",
+      "/testdir/a/beans"
+    ]);
+
+    var ignores = ["**/*.txt", "**/a/beans"];
+
+    readdir(p.join(__dirname, "testdir"), ignores, function(err, list) {
+      assert.ifError(err);
+      list.forEach(function(file) {
+        assert.equal(
+          notExpectedFiles.indexOf(file),
+          -1,
+          'Failed to ignore file "' + file + '".'
+        );
+      });
+      done();
+    });
+  });
+
+  context("when there is a function in the ignores array", function() {
+    it("passes each file and directory path to the function", function(done) {
+      var expectedPaths = getAbsolutePaths([
+        "/testdir/a",
+        "/testdir/a/a",
+        "/testdir/a/beans",
+        "/testdir/b",
+        "/testdir/b/123",
+        "/testdir/b/b",
+        "/testdir/b/b/hurp-durp",
+        "/testdir/c.txt",
+        "/testdir/d.txt"
+      ]);
+      var paths = [];
+      function ignoreFunction(path) {
+        paths.push(path);
+        return false;
+      }
+      readdir(p.join(__dirname, "testdir"), [ignoreFunction], function(
+        err,
+        list
+      ) {
+        assert.ifError(err);
+        assert.deepEqual(paths.sort(), expectedPaths.sort());
+        done();
+      });
+    });
+
+    it("passes the stat object of each file to the function as its second argument", function(
+      done
+    ) {
+      var paths = {};
+      function ignoreFunction(path, stats) {
+        paths[path] = stats;
+        return false;
+      }
+      readdir(p.join(__dirname, "testdir"), [ignoreFunction], function(
+        err,
+        list
+      ) {
+        assert.ifError(err);
+        assert(paths[getAbsolutePath("/testdir/a")].isDirectory());
+        assert(paths[getAbsolutePath("/testdir/c.txt")].isFile());
+        done();
+      });
+    });
+
+    it("ignores files that the function returns true for", function(done) {
+      var ignoredFiles = getAbsolutePaths([
+        "/testdir/d.txt",
+        "/testdir/a/beans"
+      ]);
+      function ignoreFunction(path) {
+        return ignoredFiles.indexOf(path) != -1;
+      }
+
+      readdir(p.join(__dirname, "testdir"), [ignoreFunction], function(
+        err,
+        list
+      ) {
+        assert.ifError(err);
+        list.forEach(function(file) {
+          assert.equal(
+            ignoredFiles.indexOf(file),
+            -1,
+            'Failed to ignore file "' + file + '".'
+          );
+        });
+        done();
+      });
+    });
+
+    it("does not ignore files that the function returns false for", function(
+      done
+    ) {
+      var notIgnoredFiles = getAbsolutePaths([
+        "/testdir/d.txt",
+        "/testdir/a/beans"
+      ]);
+      function ignoreFunction(path) {
+        return notIgnoredFiles.indexOf(path) == -1;
+      }
+
+      readdir(p.join(__dirname, "testdir"), [ignoreFunction], function(
+        err,
+        list
+      ) {
+        assert.ifError(err);
+        notIgnoredFiles.forEach(function(file) {
+          assert.notEqual(
+            notIgnoredFiles.indexOf(file),
+            -1,
+            'Incorrectly ignored file "' + file + '".'
+          );
+        });
+        done();
+      });
+    });
+
+    it("ignores directories that the function returns true for", function(
+      done
+    ) {
+      var ignoredDirectory = getAbsolutePath("/testdir/a");
+      var ignoredFiles = getAbsolutePaths(["/testdir/a/a", "/testdir/a/beans"]);
+      function ignoreFunction(path) {
+        return ignoredDirectory == path;
+      }
+
+      readdir(p.join(__dirname, "testdir"), [ignoreFunction], function(
+        err,
+        list
+      ) {
+        assert.ifError(err);
+        list.forEach(function(file) {
+          assert.equal(
+            ignoredFiles.indexOf(file),
+            -1,
+            'Failed to ignore file "' + file + '".'
+          );
+        });
+        done();
+      });
+    });
+
+    it("does not ignore directories that the function returns false for", function(
+      done
+    ) {
+      var ignoredDirectory = getAbsolutePath("/testdir/a");
+      var notIgnoredFiles = getAbsolutePaths([
+        "/testdir/b/123",
+        "/testdir/b/b/hurp-durp"
+      ]);
+      function ignoreFunction(path) {
+        return ignoredDirectory == path;
+      }
+
+      readdir(p.join(__dirname, "testdir"), [ignoreFunction], function(
+        err,
+        list
+      ) {
+        assert.ifError(err);
+        notIgnoredFiles.forEach(function(file) {
+          assert.notEqual(
+            notIgnoredFiles.indexOf(file),
+            -1,
+            'Incorrectly ignored file "' + file + '".'
+          );
+        });
+        done();
+      });
+    });
+
+    it("does not descend into directories that the function returns true for", function(
+      done
+    ) {
+      var ignoredDirectory = getAbsolutePath("/testdir/a");
+      var ignoredFiles = getAbsolutePaths(["/testdir/a/a", "/testdir/a/beans"]);
+      var paths = [];
+      function ignoreFunction(path) {
+        paths.push(path);
+        return ignoredDirectory == path;
+      }
+
+      readdir(p.join(__dirname, "testdir"), [ignoreFunction], function(
+        err,
+        list
+      ) {
+        assert.ifError(err);
+        paths.forEach(function(file) {
+          assert.equal(
+            ignoredFiles.indexOf(file),
+            -1,
+            'Transversed file in ignored directory "' + file + '".'
+          );
+        });
+        done();
+      });
+    });
+  });
+
+  it("works when there are no files to report except ignored files", function(
+    done
+  ) {
+    readdir(p.join(__dirname, "testdirBeta"), ["*"], function(err, list) {
+      assert.ifError(err);
+      assert.equal(list.length, 0, "expect to report 0 files");
+      done();
+    });
+  });
+
+  it("works when negated ignore list is given", function(done) {
+    var expectedFiles = getAbsolutePaths(["/testdirBeta/ignore.txt"]);
+
+    readdir(p.join(__dirname, "testdirBeta"), ["!*.txt"], function(err, list) {
+      assert.ifError(err);
+      assert.deepEqual(
+        list.sort(),
+        expectedFiles,
+        "Failed to find expected files."
+      );
+      done();
+    });
+  });
+
+  it("traverses directory and file symbolic links", function(done) {
+    var expectedFiles = getAbsolutePaths([
+      "/testsymlinks/testdir/linkeddir/hi.docx",
+      "/testsymlinks/testdir/linkedfile.wmf"
+    ]);
+
+    readdir(p.join(__dirname, "testsymlinks", "testdir"), function(err, list) {
+      assert.ifError(err);
+      assert.deepEqual(
+        list.sort(),
+        expectedFiles,
+        "Failed to find expected files."
+      );
+      done();
+    });
+  });
+
+  if (!global.Promise) {
+    console.log("Native Promise not supported - skipping tests");
+  } else {
+    it("works with promises", function(done) {
+      var expectedFiles = getAbsolutePaths([
+        "/testdir/a/a",
+        "/testdir/a/beans",
+        "/testdir/b/123",
+        "/testdir/b/b/hurp-durp",
+        "/testdir/c.txt",
+        "/testdir/d.txt"
+      ]);
+
+      readdir(p.join(__dirname, "testdir"))
+        .then(function(list) {
+          assert.deepEqual(list.sort(), expectedFiles.sort());
+          done();
+        })
+        .catch(done);
+    });
+
+    it("correctly ignores when using promises", function(done) {
+      var expectedFiles = getAbsolutePaths([
+        "/testdir/a/a",
+        "/testdir/a/beans",
+        "/testdir/b/123",
+        "/testdir/b/b/hurp-durp"
+      ]);
+
+      readdir(p.join(__dirname, "testdir"), ["*.txt"])
+        .then(function(list) {
+          assert.deepEqual(list.sort(), expectedFiles.sort());
+          done();
+        })
+        .catch(done);
+    });
+  }
+});