08-27-周三_17-09-29

node_modules/extract-zip/.npmignore

@@ -0,0 +1 @@
+test/

node_modules/extract-zip/.travis.yml

@@ -0,0 +1,4 @@
+language: node_js
+node_js:
+  - '0.12'
+  - 'iojs'

node_modules/extract-zip/CONTRIBUTING.md

@@ -0,0 +1 @@
+Before potentially wasting your time by making major, opinionated changes to this codebase please feel free to open a discussion repos in the Issues section of the repository. Outline your proposed idea and seek feedback from the maintainer first before implementing major features.

node_modules/extract-zip/cli.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+
+var extract = require('./')
+
+var args = process.argv.slice(2)
+var source = args[0]
+var dest = args[1] || process.cwd()
+if (!source) {
+  console.error('Usage: extract-zip foo.zip <targetDirectory>')
+  process.exit(1)
+}
+
+extract(source, {dir: dest}, function (err, results) {
+  if (err) {
+    console.error('error!', err)
+    process.exit(1)
+  } else {
+    process.exit(0)
+  }
+})

node_modules/extract-zip/index.js

@@ -0,0 +1,163 @@
+var fs = require('fs')
+var path = require('path')
+var yauzl = require('yauzl')
+var mkdirp = require('mkdirp')
+var concat = require('concat-stream')
+var debug = require('debug')('extract-zip')
+
+module.exports = function (zipPath, opts, cb) {
+  debug('creating target directory', opts.dir)
+
+  mkdirp(opts.dir, function (err) {
+    if (err) return cb(err)
+    openZip()
+  })
+
+  function openZip () {
+    debug('opening', zipPath, 'with opts', opts)
+
+    yauzl.open(zipPath, {lazyEntries: true}, function (err, zipfile) {
+      if (err) return cb(err)
+
+      var cancelled = false
+
+      zipfile.readEntry()
+
+      zipfile.on('close', function () {
+        if (!cancelled) {
+          debug('zip extraction complete')
+          cb()
+        }
+      })
+
+      zipfile.on('entry', function (entry) {
+        if (cancelled) {
+          debug('skipping entry', entry.fileName, {cancelled: cancelled})
+          return
+        }
+
+        debug('zipfile entry', entry.fileName)
+
+        if (/^__MACOSX\//.test(entry.fileName)) {
+          // dir name starts with __MACOSX/
+          zipfile.readEntry()
+          return
+        }
+
+        extractEntry(entry, function (err) {
+          // if any extraction fails then abort everything
+          if (err) {
+            cancelled = true
+            zipfile.close()
+            return cb(err)
+          }
+          debug('finished processing', entry.fileName)
+          zipfile.readEntry()
+        })
+      })
+
+      function extractEntry (entry, done) {
+        if (cancelled) {
+          debug('skipping entry extraction', entry.fileName, {cancelled: cancelled})
+          return setImmediate(done)
+        }
+
+        if (opts.onEntry) {
+          opts.onEntry(entry)
+        }
+
+        var dest = path.join(opts.dir, entry.fileName)
+
+        // convert external file attr int into a fs stat mode int
+        var mode = (entry.externalFileAttributes >> 16) & 0xFFFF
+        // check if it's a symlink or dir (using stat mode constants)
+        var IFMT = 61440
+        var IFDIR = 16384
+        var IFLNK = 40960
+        var symlink = (mode & IFMT) === IFLNK
+        var isDir = (mode & IFMT) === IFDIR
+
+        // check for windows weird way of specifying a directory
+        // https://github.com/maxogden/extract-zip/issues/13#issuecomment-154494566
+        var madeBy = entry.versionMadeBy >> 8
+        if (!isDir) isDir = (madeBy === 0 && entry.externalFileAttributes === 16)
+
+        // if no mode then default to default modes
+        if (mode === 0) {
+          if (isDir) {
+            if (opts.defaultDirMode) mode = parseInt(opts.defaultDirMode, 10)
+            if (!mode) mode = 493 // Default to 0755
+          } else {
+            if (opts.defaultFileMode) mode = parseInt(opts.defaultFileMode, 10)
+            if (!mode) mode = 420 // Default to 0644
+          }
+        }
+
+        debug('extracting entry', { filename: entry.fileName, isDir: isDir, isSymlink: symlink })
+
+        // reverse umask first (~)
+        var umask = ~process.umask()
+        // & with processes umask to override invalid perms
+        var procMode = mode & umask
+
+        // always ensure folders are created
+        var destDir = dest
+        if (!isDir) destDir = path.dirname(dest)
+
+        debug('mkdirp', {dir: destDir})
+        mkdirp(destDir, function (err) {
+          if (err) {
+            debug('mkdirp error', destDir, {error: err})
+            cancelled = true
+            return done(err)
+          }
+
+          if (isDir) return done()
+
+          debug('opening read stream', dest)
+          zipfile.openReadStream(entry, function (err, readStream) {
+            if (err) {
+              debug('openReadStream error', err)
+              cancelled = true
+              return done(err)
+            }
+
+            readStream.on('error', function (err) {
+              console.log('read err', err)
+            })
+
+            if (symlink) writeSymlink()
+            else writeStream()
+
+            function writeStream () {
+              var writeStream = fs.createWriteStream(dest, {mode: procMode})
+              readStream.pipe(writeStream)
+
+              writeStream.on('finish', function () {
+                done()
+              })
+
+              writeStream.on('error', function (err) {
+                debug('write error', {error: err})
+                cancelled = true
+                return done(err)
+              })
+            }
+
+            // AFAICT the content of the symlink file itself is the symlink target filename string
+            function writeSymlink () {
+              readStream.pipe(concat(function (data) {
+                var link = data.toString()
+                debug('creating symlink', link, dest)
+                fs.symlink(link, dest, function (err) {
+                  if (err) cancelled = true
+                  done(err)
+                })
+              }))
+            }
+          })
+        })
+      }
+    })
+  }
+}

