Initial commit

node_modules/gtoken/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Ryan Seys
+
+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/gtoken/build/src/index.js

@@ -0,0 +1,282 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [0, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var axios_1 = require("axios");
+var fs = require("fs");
+var jws = require("jws");
+var mime = require("mime");
+var pify = require("pify");
+var querystring = require("querystring");
+var readFile = pify(fs.readFile);
+var GOOGLE_TOKEN_URL = 'https://www.googleapis.com/oauth2/v4/token';
+var GOOGLE_REVOKE_TOKEN_URL = 'https://accounts.google.com/o/oauth2/revoke?token=';
+var ErrorWithCode = /** @class */ (function (_super) {
+    __extends(ErrorWithCode, _super);
+    function ErrorWithCode(message, code) {
+        var _this = _super.call(this, message) || this;
+        _this.code = code;
+        return _this;
+    }
+    return ErrorWithCode;
+}(Error));
+var getPem;
+var GoogleToken = /** @class */ (function () {
+    /**
+     * Create a GoogleToken.
+     *
+     * @param options  Configuration object.
+     */
+    function GoogleToken(options) {
+        this.token = null;
+        this.expiresAt = null;
+        this.rawToken = null;
+        this.tokenExpires = null;
+        this.configure(options);
+    }
+    /**
+     * Returns whether the token has expired.
+     *
+     * @return true if the token has expired, false otherwise.
+     */
+    GoogleToken.prototype.hasExpired = function () {
+        var now = (new Date()).getTime();
+        if (this.token && this.expiresAt) {
+            return now >= this.expiresAt;
+        }
+        else {
+            return true;
+        }
+    };
+    GoogleToken.prototype.getToken = function (callback) {
+        if (callback) {
+            this.getTokenAsync()
+                .then(function (t) {
+                callback(null, t);
+            })
+                .catch(callback);
+            return;
+        }
+        return this.getTokenAsync();
+    };
+    /**
+     * Given a keyFile, extract the key and client email if available
+     * @param keyFile Path to a json, pem, or p12 file that contains the key.
+     * @returns an object with privateKey and clientEmail properties
+     */
+    GoogleToken.prototype.getCredentials = function (keyFile) {
+        return __awaiter(this, void 0, void 0, function () {
+            var mimeType, _a, key, body, privateKey, clientEmail, privateKey, privateKey;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        mimeType = mime.getType(keyFile);
+                        _a = mimeType;
+                        switch (_a) {
+                            case 'application/json': return [3 /*break*/, 1];
+                            case 'application/x-x509-ca-cert': return [3 /*break*/, 3];
+                            case 'application/x-pkcs12': return [3 /*break*/, 5];
+                        }
+                        return [3 /*break*/, 9];
+                    case 1: return [4 /*yield*/, readFile(keyFile, 'utf8')];
+                    case 2:
+                        key = _b.sent();
+                        body = JSON.parse(key);
+                        privateKey = body.private_key;
+                        clientEmail = body.client_email;
+                        if (!privateKey || !clientEmail) {
+                            throw new ErrorWithCode('private_key and client_email are required.', 'MISSING_CREDENTIALS');
+                        }
+                        return [2 /*return*/, { privateKey: privateKey, clientEmail: clientEmail }];
+                    case 3: return [4 /*yield*/, readFile(keyFile, 'utf8')];
+                    case 4:
+                        privateKey = _b.sent();
+                        return [2 /*return*/, { privateKey: privateKey }];
+                    case 5:
+                        if (!!getPem) return [3 /*break*/, 7];
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('google-p12-pem'); })];
+                    case 6:
+                        getPem = (_b.sent()).getPem;
+                        _b.label = 7;
+                    case 7: return [4 /*yield*/, getPem(keyFile)];
+                    case 8:
+                        privateKey = _b.sent();
+                        return [2 /*return*/, { privateKey: privateKey }];
+                    case 9: throw new ErrorWithCode('Unknown certificate type. Type is determined based on file extension. ' +
+                        'Current supported extensions are *.json, *.pem, and *.p12.', 'UNKNOWN_CERTIFICATE_TYPE');
+                }
+            });
+        });
+    };
+    GoogleToken.prototype.getTokenAsync = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var creds;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.hasExpired()) {
+                            return [2 /*return*/, Promise.resolve(this.token)];
+                        }
+                        if (!this.key && !this.keyFile) {
+                            throw new Error('No key or keyFile set.');
+                        }
+                        if (!(!this.key && this.keyFile)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.getCredentials(this.keyFile)];
+                    case 1:
+                        creds = _a.sent();
+                        this.key = creds.privateKey;
+                        this.iss = creds.clientEmail || this.iss;
+                        if (!creds.clientEmail) {
+                            this.ensureEmail();
+                        }
+                        _a.label = 2;
+                    case 2: return [2 /*return*/, this.requestToken()];
+                }
+            });
+        });
+    };
+    GoogleToken.prototype.ensureEmail = function () {
+        if (!this.iss) {
+            throw new ErrorWithCode('email is required.', 'MISSING_CREDENTIALS');
+        }
+    };
+    GoogleToken.prototype.revokeToken = function (callback) {
+        if (callback) {
+            this.revokeTokenAsync().then(function () { return callback(); }).catch(callback);
+            return;
+        }
+        return this.revokeTokenAsync();
+    };
+    GoogleToken.prototype.revokeTokenAsync = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                if (!this.token) {
+                    throw new Error('No token to revoke.');
+                }
+                return [2 /*return*/, axios_1.default.get(GOOGLE_REVOKE_TOKEN_URL + this.token).then(function (r) {
+                        _this.configure({
+                            email: _this.iss,
+                            sub: _this.sub,
+                            key: _this.key,
+                            keyFile: _this.keyFile,
+                            scope: _this.scope,
+                            additionalClaims: _this.additionalClaims,
+                        });
+                    })];
+            });
+        });
+    };
+    /**
+     * Configure the GoogleToken for re-use.
+     * @param  {object} options Configuration object.
+     */
+    GoogleToken.prototype.configure = function (options) {
+        if (options === void 0) { options = {}; }
+        this.keyFile = options.keyFile;
+        this.key = options.key;
+        this.token = this.expiresAt = this.rawToken = null;
+        this.iss = options.email || options.iss;
+        this.sub = options.sub;
+        this.additionalClaims = options.additionalClaims;
+        if (typeof options.scope === 'object') {
+            this.scope = options.scope.join(' ');
+        }
+        else {
+            this.scope = options.scope;
+        }
+    };
+    /**
+     * Request the token from Google.
+     */
+    GoogleToken.prototype.requestToken = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            var iat, additionalClaims, payload, signedJWT;
+            return __generator(this, function (_a) {
+                iat = Math.floor(new Date().getTime() / 1000);
+                additionalClaims = this.additionalClaims || {};
+                payload = Object.assign({
+                    iss: this.iss,
+                    scope: this.scope,
+                    aud: GOOGLE_TOKEN_URL,
+                    exp: iat + 3600,
+                    iat: iat,
+                    sub: this.sub
+                }, additionalClaims);
+                signedJWT = jws.sign({ header: { alg: 'RS256' }, payload: payload, secret: this.key });
+                return [2 /*return*/, axios_1.default
+                        .post(GOOGLE_TOKEN_URL, querystring.stringify({
+                        grant_type: 'urn:ietf:params:oauth:grant-type:jwt-bearer',
+                        assertion: signedJWT
+                    }), { headers: { 'Content-Type': 'application/x-www-form-urlencoded' } })
+                        .then(function (r) {
+                        _this.rawToken = r.data;
+                        _this.token = r.data.access_token;
+                        _this.expiresAt =
+                            (r.data.expires_in === null || r.data.expires_in === undefined) ?
+                                null :
+                                (iat + r.data.expires_in) * 1000;
+                        return _this.token;
+                    })
+                        .catch(function (e) {
+                        _this.token = null;
+                        _this.tokenExpires = null;
+                        var body = (e.response && e.response.data) ? e.response.data : {};
+                        var err = e;
+                        if (body.error) {
+                            var desc = body.error_description ? ": " + body.error_description : '';
+                            err = new Error("" + body.error + desc);
+                        }
+                        throw err;
+                    })];
+            });
+        });
+    };
+    return GoogleToken;
+}());
+exports.GoogleToken = GoogleToken;
+//# sourceMappingURL=index.js.map

