Initial commit

node_modules/pn/_promise.js

@@ -0,0 +1,6 @@
+// Allow the user to customize the Promise type returned by this library.
+var mypromise = global.Promise;
+module.exports = function getOrSetPromise(p) {
+    if (p) { mypromise = p; }
+    return mypromise;
+};

node_modules/pn/_promisify.js

@@ -0,0 +1,58 @@
+// freeze Array#slice, just in case of funny business later.
+var _slice = Array.prototype.slice;
+var getPromise = require('./_promise.js');
+
+// deferred gets its own scope to prevent inadvertent capture in the closure
+var deferred = function(options) {
+    var Promise = getPromise();
+    var resolve, reject, p = new Promise(function(_resolve, _reject) {
+        resolve = _resolve; reject = _reject;
+    });
+    var pattern = (options && options.pattern);
+    var noError = (options && options.noError);
+    var cb = pattern ? function(err) {
+        if (err && !noError) { return reject(err); }
+        var result = {}, i, offset = noError ? 0 : 1;
+        for (i = 0; i < pattern.length; i++) {
+            result[pattern[i]] = arguments[i+offset];
+        }
+        resolve(result);
+    } : noError ? resolve : function(err, val) {
+        if (err) { reject(err); } else { resolve(val); }
+    };
+    return { promise: p, callback: cb };
+};
+var promisify = module.exports = function(context, func, mandatoryArgs, options) {
+    if (options && options.callbackIsFirstArg) {
+        // duplicate some code here so we don't have to process this unusual
+        // situation at runtime in the common case.
+        return function(cb) {
+            if (typeof(cb) === 'function') {
+                return func.apply(context, arguments);
+            }
+            var d = deferred(options);
+            var a = _slice.call(arguments, 0);
+            a.unshift(d.callback);
+            func.apply(context, a);
+            return d.promise;
+        };
+    }
+    return function() {
+        var cb = arguments[arguments.length - 1];
+        if (typeof(cb) === 'function') {
+            return func.apply(context, arguments);
+        }
+        // ooh, promises.
+        var d = deferred(options);
+        var a = _slice.call(arguments, 0);
+        while (a.length < mandatoryArgs) { a.push(undefined); }
+        a.push(d.callback);
+        var retval = func.apply(context, a);
+        if (options && options.returnsObject) {
+            // it would be nice to have a better convention here
+            Object.defineProperty(retval, 'promise', { value: d.promise });
+            return retval;
+        }
+        return d.promise;
+    };
+};

node_modules/pn/assert.js

@@ -0,0 +1,2 @@
+var assert = require("assert");
+module.exports = assert;

node_modules/pn/async_hooks.js

@@ -0,0 +1,3 @@
+var async_hooks = {};
+try { async_hooks = require("async_hooks"); } catch (e) { }
+module.exports = async_hooks;

node_modules/pn/buffer.js

@@ -0,0 +1,2 @@
+var buffer = require("buffer");
+module.exports = buffer;

node_modules/pn/child_process.js

@@ -0,0 +1,14 @@
+var child_process = require("child_process");
+var promisify = require("./_promisify.js");
+var bind = function(c, f) { return f && f.bind(c); };
+Object.defineProperties(module.exports, {
+  ChildProcess: { enumerable: true, value: child_process.ChildProcess },
+  //_forkChild: // skipping
+  exec: { enumerable: true, value: promisify(child_process, child_process.exec, 1, {"pattern":["stdout","stderr"],"returnsObject":true}) },
+  execFile: { enumerable: true, value: promisify(child_process, child_process.execFile, 1, {"pattern":["stdout","stderr"],"returnsObject":true}) },
+  execFileSync: { enumerable: true, value: bind(child_process, child_process.execFileSync) },
+  execSync: { enumerable: true, value: bind(child_process, child_process.execSync) },
+  fork: { enumerable: true, value: bind(child_process, child_process.fork) },
+  spawn: { enumerable: true, value: bind(child_process, child_process.spawn) },
+  spawnSync: { enumerable: true, value: bind(child_process, child_process.spawnSync) },
+});

node_modules/pn/cluster.js

@@ -0,0 +1,20 @@
+var cluster = require("cluster");
+var promisify = require("./_promisify.js");
+var bind = function(c, f) { return f && f.bind(c); };
+Object.defineProperties(module.exports, {
+  SCHED_NONE: { enumerable: true, value: cluster.SCHED_NONE },
+  SCHED_RR: { enumerable: true, value: cluster.SCHED_RR },
+  Worker: { enumerable: true, value: cluster.Worker },
+  //_events: // skipping
+  //_eventsCount: // skipping
+  //_maxListeners: // skipping
+  disconnect: { enumerable: true, value: promisify(cluster, cluster.disconnect, 0) },
+  domain: { enumerable: true, get: function() { return cluster.domain; }, set: function(v) { cluster.domain = v; } },
+  fork: { enumerable: true, value: bind(cluster, cluster.fork) },
+  isMaster: { enumerable: true, get: function() { return cluster.isMaster; }, set: function(v) { cluster.isMaster = v; } },
+  isWorker: { enumerable: true, get: function() { return cluster.isWorker; }, set: function(v) { cluster.isWorker = v; } },
+  schedulingPolicy: { enumerable: true, get: function() { return cluster.schedulingPolicy; }, set: function(v) { cluster.schedulingPolicy = v; } },
+  settings: { enumerable: true, get: function() { return cluster.settings; }, set: function(v) { cluster.settings = v; } },
+  setupMaster: { enumerable: true, value: bind(cluster, cluster.setupMaster) },
+  workers: { enumerable: true, get: function() { return cluster.workers; }, set: function(v) { cluster.workers = v; } },
+});

node_modules/pn/console.js

@@ -0,0 +1,2 @@
+var console = require("console");
+module.exports = console;

node_modules/pn/crypto.js