node_modules/extract-zip/node_modules/.bin/mkdirp

@@ -0,0 +1 @@
+../mkdirp/bin/cmd.js

node_modules/extract-zip/node_modules/mkdirp/.npmignore

@@ -0,0 +1,2 @@
+node_modules/
+npm-debug.log

node_modules/extract-zip/node_modules/mkdirp/.travis.yml

@@ -0,0 +1,5 @@
+language: node_js
+node_js:
+  - 0.6
+  - 0.8
+  - "0.10"

node_modules/extract-zip/node_modules/mkdirp/LICENSE

@@ -0,0 +1,21 @@
+Copyright 2010 James Halliday (mail@substack.net)
+
+This project is free software released under the MIT/X11 license:
+
+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.

node_modules/extract-zip/node_modules/mkdirp/bin/cmd.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+
+var mkdirp = require('../');
+var minimist = require('minimist');
+var fs = require('fs');
+
+var argv = minimist(process.argv.slice(2), {
+    alias: { m: 'mode', h: 'help' },
+    string: [ 'mode' ]
+});
+if (argv.help) {
+    fs.createReadStream(__dirname + '/usage.txt').pipe(process.stdout);
+    return;
+}
+
+var paths = argv._.slice();
+var mode = argv.mode ? parseInt(argv.mode, 8) : undefined;
+
+(function next () {
+    if (paths.length === 0) return;
+    var p = paths.shift();
+    
+    if (mode === undefined) mkdirp(p, cb)
+    else mkdirp(p, mode, cb)
+    
+    function cb (err) {
+        if (err) {
+            console.error(err.message);
+            process.exit(1);
+        }
+        else next();
+    }
+})();

node_modules/extract-zip/node_modules/mkdirp/bin/usage.txt

@@ -0,0 +1,12 @@
+usage: mkdirp [DIR1,DIR2..] {OPTIONS}
+
+  Create each supplied directory including any necessary parent directories that
+  don't yet exist.
+  
+  If the directory already exists, do nothing.
+
+OPTIONS are:
+
+  -m, --mode   If a directory needs to be created, set the mode as an octal
+               permission string.
+

node_modules/extract-zip/node_modules/mkdirp/examples/pow.js

@@ -0,0 +1,6 @@
+var mkdirp = require('mkdirp');
+
+mkdirp('/tmp/foo/bar/baz', function (err) {
+    if (err) console.error(err)
+    else console.log('pow!')
+});

node_modules/extract-zip/node_modules/mkdirp/index.js