node_modules/gtoken/node_modules/mime/.eslintrc.json

@@ -0,0 +1,51 @@
+{
+  "root": true,
+  "parserOptions": {
+    "ecmaVersion": 6
+  },
+  "env": {
+    "browser": true,
+    "commonjs": true,
+    "node": true,
+    "mocha": true
+  },
+  "extends": ["eslint:recommended"],
+  "rules": {
+    "array-bracket-spacing": ["warn", "never"],
+    "arrow-body-style": ["warn", "as-needed"],
+    "arrow-parens": ["warn", "as-needed"],
+    "arrow-spacing": "warn",
+    "brace-style": ["warn", "1tbs"],
+    "camelcase": "warn",
+    "comma-spacing": ["warn", {"after": true}],
+    "dot-notation": "warn",
+    "eqeqeq": ["warn", "smart"],
+    "indent": ["warn", 2, {
+      "SwitchCase": 1,
+      "FunctionDeclaration": {"parameters": 1},
+      "MemberExpression": 1,
+      "CallExpression": {"arguments": 1}
+    }],
+    "key-spacing": ["warn", {"beforeColon": false, "afterColon": true, "mode": "minimum"}],
+    "keyword-spacing": "warn",
+    "no-console": "off",
+    "no-empty": "off",
+    "no-multi-spaces": "warn",
+    "no-redeclare": "off",
+    "no-restricted-globals": ["warn", "Promise"],
+    "no-trailing-spaces": "warn",
+    "no-undef": "error",
+    "no-unused-vars": ["warn", {"args": "none"}],
+    "one-var": ["warn", "never"],
+    "padded-blocks": ["warn", "never"],
+    "object-curly-spacing": ["warn", "never"],
+    "quotes": ["warn", "single"],
+    "react/prop-types": "off",
+    "react/jsx-no-bind": "off",
+    "semi": ["warn", "always"],
+    "space-before-blocks": ["warn", "always"],
+    "space-before-function-paren": ["warn", "never"],
+    "space-in-parens": ["warn", "never"],
+    "strict": ["warn", "global"]
+  }
+}