@@ -0,0 +1,53 @@
+var crypto = require("crypto");
+var promisify = require("./_promisify.js");
+var bind = function(c, f) { return f && f.bind(c); };
+Object.defineProperties(module.exports, {
+  Certificate: { enumerable: true, value: crypto.Certificate },
+  Cipher: { enumerable: true, value: crypto.Cipher },
+  Cipheriv: { enumerable: true, value: crypto.Cipheriv },
+  Credentials: { enumerable: true, value: crypto.Credentials },
+  DEFAULT_ENCODING: { enumerable: true, get: function() { return crypto.DEFAULT_ENCODING; }, set: function(v) { crypto.DEFAULT_ENCODING = v; } },
+  Decipher: { enumerable: true, value: crypto.Decipher },
+  Decipheriv: { enumerable: true, value: crypto.Decipheriv },
+  DiffieHellman: { enumerable: true, value: crypto.DiffieHellman },
+  DiffieHellmanGroup: { enumerable: true, value: crypto.DiffieHellmanGroup },
+  ECDH: { enumerable: true, value: crypto.ECDH },
+  Hash: { enumerable: true, value: crypto.Hash },
+  Hmac: { enumerable: true, value: crypto.Hmac },
+  Sign: { enumerable: true, value: crypto.Sign },
+  Verify: { enumerable: true, value: crypto.Verify },
+  //_toBuf: // skipping
+  constants: { enumerable: true, get: function() { return crypto.constants; }, set: function(v) { crypto.constants = v; } },
+  createCipher: { enumerable: true, value: bind(crypto, crypto.createCipher) },
+  createCipheriv: { enumerable: true, value: bind(crypto, crypto.createCipheriv) },
+  createCredentials: { enumerable: true, value: bind(crypto, crypto.createCredentials) },
+  createDecipher: { enumerable: true, value: bind(crypto, crypto.createDecipher) },
+  createDecipheriv: { enumerable: true, value: bind(crypto, crypto.createDecipheriv) },
+  createDiffieHellman: { enumerable: true, value: bind(crypto, crypto.createDiffieHellman) },
+  createDiffieHellmanGroup: { enumerable: true, value: bind(crypto, crypto.createDiffieHellmanGroup) },
+  createECDH: { enumerable: true, value: bind(crypto, crypto.createECDH) },
+  createHash: { enumerable: true, value: bind(crypto, crypto.createHash) },
+  createHmac: { enumerable: true, value: bind(crypto, crypto.createHmac) },
+  createSign: { enumerable: true, value: bind(crypto, crypto.createSign) },
+  createVerify: { enumerable: true, value: bind(crypto, crypto.createVerify) },
+  getCiphers: { enumerable: true, value: bind(crypto, crypto.getCiphers) },
+  getCurves: { enumerable: true, value: bind(crypto, crypto.getCurves) },
+  getDiffieHellman: { enumerable: true, value: bind(crypto, crypto.getDiffieHellman) },
+  getHashes: { enumerable: true, value: bind(crypto, crypto.getHashes) },
+  pbkdf2: { enumerable: true, value: promisify(crypto, crypto.pbkdf2, 5) },
+  pbkdf2Sync: { enumerable: true, value: bind(crypto, crypto.pbkdf2Sync) },
+  privateDecrypt: { enumerable: true, value: bind(crypto, crypto.privateDecrypt) },
+  privateEncrypt: { enumerable: true, value: bind(crypto, crypto.privateEncrypt) },
+  prng: { enumerable: true, value: bind(crypto, crypto.prng) },
+  pseudoRandomBytes: { enumerable: true, value: promisify(crypto, crypto.pseudoRandomBytes, 1) },
+  pseudoRandomBytesSync: { enumerable: true, value: crypto.pseudoRandomBytes.bind(crypto) },
+  publicDecrypt: { enumerable: true, value: bind(crypto, crypto.publicDecrypt) },
+  publicEncrypt: { enumerable: true, value: bind(crypto, crypto.publicEncrypt) },
+  randomBytes: { enumerable: true, value: promisify(crypto, crypto.randomBytes, 1) },
+  randomBytesSync: { enumerable: true, value: crypto.randomBytes.bind(crypto) },
+  randomFill: { enumerable: true, value: promisify(crypto, crypto.randomFill, 1) },
+  randomFillSync: { enumerable: true, value: bind(crypto, crypto.randomFillSync) },
+  rng: { enumerable: true, value: bind(crypto, crypto.rng) },
+  setEngine: { enumerable: true, value: bind(crypto, crypto.setEngine) },
+  timingSafeEqual: { enumerable: true, value: bind(crypto, crypto.timingSafeEqual) },
+});

node_modules/pn/dgram.js

@@ -0,0 +1,8 @@
+var dgram = require("dgram");
+var promisify = require("./_promisify.js");
+var bind = function(c, f) { return f && f.bind(c); };
+Object.defineProperties(module.exports, {
+  Socket: { enumerable: true, value: dgram.Socket },
+  //_createSocketHandle: // skipping
+  createSocket: { enumerable: true, value: bind(dgram, dgram.createSocket) },
+});

node_modules/pn/dns.js

@@ -0,0 +1,49 @@
+var dns = require("dns");
+var promisify = require("./_promisify.js");
+var bind = function(c, f) { return f && f.bind(c); };
+Object.defineProperties(module.exports, {
+  ADDRCONFIG: { enumerable: true, value: dns.ADDRCONFIG },
+  ADDRGETNETWORKPARAMS: { enumerable: true, value: dns.ADDRGETNETWORKPARAMS },
+  BADFAMILY: { enumerable: true, value: dns.BADFAMILY },
+  BADFLAGS: { enumerable: true, value: dns.BADFLAGS },
+  BADHINTS: { enumerable: true, value: dns.BADHINTS },
+  BADNAME: { enumerable: true, value: dns.BADNAME },
+  BADQUERY: { enumerable: true, value: dns.BADQUERY },
+  BADRESP: { enumerable: true, value: dns.BADRESP },
+  BADSTR: { enumerable: true, value: dns.BADSTR },
+  CANCELLED: { enumerable: true, value: dns.CANCELLED },
+  CONNREFUSED: { enumerable: true, value: dns.CONNREFUSED },
+  DESTRUCTION: { enumerable: true, value: dns.DESTRUCTION },
+  EOF: { enumerable: true, value: dns.EOF },
+  FILE: { enumerable: true, value: dns.FILE },
+  FORMERR: { enumerable: true, value: dns.FORMERR },
+  LOADIPHLPAPI: { enumerable: true, value: dns.LOADIPHLPAPI },
+  NODATA: { enumerable: true, value: dns.NODATA },
+  NOMEM: { enumerable: true, value: dns.NOMEM },
+  NONAME: { enumerable: true, value: dns.NONAME },
+  NOTFOUND: { enumerable: true, value: dns.NOTFOUND },
+  NOTIMP: { enumerable: true, value: dns.NOTIMP },
+  NOTINITIALIZED: { enumerable: true, value: dns.NOTINITIALIZED },
+  REFUSED: { enumerable: true, value: dns.REFUSED },
+  Resolver: { enumerable: true, value: dns.Resolver },
+  SERVFAIL: { enumerable: true, value: dns.SERVFAIL },
+  TIMEOUT: { enumerable: true, value: dns.TIMEOUT },
+  V4MAPPED: { enumerable: true, value: dns.V4MAPPED },
+  getServers: { enumerable: true, value: bind(dns, dns.getServers) },
+  lookup: { enumerable: true, value: promisify(dns, dns.lookup, 1) },
+  lookupService: { enumerable: true, value: promisify(dns, dns.lookupService, 2, {"pattern":["hostname","service"]}) },
+  resolve: { enumerable: true, value: promisify(dns, dns.resolve, 1) },
+  resolve4: { enumerable: true, value: promisify(dns, dns.resolve4, 1) },
+  resolve6: { enumerable: true, value: promisify(dns, dns.resolve6, 1) },
+  resolveAny: { enumerable: true, value: promisify(dns, dns.resolveAny, 1) },
+  resolveCname: { enumerable: true, value: promisify(dns, dns.resolveCname, 1) },
+  resolveMx: { enumerable: true, value: promisify(dns, dns.resolveMx, 1) },
+  resolveNaptr: { enumerable: true, value: promisify(dns, dns.resolveNaptr, 1) },
+  resolveNs: { enumerable: true, value: promisify(dns, dns.resolveNs, 1) },
+  resolvePtr: { enumerable: true, value: promisify(dns, dns.resolvePtr, 1) },
+  resolveSoa: { enumerable: true, value: promisify(dns, dns.resolveSoa, 1) },
+  resolveSrv: { enumerable: true, value: promisify(dns, dns.resolveSrv, 1) },
+  resolveTxt: { enumerable: true, value: promisify(dns, dns.resolveTxt, 1) },
+  reverse: { enumerable: true, value: promisify(dns, dns.reverse, 1) },
+  setServers: { enumerable: true, value: bind(dns, dns.setServers) },
+});

node_modules/pn/domain.js

