install fstream-npm

17 files changed, 2198 insertions, 0 deletions

diff --git a/node_modules/fstream-npm/.npmignore b/node_modules/fstream-npm/.npmignore
new file mode 100644
index 000000000..06aea6917
--- /dev/null
+++ b/node_modules/fstream-npm/.npmignore
@@ -0,0 +1,2 @@
+# ignore the output junk from the example scripts
+example/output
diff --git a/node_modules/fstream-npm/README.md b/node_modules/fstream-npm/README.md
new file mode 100644
index 000000000..2c01e9073
--- /dev/null
+++ b/node_modules/fstream-npm/README.md
@@ -0,0 +1,18 @@
+# fstream-npm
+
+This is an fstream DirReader class that will read a directory and filter
+things according to the semantics of what goes in an npm package.
+
+For example:
+
+```javascript
+// This will print out all the files that would be included
+// by 'npm publish' or 'npm install' of this directory.
+
+var FN = require("fstream-npm")
+FN({ path: "./" })
+  .on("child", function (e) {
+    console.error(e.path.substr(e.root.path.length + 1))
+  })
+```
+
diff --git a/node_modules/fstream-npm/fstream-npm.js b/node_modules/fstream-npm/fstream-npm.js
new file mode 100644
index 000000000..69ad84079
--- /dev/null
+++ b/node_modules/fstream-npm/fstream-npm.js
@@ -0,0 +1,209 @@
+var Ignore = require("fstream-ignore")
+, inherits = require("inherits")
+, path = require("path")
+
+module.exports = Packer
+
+inherits(Packer, Ignore)
+
+function Packer (props) {
+  if (!(this instanceof Packer)) {
+    return new Packer(props)
+  }
+
+  if (typeof props === "string") {
+    props = { path: props }
+  }
+
+  props.ignoreFiles = [ ".npmignore",
+                        ".gitignore",
+                        "package.json" ]
+
+  Ignore.call(this, props)
+
+  this.package = props.package
+
+  // in a node_modules folder, resolve symbolic links to
+  // bundled dependencies when creating the package.
+  props.follow = this.follow = this.basename === "node_modules"
+  // console.error("follow?", this.path, props.follow)
+
+
+  this.on("entryStat", function (entry, props) {
+    // files should *always* get into tarballs
+    // in a user-writable state, even if they're
+    // being installed from some wackey vm-mounted
+    // read-only filesystem.
+    entry.mode = props.mode = props.mode | 0200
+  })
+}
+
+Packer.prototype.applyIgnores = function (entry, partial) {
+
+  // package.json files can never be ignored.
+  if (entry === "package.json") return true
+
+  // in a node_modules folder, we only include bundled dependencies
+  // also, prevent packages in node_modules from being affected
+  // by rules set in the containing package, so that
+  // bundles don't get busted.
+  if (this.basename === "node_modules") {
+    if (entry.indexOf("/") === -1) {
+      var bd = this.package && this.package.bundleDependencies
+      var shouldBundle = bd && bd.indexOf(entry) !== -1
+      // console.error("should bundle?", shouldBundle, this.package)
+      return shouldBundle
+    }
+    return true
+  }
+
+  // some files are *never* allowed under any circumstances
+  if (entry === ".git" ||
+      entry === ".lock-wscript" ||
+      entry.match(/^\.wafpickle-[0-9]+$/) ||
+      entry === "CVS" ||
+      entry === ".svn" ||
+      entry === ".hg" ||
+      entry.match(/^\..*\.swp$/) ||
+      entry === ".DS_Store" ||
+      entry.match(/^\._/) ||
+      entry === "npm-debug.log"
+    ) {
+    return false
+  }
+
+  return Ignore.prototype.applyIgnores.call(this, entry, partial)
+}
+
+Packer.prototype.addIgnoreFiles = function () {
+  var entries = this.entries
+  // if there's a .npmignore, then we do *not* want to
+  // read the .gitignore.
+  if (-1 !== entries.indexOf(".npmignore")) {
+    var i = entries.indexOf(".gitignore")
+    if (i !== -1) {
+      entries.splice(i, 1)
+    }
+  }
+
+  this.entries = entries
+
+  Ignore.prototype.addIgnoreFiles.call(this)
+}
+
+Packer.prototype.readRules = function (buf, e) {
+  if (e !== "package.json") {
+    return Ignore.prototype.readRules.call(this, buf, e)
+  }
+
+  var p = this.package = JSON.parse(buf.toString())
+  this.packageRoot = true
+  this.emit("package", p)
+
+  // make bundle deps predictable
+  if (p.bundledDependencies && !p.bundleDependencies) {
+    p.bundleDependencies = p.bundledDependencies
+    delete p.bundledDependencies
+  }
+
+  if (!p.files || !Array.isArray(p.files)) return []
+
+  // ignore everything except what's in the files array.
+  return ["*"].concat(p.files.map(function (f) {
+    return "!" + f
+  }))
+}
+
+Packer.prototype.getChildProps = function (stat) {
+  var props = Ignore.prototype.getChildProps.call(this, stat)
+
+  props.package = this.package
+
+  // Directories have to be read as Packers
+  // otherwise fstream.Reader will create a DirReader instead.
+  if (stat.isDirectory()) {
+    props.type = this.constructor
+  }
+
+  // only follow symbolic links directly in the node_modules folder.
+  props.follow = false
+  return props
+}
+
+
+var order =
+  [ "package.json"
+  , ".npmignore"
+  , ".gitignore"
+  , /^README(\.md)?$/
+  , "LICENCE"
+  , "LICENSE"
+  , /\.js$/ ]
+
+Packer.prototype.sort = function (a, b) {
+  for (var i = 0, l = order.length; i < l; i ++) {
+    var o = order[i]
+    if (typeof o === "string") {
+      if (a === o) return -1
+      if (b === o) return 1
+    } else {
+      if (a.match(o)) return -1
+      if (b.match(o)) return 1
+    }
+  }
+
+  // deps go in the back
+  if (a === "node_modules") return 1
+  if (b === "node_modules") return -1
+
+  return Ignore.prototype.sort.call(this, a, b)
+}
+
+
+
+Packer.prototype.emitEntry = function (entry) {
+  if (this._paused) {
+    this.once("resume", this.emitEntry.bind(this, entry))
+    return
+  }
+
+  // if there is a .gitignore, then we're going to
+  // rename it to .npmignore in the output.
+  if (entry.basename === ".gitignore") {
+    entry.basename = ".npmignore"
+    entry.path = path.resolve(entry.dirname, entry.basename)
+  }
+
+  // skip over symbolic links if we're not in the node_modules
+  // folder doing bundle whatevers
+  if (this.basename !== "node_modules" && entry.type === "SymbolicLink") {
+    return
+  }
+
+  if (entry.type !== "Directory") {
+    // make it so that the folder in the tarball is named "package"
+    var h = path.dirname((entry.root || entry).path)
+    , t = entry.path.substr(h.length + 1).replace(/^[^\/\\]+/, "package")
+    , p = h + "/" + t
+
+    entry.path = p
+    entry.dirname = path.dirname(p)
+    return Ignore.prototype.emitEntry.call(this, entry)
+  }
+
+  // we don't want empty directories to show up in package
+  // tarballs.
+  // don't emit entry events for dirs, but still walk through
+  // and read them.  This means that we need to proxy up their
+  // entry events so that those entries won't be missed, since
+  // .pipe() doesn't do anythign special with "child" events, on
+  // with "entry" events.
+  var me = this
+  entry.on("entry", function (e) {
+    if (e.parent === entry) {
+      e.parent = me
+      me.emit("entry", e)
+    }
+  })
+  entry.on("package", this.emit.bind(this, "package"))
+}
diff --git a/node_modules/fstream-npm/node_modules/fstream-ignore/.npmignore b/node_modules/fstream-npm/node_modules/fstream-ignore/.npmignore
new file mode 100644
index 000000000..a843dc44a
--- /dev/null
+++ b/node_modules/fstream-npm/node_modules/fstream-ignore/.npmignore
@@ -0,0 +1 @@
+test/fixtures
diff --git a/node_modules/fstream-npm/node_modules/fstream-ignore/README.md b/node_modules/fstream-npm/node_modules/fstream-ignore/README.md
new file mode 100644
index 000000000..31170feae
--- /dev/null
+++ b/node_modules/fstream-npm/node_modules/fstream-ignore/README.md
@@ -0,0 +1,22 @@
+# fstream-ignore
+
+A fstream DirReader that filters out files that match globs in `.ignore`
+files throughout the tree, like how git ignores files based on a
+`.gitignore` file.
+
+Here's an example:
+
+```javascript
+var Ignore = require("fstream-ignore")
+Ignore({ path: __dirname
+       , ignoreFiles: [".ignore", ".gitignore"]
+       })
+  .on("child", function (c) {
+    console.error(c.path.substr(c.root.path.length + 1))
+  })
+  .pipe(tar.Pack())
+  .pipe(fs.createWriteStream("foo.tar"))
+```
+
+This will tar up the files in __dirname into `foo.tar`, ignoring
+anything matched by the globs in any .iginore or .gitignore file.
diff --git a/node_modules/fstream-npm/node_modules/fstream-ignore/example/basic.js b/node_modules/fstream-npm/node_modules/fstream-ignore/example/basic.js
new file mode 100644
index 000000000..ff4534289
--- /dev/null
+++ b/node_modules/fstream-npm/node_modules/fstream-ignore/example/basic.js
@@ -0,0 +1,13 @@
+var Ignore = require("../")
+Ignore({ path: __dirname
+       , ignoreFiles: [".ignore", ".gitignore"]
+       })
+  .on("child", function (c) {
+    console.error(c.path.substr(c.root.path.length + 1))
+    c.on("ignoreFile", onIgnoreFile)
+  })
+  .on("ignoreFile", onIgnoreFile)
+
+function onIgnoreFile (e) {
+  console.error("adding ignore file", e.path)
+}
diff --git a/node_modules/fstream-npm/node_modules/fstream-ignore/ignore.js b/node_modules/fstream-npm/node_modules/fstream-ignore/ignore.js
new file mode 100644
index 000000000..839ad56ae
--- /dev/null
+++ b/node_modules/fstream-npm/node_modules/fstream-ignore/ignore.js
@@ -0,0 +1,263 @@
+// Essentially, this is a fstream.DirReader class, but with a
+// bit of special logic to read the specified sort of ignore files,
+// and a filter that prevents it from picking up anything excluded
+// by those files.
+
+var Minimatch = require("minimatch").Minimatch
+, fstream = require("fstream")
+, DirReader = fstream.DirReader
+, inherits = require("inherits")
+, path = require("path")
+, fs = require("fs")
+
+module.exports = IgnoreReader
+
+inherits(IgnoreReader, DirReader)
+
+function IgnoreReader (props) {
+  if (!(this instanceof IgnoreReader)) {
+    return new IgnoreReader(props)
+  }
+
+  // must be a Directory type
+  if (typeof props === "string") {
+    props = { path: path.resolve(props) }
+  }
+
+  props.type = "Directory"
+  props.Directory = true
+
+  if (!props.ignoreFiles) props.ignoreFiles = [".ignore"]
+  this.ignoreFiles = props.ignoreFiles
+
+  this.ignoreRules = null
+
+  // ensure that .ignore files always show up at the top of the list
+  // that way, they can be read before proceeding to handle other
+  // entries in that same folder
+  if (props.sort) {
+    this._sort = props.sort === "alpha" ? alphasort : props.sort
+    props.sort = null
+  }
+
+  this.on("entries", function () {
+    // if there are any ignore files in the list, then
+    // pause and add them.
+    // then, filter the list based on our ignoreRules
+
+    var hasIg = this.entries.some(this.isIgnoreFile, this)
+
+    if (!hasIg) return this.filterEntries()
+
+    this.addIgnoreFiles()
+  })
+
+  // we filter entries before we know what they are.
+  // however, directories have to be re-tested against
+  // rules with a "/" appended, because "a/b/" will only
+  // match if "a/b" is a dir, and not otherwise.
+  this.on("entryStat", function (entry, props) {
+    var t = entry.basename
+    if (!this.applyIgnores(entry.basename, entry.type === "Directory")) {
+      entry.abort()
+    }
+  }.bind(this))
+
+  DirReader.call(this, props)
+}
+
+
+IgnoreReader.prototype.addIgnoreFiles = function () {
+  this.pause()
+  var newIg = this.entries.filter(this.isIgnoreFile, this)
+  , count = newIg.length
+  , errState = null
+
+  var then = function then (er) {
+    if (errState) return
+    if (er) return this.emit("error", errState = er)
+    if (-- count === 0) {
+      this.filterEntries()
+      this.resume()
+    }
+  }.bind(this)
+
+  newIg.forEach(function (ig) {
+    this.addIgnoreFile(ig, then)
+  }, this)
+}
+
+
+IgnoreReader.prototype.isIgnoreFile = function (e) {
+  return e !== "." &&
+         e !== ".." &&
+         -1 !== this.ignoreFiles.indexOf(e)
+}
+
+
+IgnoreReader.prototype.getChildProps = function (stat) {
+  var props = DirReader.prototype.getChildProps.call(this, stat)
+  props.ignoreFiles = this.ignoreFiles
+
+  // Directories have to be read as IgnoreReaders
+  // otherwise fstream.Reader will create a DirReader instead.
+  if (stat.isDirectory()) {
+    props.type = this.constructor
+  }
+  return props
+}
+
+
+IgnoreReader.prototype.addIgnoreFile = function (e, cb) {
+  // read the file, and then call addIgnoreRules
+  // if there's an error, then tell the cb about it.
+
+  var ig = path.resolve(this.path, e)
+  fs.readFile(ig, function (er, data) {
+    if (er) return cb(er)
+
+    this.emit("ignoreFile", e, data)
+    var rules = this.readRules(data, e)
+    this.addIgnoreRules(rules, e)
+    cb()
+  }.bind(this))
+}
+
+
+IgnoreReader.prototype.readRules = function (buf, e) {
+  return buf.toString().split(/\r?\n/)
+}
+
+
+// Override this to do fancier things, like read the
+// "files" array from a package.json file or something.
+IgnoreReader.prototype.addIgnoreRules = function (set, e) {
+  // filter out anything obvious
+  set = set.filter(function (s) {
+    s = s.trim()
+    return s && !s.match(/^#/)
+  })
+
+  // no rules to add!
+  if (!set.length) return
+
+  // now get a minimatch object for each one of these.
+  // Note that we need to allow dot files by default, and
+  // not switch the meaning of their exclusion
+  var mmopt = { matchBase: true, dot: true, flipNegate: true }
+  , mm = set.map(function (s) {
+    var m = new Minimatch(s, mmopt)
+    m.ignoreFile = e
+    return m
+  })
+
+  if (!this.ignoreRules) this.ignoreRules = []
+  this.ignoreRules.push.apply(this.ignoreRules, mm)
+}
+
+
+IgnoreReader.prototype.filterEntries = function () {
+  // this exclusion is at the point where we know the list of
+  // entries in the dir, but don't know what they are.  since
+  // some of them *might* be directories, we have to run the
+  // match in dir-mode as well, so that we'll pick up partials
+  // of files that will be included later.  Anything included
+  // at this point will be checked again later once we know
+  // what it is.
+  this.entries = this.entries.filter(function (entry) {
+    // at this point, we don't know if it's a dir or not.
+    return this.applyIgnores(entry) || this.applyIgnores(entry, true)
+  }, this)
+}
+
+
+IgnoreReader.prototype.applyIgnores = function (entry, partial) {
+  var included = true
+
+  // this = /a/b/c
+  // entry = d
+  // parent /a/b sees c/d
+  if (this.parent && this.parent.applyIgnores) {
+    var pt = this.basename + "/" + entry
+    included = this.parent.applyIgnores(pt, partial)
+  }
+
+  // Negated Rules
+  // Since we're *ignoring* things here, negating means that a file
+  // is re-included, if it would have been excluded by a previous
+  // rule.  So, negated rules are only relevant if the file
+  // has been excluded.
+  //
+  // Similarly, if a file has been excluded, then there's no point
+  // trying it against rules that have already been applied
+  //
+  // We're using the "flipnegate" flag here, which tells minimatch
+  // to set the "negate" for our information, but still report
+  // whether the core pattern was a hit or a miss.
+
+  if (!this.ignoreRules) {
+    return included
+  }
+
+  this.ignoreRules.forEach(function (rule) {
+    // negation means inclusion
+    if (rule.negate && included ||
+        !rule.negate && !included) {
+      // unnecessary
+      return
+    }
+
+    // first, match against /foo/bar
+    var match = rule.match("/" + entry)
+
+    if (!match) {
+      // try with the leading / trimmed off the test
+      // eg: foo/bar instead of /foo/bar
+      match = rule.match(entry)
+    }
+
+    // if the entry is a directory, then it will match
+    // with a trailing slash. eg: /foo/bar/ or foo/bar/
+    if (!match && partial) {
+      match = rule.match("/" + entry + "/") ||
+              rule.match(entry + "/")
+    }
+
+    // When including a file with a negated rule, it's
+    // relevant if a directory partially matches, since
+    // it may then match a file within it.
+    // Eg, if you ignore /a, but !/a/b/c
+    if (!match && rule.negate && partial) {
+      match = rule.match("/" + entry, true) ||
+              rule.match(entry, true)
+    }
+
+    if (match) {
+      included = rule.negate
+    }
+  }, this)
+
+  return included
+}
+
+
+IgnoreReader.prototype.sort = function (a, b) {
+  var aig = this.ignoreFiles.indexOf(a) !== -1
+  , big = this.ignoreFiles.indexOf(b) !== -1
+
+  if (aig && !big) return -1
+  if (big && !aig) return 1
+  return this._sort(a, b)
+}
+
+IgnoreReader.prototype._sort = function (a, b) {
+  return 0
+}
+
+function alphasort (a, b) {
+  return a === b ? 0
+       : a.toLowerCase() > b.toLowerCase() ? 1
+       : a.toLowerCase() < b.toLowerCase() ? -1
+       : a > b ? 1
+       : -1
+}
diff --git a/node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/.travis.yml b/node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/.travis.yml
new file mode 100644
index 000000000..f1d0f13c8
--- /dev/null
+++ b/node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/.travis.yml
@@ -0,0 +1,4 @@
+language: node_js
+node_js:
+  - 0.4
+  - 0.6
diff --git a/node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/LICENSE b/node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/LICENSE
new file mode 100644
index 000000000..05a401094
--- /dev/null
+++ b/node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/LICENSE
@@ -0,0 +1,23 @@
+Copyright 2009, 2010, 2011 Isaac Z. Schlueter.
+All rights reserved.
+
+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.
diff --git a/node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/README.md b/node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/README.md
new file mode 100644
index 000000000..6fd07d2e9
--- /dev/null
+++ b/node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/README.md
@@ -0,0 +1,218 @@
+# minimatch
+
+A minimal matching utility.
+
+[![Build Status](https://secure.travis-ci.org/isaacs/minimatch.png)](http://travis-ci.org/isaacs/minimatch)
+
+
+This is the matching library used internally by npm.
+
+Eventually, it will replace the C binding in node-glob.
+
+It works by converting glob expressions into JavaScript `RegExp`
+objects.
+
+## Usage
+
+```javascript
+var minimatch = require("minimatch")
+
+minimatch("bar.foo", "*.foo") // true!
+minimatch("bar.foo", "*.bar") // false!
+```
+
+## Features
+
+Supports these glob features:
+
+* Brace Expansion
+* Extended glob matching
+* "Globstar" `**` matching
+
+See:
+
+* `man sh`
+* `man bash`
+* `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.
+
+```javascript
+var Minimatch = require("minimatch").Minimatch
+var mm = new Minimatch(pattern, options)
+```
+
+### Properties
+
+* `pattern` The original pattern the minimatch object represents.
+* `options` The options supplied to the constructor.
+* `set` A 2-dimensional array of regexp or string expressions.
+  Each row in the
+  array corresponds to a brace-expanded pattern.  Each item in the row
+  corresponds to a single path-part.  For example, the pattern
+  `{a,b/c}/d` would expand to a set of patterns like:
+
+        [ [ a, d ]
+        , [ b, c, d ] ]
+
+    If a portion of the pattern doesn't have any "magic" in it
+    (that is, it's something like `"foo"` rather than `fo*o?`), then it
+    will be left as a string rather than converted to a regular
+    expression.
+
+* `regexp` Created by the `makeRe` method.  A single regular expression
+  expressing the entire pattern.  This is useful in cases where you wish
+  to use the pattern somewhat like `fnmatch(3)` with `FNM_PATH` enabled.
+* `negate` True if the pattern is negated.
+* `comment` True if the pattern is a comment.
+* `empty` True if the pattern is `""`.
+
+### Methods
+
+* `makeRe` Generate the `regexp` member if necessary, and return it.
+  Will return `false` if the pattern is invalid.
+* `match(fname)` Return true if the filename matches the pattern, or
+  false otherwise.
+* `matchOne(fileArray, patternArray, partial)` Take a `/`-split
+  filename, and match it against a single row in the `regExpSet`.  This
+  method is mainly for internal use, but is exposed so that it can be
+  used by a glob-walker that needs to avoid excessive filesystem calls.
+
+All other methods are internal, and will be called as necessary.
+
+## Functions
+
+The top-level exported function has a `cache` property, which is an LRU
+cache set to store 100 items.  So, calling these methods repeatedly
+with the same pattern and options will use the same Minimatch object,
+saving the cost of parsing it multiple times.
+
+### minimatch(path, pattern, options)
+
+Main export.  Tests a path against the pattern using the options.
+
+```javascript
+var isJS = minimatch(file, "*.js", { matchBase: true })
+```
+
+### minimatch.filter(pattern, options)
+
+Returns a function that tests its
+supplied argument, suitable for use with `Array.filter`.  Example:
+
+```javascript
+var javascripts = fileList.filter(minimatch.filter("*.js", {matchBase: true}))
+```
+
+### minimatch.match(list, pattern, options)
+
+Match against the list of
+files, in the style of fnmatch or glob.  If nothing is matched, and
+options.nonull is set, then return a list containing the pattern itself.
+
+```javascript
+var javascripts = minimatch.match(fileList, "*.js", {matchBase: true}))
+```
+
+### minimatch.makeRe(pattern, options)
+
+Make a regular expression object from the pattern.
+
+## Options
+
+All options are `false` by default.
+
+### debug
+
+Dump a ton of stuff to stderr.
+
+### nobrace
+
+Do not expand `{a,b}` and `{1..3}` brace sets.
+
+### noglobstar
+
+Disable `**` matching against multiple folder names.
+
+### dot
+
+Allow patterns to match filenames starting with a period, even if
+the pattern does not explicitly have a period in that spot.
+
+Note that by default, `a/**/b` will **not** match `a/.d/b`, unless `dot`
+is set.
+
+### noext
+
+Disable "extglob" style patterns like `+(a|b)`.
+
+### nocase
+
+Perform a case-insensitive match.
+
+### nonull
+
+When a match is not found by `minimatch.match`, return a list containing
+the pattern itself.  When set, an empty list is returned if there are
+no matches.
+
+### matchBase
+
+If set, then patterns without slashes will be matched
+against the basename of the path if it contains slashes.  For example,
+`a?b` would match the path `/xyz/123/acb`, but not `/xyz/acb/123`.
+
+### nocomment
+
+Suppress the behavior of treating `#` at the start of a pattern as a
+comment.
+
+### nonegate
+
+Suppress the behavior of treating a leading `!` character as negation.
+
+### flipNegate
+
+Returns from negate expressions the same as if they were not negated.
+(Ie, true on a hit, false on a miss.)
diff --git a/node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/minimatch.js b/node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/minimatch.js
new file mode 100644
index 000000000..1ca08104e
--- /dev/null
+++ b/node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/minimatch.js
@@ -0,0 +1,986 @@
+module.exports = minimatch
+minimatch.Minimatch = Minimatch
+
+var LRU = require("lru-cache")
+  , cache = minimatch.cache = new LRU(100)
+  , GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {}
+
+var path = require("path")
+  // any single thing other than /
+  // don't need to escape / when using new RegExp()
+  , qmark = "[^/]"
+
+  // * => any number of characters
+  , 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.
+  , twoStarDot = "(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?"
+
+  // not a ^ or / followed by a dot,
+  // followed by anything, any number of times.
+  , twoStarNoDot = "(?:(?!(?:\\\/|^)\\.).)*?"
+
+  // characters that need to be escaped in RegExp.
+  , 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.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 || {}
+  return function (p, i, list) {
+    return minimatch(p, pattern, options)
+  }
+}
+
+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, cache)
+  }
+
+  if (typeof pattern !== "string") {
+    throw new TypeError("glob pattern string required")
+  }
+
+  if (!options) options = {}
+  pattern = pattern.trim()
+
+  // lru storage.
+  // these things aren't particularly big, but walking down the string
+  // and turning it into a regexp can get pretty costly.
+  var cacheKey = pattern + "\n" + Object.keys(options).filter(function (k) {
+    return options[k]
+  }).join(":")
+  var cached = minimatch.cache.get(cacheKey)
+  if (cached) return cached
+  minimatch.cache.set(cacheKey, this)
+
+  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.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) console.error(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)
+  })
+
+  if (options.debug) console.error(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)
+
+  // 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.set = set
+}
+
+Minimatch.prototype.parseNegate = parseNegate
+function parseNegate () {
+  var pattern = this.pattern
+    , negate = false
+    , options = this.options
+    , 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 new Minimatch(pattern, options).braceExpand()
+}
+
+Minimatch.prototype.braceExpand = braceExpand
+function braceExpand (pattern, options) {
+  options = options || this.options
+  pattern = typeof pattern === "undefined"
+    ? this.pattern : pattern
+
+  if (typeof pattern === "undefined") {
+    throw new Error("undefined pattern")
+  }
+
+  if (options.nobrace ||
+      !pattern.match(/\{.*\}/)) {
+    // shortcut. no need to expand.
+    return [pattern]
+  }
+
+  var escaping = false
+
+  // examples and comments refer to this crazy pattern:
+  // a{b,c{d,e},{f,g}h}x{y,z}
+  // expected:
+  // abxy
+  // abxz
+  // acdxy
+  // acdxz
+  // acexy
+  // acexz
+  // afhxy
+  // afhxz
+  // aghxy
+  // aghxz
+
+  // everything before the first \{ is just a prefix.
+  // 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)
+    var prefix = null
+    for (var i = 0, l = pattern.length; i < l; i ++) {
+      var c = pattern.charAt(i)
+      // console.error(i, c)
+      if (c === "\\") {
+        escaping = !escaping
+      } else if (c === "{" && !escaping) {
+        prefix = pattern.substr(0, i)
+        break
+      }
+    }
+
+    // actually no sets, all { were escaped.
+    if (prefix === null) {
+      // console.error("no sets")
+      return [pattern]
+    }
+
+    var tail = braceExpand(pattern.substr(i), options)
+    return tail.map(function (t) {
+      return prefix + t
+    })
+  }
+
+  // now we have something like:
+  // {b,c{d,e},{f,g}h}x{y,z}
+  // walk through the set, expanding each part, until
+  // the set ends.  then, we'll expand the suffix.
+  // If the set only has a single member, then'll put the {} back
+
+  // 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)
+      , start = +numset[1]
+      , end = +numset[2]
+      , inc = start > end ? -1 : 1
+      , set = []
+    for (var i = start; i != (end + inc); i += inc) {
+      // append all the suffixes
+      for (var ii = 0, ll = suf.length; ii < ll; ii ++) {
+        set.push(i + suf[ii])
+      }
+    }
+    return set
+  }
+
+  // ok, walk through the set
+  // We hope, somewhat optimistically, that there
+  // will be a } at the end.
+  // If the closing brace isn't found, then the pattern is
+  // interpreted as braceExpand("\\" + pattern) so that
+  // the leading \{ will be interpreted literally.
+  var i = 1 // skip the \{
+    , depth = 1
+    , set = []
+    , member = ""
+    , sawEnd = false
+    , escaping = false
+
+  function addMember () {
+    set.push(member)
+    member = ""
+  }
+
+  // console.error("Entering for")
+  FOR: for (i = 1, l = pattern.length; i < l; i ++) {
+    var c = pattern.charAt(i)
+    // console.error("", i, c)
+
+    if (escaping) {
+      escaping = false
+      member += "\\" + c
+    } else {
+      switch (c) {
+        case "\\":
+          escaping = true
+          continue
+
+        case "{":
+          depth ++
+          member += "{"
+          continue
+
+        case "}":
+          depth --
+          // if this closes the actual set, then we're done
+          if (depth === 0) {
+            addMember()
+            // pluck off the close-brace
+            i ++
+            break FOR
+          } else {
+            member += c
+            continue
+          }
+
+        case ",":
+          if (depth === 1) {
+            addMember()
+          } else {
+            member += c
+          }
+          continue
+
+        default:
+          member += c
+          continue
+      } // switch
+    } // else
+  } // for
+
+  // now we've either finished the set, and the suffix is
+  // 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)
+  }
+
+  // x{y,z} -> ["xy", "xz"]
+  // console.error("set", set)
+  // console.error("suffix", pattern.substr(i))
+  var suf = braceExpand(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)
+  set = set.map(function (p) {
+    return braceExpand(p, options)
+  })
+  // console.error("set expanded", set)
+
+
+  // [["b"], ["cd", "ce"], ["fh", "gh"]] ->
+  //   ["b", "cd", "ce", "fh", "gh"]
+  set = set.reduce(function (l, r) {
+    return l.concat(r)
+  })
+
+  if (addBraces) {
+    set = set.map(function (s) {
+      return "{" + s + "}"
+    })
+  }
+
+  // now attach the suffixes.
+  var ret = []
+  for (var i = 0, l = set.length; i < l; i ++) {
+    for (var ii = 0, ll = suf.length; ii < ll; ii ++) {
+      ret.push(set[i] + suf[ii])
+    }
+  }
+  return ret
+}
+
+// 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) {
+  var options = this.options
+
+  // shortcuts
+  if (!options.noglobstar && pattern === "**") return GLOBSTAR
+  if (pattern === "") return ""
+
+  var re = ""
+    , hasMagic = false
+    , escaping = false
+    // ? => one single character
+    , patternListStack = []
+    , plType
+    , stateChar
+    , inClass = false
+    , reClassStart = -1
+    , classStart = -1
+    // . and .. never match anything that doesn't start with .,
+    // even when options.dot is set.
+    , patternStart = pattern.charAt(0) === "." ? "" // anything
+      // not (start or / followed by . or .. followed by / or end)
+      : options.dot ? "(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))"
+      : "(?!\\.)"
+
+  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
+      }
+      stateChar = false
+    }
+  }
+
+  for ( var i = 0, len = pattern.length, c
+      ; (i < len) && (c = pattern.charAt(i))
+      ; i ++ ) {
+
+    if (options.debug) {
+      console.error("%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: 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 "!":
+        if (options.debug) {
+          console.error("%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) {
+          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.
+        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
+        }
+
+        plType = stateChar
+        patternListStack.push({ type: plType
+                              , start: i - 1
+                              , reStart: re.length })
+        // negation is (?:(?!js)[^/]*)
+        re += stateChar === "!" ? "(?:(?!" : "(?:"
+        stateChar = false
+        continue
+
+      case ")":
+        if (inClass || !patternListStack.length) {
+          re += "\\)"
+          continue
+        }
+
+        hasMagic = true
+        re += ")"
+        plType = patternListStack.pop().type
+        // negation is (?:(?!js)[^/]*)
+        // The others are (?:<pattern>)<type>
+        switch (plType) {
+          case "!":
+            re += "[^/]*?)"
+            break
+          case "?":
+          case "+":
+          case "*": re += plType
+          case "@": break // the default anyway
+        }
+        continue
+
+      case "|":
+        if (inClass || !patternListStack.length || escaping) {
+          re += "\\|"
+          escaping = false
+          continue
+        }
+
+        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
+        }
+
+        // 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
+    var 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.
+  var pl
+  while (pl = patternListStack.pop()) {
+    var tail = re.slice(pl.reStart + 3)
+    // maybe some even number of \, then maybe 1 \, followed by a |
+    tail = tail.replace(/((?:\\{2})*)(\\?)\|/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 + "|"
+    })
+
+    // console.error("tail=%j\n   %s", tail, tail)
+    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
+  }
+
+  // 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" : ""
+    , regExp = new RegExp("^" + re + "$", flags)
+
+  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) return this.regexp = false
+  var options = this.options
+
+  var twoStar = options.noglobstar ? star
+      : options.dot ? twoStarDot
+      : twoStarNoDot
+    , 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 {
+    return this.regexp = new RegExp(re, flags)
+  } catch (ex) {
+    return this.regexp = false
+  }
+}
+
+minimatch.match = function (list, pattern, options) {
+  var mm = new Minimatch(pattern, options)
+  list = list.filter(function (f) {
+    return mm.match(f)
+  })
+  if (options.nonull && !list.length) {
+    list.push(pattern)
+  }
+  return list
+}
+
+Minimatch.prototype.match = match
+function match (f, partial) {
+  // console.error("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
+
+  // first, normalize any slash-separated path parts.
+  // f = path.normalize(f)
+
+  // windows: need to use /, not \
+  // On other platforms, \ is a valid (albeit bad) filename char.
+  if (process.platform === "win32") {
+    f = f.split("\\").join("/")
+  }
+
+  // treat the test path as a set of pathparts.
+  f = f.split(slashSplit)
+  if (options.debug) {
+    console.error(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
+  // console.error(this.pattern, "set", set)
+
+  for (var i = 0, l = set.length; i < l; i ++) {
+    var pattern = set[i]
+    var hit = this.matchOne(f, 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
+
+  if (options.debug) {
+    console.error("matchOne",
+                  { "this": this
+                  , file: file
+                  , pattern: pattern })
+  }
+
+  if (options.matchBase && pattern.length === 1) {
+    file = path.basename(file.join("/")).split("/")
+  }
+
+  if (options.debug) {
+    console.error("matchOne", file.length, pattern.length)
+  }
+
+  for ( var fi = 0
+          , pi = 0
+          , fl = file.length
+          , pl = pattern.length
+      ; (fi < fl) && (pi < pl)
+      ; fi ++, pi ++ ) {
+
+    if (options.debug) {
+      console.error("matchOne loop")
+    }
+    var p = pattern[pi]
+      , f = file[fi]
+
+    if (options.debug) {
+      console.error(pattern, p, f)
+    }
+
+    // should be impossible.
+    // some invalid regexp stuff in the set.
+    if (p === false) return false
+
+    if (p === GLOBSTAR) {
+      // "**"
+      // 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/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
+        , pr = pi + 1
+      if (pr === pl) {
+        // 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: while (fr < fl) {
+        var swallowee = file[fr]
+        if (swallowee === "." || swallowee === ".." ||
+            (!options.dot && swallowee.charAt(0) === ".")) {
+          // console.error("dot detected!")
+          break WHILE
+        }
+
+        // XXX remove this slice.  Just pass the start index.
+        if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
+          // found a match.
+          return true
+        } else {
+          // ** swallows 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
+        // console.error("\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
+      }
+      if (options.debug) {
+        console.error("string match", p, f, hit)
+      }
+    } else {
+      hit = f.match(p)
+      if (options.debug) {
+        console.error("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, "\\$&")
+}
diff --git a/node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/package.json b/node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/package.json
new file mode 100644
index 000000000..6fa58e2be
--- /dev/null
+++ b/node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/package.json
@@ -0,0 +1,44 @@
+{
+  "author": {
+    "name": "Isaac Z. Schlueter",
+    "email": "i@izs.me",
+    "url": "http://blog.izs.me"
+  },
+  "name": "minimatch",
+  "description": "a glob matcher in javascript",
+  "version": "0.2.2",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/isaacs/minimatch.git"
+  },
+  "main": "minimatch.js",
+  "scripts": {
+    "test": "tap test"
+  },
+  "engines": {
+    "node": "*"
+  },
+  "dependencies": {
+    "lru-cache": "~1.0.5"
+  },
+  "devDependencies": {
+    "tap": ""
+  },
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "http://github.com/isaacs/minimatch/raw/master/LICENSE"
+    }
+  ],
+  "_npmUser": {
+    "name": "isaacs",
+    "email": "i@izs.me"
+  },
+  "_id": "minimatch@0.2.2",
+  "optionalDependencies": {},
+  "_engineSupported": true,
+  "_npmVersion": "1.1.12",
+  "_nodeVersion": "v0.7.7-pre",
+  "_defaultsLoaded": true,
+  "_from": "minimatch@~0.2.0"
+}
diff --git a/node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/test/basic.js b/node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/test/basic.js
new file mode 100644
index 000000000..cf1778a57
--- /dev/null
+++ b/node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/test/basic.js
@@ -0,0 +1,273 @@
+// http://www.bashcookbook.com/bashinfo/source/bash-1.14.7/tests/glob-test
+//
+// TODO: Some of these tests do very bad things with backslashes, and will
+// most likely fail badly on windows.  They should probably be skipped.
+
+var tap = require("tap")
+  , globalBefore = Object.keys(global)
+  , mm = require("../")
+  , files = [ "a", "b", "c", "d", "abc"
+            , "abd", "abe", "bb", "bcd"
+            , "ca", "cb", "dd", "de"
+            , "bdir/", "bdir/cfile"]
+  , next = files.concat([ "a-b", "aXb"
+                        , ".x", ".y" ])
+
+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"] ]
+
+    ].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 )
+    })
+
+  t.comment("time=" + (Date.now() - start) + "ms")
+  t.end()
+})
+
+tap.test("global leak test", function (t) {
+  var globalAfter = Object.keys(global)
+  t.equivalent(globalAfter, globalBefore, "no new globals, please")
+  t.end()
+})
+
+function alpha (a, b) {
+  return a > b ? 1 : -1
+}
diff --git a/node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/test/brace-expand.js b/node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/test/brace-expand.js
new file mode 100644
index 000000000..7ee278a27
--- /dev/null
+++ b/node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/test/brace-expand.js
@@ -0,0 +1,33 @@
+var tap = require("tap")
+  , minimatch = require("../")
+
+tap.test("brace expansion", function (t) {
+  // [ pattern, [expanded] ]
+  ; [ [ "a{b,c{d,e},{f,g}h}x{y,z}"
+      , [ "abxy"
+        , "abxz"
+        , "acdxy"
+        , "acdxz"
+        , "acexy"
+        , "acexz"
+        , "afhxy"
+        , "afhxz"
+        , "aghxy"
+        , "aghxz" ] ]
+    , [ "a{1..5}b"
+      , [ "a1b"
+        , "a2b"
+        , "a3b"
+        , "a4b"
+        , "a5b" ] ]
+    , [ "a{b}c", ["a{b}c"] ]
+  ].forEach(function (tc) {
+    var p = tc[0]
+      , expect = tc[1]
+    t.equivalent(minimatch.braceExpand(p), expect, p)
+  })
+  console.error("ending")
+  t.end()
+})
+
+
diff --git a/node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/test/caching.js b/node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/test/caching.js
new file mode 100644
index 000000000..0fec4b0fa
--- /dev/null
+++ b/node_modules/fstream-npm/node_modules/fstream-ignore/node_modules/minimatch/test/caching.js
@@ -0,0 +1,14 @@
+var Minimatch = require("../minimatch.js").Minimatch
+var tap = require("tap")
+tap.test("cache test", function (t) {
+  var mm1 = new Minimatch("a?b")
+  var mm2 = new Minimatch("a?b")
+  t.equal(mm1, mm2, "should get the same object")
+  // the lru should drop it after 100 entries
+  for (var i = 0; i < 100; i ++) {
+    new Minimatch("a"+i)
+  }
+  mm2 = new Minimatch("a?b")
+  t.notEqual(mm1, mm2, "cache should have dropped")
+  t.end()
+})
diff --git a/node_modules/fstream-npm/node_modules/fstream-ignore/package.json b/node_modules/fstream-npm/node_modules/fstream-ignore/package.json
new file mode 100644
index 000000000..867091ea0
--- /dev/null
+++ b/node_modules/fstream-npm/node_modules/fstream-ignore/package.json
@@ -0,0 +1,42 @@
+{
+  "author": {
+    "name": "Isaac Z. Schlueter",
+    "email": "i@izs.me",
+    "url": "http://blog.izs.me/"
+  },
+  "name": "fstream-ignore",
+  "description": "A thing for ignoring files based on globs",
+  "version": "0.0.3",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/isaacs/fstream-ignore.git"
+  },
+  "main": "ignore.js",
+  "scripts": {
+    "test": "tap test/*.js"
+  },
+  "dependencies": {
+    "minimatch": "~0.2.0",
+    "fstream": "~0.1.15",
+    "inherits": "~1.0.0"
+  },
+  "devDependencies": {
+    "tap": "",
+    "rimraf": "",
+    "mkdirp": ""
+  },
+  "_npmUser": {
+    "name": "isaacs",
+    "email": "i@izs.me"
+  },
+  "_id": "fstream-ignore@0.0.3",
+  "optionalDependencies": {},
+  "engines": {
+    "node": "*"
+  },
+  "_engineSupported": true,
+  "_npmVersion": "1.1.12",
+  "_nodeVersion": "v0.7.7-pre",
+  "_defaultsLoaded": true,
+  "_from": "fstream-ignore@~0.0.2"
+}
diff --git a/node_modules/fstream-npm/package.json b/node_modules/fstream-npm/package.json
new file mode 100644
index 000000000..231bde2a1
--- /dev/null
+++ b/node_modules/fstream-npm/package.json
@@ -0,0 +1,33 @@
+{
+  "author": {
+    "name": "Isaac Z. Schlueter",
+    "email": "i@izs.me",
+    "url": "http://blog.izs.me/"
+  },
+  "name": "fstream-npm",
+  "description": "fstream class for creating npm packages",
+  "version": "0.0.1",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/isaacs/fstream-npm.git"
+  },
+  "main": "./fstream-npm.js",
+  "dependencies": {
+    "fstream-ignore": "~0.0.2"
+  },
+  "_npmUser": {
+    "name": "isaacs",
+    "email": "i@izs.me"
+  },
+  "_id": "fstream-npm@0.0.1",
+  "devDependencies": {},
+  "optionalDependencies": {},
+  "engines": {
+    "node": "*"
+  },
+  "_engineSupported": true,
+  "_npmVersion": "1.1.12",
+  "_nodeVersion": "v0.7.7-pre",
+  "_defaultsLoaded": true,
+  "_from": "fstream-npm"
+}