@@ -0,0 +1,97 @@
+var path = require('path');
+var fs = require('fs');
+
+module.exports = mkdirP.mkdirp = mkdirP.mkdirP = mkdirP;
+
+function mkdirP (p, opts, f, made) {
+    if (typeof opts === 'function') {
+        f = opts;
+        opts = {};
+    }
+    else if (!opts || typeof opts !== 'object') {
+        opts = { mode: opts };
+    }
+    
+    var mode = opts.mode;
+    var xfs = opts.fs || fs;
+    
+    if (mode === undefined) {
+        mode = 0777 & (~process.umask());
+    }
+    if (!made) made = null;
+    
+    var cb = f || function () {};
+    p = path.resolve(p);
+    
+    xfs.mkdir(p, mode, function (er) {
+        if (!er) {
+            made = made || p;
+            return cb(null, made);
+        }
+        switch (er.code) {
+            case 'ENOENT':
+                mkdirP(path.dirname(p), opts, function (er, made) {
+                    if (er) cb(er, made);
+                    else mkdirP(p, opts, cb, made);
+                });
+                break;
+
+            // In the case of any other error, just see if there's a dir
+            // there already.  If so, then hooray!  If not, then something
+            // is borked.
+            default:
+                xfs.stat(p, function (er2, stat) {
+                    // if the stat fails, then that's super weird.
+                    // let the original error be the failure reason.
+                    if (er2 || !stat.isDirectory()) cb(er, made)
+                    else cb(null, made);
+                });
+                break;
+        }
+    });
+}
+
+mkdirP.sync = function sync (p, opts, made) {
+    if (!opts || typeof opts !== 'object') {
+        opts = { mode: opts };
+    }
+    
+    var mode = opts.mode;
+    var xfs = opts.fs || fs;
+    
+    if (mode === undefined) {
+        mode = 0777 & (~process.umask());
+    }
+    if (!made) made = null;
+
+    p = path.resolve(p);
+
+    try {
+        xfs.mkdirSync(p, mode);
+        made = made || p;
+    }
+    catch (err0) {
+        switch (err0.code) {
+            case 'ENOENT' :
+                made = sync(path.dirname(p), opts, made);
+                sync(p, opts, made);
+                break;
+
+            // In the case of any other error, just see if there's a dir
+            // there already.  If so, then hooray!  If not, then something
+            // is borked.
+            default:
+                var stat;
+                try {
+                    stat = xfs.statSync(p);
+                }
+                catch (err1) {
+                    throw err0;
+                }
+                if (!stat.isDirectory()) throw err0;
+                break;
+        }
+    }
+
+    return made;
+};

node_modules/extract-zip/node_modules/mkdirp/package.json

@@ -0,0 +1,98 @@
+{
+  "_args": [
+    [
+      {
+        "name": "mkdirp",
+        "raw": "mkdirp@0.5.0",
+        "rawSpec": "0.5.0",
+        "scope": null,
+        "spec": "0.5.0",
+        "type": "version"
+      },
+      "/root/gitbook/node_modules/extract-zip"
+    ]
+  ],
+  "_from": "mkdirp@0.5.0",
+  "_id": "mkdirp@0.5.0",
+  "_inCache": true,
+  "_installable": true,
+  "_location": "/extract-zip/mkdirp",
+  "_npmUser": {
+    "email": "mail@substack.net",
+    "name": "substack"
+  },
+  "_npmVersion": "1.4.3",
+  "_phantomChildren": {},
+  "_requested": {
+    "name": "mkdirp",
+    "raw": "mkdirp@0.5.0",
+    "rawSpec": "0.5.0",
+    "scope": null,
+    "spec": "0.5.0",
+    "type": "version"
+  },
+  "_requiredBy": [
+    "/extract-zip"
+  ],
+  "_resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.0.tgz",
+  "_shasum": "1d73076a6df986cd9344e15e71fcc05a4c9abf12",
+  "_shrinkwrap": null,
+  "_spec": "mkdirp@0.5.0",
+  "_where": "/root/gitbook/node_modules/extract-zip",
+  "author": {
+    "email": "mail@substack.net",
+    "name": "James Halliday",
+    "url": "http://substack.net"
+  },
+  "bin": {
+    "mkdirp": "bin/cmd.js"
+  },
+  "bugs": {
+    "url": "https://github.com/substack/node-mkdirp/issues"
+  },
+  "dependencies": {
+    "minimist": "0.0.8"
+  },
+  "deprecated": "Legacy versions of mkdirp are no longer supported. Please update to mkdirp 1.x. (Note that the API surface has changed to use Promises in 1.x.)",
+  "description": "Recursively mkdir, like `mkdir -p`",
+  "devDependencies": {
+    "mock-fs": "~2.2.0",
+    "tap": "~0.4.0"
+  },
+  "directories": {},
+  "dist": {
+    "integrity": "sha512-xjjNGy+ry1lhtIKcr2PT6ok3aszhQfgrUDp4OZLHacgRgFmF6XR9XCOJVcXlVGQonIqXcK1DvqgKKQOPWYGSfw==",
+    "shasum": "1d73076a6df986cd9344e15e71fcc05a4c9abf12",
+    "signatures": [
+      {
+        "keyid": "SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA",
+        "sig": "MEUCIQDzJnxAoy1oo5PiesxWQ88orv/Z1Kp+MettH3fagHAJ0AIgHesBmlz15PP6e45unLqXb4A0jKbuNTStl57VNfdGXAw="
+      }
+    ],
+    "tarball": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.0.tgz"
+  },
+  "homepage": "https://github.com/substack/node-mkdirp",
+  "keywords": [
+    "mkdir",
+    "directory"
+  ],
+  "license": "MIT",
+  "main": "./index",
+  "maintainers": [
+    {
+      "email": "mail@substack.net",
+      "name": "substack"
+    }
+  ],
+  "name": "mkdirp",
+  "optionalDependencies": {},
+  "readme": "ERROR: No README data found!",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/substack/node-mkdirp.git"
+  },
+  "scripts": {
+    "test": "tap test/*.js"
+  },
+  "version": "0.5.0"
+}