@@ -0,0 +1,10 @@
+var domain = require("domain");
+var promisify = require("./_promisify.js");
+var bind = function(c, f) { return f && f.bind(c); };
+Object.defineProperties(module.exports, {
+  Domain: { enumerable: true, value: domain.Domain },
+  //_stack: // skipping
+  active: { enumerable: true, get: function() { return domain.active; }, set: function(v) { domain.active = v; } },
+  create: { enumerable: true, value: bind(domain, domain.create) },
+  createDomain: { enumerable: true, value: bind(domain, domain.createDomain) },
+});

node_modules/pn/events.js

@@ -0,0 +1,2 @@
+var events = require("events");
+module.exports = events;

node_modules/pn/fs.js

@@ -0,0 +1,87 @@
+var fs = require("fs");
+var promisify = require("./_promisify.js");
+var bind = function(c, f) { return f && f.bind(c); };
+Object.defineProperties(module.exports, {
+  F_OK: { enumerable: true, value: fs.F_OK },
+  FileReadStream: { enumerable: true, value: fs.FileReadStream },
+  FileWriteStream: { enumerable: true, value: fs.FileWriteStream },
+  R_OK: { enumerable: true, value: fs.R_OK },
+  ReadStream: { enumerable: true, value: fs.ReadStream },
+  Stats: { enumerable: true, value: fs.Stats },
+  W_OK: { enumerable: true, value: fs.W_OK },
+  WriteStream: { enumerable: true, value: fs.WriteStream },
+  X_OK: { enumerable: true, value: fs.X_OK },
+  //_toUnixTimestamp: // skipping
+  access: { enumerable: true, value: promisify(fs, fs.access, 1) },
+  accessSync: { enumerable: true, value: bind(fs, fs.accessSync) },
+  appendFile: { enumerable: true, value: promisify(fs, fs.appendFile, 2) },
+  appendFileSync: { enumerable: true, value: bind(fs, fs.appendFileSync) },
+  chmod: { enumerable: true, value: promisify(fs, fs.chmod, 2) },
+  chmodSync: { enumerable: true, value: bind(fs, fs.chmodSync) },
+  chown: { enumerable: true, value: promisify(fs, fs.chown, 3) },
+  chownSync: { enumerable: true, value: bind(fs, fs.chownSync) },
+  close: { enumerable: true, value: promisify(fs, fs.close, 1) },
+  closeSync: { enumerable: true, value: bind(fs, fs.closeSync) },
+  constants: { enumerable: true, get: function() { return fs.constants; }, set: function(v) { fs.constants = v; } },
+  copyFile: { enumerable: true, value: promisify(fs, fs.copyFile, 2) },
+  copyFileSync: { enumerable: true, value: bind(fs, fs.copyFileSync) },
+  createReadStream: { enumerable: true, value: bind(fs, fs.createReadStream) },
+  createWriteStream: { enumerable: true, value: bind(fs, fs.createWriteStream) },
+  exists: { enumerable: true, value: promisify(fs, fs.exists, 1, {"noError":true}) },
+  existsSync: { enumerable: true, value: bind(fs, fs.existsSync) },
+  fchmod: { enumerable: true, value: promisify(fs, fs.fchmod, 2) },
+  fchmodSync: { enumerable: true, value: bind(fs, fs.fchmodSync) },
+  fchown: { enumerable: true, value: promisify(fs, fs.fchown, 3) },
+  fchownSync: { enumerable: true, value: bind(fs, fs.fchownSync) },
+  fdatasync: { enumerable: true, value: promisify(fs, fs.fdatasync, 1) },
+  fdatasyncSync: { enumerable: true, value: bind(fs, fs.fdatasyncSync) },
+  fstat: { enumerable: true, value: promisify(fs, fs.fstat, 1) },
+  fstatSync: { enumerable: true, value: bind(fs, fs.fstatSync) },
+  fsync: { enumerable: true, value: promisify(fs, fs.fsync, 1) },
+  fsyncSync: { enumerable: true, value: bind(fs, fs.fsyncSync) },
+  ftruncate: { enumerable: true, value: promisify(fs, fs.ftruncate, 2) },
+  ftruncateSync: { enumerable: true, value: bind(fs, fs.ftruncateSync) },
+  futimes: { enumerable: true, value: promisify(fs, fs.futimes, 3) },
+  futimesSync: { enumerable: true, value: bind(fs, fs.futimesSync) },
+  link: { enumerable: true, value: promisify(fs, fs.link, 2) },
+  linkSync: { enumerable: true, value: bind(fs, fs.linkSync) },
+  lstat: { enumerable: true, value: promisify(fs, fs.lstat, 1) },
+  lstatSync: { enumerable: true, value: bind(fs, fs.lstatSync) },
+  mkdir: { enumerable: true, value: promisify(fs, fs.mkdir, 1) },
+  mkdirSync: { enumerable: true, value: bind(fs, fs.mkdirSync) },
+  mkdtemp: { enumerable: true, value: promisify(fs, fs.mkdtemp, 1) },
+  mkdtempSync: { enumerable: true, value: bind(fs, fs.mkdtempSync) },
+  open: { enumerable: true, value: promisify(fs, fs.open, 2) },
+  openSync: { enumerable: true, value: bind(fs, fs.openSync) },
+  read: { enumerable: true, value: promisify(fs, fs.read, 5, {"pattern":["read","buffer"]}) },
+  readFile: { enumerable: true, value: promisify(fs, fs.readFile, 1) },
+  readFileSync: { enumerable: true, value: bind(fs, fs.readFileSync) },
+  readSync: { enumerable: true, value: bind(fs, fs.readSync) },
+  readdir: { enumerable: true, value: promisify(fs, fs.readdir, 1) },
+  readdirSync: { enumerable: true, value: bind(fs, fs.readdirSync) },
+  readlink: { enumerable: true, value: promisify(fs, fs.readlink, 1) },
+  readlinkSync: { enumerable: true, value: bind(fs, fs.readlinkSync) },
+  realpath: { enumerable: true, value: promisify(fs, fs.realpath, 1) },
+  realpathSync: { enumerable: true, value: bind(fs, fs.realpathSync) },
+  rename: { enumerable: true, value: promisify(fs, fs.rename, 2) },
+  renameSync: { enumerable: true, value: bind(fs, fs.renameSync) },
+  rmdir: { enumerable: true, value: promisify(fs, fs.rmdir, 1) },
+  rmdirSync: { enumerable: true, value: bind(fs, fs.rmdirSync) },
+  stat: { enumerable: true, value: promisify(fs, fs.stat, 1) },
+  statSync: { enumerable: true, value: bind(fs, fs.statSync) },
+  symlink: { enumerable: true, value: promisify(fs, fs.symlink, 2) },
+  symlinkSync: { enumerable: true, value: bind(fs, fs.symlinkSync) },
+  truncate: { enumerable: true, value: promisify(fs, fs.truncate, 2) },
+  truncateSync: { enumerable: true, value: bind(fs, fs.truncateSync) },
+  unlink: { enumerable: true, value: promisify(fs, fs.unlink, 1) },
+  unlinkSync: { enumerable: true, value: bind(fs, fs.unlinkSync) },
+  unwatchFile: { enumerable: true, value: bind(fs, fs.unwatchFile) },
+  utimes: { enumerable: true, value: promisify(fs, fs.utimes, 3) },
+  utimesSync: { enumerable: true, value: bind(fs, fs.utimesSync) },
+  watch: { enumerable: true, value: bind(fs, fs.watch) },
+  watchFile: { enumerable: true, value: bind(fs, fs.watchFile) },
+  write: { enumerable: true, value: promisify(fs, fs.write, 5, {"pattern":["written","buffer"]}) },
+  writeFile: { enumerable: true, value: promisify(fs, fs.writeFile, 2) },
+  writeFileSync: { enumerable: true, value: bind(fs, fs.writeFileSync) },
+  writeSync: { enumerable: true, value: bind(fs, fs.writeSync) },
+});