node_modules/gtoken/node_modules/mime/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2010 Benjamin Thomas, Robert Kieffer
+
+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/gtoken/node_modules/mime/Mime.js

@@ -0,0 +1,89 @@
+'use strict';
+
+/**
+ * @param typeMap [Object] Map of MIME type -> Array[extensions]
+ * @param ...
+ */
+function Mime() {
+  this._types = Object.create(null);
+  this._extensions = Object.create(null);
+
+  for (var i = 0; i < arguments.length; i++) {
+    this.define(arguments[i]);
+  }
+}
+
+/**
+ * Define mimetype -> xtension mappings.  Each key is a mime-type that maps
+ * to an array of extensions associated with the type.  The first extension is
+ * used as the default extension for the type.
+ *
+ * e.g. mime.define({'audio/ogg', ['oga', 'ogg', 'spx']});
+ *
+ * If a type declares an extension that has already been defined, an error will
+ * be thrown.  To suppress this error and force the extension to be associated
+ * with the new type, pass `force`=true.  Alternatively, you may prefix the
+ * extension with "*" to map the type to extension, without mapping the
+ * extension to the type.
+ *
+ * e.g. mime.define({'audio/wav', ['wav']}, {'audio/x-wav', ['*wav']});
+ *
+ *
+ * @param map (Object) type definitions
+ * @param force (Boolean) if true, force overriding of existing definitions
+ */
+Mime.prototype.define = function(typeMap, force) {
+  for (var type in typeMap) {
+    var extensions = typeMap[type];
+    for (var i = 0; i < extensions.length; i++) {
+      var ext = extensions[i];
+
+      // '*' prefix = not the preferred type for this extension.  So fixup the
+      // extension, and skip it.
+      if (ext[0] == '*') {
+        continue;
+      }
+
+      if (!force && (ext in this._types)) {
+        throw new Error(
+          'Attempt to change mapping for "' + ext +
+          '" extension from "' + this._types[ext] + '" to "' + type +
+          '". Pass `force=true` to allow this, otherwise remove "' + ext +
+          '" from the list of extensions for "' + type + '".'
+        );
+      }
+
+      this._types[ext] = type;
+    }
+
+    // Use first extension as default
+    if (force || !this._extensions[type]) {
+      var ext = extensions[0];
+      this._extensions[type] = (ext[0] != '*') ? ext : ext.substr(1)
+    }
+  }
+};
+
+/**
+ * Lookup a mime type based on extension
+ */
+Mime.prototype.getType = function(path) {
+  path = String(path);
+  var last = path.replace(/^.*[/\\]/, '').toLowerCase();
+  var ext = last.replace(/^.*\./, '').toLowerCase();
+
+  var hasPath = last.length < path.length;
+  var hasDot = ext.length < last.length - 1;
+
+  return (hasDot || !hasPath) && this._types[ext] || null;
+};
+
+/**
+ * Return file extension associated with a mime type
+ */
+Mime.prototype.getExtension = function(type) {
+  type = /^\s*([^;\s]*)/.test(type) && RegExp.$1;
+  return type && this._extensions[type.toLowerCase()] || null;
+};
+
+module.exports = Mime;