node_modules/extract-zip/node_modules/mkdirp/readme.markdown

@@ -0,0 +1,100 @@
+# mkdirp
+
+Like `mkdir -p`, but in node.js!
+
+[![build status](https://secure.travis-ci.org/substack/node-mkdirp.png)](http://travis-ci.org/substack/node-mkdirp)
+
+# example
+
+## pow.js
+
+```js
+var mkdirp = require('mkdirp');
+    
+mkdirp('/tmp/foo/bar/baz', function (err) {
+    if (err) console.error(err)
+    else console.log('pow!')
+});
+```
+
+Output
+
+```
+pow!
+```
+
+And now /tmp/foo/bar/baz exists, huzzah!
+
+# methods
+
+```js
+var mkdirp = require('mkdirp');
+```
+
+## mkdirp(dir, opts, cb)
+
+Create a new directory and any necessary subdirectories at `dir` with octal
+permission string `opts.mode`. If `opts` is a non-object, it will be treated as
+the `opts.mode`.
+
+If `opts.mode` isn't specified, it defaults to `0777 & (~process.umask())`.
+
+`cb(err, made)` fires with the error or the first directory `made`
+that had to be created, if any.
+
+You can optionally pass in an alternate `fs` implementation by passing in
+`opts.fs`. Your implementation should have `opts.fs.mkdir(path, mode, cb)` and
+`opts.fs.stat(path, cb)`.
+
+## mkdirp.sync(dir, opts)
+
+Synchronously create a new directory and any necessary subdirectories at `dir`
+with octal permission string `opts.mode`. If `opts` is a non-object, it will be
+treated as the `opts.mode`.
+
+If `opts.mode` isn't specified, it defaults to `0777 & (~process.umask())`.
+
+Returns the first directory that had to be created, if any.
+
+You can optionally pass in an alternate `fs` implementation by passing in
+`opts.fs`. Your implementation should have `opts.fs.mkdirSync(path, mode)` and
+`opts.fs.statSync(path)`.
+
+# usage
+
+This package also ships with a `mkdirp` command.
+
+```
+usage: mkdirp [DIR1,DIR2..] {OPTIONS}
+
+  Create each supplied directory including any necessary parent directories that
+  don't yet exist.
+  
+  If the directory already exists, do nothing.
+
+OPTIONS are:
+
+  -m, --mode   If a directory needs to be created, set the mode as an octal
+               permission string.
+
+```
+
+# install
+
+With [npm](http://npmjs.org) do:
+
+```
+npm install mkdirp
+```
+
+to get the library, or
+
+```
+npm install -g mkdirp
+```
+
+to get the command.
+
+# license
+
+MIT

node_modules/extract-zip/node_modules/mkdirp/test/chmod.js

@@ -0,0 +1,38 @@
+var mkdirp = require('../').mkdirp;
+var path = require('path');
+var fs = require('fs');
+var test = require('tap').test;
+
+var ps = [ '', 'tmp' ];
+
+for (var i = 0; i < 25; i++) {
+    var dir = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    ps.push(dir);
+}
+
+var file = ps.join('/');
+
+test('chmod-pre', function (t) {
+    var mode = 0744
+    mkdirp(file, mode, function (er) {
+        t.ifError(er, 'should not error');
+        fs.stat(file, function (er, stat) {
+            t.ifError(er, 'should exist');
+            t.ok(stat && stat.isDirectory(), 'should be directory');
+            t.equal(stat && stat.mode & 0777, mode, 'should be 0744');
+            t.end();
+        });
+    });
+});
+
+test('chmod', function (t) {
+    var mode = 0755
+    mkdirp(file, mode, function (er) {
+        t.ifError(er, 'should not error');
+        fs.stat(file, function (er, stat) {
+            t.ifError(er, 'should exist');
+            t.ok(stat && stat.isDirectory(), 'should be directory');
+            t.end();
+        });
+    });
+});

node_modules/extract-zip/node_modules/mkdirp/test/clobber.js

@@ -0,0 +1,37 @@
+var mkdirp = require('../').mkdirp;
+var path = require('path');
+var fs = require('fs');
+var test = require('tap').test;
+
+var ps = [ '', 'tmp' ];
+
+for (var i = 0; i < 25; i++) {
+    var dir = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    ps.push(dir);
+}
+
+var file = ps.join('/');
+
+// a file in the way
+var itw = ps.slice(0, 3).join('/');
+
+
+test('clobber-pre', function (t) {
+    console.error("about to write to "+itw)
+    fs.writeFileSync(itw, 'I AM IN THE WAY, THE TRUTH, AND THE LIGHT.');
+
+    fs.stat(itw, function (er, stat) {
+        t.ifError(er)
+        t.ok(stat && stat.isFile(), 'should be file')
+        t.end()
+    })
+})
+
+test('clobber', function (t) {
+    t.plan(2);
+    mkdirp(file, 0755, function (err) {
+        t.ok(err);
+        t.equal(err.code, 'ENOTDIR');
+        t.end();
+    });
+});

node_modules/extract-zip/node_modules/mkdirp/test/mkdirp.js

@@ -0,0 +1,26 @@
+var mkdirp = require('../');
+var path = require('path');
+var fs = require('fs');
+var exists = fs.exists || path.exists;
+var test = require('tap').test;
+
+test('woo', function (t) {
+    t.plan(5);
+    var x = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var y = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var z = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    
+    var file = '/tmp/' + [x,y,z].join('/');
+    
+    mkdirp(file, 0755, function (err) {
+        t.ifError(err);
+        exists(file, function (ex) {
+            t.ok(ex, 'file created');
+            fs.stat(file, function (err, stat) {
+                t.ifError(err);
+                t.equal(stat.mode & 0777, 0755);
+                t.ok(stat.isDirectory(), 'target not a directory');
+            })
+        })
+    });
+});

node_modules/extract-zip/node_modules/mkdirp/test/opts_fs.js

@@ -0,0 +1,27 @@
+var mkdirp = require('../');
+var path = require('path');
+var test = require('tap').test;
+var mockfs = require('mock-fs');
+
+test('opts.fs', function (t) {
+    t.plan(5);
+    
+    var x = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var y = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var z = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    
+    var file = '/beep/boop/' + [x,y,z].join('/');
+    var xfs = mockfs.fs();
+    
+    mkdirp(file, { fs: xfs, mode: 0755 }, function (err) {
+        t.ifError(err);
+        xfs.exists(file, function (ex) {
+            t.ok(ex, 'created file');
+            xfs.stat(file, function (err, stat) {
+                t.ifError(err);
+                t.equal(stat.mode & 0777, 0755);
+                t.ok(stat.isDirectory(), 'target not a directory');
+            });
+        });
+    });
+});

node_modules/extract-zip/node_modules/mkdirp/test/opts_fs_sync.js

@@ -0,0 +1,25 @@
+var mkdirp = require('../');
+var path = require('path');
+var test = require('tap').test;
+var mockfs = require('mock-fs');
+
+test('opts.fs sync', function (t) {
+    t.plan(4);
+    
+    var x = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var y = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var z = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    
+    var file = '/beep/boop/' + [x,y,z].join('/');
+    var xfs = mockfs.fs();
+    
+    mkdirp.sync(file, { fs: xfs, mode: 0755 });
+    xfs.exists(file, function (ex) {
+        t.ok(ex, 'created file');
+        xfs.stat(file, function (err, stat) {
+            t.ifError(err);
+            t.equal(stat.mode & 0777, 0755);
+            t.ok(stat.isDirectory(), 'target not a directory');
+        });
+    });
+});

node_modules/extract-zip/node_modules/mkdirp/test/perm.js

@@ -0,0 +1,30 @@
+var mkdirp = require('../');
+var path = require('path');
+var fs = require('fs');
+var exists = fs.exists || path.exists;
+var test = require('tap').test;
+
+test('async perm', function (t) {
+    t.plan(5);
+    var file = '/tmp/' + (Math.random() * (1<<30)).toString(16);
+    
+    mkdirp(file, 0755, function (err) {
+        t.ifError(err);
+        exists(file, function (ex) {
+            t.ok(ex, 'file created');
+            fs.stat(file, function (err, stat) {
+                t.ifError(err);
+                t.equal(stat.mode & 0777, 0755);
+                t.ok(stat.isDirectory(), 'target not a directory');
+            })
+        })
+    });
+});
+
+test('async root perm', function (t) {
+    mkdirp('/tmp', 0755, function (err) {
+        if (err) t.fail(err);
+        t.end();
+    });
+    t.end();
+});

node_modules/extract-zip/node_modules/mkdirp/test/perm_sync.js

@@ -0,0 +1,34 @@
+var mkdirp = require('../');
+var path = require('path');
+var fs = require('fs');
+var exists = fs.exists || path.exists;
+var test = require('tap').test;
+
+test('sync perm', function (t) {
+    t.plan(4);
+    var file = '/tmp/' + (Math.random() * (1<<30)).toString(16) + '.json';
+    
+    mkdirp.sync(file, 0755);
+    exists(file, function (ex) {
+        t.ok(ex, 'file created');
+        fs.stat(file, function (err, stat) {
+            t.ifError(err);
+            t.equal(stat.mode & 0777, 0755);
+            t.ok(stat.isDirectory(), 'target not a directory');
+        });
+    });
+});
+
+test('sync root perm', function (t) {
+    t.plan(3);
+    
+    var file = '/tmp';
+    mkdirp.sync(file, 0755);
+    exists(file, function (ex) {
+        t.ok(ex, 'file created');
+        fs.stat(file, function (err, stat) {
+            t.ifError(err);
+            t.ok(stat.isDirectory(), 'target not a directory');
+        })
+    });
+});

node_modules/extract-zip/node_modules/mkdirp/test/race.js

@@ -0,0 +1,40 @@
+var mkdirp = require('../').mkdirp;
+var path = require('path');
+var fs = require('fs');
+var exists = fs.exists || path.exists;
+var test = require('tap').test;
+
+test('race', function (t) {
+    t.plan(6);
+    var ps = [ '', 'tmp' ];
+    
+    for (var i = 0; i < 25; i++) {
+        var dir = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+        ps.push(dir);
+    }
+    var file = ps.join('/');
+    
+    var res = 2;
+    mk(file, function () {
+        if (--res === 0) t.end();
+    });
+    
+    mk(file, function () {
+        if (--res === 0) t.end();
+    });
+    
+    function mk (file, cb) {
+        mkdirp(file, 0755, function (err) {
+            t.ifError(err);
+            exists(file, function (ex) {
+                t.ok(ex, 'file created');
+                fs.stat(file, function (err, stat) {
+                    t.ifError(err);
+                    t.equal(stat.mode & 0777, 0755);
+                    t.ok(stat.isDirectory(), 'target not a directory');
+                    if (cb) cb();
+                });
+            })
+        });
+    }
+});

node_modules/extract-zip/node_modules/mkdirp/test/rel.js

@@ -0,0 +1,30 @@
+var mkdirp = require('../');
+var path = require('path');
+var fs = require('fs');
+var exists = fs.exists || path.exists;
+var test = require('tap').test;
+
+test('rel', function (t) {
+    t.plan(5);
+    var x = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var y = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var z = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    
+    var cwd = process.cwd();
+    process.chdir('/tmp');
+    
+    var file = [x,y,z].join('/');
+    
+    mkdirp(file, 0755, function (err) {
+        t.ifError(err);
+        exists(file, function (ex) {
+            t.ok(ex, 'file created');
+            fs.stat(file, function (err, stat) {
+                t.ifError(err);
+                process.chdir(cwd);
+                t.equal(stat.mode & 0777, 0755);
+                t.ok(stat.isDirectory(), 'target not a directory');
+            })
+        })
+    });
+});

node_modules/extract-zip/node_modules/mkdirp/test/return.js

@@ -0,0 +1,25 @@
+var mkdirp = require('../');
+var path = require('path');
+var fs = require('fs');
+var test = require('tap').test;
+
+test('return value', function (t) {
+    t.plan(4);
+    var x = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var y = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var z = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+
+    var file = '/tmp/' + [x,y,z].join('/');
+
+    // should return the first dir created.
+    // By this point, it would be profoundly surprising if /tmp didn't
+    // already exist, since every other test makes things in there.
+    mkdirp(file, function (err, made) {
+        t.ifError(err);
+        t.equal(made, '/tmp/' + x);
+        mkdirp(file, function (err, made) {
+          t.ifError(err);
+          t.equal(made, null);
+        });
+    });
+});

node_modules/extract-zip/node_modules/mkdirp/test/return_sync.js

@@ -0,0 +1,24 @@
+var mkdirp = require('../');
+var path = require('path');
+var fs = require('fs');
+var test = require('tap').test;
+
+test('return value', function (t) {
+    t.plan(2);
+    var x = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var y = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var z = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+
+    var file = '/tmp/' + [x,y,z].join('/');
+
+    // should return the first dir created.
+    // By this point, it would be profoundly surprising if /tmp didn't
+    // already exist, since every other test makes things in there.
+    // Note that this will throw on failure, which will fail the test.
+    var made = mkdirp.sync(file);
+    t.equal(made, '/tmp/' + x);
+
+    // making the same file again should have no effect.
+    made = mkdirp.sync(file);
+    t.equal(made, null);
+});

node_modules/extract-zip/node_modules/mkdirp/test/root.js

@@ -0,0 +1,18 @@
+var mkdirp = require('../');
+var path = require('path');
+var fs = require('fs');
+var test = require('tap').test;
+
+test('root', function (t) {
+    // '/' on unix, 'c:/' on windows.
+    var file = path.resolve('/');
+
+    mkdirp(file, 0755, function (err) {
+        if (err) throw err
+        fs.stat(file, function (er, stat) {
+            if (er) throw er
+            t.ok(stat.isDirectory(), 'target is a directory');
+            t.end();
+        })
+    });
+});

node_modules/extract-zip/node_modules/mkdirp/test/sync.js

@@ -0,0 +1,30 @@
+var mkdirp = require('../');
+var path = require('path');
+var fs = require('fs');
+var exists = fs.exists || path.exists;
+var test = require('tap').test;
+
+test('sync', function (t) {
+    t.plan(4);
+    var x = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var y = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var z = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+
+    var file = '/tmp/' + [x,y,z].join('/');
+
+    try {
+        mkdirp.sync(file, 0755);
+    } catch (err) {
+        t.fail(err);
+        return t.end();
+    }
+
+    exists(file, function (ex) {
+        t.ok(ex, 'file created');
+        fs.stat(file, function (err, stat) {
+            t.ifError(err);
+            t.equal(stat.mode & 0777, 0755);
+            t.ok(stat.isDirectory(), 'target not a directory');
+        });
+    });
+});

node_modules/extract-zip/node_modules/mkdirp/test/umask.js

@@ -0,0 +1,26 @@
+var mkdirp = require('../');
+var path = require('path');
+var fs = require('fs');
+var exists = fs.exists || path.exists;
+var test = require('tap').test;
+
+test('implicit mode from umask', function (t) {
+    t.plan(5);
+    var x = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var y = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var z = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    
+    var file = '/tmp/' + [x,y,z].join('/');
+    
+    mkdirp(file, function (err) {
+        t.ifError(err);
+        exists(file, function (ex) {
+            t.ok(ex, 'file created');
+            fs.stat(file, function (err, stat) {
+                t.ifError(err);
+                t.equal(stat.mode & 0777, 0777 & (~process.umask()));
+                t.ok(stat.isDirectory(), 'target not a directory');
+            });
+        })
+    });
+});

node_modules/extract-zip/node_modules/mkdirp/test/umask_sync.js

@@ -0,0 +1,30 @@
+var mkdirp = require('../');
+var path = require('path');
+var fs = require('fs');
+var exists = fs.exists || path.exists;
+var test = require('tap').test;
+
+test('umask sync modes', function (t) {
+    t.plan(4);
+    var x = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var y = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+    var z = Math.floor(Math.random() * Math.pow(16,4)).toString(16);
+
+    var file = '/tmp/' + [x,y,z].join('/');
+
+    try {
+        mkdirp.sync(file);
+    } catch (err) {
+        t.fail(err);
+        return t.end();
+    }
+
+    exists(file, function (ex) {
+        t.ok(ex, 'file created');
+        fs.stat(file, function (err, stat) {
+            t.ifError(err);
+            t.equal(stat.mode & 0777, (0777 & (~process.umask())));
+            t.ok(stat.isDirectory(), 'target not a directory');
+        });
+    });
+});

node_modules/extract-zip/package.json

@@ -0,0 +1,110 @@
+{
+  "_args": [
+    [
+      {
+        "name": "extract-zip",
+        "raw": "extract-zip@~1.5.0",
+        "rawSpec": "~1.5.0",
+        "scope": null,
+        "spec": ">=1.5.0 <1.6.0",
+        "type": "range"
+      },
+      "/root/gitbook/node_modules/phantomjs"
+    ]
+  ],
+  "_from": "extract-zip@>=1.5.0 <1.6.0",
+  "_id": "extract-zip@1.5.0",
+  "_inCache": true,
+  "_installable": true,
+  "_location": "/extract-zip",
+  "_nodeVersion": "4.2.3",
+  "_npmOperationalInternal": {
+    "host": "packages-13-west.internal.npmjs.com",
+    "tmp": "tmp/extract-zip-1.5.0.tgz_1457378610579_0.8177433146629483"
+  },
+  "_npmUser": {
+    "email": "max@maxogden.com",
+    "name": "maxogden"
+  },
+  "_npmVersion": "2.14.15",
+  "_phantomChildren": {
+    "minimist": "0.0.8"
+  },
+  "_requested": {
+    "name": "extract-zip",
+    "raw": "extract-zip@~1.5.0",
+    "rawSpec": "~1.5.0",
+    "scope": null,
+    "spec": ">=1.5.0 <1.6.0",
+    "type": "range"
+  },
+  "_requiredBy": [
+    "/phantomjs"
+  ],
+  "_resolved": "https://registry.npmjs.org/extract-zip/-/extract-zip-1.5.0.tgz",
+  "_shasum": "92ccf6d81ef70a9fa4c1747114ccef6d8688a6c4",
+  "_shrinkwrap": null,
+  "_spec": "extract-zip@~1.5.0",
+  "_where": "/root/gitbook/node_modules/phantomjs",
+  "author": {
+    "name": "max ogden"
+  },
+  "bin": {
+    "extract-zip": "cli.js"
+  },
+  "bugs": {
+    "url": "https://github.com/maxogden/extract-zip/issues"
+  },
+  "dependencies": {
+    "concat-stream": "1.5.0",
+    "debug": "0.7.4",
+    "mkdirp": "0.5.0",
+    "yauzl": "2.4.1"
+  },
+  "description": "unzip a zip file into a directory using 100% pure gluten-free organic javascript",
+  "devDependencies": {
+    "rimraf": "^2.2.8",
+    "standard": "^5.2.2",
+    "tape": "^4.2.0"
+  },
+  "directories": {
+    "test": "test"
+  },
+  "dist": {
+    "integrity": "sha512-Ht7oUiEXWnX5BvLzMX/UBNIjrAs53lhXtNxMNeUe8Nv0S8rfy5UGqsKOXpP8ZQMWLvheOvRqYYShBoj6fTO9bg==",
+    "shasum": "92ccf6d81ef70a9fa4c1747114ccef6d8688a6c4",
+    "signatures": [
+      {
+        "keyid": "SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA",
+        "sig": "MEQCIAtiEaR/qSJRPFzkE12PJy+EMuvLAr2YadeP5ki12cYcAiBu2XGeMqMWFUzsuvryZYWC+8YfKttz8LhnCtVnljMWHQ=="
+      }
+    ],
+    "tarball": "https://registry.npmjs.org/extract-zip/-/extract-zip-1.5.0.tgz"
+  },
+  "gitHead": "bb5798317dad5b23af6ef098cc43379b2d19d0b8",
+  "homepage": "https://github.com/maxogden/extract-zip",
+  "keywords": [
+    "unzip",
+    "zip",
+    "extract"
+  ],
+  "license": "BSD-2-Clause",
+  "main": "index.js",
+  "maintainers": [
+    {
+      "email": "max+DONT+EMAIL+ME@maxogden.com",
+      "name": "maxogden"
+    }
+  ],
+  "name": "extract-zip",
+  "optionalDependencies": {},
+  "readme": "ERROR: No README data found!",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/maxogden/extract-zip.git"
+  },
+  "scripts": {
+    "test": "standard && node test/test.js"
+  },
+  "version": "1.5.0"
+}

node_modules/extract-zip/readme.md

@@ -0,0 +1,48 @@
+# extract-zip
+
+Unzip written in pure JavaScript. Extracts a zip into a directory. Available as a library or a command line program.
+
+Uses the [`yauzl`](http://npmjs.org/yauzl) ZIP parser.
+
+[![NPM](https://nodei.co/npm/extract-zip.png?global=true)](https://nodei.co/npm/extract-zip/)
+[![js-standard-style](https://cdn.rawgit.com/feross/standard/master/badge.svg)](https://github.com/feross/standard)
+
+## Installation
+
+Get the library:
+
+```
+npm install extract-zip --save
+```
+
+Install the command line program:
+
+```
+npm install extract-zip -g
+```
+
+## JS API
+
+```js
+var extract = require('extract-zip')
+extract(source, {dir: target}, function (err) {
+ // extraction is complete. make sure to handle the err
+})
+```
+
+### Options
+
+- `dir` - defaults to `process.cwd()`
+- `defaultDirMode` - integer - Directory Mode (permissions) will default to `493` (octal `0755` in integer)
+- `defaultFileMode` - integer - File Mode (permissions) will default to `420` (octal `0644` in integer)
+- `onEntry` - function - if present, will be called with every entry from the zip file. forwarded from the `entry` event from yauzl.
+
+Default modes are only used if no permissions are set in the zip file.
+
+## CLI Usage
+
+```
+extract-zip foo.zip <targetDirectory>
+```
+
+If not specified, `targetDirectory` will default to `process.cwd()`.