node_modules/pn/http.js

@@ -0,0 +1,20 @@
+var http = require("http");
+var promisify = require("./_promisify.js");
+var bind = function(c, f) { return f && f.bind(c); };
+Object.defineProperties(module.exports, {
+  Agent: { enumerable: true, value: http.Agent },
+  Client: { enumerable: true, value: http.Client },
+  ClientRequest: { enumerable: true, value: http.ClientRequest },
+  IncomingMessage: { enumerable: true, value: http.IncomingMessage },
+  METHODS: { enumerable: true, value: http.METHODS },
+  OutgoingMessage: { enumerable: true, value: http.OutgoingMessage },
+  STATUS_CODES: { enumerable: true, value: http.STATUS_CODES },
+  Server: { enumerable: true, value: http.Server },
+  ServerResponse: { enumerable: true, value: http.ServerResponse },
+  //_connectionListener: // skipping
+  createClient: { enumerable: true, value: bind(http, http.createClient) },
+  createServer: { enumerable: true, value: bind(http, http.createServer) },
+  get: { enumerable: true, value: promisify(http, http.get, 1, {"returnsObject":true}) },
+  globalAgent: { enumerable: true, get: function() { return http.globalAgent; }, set: function(v) { http.globalAgent = v; } },
+  request: { enumerable: true, value: promisify(http, http.request, 1, {"returnsObject":true}) },
+});

node_modules/pn/http2.js

@@ -0,0 +1,15 @@
+var http2 = {};
+try { http2 = require("http2"); } catch (e) { }
+var promisify = require("./_promisify.js");
+var bind = function(c, f) { return f && f.bind(c); };
+Object.defineProperties(module.exports, {
+  Http2ServerRequest: { enumerable: true, value: http2.Http2ServerRequest },
+  Http2ServerResponse: { enumerable: true, value: http2.Http2ServerResponse },
+  connect: { enumerable: true, value: bind(http2, http2.connect) },
+  constants: { enumerable: true, get: function() { return http2.constants; }, set: function(v) { http2.constants = v; } },
+  createSecureServer: { enumerable: true, value: bind(http2, http2.createSecureServer) },
+  createServer: { enumerable: true, value: bind(http2, http2.createServer) },
+  getDefaultSettings: { enumerable: true, value: bind(http2, http2.getDefaultSettings) },
+  getPackedSettings: { enumerable: true, value: bind(http2, http2.getPackedSettings) },
+  getUnpackedSettings: { enumerable: true, value: bind(http2, http2.getUnpackedSettings) },
+});

node_modules/pn/https.js

@@ -0,0 +1,11 @@
+var https = require("https");
+var promisify = require("./_promisify.js");
+var bind = function(c, f) { return f && f.bind(c); };
+Object.defineProperties(module.exports, {
+  Agent: { enumerable: true, value: https.Agent },
+  Server: { enumerable: true, value: https.Server },
+  createServer: { enumerable: true, value: bind(https, https.createServer) },
+  get: { enumerable: true, value: promisify(https, https.get, 1, {"returnsObject":true}) },
+  globalAgent: { enumerable: true, get: function() { return https.globalAgent; }, set: function(v) { https.globalAgent = v; } },
+  request: { enumerable: true, value: promisify(https, https.request, 1, {"returnsObject":true}) },
+});

node_modules/pn/inspector.js

@@ -0,0 +1,3 @@
+var inspector = {};
+try { inspector = require("inspector"); } catch (e) { }
+module.exports = inspector;

node_modules/pn/net.js

@@ -0,0 +1,17 @@
+var net = require("net");
+var promisify = require("./_promisify.js");
+var bind = function(c, f) { return f && f.bind(c); };
+Object.defineProperties(module.exports, {
+  Server: { enumerable: true, value: net.Server },
+  Socket: { enumerable: true, value: net.Socket },
+  Stream: { enumerable: true, value: net.Stream },
+  //_createServerHandle: // skipping
+  //_normalizeArgs: // skipping
+  //_setSimultaneousAccepts: // skipping
+  connect: { enumerable: true, value: bind(net, net.connect) },
+  createConnection: { enumerable: true, value: bind(net, net.createConnection) },
+  createServer: { enumerable: true, value: bind(net, net.createServer) },
+  isIP: { enumerable: true, value: bind(net, net.isIP) },
+  isIPv4: { enumerable: true, value: bind(net, net.isIPv4) },
+  isIPv6: { enumerable: true, value: bind(net, net.isIPv6) },
+});

node_modules/pn/os.js

@@ -0,0 +1,2 @@
+var os = require("os");
+module.exports = os;

node_modules/pn/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "pn",
+  "version": "1.1.0",
+  "description": "Promisify the node standard library.",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/cscott/node-pn"
+  },
+  "author": "C. Scott Ananian",
+  "license": "MIT",
+  "devDependencies": {
+    "es6-shim": "~0.35.3",
+    "mocha": "~3.5.0",
+    "prfun": "~2.1.4"
+  }
+}

node_modules/pn/path.js

@@ -0,0 +1,2 @@
+var path = require("path");
+module.exports = path;

node_modules/pn/perf_hooks.js

@@ -0,0 +1,3 @@
+var perf_hooks = {};
+try { perf_hooks = require("perf_hooks"); } catch (e) { }
+module.exports = perf_hooks;

node_modules/pn/process.js