node_modules/gtoken/node_modules/mime/cli.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+
+'use strict';
+
+var mime = require('.');
+var file = process.argv[2];
+var type = mime.getType(file);
+
+process.stdout.write(type + '\n');
+

node_modules/gtoken/node_modules/mime/index.js

@@ -0,0 +1,4 @@
+'use strict';
+
+var Mime = require('./Mime');
+module.exports = new Mime(require('./types/standard'), require('./types/other'));

node_modules/gtoken/node_modules/mime/lite.js

@@ -0,0 +1,4 @@
+'use strict';
+
+var Mime = require('./Mime');
+module.exports = new Mime(require('./types/standard'));

node_modules/gtoken/node_modules/mime/package.json

@@ -0,0 +1,32 @@
+{
+  "author": {
+    "name": "Robert Kieffer",
+    "url": "http://github.com/broofa",
+    "email": "robert@broofa.com"
+  },
+  "engines": {
+    "node": ">=4.0.0"
+  },
+  "bin": {
+    "mime": "cli.js"
+  },
+  "description": "A comprehensive library for mime-type mapping",
+  "license": "MIT",
+  "dependencies": {},
+  "devDependencies": {
+    "chalk": "1.1.3",
+    "eslint": "4.6.1",
+    "mime-db": "1.33.0",
+    "mime-score": "1.0.1",
+    "mime-types": "2.1.15",
+    "mocha": "3.5.3",
+    "runmd": "1.0.1",
+    "standard-version": "4.2.0"
+  },
+  "name": "mime",
+  "repository": {
+    "url": "https://github.com/broofa/node-mime",
+    "type": "git"
+  },
+  "version": "2.3.1"
+}

node_modules/gtoken/node_modules/mime/src/build.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+var mimeScore = require('mime-score');
+
+var db = require('mime-db');
+var chalk = require('chalk');
+
+var STANDARD_FACET_SCORE = 900;
+
+var byExtension = {};
+
+// Clear out any conflict extensions in mime-db
+for (var type in db) {
+  var entry = db[type];
+  entry.type = type;
+  if (!entry.extensions) continue;
+
+  entry.extensions.forEach(function(ext) {
+    var drop;
+    var keep = entry;
+    if (ext in byExtension) {
+      var e0 = entry;
+      var e1 = byExtension[ext];
+
+      e0.pri = mimeScore(e0.type, e0.source);
+      e1.pri = mimeScore(e1.type, e1.source);
+
+      drop = e0.pri < e1.pri ? e0 : e1;
+      keep = e0.pri >= e1.pri ? e0 : e1;
+
+      // Prefix lower-priority extensions with '*'
+      drop.extensions = drop.extensions.map(function(e) {return e == ext ? '*' + e : e});
+
+      console.log(
+        ext + ': Preferring ' + chalk.green(keep.type) + ' (' + keep.pri +
+        ') over ' + chalk.red(drop.type) + ' (' + drop.pri + ')' + ' for ' + ext
+      );
+    }
+
+    // Cache the hightest ranking type for this extension
+    if (keep == entry) byExtension[ext] = entry;
+  });
+}
+
+function writeTypesFile(types, path) {
+  fs.writeFileSync(path, JSON.stringify(types));
+}
+
+// Segregate into standard and non-standard types based on facet per
+// https://tools.ietf.org/html/rfc6838#section-3.1
+var standard = {};
+var other = {};
+
+Object.keys(db).sort().forEach(function(k) {
+  var entry = db[k];
+
+  if (entry.extensions) {
+    if (mimeScore(entry.type, entry.source) >= STANDARD_FACET_SCORE) {
+      standard[entry.type] = entry.extensions;
+    } else {
+      other[entry.type] = entry.extensions;
+    }
+  }
+});
+
+writeTypesFile(standard, path.join(__dirname, '../types', 'standard.json'));
+writeTypesFile(other, path.join(__dirname, '../types', 'other.json'));