@@ -0,0 +1,74 @@
+var promisify = require("./_promisify.js");
+var bind = function(c, f) { return f && f.bind(c); };
+Object.defineProperties(module.exports, {
+  EventEmitter: { enumerable: true, value: process.EventEmitter },
+  //_debugEnd: // skipping
+  //_debugPause: // skipping
+  //_debugProcess: // skipping
+  //_events: // skipping
+  //_eventsCount: // skipping
+  //_exiting: // skipping
+  //_fatalException: // skipping
+  //_getActiveHandles: // skipping
+  //_getActiveRequests: // skipping
+  //_immediateCallback: // skipping
+  //_kill: // skipping
+  //_linkedBinding: // skipping
+  //_maxListeners: // skipping
+  //_rawDebug: // skipping
+  //_startProfilerIdleNotifier: // skipping
+  //_stopProfilerIdleNotifier: // skipping
+  //_tickCallback: // skipping
+  abort: { enumerable: true, value: bind(process, process.abort) },
+  arch: { enumerable: true, get: function() { return process.arch; }, set: function(v) { process.arch = v; } },
+  argv: { enumerable: true, get: function() { return process.argv; }, set: function(v) { process.argv = v; } },
+  argv0: { enumerable: true, get: function() { return process.argv0; }, set: function(v) { process.argv0 = v; } },
+  assert: { enumerable: true, value: bind(process, process.assert) },
+  binding: { enumerable: true, value: bind(process, process.binding) },
+  chdir: { enumerable: true, value: bind(process, process.chdir) },
+  config: { enumerable: true, get: function() { return process.config; }, set: function(v) { process.config = v; } },
+  cpuUsage: { enumerable: true, value: bind(process, process.cpuUsage) },
+  cwd: { enumerable: true, value: bind(process, process.cwd) },
+  debugPort: { enumerable: true, get: function() { return process.debugPort; }, set: function(v) { process.debugPort = v; } },
+  dlopen: { enumerable: true, value: bind(process, process.dlopen) },
+  domain: { enumerable: true, get: function() { return process.domain; }, set: function(v) { process.domain = v; } },
+  emitWarning: { enumerable: true, value: bind(process, process.emitWarning) },
+  env: { enumerable: true, get: function() { return process.env; }, set: function(v) { process.env = v; } },
+  execArgv: { enumerable: true, get: function() { return process.execArgv; }, set: function(v) { process.execArgv = v; } },
+  execPath: { enumerable: true, get: function() { return process.execPath; }, set: function(v) { process.execPath = v; } },
+  exit: { enumerable: true, value: bind(process, process.exit) },
+  features: { enumerable: true, get: function() { return process.features; }, set: function(v) { process.features = v; } },
+  getegid: { enumerable: true, value: bind(process, process.getegid) },
+  geteuid: { enumerable: true, value: bind(process, process.geteuid) },
+  getgid: { enumerable: true, value: bind(process, process.getgid) },
+  getgroups: { enumerable: true, value: bind(process, process.getgroups) },
+  getuid: { enumerable: true, value: bind(process, process.getuid) },
+  hasUncaughtExceptionCaptureCallback: { enumerable: true, value: bind(process, process.hasUncaughtExceptionCaptureCallback) },
+  hrtime: { enumerable: true, value: bind(process, process.hrtime) },
+  initgroups: { enumerable: true, value: bind(process, process.initgroups) },
+  kill: { enumerable: true, value: bind(process, process.kill) },
+  mainModule: { enumerable: true, get: function() { return process.mainModule; }, set: function(v) { process.mainModule = v; } },
+  memoryUsage: { enumerable: true, value: bind(process, process.memoryUsage) },
+  moduleLoadList: { enumerable: true, get: function() { return process.moduleLoadList; }, set: function(v) { process.moduleLoadList = v; } },
+  nextTick: { enumerable: true, value: promisify(process, process.nextTick, 0) },
+  openStdin: { enumerable: true, value: bind(process, process.openStdin) },
+  pid: { enumerable: true, get: function() { return process.pid; }, set: function(v) { process.pid = v; } },
+  platform: { enumerable: true, get: function() { return process.platform; }, set: function(v) { process.platform = v; } },
+  ppid: { enumerable: true, get: function() { return process.ppid; }, set: function(v) { process.ppid = v; } },
+  reallyExit: { enumerable: true, value: bind(process, process.reallyExit) },
+  release: { enumerable: true, get: function() { return process.release; }, set: function(v) { process.release = v; } },
+  setUncaughtExceptionCaptureCallback: { enumerable: true, value: bind(process, process.setUncaughtExceptionCaptureCallback) },
+  setegid: { enumerable: true, value: bind(process, process.setegid) },
+  seteuid: { enumerable: true, value: bind(process, process.seteuid) },
+  setgid: { enumerable: true, value: bind(process, process.setgid) },
+  setgroups: { enumerable: true, value: bind(process, process.setgroups) },
+  setuid: { enumerable: true, value: bind(process, process.setuid) },
+  stderr: { enumerable: true, get: function() { return process.stderr; }, set: function(v) { process.stderr = v; } },
+  stdin: { enumerable: true, get: function() { return process.stdin; }, set: function(v) { process.stdin = v; } },
+  stdout: { enumerable: true, get: function() { return process.stdout; }, set: function(v) { process.stdout = v; } },
+  title: { enumerable: true, get: function() { return process.title; }, set: function(v) { process.title = v; } },
+  umask: { enumerable: true, value: bind(process, process.umask) },
+  uptime: { enumerable: true, value: bind(process, process.uptime) },
+  version: { enumerable: true, get: function() { return process.version; }, set: function(v) { process.version = v; } },
+  versions: { enumerable: true, get: function() { return process.versions; }, set: function(v) { process.versions = v; } },
+});

node_modules/pn/punycode.js

@@ -0,0 +1,3 @@
+var punycode = {};
+try { punycode = require("punycode"); } catch (e) { }
+module.exports = punycode;

node_modules/pn/querystring.js

@@ -0,0 +1,2 @@
+var querystring = require("querystring");
+module.exports = querystring;

node_modules/pn/readline.js

@@ -0,0 +1,16 @@
+var readline = require("readline");
+var promisify = require("./_promisify.js");
+var bind = function(c, f) { return f && f.bind(c); };
+Object.defineProperties(module.exports, {
+  Interface: { enumerable: true, value: readline.Interface },
+  clearLine: { enumerable: true, value: bind(readline, readline.clearLine) },
+  clearScreenDown: { enumerable: true, value: bind(readline, readline.clearScreenDown) },
+  codePointAt: { enumerable: true, value: bind(readline, readline.codePointAt) },
+  createInterface: { enumerable: true, value: bind(readline, readline.createInterface) },
+  cursorTo: { enumerable: true, value: bind(readline, readline.cursorTo) },
+  emitKeypressEvents: { enumerable: true, value: bind(readline, readline.emitKeypressEvents) },
+  getStringWidth: { enumerable: true, value: bind(readline, readline.getStringWidth) },
+  isFullWidthCodePoint: { enumerable: true, value: bind(readline, readline.isFullWidthCodePoint) },
+  moveCursor: { enumerable: true, value: bind(readline, readline.moveCursor) },
+  stripVTControlCharacters: { enumerable: true, value: bind(readline, readline.stripVTControlCharacters) },
+});

node_modules/pn/repl.js

@@ -0,0 +1,2 @@
+var repl = require("repl");
+module.exports = repl;

node_modules/pn/scripts/generate.js

@@ -0,0 +1,244 @@
+#!/usr/bin/env node
+var fs = require('fs');
+var path = require('path');
+
+// These are the node packages we are going to wrap.
+var packages = {
+    assert: { skip: true },
+    async_hooks: { optional: true, skip: true },
+    buffer: { skip: true },
+    child_process: {
+        exec: { promisify: true, returnsObject: true, args: 1, cb:['stdout','stderr'] },
+        execFile: { promisify: true, returnsObject: true, args: 1, cb:['stdout','stderr'] },
+        fork: { promisify: false },
+        spawn: { promisify: false },
+    },
+    cluster: {
+        disconnect: { promisify: true, args: 0 },
+    },
+    console: { skip: true },
+    crypto: {
+        DEFAULT_ENCODING: { constant: false },
+        pseudoRandomBytes: { promisify: true, syncIfNoCallback: true, args: 1 },
+        randomBytes: { promisify: true, syncIfNoCallback: true, args: 1 },
+        randomFill: { args: 1 },
+    },
+    dns: {
+        // XXX: Resolver could be wrapped...
+        ADNAME: { skip: true },
+        lookup: { promisify: true, args: 1 },
+        lookupService: { promisify: true, args: 2, cb:['hostname','service'] },
+        resolve: { promisify: true, args: 1 },
+        resolve4: { promisify: true, args: 1 },
+        resolve6: { promisify: true, args: 1 },
+        resolveAny: { promisify: true, args: 1 },
+        resolveCname: { promisify: true, args: 1 },
+        resolveMx: { promisify: true, args: 1 },
+        resolveNaptr: { promisify: true, args: 1 },
+        resolveNs: { promisify: true, args: 1 },
+        resolvePtr: { promisify: true, args: 1 },
+        resolveSoa: { promisify: true, args: 1 },
+        resolveSrv: { promisify: true, args: 1 },
+        resolveTxt: { promisify: true, args: 1 },
+        reverse: { promisify: true, args: 1 },
+    },
+    domain: {
+        // XXX Domain#bind and Domain#intercept should be promisified
+    },
+    events: {
+        skip: true,
+    },
+    fs: {
+        access: { args: 1 },
+        appendFile: { args: 2 },
+        copyFile: { args: 2 },
+        exists: { promisify: true, noError: true },
+        mkdir: { args: 1 },
+        mkdtemp: { args: 1 },
+        open: { args: 2 },
+        read: { cb: ['read', 'buffer'] },
+        readdir: { args: 1 },
+        readlink: { args: 1 },
+        readFile: { args: 1 },
+        realpath: { args: 1 },
+        symlink: { args: 2 },
+        write: { cb: ['written', 'buffer'] },
+        writeFile: { args: 2 },
+    },
+    http: {
+        STATUS_CODES: { constant: true },
+        // XXX ClientRequest#setTimeout should be promisified
+        // XXX IncomingMessage#setTimeout should be promisified
+        // XXX Server#listen, Server#close, and Server#setTimeout
+        // should be promisified
+        // XXX ServerResponse#setTimeout should be promisified
+        request: { promisify: true, returnsObject: true, args: 1 },
+        get: { promisify: true, returnsObject: true, args: 1 },
+    },
+    http2: {
+        optional: true,
+    },
+    https: {
+        // XXX Server#listen, Server#close, and Server#setTimeout
+        // should be promisified
+        request: { promisify: true, returnsObject: true, args: 1 },
+        get: { promisify: true, returnsObject: true, args: 1 },
+    },
+    inspector: {
+        optional: true,
+        skip: true,
+    },
+    net: {
+        // XXX Server#listen, Server#close, Server#getConnections
+        // should be promisified
+        // XXX Socket#write, Socket#setTimeout should be promisified
+    },
+    os: { skip: true },
+    path: { skip: true },
+    perf_hooks: { optional: true, skip: true },
+    process: {
+        nextTick: { promisify: true, args: 0 }
+    },
+    punycode: { optional: true, skip: true },
+    querystring: { skip: true },
+    readline: {
+        // XXX Interface#question should be promisified
+    },
+    repl: { skip: true },
+    stream: {
+        super_: { skip: true },
+        // XXX Writable#write and Writable#end should be promisified
+        // XXX same for Duplex and Transform? inheritance unclear.
+        // what about _read/_write/_transform/_flush for implementers?
+    },
+    string_decoder: { skip: true },
+    timers: {
+        setImmediate: { promisify: true, callbackIsFirstArg: true, noError: true },
+        setTimeout: { promisify: true, callbackIsFirstArg: true, noError: true },
+    },
+    tls: {
+        connect: { promisify: true, returnsObject: true, args: 1 },
+        createServer: { promisify: true, returnsObject: true, args: 1 },
+    },
+    tty: {
+        skip: true
+        // should tty.ReadStream and tty.WriteStream be promisified?
+        // (process.stdin / process.stdout)
+    },
+    dgram: {
+        // note that createSocket takes a listener, not a callback
+        // XXX Socket#send and Socket#bind should be promisified
+    },
+    url: { skip: true },
+    util: {
+        pump: { promisify: true, args: 2 }
+    },
+    v8: { optional: true, skip: true },
+    vm: { skip: true },
+    zlib: {
+        codes: { constant: true },
+        deflate: { promisify: true, args: 1 },
+        deflateRaw: { promisify: true, args: 1 },
+        gzip: { promisify: true, args: 1 },
+        gunzip: { promisify: true, args: 1 },
+        inflate: { promisify: true, args: 1 },
+        inflateRaw: { promisify: true, args: 1 },
+        unzip: { promisify: true, args: 1 },
+    },
+};
+
+var sorted = function(arr) {
+    var s = arr.slice(0);
+    s.sort();
+    return s;
+}
+
+sorted(Object.keys(packages)).forEach(function(pkgname) {
+    var pkgopts = packages[pkgname] || {};
+    var script = [];
+    var emit = function(l) { script.push(l); };
+    var m;
+    if (pkgname==='process') {
+        m = process;
+    } else if (pkgopts.optional) {
+        // Package is not present in older versions of node.
+        emit('var '+pkgname+' = {};');
+        emit('try { '+pkgname+' = require("'+pkgname+'"); } catch (e) { }');
+        m = require(pkgname);
+    } else {
+        emit('var '+pkgname+' = require("'+pkgname+'");');
+        m = require(pkgname);
+    }
+    if (pkgopts.skip) {
+        emit('module.exports = '+pkgname+';');
+    } else {
+        emit('var promisify = require("./_promisify.js");');
+        emit('var bind = function(c, f) { return f && f.bind(c); };');
+        emit('Object.defineProperties(module.exports, {');
+        sorted(Object.keys(m)).forEach(function(prop) {
+            var opts = pkgopts[prop] || {};
+            // skip private properties
+            if (opts.skip !== undefined ? opts.skip : /^_/.test(prop)) {
+                emit('  //'+prop+': // skipping');
+                return;
+            }
+            var out = '  '+prop+': { enumerable: true, ';
+            // Is this a function?
+            var caps = /^[A-Z]/.test(prop);
+            var isFunction = typeof(m[prop]) === 'function';
+            var isConstant = opts.constant!==undefined ? opts.constant :
+                isFunction ?
+                (opts.bind !== undefined ? opts.bind===false : caps) :
+                caps;
+            if (isConstant) {
+                emit(out+'value: '+pkgname+'.'+prop+' },');
+                return;
+            }
+            if (!isFunction) {
+                // add getters & setters
+                emit(out+'get: function() { return '+pkgname+'.'+prop+'; }, '+
+                     'set: function(v) { '+pkgname+'.'+prop+' = v; } },');
+                return;
+            }
+            // Is this a async function?
+            var isAsync = (typeof(m[prop+'Sync']) === 'function');
+            if (opts.promisify) { isAsync = true; }
+            if (!isAsync || opts.promisify === false) {
+                emit(out+'value: bind('+pkgname+', '+pkgname+'.'+prop+') },');
+                return;
+            }
+            // OK, this is very likely an async function!
+            // number of mandatory options (may be additional optional args)
+            var nargs = opts.args!==undefined ? opts.args :
+                (typeof(m[prop+'Sync']) === 'function') ?
+                m[prop+'Sync'].length : m[prop].length;
+            var options = {}, emitOptions = false;
+            if (opts.cb) {
+                options.pattern = opts.cb;
+                emitOptions = true;
+            }
+            if (opts.noError) {
+                options.noError = true;
+                emitOptions = true;
+            }
+            if (opts.returnsObject) {
+                options.returnsObject = true;
+                emitOptions = true;
+            }
+            if (opts.callbackIsFirstArg) {
+                options.callbackIsFirstArg = true;
+                nargs = 0;
+                emitOptions = true;
+            }
+            var optString = emitOptions ? ', '+JSON.stringify(options) : '';
+            emit(out+'value: promisify('+pkgname+', '+pkgname+'.'+prop+', '+nargs+optString+') },');
+            if (opts.syncIfNoCallback) {
+                emit(out.replace(/:/,"Sync:")+'value: '+pkgname+'.'+prop+'.bind('+pkgname+') },');
+            }
+        });
+        emit('});');
+    }
+    // Write out this wrapped package!
+    fs.writeFileSync(path.join(__dirname,'..',pkgname+'.js'),
+                     script.join('\n'), 'utf-8');
+});