node_modules/gtoken/node_modules/mime/src/test.js

@@ -0,0 +1,257 @@
+'use strict';
+
+var mime = require('..');
+var mimeTypes = require('../node_modules/mime-types');
+var assert = require('assert');
+var chalk = require('chalk');
+
+describe('class Mime', function() {
+  it('mime and mime/lite coexist', function() {
+    assert.doesNotThrow(function() {
+      require('../lite');
+    });
+  });
+
+  it('new constructor()', function() {
+    var Mime = require('../Mime');
+
+    var mime = new Mime(
+      {'text/a': ['a', 'a1']},
+      {'text/b': ['b', 'b1']}
+    );
+
+    assert.deepEqual(mime._types, {
+      a: 'text/a',
+      a1: 'text/a',
+      b: 'text/b',
+      b1: 'text/b',
+    });
+
+    assert.deepEqual(mime._extensions, {
+      'text/a': 'a',
+      'text/b': 'b',
+    });
+  });
+
+  it('define()', function() {
+    var Mime = require('../Mime');
+
+    var mime = new Mime({'text/a': ['a']}, {'text/b': ['b']});
+
+    assert.throws(function() {
+      mime.define({'text/c': ['b']});
+    });
+
+    assert.doesNotThrow(function() {
+      mime.define({'text/c': ['b']}, true);
+    });
+
+    assert.deepEqual(mime._types, {
+      a: 'text/a',
+      b: 'text/c',
+    });
+
+    assert.deepEqual(mime._extensions, {
+      'text/a': 'a',
+      'text/b': 'b',
+      'text/c': 'b',
+    });
+  });
+
+  it('define() *\'ed types', function() {
+    var Mime = require('../Mime');
+
+    var mime = new Mime(
+      {'text/a': ['*b']},
+      {'text/b': ['b']}
+    );
+
+    assert.deepEqual(mime._types, {
+      b: 'text/b',
+    });
+
+    assert.deepEqual(mime._extensions, {
+      'text/a': 'b',
+      'text/b': 'b',
+    });
+  });
+
+  it('getType()', function() {
+    // Upper/lower case
+    assert.equal(mime.getType('text.txt'), 'text/plain');
+    assert.equal(mime.getType('TEXT.TXT'), 'text/plain');
+
+    // Bare extension
+    assert.equal(mime.getType('txt'), 'text/plain');
+    assert.equal(mime.getType('.txt'), 'text/plain');
+    assert.strictEqual(mime.getType('.bogus'), null);
+    assert.strictEqual(mime.getType('bogus'), null);
+
+    // Non-sensical
+    assert.strictEqual(mime.getType(null), null);
+    assert.strictEqual(mime.getType(undefined), null);
+    assert.strictEqual(mime.getType(42), null);
+    assert.strictEqual(mime.getType({}), null);
+
+    // File paths
+    assert.equal(mime.getType('dir/text.txt'), 'text/plain');
+    assert.equal(mime.getType('dir\\text.txt'), 'text/plain');
+    assert.equal(mime.getType('.text.txt'), 'text/plain');
+    assert.equal(mime.getType('.txt'), 'text/plain');
+    assert.equal(mime.getType('txt'), 'text/plain');
+    assert.equal(mime.getType('/path/to/page.html'), 'text/html');
+    assert.equal(mime.getType('c:\\path\\to\\page.html'), 'text/html');
+    assert.equal(mime.getType('page.html'), 'text/html');
+    assert.equal(mime.getType('path/to/page.html'), 'text/html');
+    assert.equal(mime.getType('path\\to\\page.html'), 'text/html');
+    assert.strictEqual(mime.getType('/txt'), null);
+    assert.strictEqual(mime.getType('\\txt'), null);
+    assert.strictEqual(mime.getType('text.nope'), null);
+    assert.strictEqual(mime.getType('/path/to/file.bogus'), null);
+    assert.strictEqual(mime.getType('/path/to/json'), null);
+    assert.strictEqual(mime.getType('/path/to/.json'), null);
+    assert.strictEqual(mime.getType('/path/to/.config.json'), 'application/json');
+    assert.strictEqual(mime.getType('.config.json'), 'application/json');
+  });
+
+  it('getExtension()', function() {
+    assert.equal(mime.getExtension('text/html'), 'html');
+    assert.equal(mime.getExtension(' text/html'), 'html');
+    assert.equal(mime.getExtension('text/html '), 'html');
+    assert.strictEqual(mime.getExtension('application/x-bogus'), null);
+    assert.strictEqual(mime.getExtension('bogus'), null);
+    assert.strictEqual(mime.getExtension(null), null);
+    assert.strictEqual(mime.getExtension(undefined), null);
+    assert.strictEqual(mime.getExtension(42), null);
+    assert.strictEqual(mime.getExtension({}), null);
+  });
+});
+
+describe('DB', function() {
+  var diffs = [];
+
+  after(function() {
+    if (diffs.length) {
+      console.log('\n[INFO] The following inconsistencies with MDN (https://goo.gl/lHrFU6) and/or mime-types (https://github.com/jshttp/mime-types) are expected:');
+      diffs.forEach(function(d) {
+        console.warn(
+          '  ' + d[0]+ '[' + chalk.blue(d[1]) + '] = ' + chalk.red(d[2]) +
+          ', mime[' + d[1] + '] = ' + chalk.green(d[3])
+        );
+      });
+    }
+  });
+
+  it('Consistency', function() {
+    for (var ext in this.types) {
+      assert.equal(ext, this.extensions[this.types[ext]], '${ext} does not have consistent ext->type->ext mapping');
+    }
+  });
+
+  it('MDN types', function() {
+    // MDN types listed at https://goo.gl/lHrFU6
+    var MDN = {
+      'aac': 'audio/aac',
+      'abw': 'application/x-abiword',
+      'arc': 'application/octet-stream',
+      'avi': 'video/x-msvideo',
+      'azw': 'application/vnd.amazon.ebook',
+      'bin': 'application/octet-stream',
+      'bz': 'application/x-bzip',
+      'bz2': 'application/x-bzip2',
+      'csh': 'application/x-csh',
+      'css': 'text/css',
+      'csv': 'text/csv',
+      'doc': 'application/msword',
+      'epub': 'application/epub+zip',
+      'gif': 'image/gif',
+      'html': 'text/html',
+      'ico': 'image/x-icon',
+      'ics': 'text/calendar',
+      'jar': 'application/java-archive',
+      'jpg': 'image/jpeg',
+      'js': 'application/javascript',
+      'json': 'application/json',
+      'midi': 'audio/midi',
+      'mpeg': 'video/mpeg',
+      'mpkg': 'application/vnd.apple.installer+xml',
+      'odp': 'application/vnd.oasis.opendocument.presentation',
+      'ods': 'application/vnd.oasis.opendocument.spreadsheet',
+      'odt': 'application/vnd.oasis.opendocument.text',
+      'oga': 'audio/ogg',
+      'ogv': 'video/ogg',
+      'ogx': 'application/ogg',
+      'png': 'image/png',
+      'pdf': 'application/pdf',
+      'ppt': 'application/vnd.ms-powerpoint',
+      'rar': 'application/x-rar-compressed',
+      'rtf': 'application/rtf',
+      'sh': 'application/x-sh',
+      'svg': 'image/svg+xml',
+      'swf': 'application/x-shockwave-flash',
+      'tar': 'application/x-tar',
+      'tiff': 'image/tiff',
+      'ttf': 'font/ttf',
+      'vsd': 'application/vnd.visio',
+      'wav': 'audio/x-wav',
+      'weba': 'audio/webm',
+      'webm': 'video/webm',
+      'webp': 'image/webp',
+      'woff': 'font/woff',
+      'woff2': 'font/woff2',
+      'xhtml': 'application/xhtml+xml',
+      'xls': 'application/vnd.ms-excel',
+      'xml': 'application/xml',
+      'xul': 'application/vnd.mozilla.xul+xml',
+      'zip': 'application/zip',
+      '3gp': 'video/3gpp',
+      '3g2': 'video/3gpp2',
+      '7z': 'application/x-7z-compressed',
+    };
+
+    for (var ext in MDN) {
+      var expected = MDN[ext];
+      var actual = mime.getType(ext);
+      if (actual !== expected) diffs.push(['MDN', ext, expected, actual]);
+    }
+
+    for (var ext in mimeTypes.types) {
+      var expected = mimeTypes.types[ext];
+      var actual = mime.getType(ext);
+      if (actual !== expected) diffs.push(['mime-types', ext, expected, actual]);
+    }
+  });
+
+  it('Specific types', function() {
+    // Assortment of types we sanity check for good measure
+    assert.equal(mime.getType('html'), 'text/html');
+    assert.equal(mime.getType('js'), 'application/javascript');
+    assert.equal(mime.getType('json'), 'application/json');
+    assert.equal(mime.getType('rtf'), 'application/rtf');
+    assert.equal(mime.getType('txt'), 'text/plain');
+    assert.equal(mime.getType('xml'), 'application/xml');
+
+    assert.equal(mime.getType('wasm'), 'application/wasm');
+  });
+
+  it('Specific extensions', function() {
+    assert.equal(mime.getExtension('text/html;charset=UTF-8'), 'html');
+    assert.equal(mime.getExtension('text/HTML; charset=UTF-8'), 'html');
+    assert.equal(mime.getExtension('text/html; charset=UTF-8'), 'html');
+    assert.equal(mime.getExtension('text/html; charset=UTF-8 '), 'html');
+    assert.equal(mime.getExtension('text/html ; charset=UTF-8'), 'html');
+    assert.equal(mime.getExtension(mime._types.text), 'txt');
+    assert.equal(mime.getExtension(mime._types.htm), 'html');
+    assert.equal(mime.getExtension('application/octet-stream'), 'bin');
+    assert.equal(mime.getExtension('application/octet-stream '), 'bin');
+    assert.equal(mime.getExtension(' text/html; charset=UTF-8'), 'html');
+    assert.equal(mime.getExtension('text/html; charset=UTF-8 '), 'html');
+    assert.equal(mime.getExtension('text/html; charset=UTF-8'), 'html');
+    assert.equal(mime.getExtension('text/html ; charset=UTF-8'), 'html');
+    assert.equal(mime.getExtension('text/html;charset=UTF-8'), 'html');
+    assert.equal(mime.getExtension('text/Html;charset=UTF-8'), 'html');
+    assert.equal(mime.getExtension('unrecognized'), null);
+
+    assert.equal(mime.getExtension('text/xml'), 'xml'); // See #180
+  });
+});

node_modules/gtoken/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "gtoken",
+  "version": "2.3.0",
+  "description": "Node.js Google Authentication Service Account Tokens",
+  "main": "./build/src/index.js",
+  "types": "./build/src/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/google/node-gtoken.git"
+  },
+  "author": {
+    "name": "Ryan Seys"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^0.18.0",
+    "google-p12-pem": "^1.0.0",
+    "jws": "^3.1.4",
+    "mime": "^2.2.0",
+    "pify": "^3.0.0"
+  },
+  "devDependencies": {
+    "@types/jws": "^3.1.0",
+    "@types/mime": "^2.0.0",
+    "@types/mocha": "^5.0.0",
+    "@types/nock": "^9.1.2",
+    "@types/node": "^9.4.6",
+    "@types/pify": "^3.0.0",
+    "codecov": "^3.0.0",
+    "gts": "^0.5.3",
+    "mocha": "^5.0.1",
+    "js-green-licenses": "^0.5.0",
+    "nock": "^9.1.6",
+    "nyc": "^11.4.1",
+    "source-map-support": "^0.5.3",
+    "typescript": "~2.7.2"
+  },
+  "files": [
+    "build/src",
+    "LICENSE",
+    "packge.json",
+    "README.md"
+  ]
+}