node_modules/pn/stream.js

@@ -0,0 +1,14 @@
+var stream = require("stream");
+var promisify = require("./_promisify.js");
+var bind = function(c, f) { return f && f.bind(c); };
+Object.defineProperties(module.exports, {
+  Duplex: { enumerable: true, value: stream.Duplex },
+  PassThrough: { enumerable: true, value: stream.PassThrough },
+  Readable: { enumerable: true, value: stream.Readable },
+  Stream: { enumerable: true, value: stream.Stream },
+  Transform: { enumerable: true, value: stream.Transform },
+  Writable: { enumerable: true, value: stream.Writable },
+  //_isUint8Array: // skipping
+  //_uint8ArrayToBuffer: // skipping
+  //super_: // skipping
+});

node_modules/pn/string_decoder.js

@@ -0,0 +1,2 @@
+var string_decoder = require("string_decoder");
+module.exports = string_decoder;

node_modules/pn/timers.js

@@ -0,0 +1,15 @@
+var timers = require("timers");
+var promisify = require("./_promisify.js");
+var bind = function(c, f) { return f && f.bind(c); };
+Object.defineProperties(module.exports, {
+  //_unrefActive: // skipping
+  active: { enumerable: true, value: bind(timers, timers.active) },
+  clearImmediate: { enumerable: true, value: bind(timers, timers.clearImmediate) },
+  clearInterval: { enumerable: true, value: bind(timers, timers.clearInterval) },
+  clearTimeout: { enumerable: true, value: bind(timers, timers.clearTimeout) },
+  enroll: { enumerable: true, value: bind(timers, timers.enroll) },
+  setImmediate: { enumerable: true, value: promisify(timers, timers.setImmediate, 0, {"noError":true,"callbackIsFirstArg":true}) },
+  setInterval: { enumerable: true, value: bind(timers, timers.setInterval) },
+  setTimeout: { enumerable: true, value: promisify(timers, timers.setTimeout, 0, {"noError":true,"callbackIsFirstArg":true}) },
+  unenroll: { enumerable: true, value: bind(timers, timers.unenroll) },
+});

node_modules/pn/tls.js

@@ -0,0 +1,22 @@
+var tls = require("tls");
+var promisify = require("./_promisify.js");
+var bind = function(c, f) { return f && f.bind(c); };
+Object.defineProperties(module.exports, {
+  CLIENT_RENEG_LIMIT: { enumerable: true, value: tls.CLIENT_RENEG_LIMIT },
+  CLIENT_RENEG_WINDOW: { enumerable: true, value: tls.CLIENT_RENEG_WINDOW },
+  DEFAULT_CIPHERS: { enumerable: true, value: tls.DEFAULT_CIPHERS },
+  DEFAULT_ECDH_CURVE: { enumerable: true, value: tls.DEFAULT_ECDH_CURVE },
+  SLAB_BUFFER_SIZE: { enumerable: true, value: tls.SLAB_BUFFER_SIZE },
+  SecureContext: { enumerable: true, value: tls.SecureContext },
+  Server: { enumerable: true, value: tls.Server },
+  TLSSocket: { enumerable: true, value: tls.TLSSocket },
+  checkServerIdentity: { enumerable: true, value: bind(tls, tls.checkServerIdentity) },
+  connect: { enumerable: true, value: promisify(tls, tls.connect, 1, {"returnsObject":true}) },
+  convertALPNProtocols: { enumerable: true, value: bind(tls, tls.convertALPNProtocols) },
+  convertNPNProtocols: { enumerable: true, value: bind(tls, tls.convertNPNProtocols) },
+  createSecureContext: { enumerable: true, value: bind(tls, tls.createSecureContext) },
+  createSecurePair: { enumerable: true, value: bind(tls, tls.createSecurePair) },
+  createServer: { enumerable: true, value: promisify(tls, tls.createServer, 1, {"returnsObject":true}) },
+  getCiphers: { enumerable: true, value: bind(tls, tls.getCiphers) },
+  parseCertString: { enumerable: true, value: bind(tls, tls.parseCertString) },
+});

node_modules/pn/tty.js

@@ -0,0 +1,2 @@
+var tty = require("tty");
+module.exports = tty;

node_modules/pn/url.js

@@ -0,0 +1,2 @@
+var url = require("url");
+module.exports = url;

node_modules/pn/util.js

@@ -0,0 +1,41 @@
+var util = require("util");
+var promisify = require("./_promisify.js");
+var bind = function(c, f) { return f && f.bind(c); };
+Object.defineProperties(module.exports, {
+  TextDecoder: { enumerable: true, value: util.TextDecoder },
+  TextEncoder: { enumerable: true, value: util.TextEncoder },
+  //_errnoException: // skipping
+  //_exceptionWithHostPort: // skipping
+  //_extend: // skipping
+  callbackify: { enumerable: true, value: bind(util, util.callbackify) },
+  debug: { enumerable: true, value: bind(util, util.debug) },
+  debuglog: { enumerable: true, value: bind(util, util.debuglog) },
+  deprecate: { enumerable: true, value: bind(util, util.deprecate) },
+  error: { enumerable: true, value: bind(util, util.error) },
+  exec: { enumerable: true, value: bind(util, util.exec) },
+  format: { enumerable: true, value: bind(util, util.format) },
+  inherits: { enumerable: true, value: bind(util, util.inherits) },
+  inspect: { enumerable: true, value: bind(util, util.inspect) },
+  isArray: { enumerable: true, value: bind(util, util.isArray) },
+  isBoolean: { enumerable: true, value: bind(util, util.isBoolean) },
+  isBuffer: { enumerable: true, value: bind(util, util.isBuffer) },
+  isDate: { enumerable: true, value: bind(util, util.isDate) },
+  isDeepStrictEqual: { enumerable: true, value: bind(util, util.isDeepStrictEqual) },
+  isError: { enumerable: true, value: bind(util, util.isError) },
+  isFunction: { enumerable: true, value: bind(util, util.isFunction) },
+  isNull: { enumerable: true, value: bind(util, util.isNull) },
+  isNullOrUndefined: { enumerable: true, value: bind(util, util.isNullOrUndefined) },
+  isNumber: { enumerable: true, value: bind(util, util.isNumber) },
+  isObject: { enumerable: true, value: bind(util, util.isObject) },
+  isPrimitive: { enumerable: true, value: bind(util, util.isPrimitive) },
+  isRegExp: { enumerable: true, value: bind(util, util.isRegExp) },
+  isString: { enumerable: true, value: bind(util, util.isString) },
+  isSymbol: { enumerable: true, value: bind(util, util.isSymbol) },
+  isUndefined: { enumerable: true, value: bind(util, util.isUndefined) },
+  log: { enumerable: true, value: bind(util, util.log) },
+  p: { enumerable: true, value: bind(util, util.p) },
+  print: { enumerable: true, value: bind(util, util.print) },
+  promisify: { enumerable: true, value: bind(util, util.promisify) },
+  pump: { enumerable: true, value: promisify(util, util.pump, 2) },
+  puts: { enumerable: true, value: bind(util, util.puts) },
+});

node_modules/pn/v8.js

@@ -0,0 +1,3 @@
+var v8 = {};
+try { v8 = require("v8"); } catch (e) { }
+module.exports = v8;

node_modules/pn/vm.js

@@ -0,0 +1,2 @@
+var vm = require("vm");
+module.exports = vm;

node_modules/pn/zlib.js

@@ -0,0 +1,81 @@
+var zlib = require("zlib");
+var promisify = require("./_promisify.js");
+var bind = function(c, f) { return f && f.bind(c); };
+Object.defineProperties(module.exports, {
+  DEFLATE: { enumerable: true, value: zlib.DEFLATE },
+  DEFLATERAW: { enumerable: true, value: zlib.DEFLATERAW },
+  Deflate: { enumerable: true, value: zlib.Deflate },
+  DeflateRaw: { enumerable: true, value: zlib.DeflateRaw },
+  GUNZIP: { enumerable: true, value: zlib.GUNZIP },
+  GZIP: { enumerable: true, value: zlib.GZIP },
+  Gunzip: { enumerable: true, value: zlib.Gunzip },
+  Gzip: { enumerable: true, value: zlib.Gzip },
+  INFLATE: { enumerable: true, value: zlib.INFLATE },
+  INFLATERAW: { enumerable: true, value: zlib.INFLATERAW },
+  Inflate: { enumerable: true, value: zlib.Inflate },
+  InflateRaw: { enumerable: true, value: zlib.InflateRaw },
+  UNZIP: { enumerable: true, value: zlib.UNZIP },
+  Unzip: { enumerable: true, value: zlib.Unzip },
+  ZLIB_VERNUM: { enumerable: true, value: zlib.ZLIB_VERNUM },
+  ZLIB_VERSION: { enumerable: true, value: zlib.ZLIB_VERSION },
+  Z_BEST_COMPRESSION: { enumerable: true, value: zlib.Z_BEST_COMPRESSION },
+  Z_BEST_SPEED: { enumerable: true, value: zlib.Z_BEST_SPEED },
+  Z_BLOCK: { enumerable: true, value: zlib.Z_BLOCK },
+  Z_BUF_ERROR: { enumerable: true, value: zlib.Z_BUF_ERROR },
+  Z_DATA_ERROR: { enumerable: true, value: zlib.Z_DATA_ERROR },
+  Z_DEFAULT_CHUNK: { enumerable: true, value: zlib.Z_DEFAULT_CHUNK },
+  Z_DEFAULT_COMPRESSION: { enumerable: true, value: zlib.Z_DEFAULT_COMPRESSION },
+  Z_DEFAULT_LEVEL: { enumerable: true, value: zlib.Z_DEFAULT_LEVEL },
+  Z_DEFAULT_MEMLEVEL: { enumerable: true, value: zlib.Z_DEFAULT_MEMLEVEL },
+  Z_DEFAULT_STRATEGY: { enumerable: true, value: zlib.Z_DEFAULT_STRATEGY },
+  Z_DEFAULT_WINDOWBITS: { enumerable: true, value: zlib.Z_DEFAULT_WINDOWBITS },
+  Z_ERRNO: { enumerable: true, value: zlib.Z_ERRNO },
+  Z_FILTERED: { enumerable: true, value: zlib.Z_FILTERED },
+  Z_FINISH: { enumerable: true, value: zlib.Z_FINISH },
+  Z_FIXED: { enumerable: true, value: zlib.Z_FIXED },
+  Z_FULL_FLUSH: { enumerable: true, value: zlib.Z_FULL_FLUSH },
+  Z_HUFFMAN_ONLY: { enumerable: true, value: zlib.Z_HUFFMAN_ONLY },
+  Z_MAX_CHUNK: { enumerable: true, value: zlib.Z_MAX_CHUNK },
+  Z_MAX_LEVEL: { enumerable: true, value: zlib.Z_MAX_LEVEL },
+  Z_MAX_MEMLEVEL: { enumerable: true, value: zlib.Z_MAX_MEMLEVEL },
+  Z_MAX_WINDOWBITS: { enumerable: true, value: zlib.Z_MAX_WINDOWBITS },
+  Z_MEM_ERROR: { enumerable: true, value: zlib.Z_MEM_ERROR },
+  Z_MIN_CHUNK: { enumerable: true, value: zlib.Z_MIN_CHUNK },
+  Z_MIN_LEVEL: { enumerable: true, value: zlib.Z_MIN_LEVEL },
+  Z_MIN_MEMLEVEL: { enumerable: true, value: zlib.Z_MIN_MEMLEVEL },
+  Z_MIN_WINDOWBITS: { enumerable: true, value: zlib.Z_MIN_WINDOWBITS },
+  Z_NEED_DICT: { enumerable: true, value: zlib.Z_NEED_DICT },
+  Z_NO_COMPRESSION: { enumerable: true, value: zlib.Z_NO_COMPRESSION },
+  Z_NO_FLUSH: { enumerable: true, value: zlib.Z_NO_FLUSH },
+  Z_OK: { enumerable: true, value: zlib.Z_OK },
+  Z_PARTIAL_FLUSH: { enumerable: true, value: zlib.Z_PARTIAL_FLUSH },
+  Z_RLE: { enumerable: true, value: zlib.Z_RLE },
+  Z_STREAM_END: { enumerable: true, value: zlib.Z_STREAM_END },
+  Z_STREAM_ERROR: { enumerable: true, value: zlib.Z_STREAM_ERROR },
+  Z_SYNC_FLUSH: { enumerable: true, value: zlib.Z_SYNC_FLUSH },
+  Z_VERSION_ERROR: { enumerable: true, value: zlib.Z_VERSION_ERROR },
+  Zlib: { enumerable: true, value: zlib.Zlib },
+  codes: { enumerable: true, value: zlib.codes },
+  constants: { enumerable: true, get: function() { return zlib.constants; }, set: function(v) { zlib.constants = v; } },
+  createDeflate: { enumerable: true, value: bind(zlib, zlib.createDeflate) },
+  createDeflateRaw: { enumerable: true, value: bind(zlib, zlib.createDeflateRaw) },
+  createGunzip: { enumerable: true, value: bind(zlib, zlib.createGunzip) },
+  createGzip: { enumerable: true, value: bind(zlib, zlib.createGzip) },
+  createInflate: { enumerable: true, value: bind(zlib, zlib.createInflate) },
+  createInflateRaw: { enumerable: true, value: bind(zlib, zlib.createInflateRaw) },
+  createUnzip: { enumerable: true, value: bind(zlib, zlib.createUnzip) },
+  deflate: { enumerable: true, value: promisify(zlib, zlib.deflate, 1) },
+  deflateRaw: { enumerable: true, value: promisify(zlib, zlib.deflateRaw, 1) },
+  deflateRawSync: { enumerable: true, value: bind(zlib, zlib.deflateRawSync) },
+  deflateSync: { enumerable: true, value: bind(zlib, zlib.deflateSync) },
+  gunzip: { enumerable: true, value: promisify(zlib, zlib.gunzip, 1) },
+  gunzipSync: { enumerable: true, value: bind(zlib, zlib.gunzipSync) },
+  gzip: { enumerable: true, value: promisify(zlib, zlib.gzip, 1) },
+  gzipSync: { enumerable: true, value: bind(zlib, zlib.gzipSync) },
+  inflate: { enumerable: true, value: promisify(zlib, zlib.inflate, 1) },
+  inflateRaw: { enumerable: true, value: promisify(zlib, zlib.inflateRaw, 1) },
+  inflateRawSync: { enumerable: true, value: bind(zlib, zlib.inflateRawSync) },
+  inflateSync: { enumerable: true, value: bind(zlib, zlib.inflateSync) },
+  unzip: { enumerable: true, value: promisify(zlib, zlib.unzip, 1) },
+  unzipSync: { enumerable: true, value: bind(zlib, zlib.unzipSync) },
+});