Initial commit

node_modules/google-auth-library/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2013 Google Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

node_modules/google-auth-library/build/src/auth/authclient.js

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * Copyright 2012 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var events_1 = require("events");
+var transporters_1 = require("../transporters");
+var AuthClient = /** @class */ (function (_super) {
+    __extends(AuthClient, _super);
+    function AuthClient() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.transporter = new transporters_1.DefaultTransporter();
+        _this.credentials = {};
+        return _this;
+    }
+    /**
+     * Sets the auth credentials.
+     */
+    AuthClient.prototype.setCredentials = function (credentials) {
+        this.credentials = credentials;
+    };
+    return AuthClient;
+}(events_1.EventEmitter));
+exports.AuthClient = AuthClient;
+//# sourceMappingURL=authclient.js.map

node_modules/google-auth-library/build/src/auth/authclient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"authclient.js","sourceRoot":"","sources":["../../../src/auth/authclient.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;;;;;;;;;;AAGH,iCAAoC;AAEpC,gDAAmD;AAQnD;IAAyC,8BAAY;IAArD;QAAA,qEAeC;QAdC,iBAAW,GAAG,IAAI,iCAAkB,EAAE,CAAC;QACvC,iBAAW,GAAgB,EAAE,CAAC;;IAahC,CAAC;IANC;;OAEG;IACH,mCAAc,GAAd,UAAe,WAAwB;QACrC,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;IACjC,CAAC;IACH,iBAAC;AAAD,CAAC,AAfD,CAAyC,qBAAY,GAepD;AAfqB,gCAAU"}

node_modules/google-auth-library/build/src/auth/computeclient.js

@@ -0,0 +1,187 @@
+"use strict";
+/**
+ * Copyright 2013 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+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 };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var axios_1 = __importDefault(require("axios"));
+var gcpMetadata = __importStar(require("gcp-metadata"));
+var rax = __importStar(require("retry-axios"));
+var oauth2client_1 = require("./oauth2client");
+// Create a scoped axios instance that will retry 3 times by default
+var ax = axios_1.default.create();
+rax.attach(ax);
+var Compute = /** @class */ (function (_super) {
+    __extends(Compute, _super);
+    /**
+     * Google Compute Engine service account credentials.
+     *
+     * Retrieve access token from the metadata server.
+     * See: https://developers.google.com/compute/docs/authentication
+     */
+    function Compute(options) {
+        if (options === void 0) { options = {}; }
+        var _this = _super.call(this, options) || this;
+        // Start with an expired refresh token, which will automatically be
+        // refreshed before the first API call is made.
+        _this.credentials = { expiry_date: 1, refresh_token: 'compute-placeholder' };
+        _this.serviceAccountEmail = options.serviceAccountEmail || 'default';
+        return _this;
+    }
+    /**
+     * Indicates whether the credential requires scopes to be created by calling
+     * createdScoped before use.
+     * @return Boolean indicating if scope is required.
+     */
+    Compute.prototype.createScopedRequired = function () {
+        // On compute engine, scopes are specified at the compute instance's
+        // creation time, and cannot be changed. For this reason, always return
+        // false.
+        return false;
+    };
+    /**
+     * Refreshes the access token.
+     * @param refreshToken Unused parameter
+     */
+    Compute.prototype.refreshTokenNoCache = function (refreshToken) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, url, res, e_1, tokens;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        url = this.tokenUrl ||
+                            "" + gcpMetadata.HOST_ADDRESS + gcpMetadata.BASE_PATH + "/instance/service-accounts/" + this.serviceAccountEmail + "/token";
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, ax.request({
+                                url: url,
+                                headers: (_a = {}, _a[gcpMetadata.HEADER_NAME] = 'Google', _a),
+                                raxConfig: { noResponseRetries: 3, retry: 3, instance: ax }
+                            })];
+                    case 2:
+                        // TODO: In 2.0, we should remove the ability to configure the tokenUrl,
+                        // and switch this over to use the gcp-metadata package instead.
+                        res = _b.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        e_1 = _b.sent();
+                        e_1.message = 'Could not refresh access token.';
+                        throw e_1;
+                    case 4:
+                        tokens = res.data;
+                        if (res.data && res.data.expires_in) {
+                            tokens.expiry_date =
+                                ((new Date()).getTime() + (res.data.expires_in * 1000));
+                            delete tokens.expires_in;
+                        }
+                        this.emit('tokens', tokens);
+                        return [2 /*return*/, { tokens: tokens, res: res }];
+                }
+            });
+        });
+    };
+    Compute.prototype.requestAsync = function (opts, retry) {
+        if (retry === void 0) { retry = false; }
+        return _super.prototype.requestAsync.call(this, opts, retry).catch(function (e) {
+            var res = e.response;
+            if (res && res.status) {
+                var helpfulMessage = null;
+                if (res.status === 403) {
+                    helpfulMessage =
+                        'A Forbidden error was returned while attempting to retrieve an access ' +
+                            'token for the Compute Engine built-in service account. This may be because the Compute ' +
+                            'Engine instance does not have the correct permission scopes specified.';
+                }
+                else if (res.status === 404) {
+                    helpfulMessage =
+                        'A Not Found error was returned while attempting to retrieve an access' +
+                            'token for the Compute Engine built-in service account. This may be because the Compute ' +
+                            'Engine instance does not have any permission scopes specified.';
+                }
+                if (helpfulMessage) {
+                    if (e && e.message && !retry) {
+                        helpfulMessage += ' ' + e.message;
+                    }
+                    if (e) {
+                        e.message = helpfulMessage;
+                    }
+                    else {
+                        e = new Error(helpfulMessage);
+                        e.code = res.status.toString();
+                    }
+                }
+            }
+            throw e;
+        });
+    };
+    return Compute;
+}(oauth2client_1.OAuth2Client));
+exports.Compute = Compute;
+//# sourceMappingURL=computeclient.js.map

node_modules/google-auth-library/build/src/auth/computeclient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"computeclient.js","sourceRoot":"","sources":["../../../src/auth/computeclient.ts"],"names":[],"mappings":"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"}

node_modules/google-auth-library/build/src/auth/credentials.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=credentials.js.map

node_modules/google-auth-library/build/src/auth/credentials.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"credentials.js","sourceRoot":"","sources":["../../../src/auth/credentials.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG"}

node_modules/google-auth-library/build/src/auth/envDetect.js

@@ -0,0 +1,139 @@
+"use strict";
+/**
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+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 };
+    }
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var gcpMetadata = __importStar(require("gcp-metadata"));
+var GCPEnv;
+(function (GCPEnv) {
+    GCPEnv["APP_ENGINE"] = "APP_ENGINE";
+    GCPEnv["KUBERNETES_ENGINE"] = "KUBERNETES_ENGINE";
+    GCPEnv["CLOUD_FUNCTIONS"] = "CLOUD_FUNCTIONS";
+    GCPEnv["COMPUTE_ENGINE"] = "COMPUTE_ENGINE";
+    GCPEnv["NONE"] = "NONE";
+})(GCPEnv = exports.GCPEnv || (exports.GCPEnv = {}));
+var env;
+function clear() {
+    env = undefined;
+}
+exports.clear = clear;
+function getEnv() {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!!env) return [3 /*break*/, 6];
+                    if (!isAppEngine()) return [3 /*break*/, 1];
+                    env = GCPEnv.APP_ENGINE;
+                    return [3 /*break*/, 6];
+                case 1:
+                    if (!isCloudFunction()) return [3 /*break*/, 2];
+                    env = GCPEnv.CLOUD_FUNCTIONS;
+                    return [3 /*break*/, 6];
+                case 2: return [4 /*yield*/, isKubernetesEngine()];
+                case 3:
+                    if (!_a.sent()) return [3 /*break*/, 4];
+                    env = GCPEnv.KUBERNETES_ENGINE;
+                    return [3 /*break*/, 6];
+                case 4: return [4 /*yield*/, isComputeEngine()];
+                case 5:
+                    if (_a.sent()) {
+                        env = GCPEnv.COMPUTE_ENGINE;
+                    }
+                    else {
+                        env = GCPEnv.NONE;
+                    }
+                    _a.label = 6;
+                case 6: return [2 /*return*/, env];
+            }
+        });
+    });
+}
+exports.getEnv = getEnv;
+function isAppEngine() {
+    return !!(process.env.GAE_SERVICE || process.env.GAE_MODULE_NAME);
+}
+function isCloudFunction() {
+    return !!process.env.FUNCTION_NAME;
+}
+function isKubernetesEngine() {
+    return __awaiter(this, void 0, void 0, function () {
+        var e_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, gcpMetadata.instance('attributes/cluster-name')];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/, true];
+                case 2:
+                    e_1 = _a.sent();
+                    return [2 /*return*/, false];
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+}
+function isComputeEngine() {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, gcpMetadata.isAvailable()];
+        });
+    });
+}
+//# sourceMappingURL=envDetect.js.map

node_modules/google-auth-library/build/src/auth/envDetect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"envDetect.js","sourceRoot":"","sources":["../../../src/auth/envDetect.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,wDAA4C;AAE5C,IAAY,MAMX;AAND,WAAY,MAAM;IAChB,mCAAyB,CAAA;IACzB,iDAAuC,CAAA;IACvC,6CAAmC,CAAA;IACnC,2CAAiC,CAAA;IACjC,uBAAa,CAAA;AACf,CAAC,EANW,MAAM,GAAN,cAAM,KAAN,cAAM,QAMjB;AAED,IAAI,GAAqB,CAAC;AAE1B;IACE,GAAG,GAAG,SAAS,CAAC;AAClB,CAAC;AAFD,sBAEC;AAED;;;;;yBACM,CAAC,GAAG,EAAJ,wBAAI;yBACF,WAAW,EAAE,EAAb,wBAAa;oBACf,GAAG,GAAG,MAAM,CAAC,UAAU,CAAC;;;yBACf,eAAe,EAAE,EAAjB,wBAAiB;oBAC1B,GAAG,GAAG,MAAM,CAAC,eAAe,CAAC;;wBACpB,qBAAM,kBAAkB,EAAE,EAAA;;yBAA1B,SAA0B,EAA1B,wBAA0B;oBACnC,GAAG,GAAG,MAAM,CAAC,iBAAiB,CAAC;;wBACtB,qBAAM,eAAe,EAAE,EAAA;;oBAA3B,IAAI,SAAuB,EAAE;wBAClC,GAAG,GAAG,MAAM,CAAC,cAAc,CAAC;qBAC7B;yBAAM;wBACL,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC;qBACnB;;wBAEH,sBAAO,GAAG,EAAC;;;;CACZ;AAfD,wBAeC;AAED;IACE,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,WAAW,IAAI,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;AACpE,CAAC;AAED;IACE,OAAO,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC;AACrC,CAAC;AAED;;;;;;;oBAEI,qBAAM,WAAW,CAAC,QAAQ,CAAC,yBAAyB,CAAC,EAAA;;oBAArD,SAAqD,CAAC;oBACtD,sBAAO,IAAI,EAAC;;;oBAEZ,sBAAO,KAAK,EAAC;;;;;CAEhB;AAED;;;YACE,sBAAO,WAAW,CAAC,WAAW,EAAE,EAAC;;;CAClC"}

node_modules/google-auth-library/build/src/auth/googleauth.js

@@ -0,0 +1,815 @@
+"use strict";
+/**
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+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 };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var child_process_1 = require("child_process");
+var crypto_1 = __importDefault(require("crypto"));
+var fs = __importStar(require("fs"));
+var gcpMetadata = __importStar(require("gcp-metadata"));
+var os_1 = __importDefault(require("os"));
+var path_1 = __importDefault(require("path"));
+var util_1 = __importDefault(require("util"));
+var transporters_1 = require("../transporters");
+var computeclient_1 = require("./computeclient");
+var envDetect_1 = require("./envDetect");
+var jwtclient_1 = require("./jwtclient");
+var refreshclient_1 = require("./refreshclient");
+var GoogleAuth = /** @class */ (function () {
+    function GoogleAuth(opts) {
+        // This shim is in place for compatibility with google-auto-auth.
+        this.getProjectId = this.getDefaultProjectId;
+        /**
+         * Caches a value indicating whether the auth layer is running on Google
+         * Compute Engine.
+         * @private
+         */
+        this.checkIsGCE = undefined;
+        // To save the contents of the JSON credential file
+        this.jsonContent = null;
+        this.cachedCredential = null;
+        opts = opts || {};
+        this._cachedProjectId = opts.projectId || null;
+        this.keyFilename = opts.keyFilename || opts.keyFile;
+        this.scopes = opts.scopes;
+        this.jsonContent = opts.credentials || null;
+    }
+    Object.defineProperty(GoogleAuth.prototype, "isGCE", {
+        // Note:  this properly is only public to satisify unit tests.
+        // https://github.com/Microsoft/TypeScript/issues/5228
+        get: function () {
+            return this.checkIsGCE;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    GoogleAuth.prototype.getDefaultProjectId = function (callback) {
+        if (callback) {
+            this.getDefaultProjectIdAsync()
+                .then(function (r) { return callback(null, r); })
+                .catch(callback);
+        }
+        else {
+            return this.getDefaultProjectIdAsync();
+        }
+    };
+    GoogleAuth.prototype.getDefaultProjectIdAsync = function () {
+        var _this = this;
+        if (this._cachedProjectId) {
+            return Promise.resolve(this._cachedProjectId);
+        }
+        // In implicit case, supports three environments. In order of precedence,
+        // the implicit environments are:
+        // - GCLOUD_PROJECT or GOOGLE_CLOUD_PROJECT environment variable
+        // - GOOGLE_APPLICATION_CREDENTIALS JSON file
+        // - Cloud SDK: `gcloud config config-helper --format json`
+        // - GCE project ID from metadata server)
+        if (!this._getDefaultProjectIdPromise) {
+            this._getDefaultProjectIdPromise =
+                new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+                    var projectId, _a, _b, _c, e_1;
+                    return __generator(this, function (_d) {
+                        switch (_d.label) {
+                            case 0:
+                                _d.trys.push([0, 7, , 8]);
+                                _c = this.getProductionProjectId();
+                                if (_c) return [3 /*break*/, 2];
+                                return [4 /*yield*/, this.getFileProjectId()];
+                            case 1:
+                                _c = (_d.sent());
+                                _d.label = 2;
+                            case 2:
+                                _b = _c;
+                                if (_b) return [3 /*break*/, 4];
+                                return [4 /*yield*/, this.getDefaultServiceProjectId()];
+                            case 3:
+                                _b = (_d.sent());
+                                _d.label = 4;
+                            case 4:
+                                _a = _b;
+                                if (_a) return [3 /*break*/, 6];
+                                return [4 /*yield*/, this.getGCEProjectId()];
+                            case 5:
+                                _a = (_d.sent());
+                                _d.label = 6;
+                            case 6:
+                                projectId = _a;
+                                this._cachedProjectId = projectId;
+                                resolve(projectId);
+                                return [3 /*break*/, 8];
+                            case 7:
+                                e_1 = _d.sent();
+                                reject(e_1);
+                                return [3 /*break*/, 8];
+                            case 8: return [2 /*return*/];
+                        }
+                    });
+                }); });
+        }
+        return this._getDefaultProjectIdPromise;
+    };
+    GoogleAuth.prototype.getApplicationDefault = function (optionsOrCallback, callback) {
+        if (optionsOrCallback === void 0) { optionsOrCallback = {}; }
+        var options;
+        if (typeof optionsOrCallback === 'function') {
+            callback = optionsOrCallback;
+        }
+        else {
+            options = optionsOrCallback;
+        }
+        if (callback) {
+            this.getApplicationDefaultAsync(options)
+                .then(function (r) { return callback(null, r.credential, r.projectId); })
+                .catch(callback);
+        }
+        else {
+            return this.getApplicationDefaultAsync(options);
+        }
+    };
+    GoogleAuth.prototype.getApplicationDefaultAsync = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, credential, projectId, gce, e_2;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!this.cachedCredential) return [3 /*break*/, 2];
+                        _a = {
+                            credential: this.cachedCredential
+                        };
+                        return [4 /*yield*/, this.getDefaultProjectIdAsync()];
+                    case 1: return [2 /*return*/, (_a.projectId = _b.sent(),
+                            _a)];
+                    case 2: return [4 /*yield*/, this._tryGetApplicationCredentialsFromEnvironmentVariable(options)];
+                    case 3:
+                        // Check for the existence of a local environment variable pointing to the
+                        // location of the credential file. This is typically used in local
+                        // developer scenarios.
+                        credential =
+                            _b.sent();
+                        if (!credential) return [3 /*break*/, 5];
+                        if (credential instanceof jwtclient_1.JWT) {
+                            credential.scopes = this.scopes;
+                        }
+                        this.cachedCredential = credential;
+                        return [4 /*yield*/, this.getDefaultProjectId()];
+                    case 4:
+                        projectId = _b.sent();
+                        return [2 /*return*/, { credential: credential, projectId: projectId }];
+                    case 5: return [4 /*yield*/, this._tryGetApplicationCredentialsFromWellKnownFile(options)];
+                    case 6:
+                        // Look in the well-known credential file location.
+                        credential =
+                            _b.sent();
+                        if (!credential) return [3 /*break*/, 8];
+                        if (credential instanceof jwtclient_1.JWT) {
+                            credential.scopes = this.scopes;
+                        }
+                        this.cachedCredential = credential;
+                        return [4 /*yield*/, this.getDefaultProjectId()];
+                    case 7:
+                        projectId = _b.sent();
+                        return [2 /*return*/, { credential: credential, projectId: projectId }];
+                    case 8:
+                        _b.trys.push([8, 13, , 14]);
+                        return [4 /*yield*/, this._checkIsGCE()];
+                    case 9:
+                        gce = _b.sent();
+                        if (!gce) return [3 /*break*/, 11];
+                        // For GCE, just return a default ComputeClient. It will take care of
+                        // the rest.
+                        this.cachedCredential = new computeclient_1.Compute(options);
+                        return [4 /*yield*/, this.getDefaultProjectId()];
+                    case 10:
+                        projectId = _b.sent();
+                        return [2 /*return*/, { projectId: projectId, credential: this.cachedCredential }];
+                    case 11: 
+                    // We failed to find the default credentials. Bail out with an error.
+                    throw new Error('Could not load the default credentials. Browse to https://developers.google.com/accounts/docs/application-default-credentials for more information.');
+                    case 12: return [3 /*break*/, 14];
+                    case 13:
+                        e_2 = _b.sent();
+                        throw new Error('Unexpected error while acquiring application default credentials: ' +
+                            e_2.message);
+                    case 14: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Determines whether the auth layer is running on Google Compute Engine.
+     * @returns A promise that resolves with the boolean.
+     * @api private
+     */
+    GoogleAuth.prototype._checkIsGCE = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(this.checkIsGCE === undefined)) return [3 /*break*/, 2];
+                        _a = this;
+                        return [4 /*yield*/, gcpMetadata.isAvailable()];
+                    case 1:
+                        _a.checkIsGCE = _b.sent();
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, this.checkIsGCE];
+                }
+            });
+        });
+    };
+    /**
+     * Attempts to load default credentials from the environment variable path..
+     * @returns Promise that resolves with the OAuth2Client or null.
+     * @api private
+     */
+    GoogleAuth.prototype._tryGetApplicationCredentialsFromEnvironmentVariable = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var credentialsPath;
+            return __generator(this, function (_a) {
+                credentialsPath = process.env['GOOGLE_APPLICATION_CREDENTIALS'];
+                if (!credentialsPath || credentialsPath.length === 0) {
+                    return [2 /*return*/, null];
+                }
+                try {
+                    return [2 /*return*/, this._getApplicationCredentialsFromFilePath(credentialsPath, options)];
+                }
+                catch (e) {
+                    throw this.createError('Unable to read the credential file specified by the GOOGLE_APPLICATION_CREDENTIALS environment variable.', e);
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * Attempts to load default credentials from a well-known file location
+     * @return Promise that resolves with the OAuth2Client or null.
+     * @api private
+     */
+    GoogleAuth.prototype._tryGetApplicationCredentialsFromWellKnownFile = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var location, home;
+            return __generator(this, function (_a) {
+                location = null;
+                if (this._isWindows()) {
+                    // Windows
+                    location = process.env['APPDATA'];
+                }
+                else {
+                    home = process.env['HOME'];
+                    if (home) {
+                        location = this._pathJoin(home, '.config');
+                    }
+                }
+                // If we found the root path, expand it.
+                if (location) {
+                    location = this._pathJoin(location, 'gcloud');
+                    location =
+                        this._pathJoin(location, 'application_default_credentials.json');
+                    location = this._mockWellKnownFilePath(location);
+                    // Check whether the file exists.
+                    if (!this._fileExists(location)) {
+                        location = null;
+                    }
+                }
+                // The file does not exist.
+                if (!location) {
+                    return [2 /*return*/, null];
+                }
+                // The file seems to exist. Try to use it.
+                return [2 /*return*/, this._getApplicationCredentialsFromFilePath(location, options)];
+            });
+        });
+    };
+    /**
+     * Attempts to load default credentials from a file at the given path..
+     * @param filePath The path to the file to read.
+     * @returns Promise that resolves with the OAuth2Client
+     * @api private
+     */
+    GoogleAuth.prototype._getApplicationCredentialsFromFilePath = function (filePath, options) {
+        if (options === void 0) { options = {}; }
+        return __awaiter(this, void 0, void 0, function () {
+            var readStream;
+            return __generator(this, function (_a) {
+                // Make sure the path looks like a string.
+                if (!filePath || filePath.length === 0) {
+                    throw new Error('The file path is invalid.');
+                }
+                // Make sure there is a file at the path. lstatSync will throw if there is
+                // nothing there.
+                try {
+                    // Resolve path to actual file in case of symlink. Expect a thrown error
+                    // if not resolvable.
+                    filePath = fs.realpathSync(filePath);
+                    if (!fs.lstatSync(filePath).isFile()) {
+                        throw new Error();
+                    }
+                }
+                catch (err) {
+                    throw this.createError(util_1.default.format('The file at %s does not exist, or it is not a file.', filePath), err);
+                }
+                // Now open a read stream on the file, and parse it.
+                try {
+                    readStream = this._createReadStream(filePath);
+                    return [2 /*return*/, this.fromStream(readStream, options)];
+                }
+                catch (err) {
+                    throw this.createError(util_1.default.format('Unable to read the file at %s.', filePath), err);
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * Create a credentials instance using the given input options.
+     * @param json The input object.
+     * @returns JWT or UserRefresh Client with data
+     */
+    GoogleAuth.prototype.fromJSON = function (json, options) {
+        var client;
+        if (!json) {
+            throw new Error('Must pass in a JSON object containing the Google auth settings.');
+        }
+        this.jsonContent = json;
+        options = options || {};
+        if (json.type === 'authorized_user') {
+            client = new refreshclient_1.UserRefreshClient(options);
+        }
+        else {
+            options.scopes = this.scopes;
+            client = new jwtclient_1.JWT(options);
+        }
+        client.fromJSON(json);
+        return client;
+    };
+    GoogleAuth.prototype.fromStream = function (inputStream, optionsOrCallback, callback) {
+        if (optionsOrCallback === void 0) { optionsOrCallback = {}; }
+        var options = {};
+        if (typeof optionsOrCallback === 'function') {
+            callback = optionsOrCallback;
+        }
+        else {
+            options = optionsOrCallback;
+        }
+        if (callback) {
+            this.fromStreamAsync(inputStream, options)
+                .then(function (r) { return callback(null, r); })
+                .catch(callback);
+        }
+        else {
+            return this.fromStreamAsync(inputStream, options);
+        }
+    };
+    GoogleAuth.prototype.fromStreamAsync = function (inputStream, options) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            if (!inputStream) {
+                throw new Error('Must pass in a stream containing the Google auth settings.');
+            }
+            var s = '';
+            inputStream.setEncoding('utf8');
+            inputStream.on('data', function (chunk) {
+                s += chunk;
+            });
+            inputStream.on('end', function () {
+                try {
+                    var data = JSON.parse(s);
+                    var r = _this.fromJSON(data, options);
+                    return resolve(r);
+                }
+                catch (err) {
+                    return reject(err);
+                }
+            });
+        });
+    };
+    /**
+     * Create a credentials instance using the given API key string.
+     * @param apiKey The API key string
+     * @param options An optional options object.
+     * @returns A JWT loaded from the key
+     */
+    GoogleAuth.prototype.fromAPIKey = function (apiKey, options) {
+        options = options || {};
+        var client = new jwtclient_1.JWT(options);
+        client.fromAPIKey(apiKey);
+        return client;
+    };
+    /**
+     * Determines whether the current operating system is Windows.
+     * @api private
+     */
+    GoogleAuth.prototype._isWindows = function () {
+        var sys = this._osPlatform();
+        if (sys && sys.length >= 3) {
+            if (sys.substring(0, 3).toLowerCase() === 'win') {
+                return true;
+            }
+        }
+        return false;
+    };
+    /**
+     * Creates a file stream. Allows mocking.
+     * @api private
+     */
+    GoogleAuth.prototype._createReadStream = function (filePath) {
+        return fs.createReadStream(filePath);
+    };
+    /**
+     * Gets the current operating system platform. Allows mocking.
+     * @api private
+     */
+    GoogleAuth.prototype._osPlatform = function () {
+        return os_1.default.platform();
+    };
+    /**
+     * Determines whether a file exists. Allows mocking.
+     * @api private
+     */
+    GoogleAuth.prototype._fileExists = function (filePath) {
+        return fs.existsSync(filePath);
+    };
+    /**
+     * Joins two parts of a path. Allows mocking.
+     * @api private
+     */
+    GoogleAuth.prototype._pathJoin = function (item1, item2) {
+        return path_1.default.join(item1, item2);
+    };
+    /**
+     * Allows mocking of the path to a well-known file.
+     * @api private
+     */
+    GoogleAuth.prototype._mockWellKnownFilePath = function (filePath) {
+        return filePath;
+    };
+    // Creates an Error containing the given message, and includes the message
+    // from the optional err passed in.
+    GoogleAuth.prototype.createError = function (message, err) {
+        var s = message || '';
+        if (err) {
+            var errorMessage = String(err);
+            if (errorMessage && errorMessage.length > 0) {
+                if (s.length > 0) {
+                    s += ' ';
+                }
+                s += errorMessage;
+            }
+        }
+        return Error(s);
+    };
+    /**
+     * Run the Google Cloud SDK command that prints the default project ID
+     */
+    GoogleAuth.prototype.getDefaultServiceProjectId = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, new Promise(function (resolve) {
+                        child_process_1.exec('gcloud config config-helper --format json', function (err, stdout, stderr) {
+                            if (!err && stdout) {
+                                try {
+                                    var projectId = JSON.parse(stdout).configuration.properties.core.project;
+                                    resolve(projectId);
+                                    return;
+                                }
+                                catch (e) {
+                                    // ignore errors
+                                }
+                            }
+                            resolve(null);
+                        });
+                    })];
+            });
+        });
+    };
+    /**
+     * Loads the project id from environment variables.
+     * @api private
+     */
+    GoogleAuth.prototype.getProductionProjectId = function () {
+        return process.env['GCLOUD_PROJECT'] || process.env['GOOGLE_CLOUD_PROJECT'];
+    };
+    /**
+     * Loads the project id from the GOOGLE_APPLICATION_CREDENTIALS json file.
+     * @api private
+     */
+    GoogleAuth.prototype.getFileProjectId = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var r;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.cachedCredential) {
+                            // Try to read the project ID from the cached credentials file
+                            return [2 /*return*/, this.cachedCredential.projectId];
+                        }
+                        return [4 /*yield*/, this._tryGetApplicationCredentialsFromEnvironmentVariable()];
+                    case 1:
+                        r = _a.sent();
+                        if (r) {
+                            return [2 /*return*/, r.projectId];
+                        }
+                        else {
+                            return [2 /*return*/, null];
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Gets the Compute Engine project ID if it can be inferred.
+     */
+    GoogleAuth.prototype.getGCEProjectId = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var r, e_3;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, gcpMetadata.project('project-id')];
+                    case 1:
+                        r = _a.sent();
+                        return [2 /*return*/, r.data];
+                    case 2:
+                        e_3 = _a.sent();
+                        // Ignore any errors
+                        return [2 /*return*/, null];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    GoogleAuth.prototype.getCredentials = function (callback) {
+        if (callback) {
+            this.getCredentialsAsync().then(function (r) { return callback(null, r); }).catch(callback);
+        }
+        else {
+            return this.getCredentialsAsync();
+        }
+    };
+    GoogleAuth.prototype.getCredentialsAsync = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var credential, isGCE, data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.jsonContent) {
+                            credential = {
+                                client_email: this.jsonContent.client_email,
+                                private_key: this.jsonContent.private_key
+                            };
+                            return [2 /*return*/, credential];
+                        }
+                        return [4 /*yield*/, this._checkIsGCE()];
+                    case 1:
+                        isGCE = _a.sent();
+                        if (!isGCE) {
+                            throw new Error('Unknown error.');
+                        }
+                        return [4 /*yield*/, gcpMetadata.instance({ property: 'service-accounts/', params: { recursive: true } })];
+                    case 2:
+                        data = (_a.sent()).data;
+                        if (!data || !data.default || !data.default.email) {
+                            throw new Error('Failure from metadata server.');
+                        }
+                        return [2 /*return*/, { client_email: data.default.email }];
+                }
+            });
+        });
+    };
+    /**
+     * Automatically obtain a client based on the provided configuration.  If no
+     * options were passed, use Application Default Credentials.
+     */
+    GoogleAuth.prototype.getClient = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, filePath, stream_1, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (options) {
+                            this.keyFilename =
+                                options.keyFilename || options.keyFile || this.keyFilename;
+                            this.scopes = options.scopes || this.scopes;
+                            this.jsonContent = options.credentials || this.jsonContent;
+                        }
+                        if (!!this.cachedCredential) return [3 /*break*/, 6];
+                        if (!this.jsonContent) return [3 /*break*/, 2];
+                        _a = this;
+                        return [4 /*yield*/, this.fromJSON(this.jsonContent)];
+                    case 1:
+                        _a.cachedCredential = _c.sent();
+                        return [3 /*break*/, 6];
+                    case 2:
+                        if (!this.keyFilename) return [3 /*break*/, 4];
+                        filePath = path_1.default.resolve(this.keyFilename);
+                        stream_1 = fs.createReadStream(filePath);
+                        _b = this;
+                        return [4 /*yield*/, this.fromStreamAsync(stream_1)];
+                    case 3:
+                        _b.cachedCredential = _c.sent();
+                        return [3 /*break*/, 6];
+                    case 4: return [4 /*yield*/, this.getApplicationDefaultAsync()];
+                    case 5:
+                        _c.sent();
+                        _c.label = 6;
+                    case 6: return [2 /*return*/, this.cachedCredential];
+                }
+            });
+        });
+    };
+    /**
+     * Automatically obtain application default credentials, and return
+     * an access token for making requests.
+     */
+    GoogleAuth.prototype.getAccessToken = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var client;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getClient()];
+                    case 1:
+                        client = _a.sent();
+                        return [4 /*yield*/, client.getAccessToken()];
+                    case 2: return [2 /*return*/, (_a.sent()).token];
+                }
+            });
+        });
+    };
+    /**
+     * Obtain the HTTP headers that will provide authorization for a given
+     * request.
+     */
+    GoogleAuth.prototype.getRequestHeaders = function (url) {
+        return __awaiter(this, void 0, void 0, function () {
+            var client;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getClient()];
+                    case 1:
+                        client = _a.sent();
+                        return [4 /*yield*/, client.getRequestMetadata(url)];
+                    case 2: return [2 /*return*/, (_a.sent()).headers];
+                }
+            });
+        });
+    };
+    /**
+     * Obtain credentials for a request, then attach the appropriate headers to
+     * the request options.
+     * @param opts Axios or Request options on which to attach the headers
+     */
+    GoogleAuth.prototype.authorizeRequest = function (opts) {
+        return __awaiter(this, void 0, void 0, function () {
+            var url, client, headers;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        opts = opts || {};
+                        url = opts.url || opts.uri;
+                        return [4 /*yield*/, this.getClient()];
+                    case 1:
+                        client = _a.sent();
+                        return [4 /*yield*/, client.getRequestMetadata(url)];
+                    case 2:
+                        headers = (_a.sent()).headers;
+                        opts.headers = Object.assign(opts.headers || {}, headers);
+                        return [2 /*return*/, opts];
+                }
+            });
+        });
+    };
+    /**
+     * Automatically obtain application default credentials, and make an
+     * HTTP request using the given options.
+     * @param opts Axios request options for the HTTP request.
+     */
+    // tslint:disable-next-line no-any
+    GoogleAuth.prototype.request = function (opts) {
+        return __awaiter(this, void 0, void 0, function () {
+            var client;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getClient()];
+                    case 1:
+                        client = _a.sent();
+                        return [2 /*return*/, client.request(opts)];
+                }
+            });
+        });
+    };
+    /**
+     * Determine the compute environment in which the code is running.
+     */
+    GoogleAuth.prototype.getEnv = function () {
+        return envDetect_1.getEnv();
+    };
+    /**
+     * Sign the given data with the current private key, or go out
+     * to the IAM API to sign it.
+     * @param data The data to be signed.
+     */
+    GoogleAuth.prototype.sign = function (data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var client, sign, projectId, creds, id, res;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getClient()];
+                    case 1:
+                        client = _a.sent();
+                        if (client instanceof jwtclient_1.JWT && client.key) {
+                            sign = crypto_1.default.createSign('RSA-SHA256');
+                            sign.update(data);
+                            return [2 /*return*/, sign.sign(client.key, 'base64')];
+                        }
+                        return [4 /*yield*/, this.getProjectId()];
+                    case 2:
+                        projectId = _a.sent();
+                        if (!projectId) {
+                            throw new Error('Cannot sign data without a project ID.');
+                        }
+                        return [4 /*yield*/, this.getCredentials()];
+                    case 3:
+                        creds = _a.sent();
+                        if (!creds.client_email) {
+                            throw new Error('Cannot sign data without `client_email`.');
+                        }
+                        id = "projects/" + projectId + "/serviceAccounts/" + creds.client_email;
+                        return [4 /*yield*/, this.request({
+                                method: 'POST',
+                                url: "https://iam.googleapis.com/v1/" + id + ":signBlob",
+                                data: { bytesToSign: Buffer.from(data).toString('base64') }
+                            })];
+                    case 4:
+                        res = _a.sent();
+                        return [2 /*return*/, res.data.signature];
+                }
+            });
+        });
+    };
+    /**
+     * Export DefaultTransporter as a static property of the class.
+     */
+    GoogleAuth.DefaultTransporter = transporters_1.DefaultTransporter;
+    return GoogleAuth;
+}());
+exports.GoogleAuth = GoogleAuth;
+//# sourceMappingURL=googleauth.js.map

node_modules/google-auth-library/build/src/auth/iam.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var IAMAuth = /** @class */ (function () {
+    /**
+     * IAM credentials.
+     *
+     * @param selector the iam authority selector
+     * @param token the token
+     * @constructor
+     */
+    function IAMAuth(selector, token) {
+        this.selector = selector;
+        this.token = token;
+        this.selector = selector;
+        this.token = token;
+    }
+    /**
+     * Indicates whether the credential requires scopes to be created by calling
+     * createdScoped before use.
+     *
+     * @return always false
+     */
+    IAMAuth.prototype.createScopedRequired = function () {
+        // IAM authorization does not use scopes.
+        return false;
+    };
+    /**
+     * Pass the selector and token to the metadataFn callback.
+     *
+     * @param unused_uri is required of the credentials interface
+     * @param metadataFn a callback invoked with object
+     *                   containing request metadata.
+     */
+    IAMAuth.prototype.getRequestMetadata = function (unusedUri, metadataFn) {
+        metadataFn(null, {
+            'x-goog-iam-authority-selector': this.selector,
+            'x-goog-iam-authorization-token': this.token
+        });
+    };
+    return IAMAuth;
+}());
+exports.IAMAuth = IAMAuth;
+//# sourceMappingURL=iam.js.map

node_modules/google-auth-library/build/src/auth/iam.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"iam.js","sourceRoot":"","sources":["../../../src/auth/iam.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;AAOH;IACE;;;;;;OAMG;IACH,iBAAmB,QAAgB,EAAS,KAAa;QAAtC,aAAQ,GAAR,QAAQ,CAAQ;QAAS,UAAK,GAAL,KAAK,CAAQ;QACvD,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;IAED;;;;;OAKG;IACH,sCAAoB,GAApB;QACE,yCAAyC;QACzC,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;;;OAMG;IACH,oCAAkB,GAAlB,UACI,SAAsB,EACtB,UAAiE;QACnE,UAAU,CAAC,IAAI,EAAE;YACf,+BAA+B,EAAE,IAAI,CAAC,QAAQ;YAC9C,gCAAgC,EAAE,IAAI,CAAC,KAAK;SAC7C,CAAC,CAAC;IACL,CAAC;IACH,cAAC;AAAD,CAAC,AAvCD,IAuCC;AAvCY,0BAAO"}

node_modules/google-auth-library/build/src/auth/jwtaccess.js

@@ -0,0 +1,136 @@
+"use strict";
+/**
+ * Copyright 2015 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var jws_1 = __importDefault(require("jws"));
+var lru_cache_1 = __importDefault(require("lru-cache"));
+var JWTAccess = /** @class */ (function () {
+    /**
+     * JWTAccess service account credentials.
+     *
+     * Create a new access token by using the credential to create a new JWT token
+     * that's recognized as the access token.
+     *
+     * @param email the service account email address.
+     * @param key the private key that will be used to sign the token.
+     */
+    function JWTAccess(email, key) {
+        this.cache = lru_cache_1.default({ max: 500, maxAge: 60 * 60 * 1000 });
+        this.email = email;
+        this.key = key;
+    }
+    /**
+     * Indicates whether the credential requires scopes to be created by calling
+     * createdScoped before use.
+     *
+     * @return always false
+     */
+    JWTAccess.prototype.createScopedRequired = function () {
+        // JWT Header authentication does not use scopes.
+        return false;
+    };
+    /**
+     * Get a non-expired access token, after refreshing if necessary.
+     *
+     * @param authURI The URI being authorized.
+     * @param additionalClaims An object with a set of additional claims to
+     * include in the payload.
+     * @returns An object that includes the authorization header.
+     */
+    JWTAccess.prototype.getRequestMetadata = function (authURI, additionalClaims) {
+        var cachedToken = this.cache.get(authURI);
+        if (cachedToken) {
+            return cachedToken;
+        }
+        var iat = Math.floor(new Date().getTime() / 1000);
+        var exp = iat + 3600; // 3600 seconds = 1 hour
+        // The payload used for signed JWT headers has:
+        // iss == sub == <client email>
+        // aud == <the authorization uri>
+        var defaultClaims = { iss: this.email, sub: this.email, aud: authURI, exp: exp, iat: iat };
+        // if additionalClaims are provided, ensure they do not collide with
+        // other required claims.
+        if (additionalClaims) {
+            for (var claim in defaultClaims) {
+                if (additionalClaims[claim]) {
+                    throw new Error("The '" + claim + "' property is not allowed when passing additionalClaims. This claim is included in the JWT by default.");
+                }
+            }
+        }
+        var payload = Object.assign(defaultClaims, additionalClaims);
+        // Sign the jwt and add it to the cache
+        var signedJWT = jws_1.default.sign({ header: { alg: 'RS256' }, payload: payload, secret: this.key });
+        var res = { headers: { Authorization: "Bearer " + signedJWT } };
+        this.cache.set(authURI, res);
+        return res;
+    };
+    /**
+     * Create a JWTAccess credentials instance using the given input options.
+     * @param json The input object.
+     */
+    JWTAccess.prototype.fromJSON = function (json) {
+        if (!json) {
+            throw new Error('Must pass in a JSON object containing the service account auth settings.');
+        }
+        if (!json.client_email) {
+            throw new Error('The incoming JSON object does not contain a client_email field');
+        }
+        if (!json.private_key) {
+            throw new Error('The incoming JSON object does not contain a private_key field');
+        }
+        // Extract the relevant information from the json key file.
+        this.email = json.client_email;
+        this.key = json.private_key;
+        this.projectId = json.project_id;
+    };
+    JWTAccess.prototype.fromStream = function (inputStream, callback) {
+        if (callback) {
+            this.fromStreamAsync(inputStream).then(function (r) { return callback(); }).catch(callback);
+        }
+        else {
+            return this.fromStreamAsync(inputStream);
+        }
+    };
+    JWTAccess.prototype.fromStreamAsync = function (inputStream) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            if (!inputStream) {
+                reject(new Error('Must pass in a stream containing the service account auth settings.'));
+            }
+            var s = '';
+            inputStream.setEncoding('utf8');
+            inputStream.on('data', function (chunk) {
+                s += chunk;
+            });
+            inputStream.on('end', function () {
+                try {
+                    var data = JSON.parse(s);
+                    _this.fromJSON(data);
+                    resolve();
+                }
+                catch (err) {
+                    reject(err);
+                }
+            });
+        });
+    };
+    return JWTAccess;
+}());
+exports.JWTAccess = JWTAccess;
+//# sourceMappingURL=jwtaccess.js.map

node_modules/google-auth-library/build/src/auth/jwtaccess.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jwtaccess.js","sourceRoot":"","sources":["../../../src/auth/jwtaccess.ts"],"names":[],"mappings":"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"}

node_modules/google-auth-library/build/src/auth/jwtclient.js

@@ -0,0 +1,306 @@
+"use strict";
+/**
+ * Copyright 2013 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+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 gtoken_1 = require("gtoken");
+var jwtaccess_1 = require("./jwtaccess");
+var oauth2client_1 = require("./oauth2client");
+var isString = require('lodash.isstring');
+var JWT = /** @class */ (function (_super) {
+    __extends(JWT, _super);
+    function JWT(optionsOrEmail, keyFile, key, scopes, subject) {
+        var _this = this;
+        var opts = (optionsOrEmail && typeof optionsOrEmail === 'object') ?
+            optionsOrEmail :
+            { email: optionsOrEmail, keyFile: keyFile, key: key, scopes: scopes, subject: subject };
+        _this = _super.call(this, { eagerRefreshThresholdMillis: opts.eagerRefreshThresholdMillis }) || this;
+        _this.email = opts.email;
+        _this.keyFile = opts.keyFile;
+        _this.key = opts.key;
+        _this.scopes = opts.scopes;
+        _this.subject = opts.subject;
+        _this.additionalClaims = opts.additionalClaims;
+        _this.credentials = { refresh_token: 'jwt-placeholder', expiry_date: 1 };
+        return _this;
+    }
+    /**
+     * Creates a copy of the credential with the specified scopes.
+     * @param scopes List of requested scopes or a single scope.
+     * @return The cloned instance.
+     */
+    JWT.prototype.createScoped = function (scopes) {
+        return new JWT({
+            email: this.email,
+            keyFile: this.keyFile,
+            key: this.key,
+            scopes: scopes,
+            subject: this.subject,
+            additionalClaims: this.additionalClaims
+        });
+    };
+    /**
+     * Obtains the metadata to be sent with the request.
+     *
+     * @param url the URI being authorized.
+     */
+    JWT.prototype.getRequestMetadataAsync = function (url) {
+        return __awaiter(this, void 0, void 0, function () {
+            var tokens;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(!this.apiKey && this.createScopedRequired() && url)) return [3 /*break*/, 4];
+                        if (!(this.additionalClaims && this.additionalClaims.target_audience)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.refreshToken()];
+                    case 1:
+                        tokens = (_a.sent()).tokens;
+                        return [2 /*return*/, { headers: { Authorization: "Bearer " + tokens.id_token } }];
+                    case 2:
+                        // no scopes have been set, but a uri has been provided. Use JWTAccess
+                        // credentials.
+                        if (!this.access) {
+                            this.access = new jwtaccess_1.JWTAccess(this.email, this.key);
+                        }
+                        return [2 /*return*/, this.access.getRequestMetadata(url, this.additionalClaims)];
+                    case 3: return [3 /*break*/, 5];
+                    case 4: return [2 /*return*/, _super.prototype.getRequestMetadataAsync.call(this, url)];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Indicates whether the credential requires scopes to be created by calling
+     * createScoped before use.
+     * @return false if createScoped does not need to be called.
+     */
+    JWT.prototype.createScopedRequired = function () {
+        // If scopes is null, always return true.
+        if (this.scopes) {
+            // For arrays, check the array length.
+            if (this.scopes instanceof Array) {
+                return this.scopes.length === 0;
+            }
+            // For others, convert to a string and check the length.
+            return String(this.scopes).length === 0;
+        }
+        return true;
+    };
+    JWT.prototype.authorize = function (callback) {
+        if (callback) {
+            this.authorizeAsync().then(function (r) { return callback(null, r); }).catch(callback);
+        }
+        else {
+            return this.authorizeAsync();
+        }
+    };
+    JWT.prototype.authorizeAsync = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.refreshToken()];
+                    case 1:
+                        result = _a.sent();
+                        if (!result) {
+                            throw new Error('No result returned');
+                        }
+                        this.credentials = result.tokens;
+                        this.credentials.refresh_token = 'jwt-placeholder';
+                        this.key = this.gtoken.key;
+                        this.email = this.gtoken.iss;
+                        return [2 /*return*/, result.tokens];
+                }
+            });
+        });
+    };
+    /**
+     * Refreshes the access token.
+     * @param refreshToken ignored
+     * @private
+     */
+    JWT.prototype.refreshTokenNoCache = function (refreshToken) {
+        return __awaiter(this, void 0, void 0, function () {
+            var gtoken, token, tokens;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        gtoken = this.createGToken();
+                        return [4 /*yield*/, gtoken.getToken()];
+                    case 1:
+                        token = _a.sent();
+                        tokens = {
+                            access_token: token,
+                            token_type: 'Bearer',
+                            expiry_date: gtoken.expiresAt,
+                            // tslint:disable-next-line no-any
+                            id_token: gtoken.rawToken.id_token
+                        };
+                        this.emit('tokens', tokens);
+                        return [2 /*return*/, { res: null, tokens: tokens }];
+                }
+            });
+        });
+    };
+    /**
+     * Create a gToken if it doesn't already exist.
+     */
+    JWT.prototype.createGToken = function () {
+        if (!this.gtoken) {
+            this.gtoken = new gtoken_1.GoogleToken({
+                iss: this.email,
+                sub: this.subject,
+                scope: this.scopes,
+                keyFile: this.keyFile,
+                key: this.key,
+                additionalClaims: this.additionalClaims
+            });
+        }
+        return this.gtoken;
+    };
+    /**
+     * Create a JWT credentials instance using the given input options.
+     * @param json The input object.
+     */
+    JWT.prototype.fromJSON = function (json) {
+        if (!json) {
+            throw new Error('Must pass in a JSON object containing the service account auth settings.');
+        }
+        if (!json.client_email) {
+            throw new Error('The incoming JSON object does not contain a client_email field');
+        }
+        if (!json.private_key) {
+            throw new Error('The incoming JSON object does not contain a private_key field');
+        }
+        // Extract the relevant information from the json key file.
+        this.email = json.client_email;
+        this.key = json.private_key;
+        this.projectId = json.project_id;
+    };
+    JWT.prototype.fromStream = function (inputStream, callback) {
+        if (callback) {
+            this.fromStreamAsync(inputStream).then(function (r) { return callback(); }).catch(callback);
+        }
+        else {
+            return this.fromStreamAsync(inputStream);
+        }
+    };
+    JWT.prototype.fromStreamAsync = function (inputStream) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            if (!inputStream) {
+                throw new Error('Must pass in a stream containing the service account auth settings.');
+            }
+            var s = '';
+            inputStream.setEncoding('utf8');
+            inputStream.on('data', function (chunk) {
+                s += chunk;
+            });
+            inputStream.on('end', function () {
+                try {
+                    var data = JSON.parse(s);
+                    _this.fromJSON(data);
+                    resolve();
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+        });
+    };
+    /**
+     * Creates a JWT credentials instance using an API Key for authentication.
+     * @param apiKey The API Key in string form.
+     */
+    JWT.prototype.fromAPIKey = function (apiKey) {
+        if (!isString(apiKey)) {
+            throw new Error('Must provide an API Key string.');
+        }
+        this.apiKey = apiKey;
+    };
+    /**
+     * Using the key or keyFile on the JWT client, obtain an object that contains
+     * the key and the client email.
+     */
+    JWT.prototype.getCredentials = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var gtoken, creds;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.key) return [3 /*break*/, 1];
+                        return [2 /*return*/, { private_key: this.key, client_email: this.email }];
+                    case 1:
+                        if (!this.keyFile) return [3 /*break*/, 3];
+                        gtoken = this.createGToken();
+                        return [4 /*yield*/, gtoken.getCredentials(this.keyFile)];
+                    case 2:
+                        creds = _a.sent();
+                        return [2 /*return*/, { private_key: creds.privateKey, client_email: creds.clientEmail }];
+                    case 3: throw new Error('A key or a keyFile must be provided to getCredentials.');
+                }
+            });
+        });
+    };
+    return JWT;
+}(oauth2client_1.OAuth2Client));
+exports.JWT = JWT;
+//# sourceMappingURL=jwtclient.js.map

node_modules/google-auth-library/build/src/auth/loginticket.js

@@ -0,0 +1,60 @@
+"use strict";
+/**
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var LoginTicket = /** @class */ (function () {
+    /**
+     * Create a simple class to extract user ID from an ID Token
+     *
+     * @param {string} env Envelope of the jwt
+     * @param {TokenPayload} pay Payload of the jwt
+     * @constructor
+     */
+    function LoginTicket(env, pay) {
+        this.envelope = env;
+        this.payload = pay;
+    }
+    LoginTicket.prototype.getEnvelope = function () {
+        return this.envelope;
+    };
+    LoginTicket.prototype.getPayload = function () {
+        return this.payload;
+    };
+    /**
+     * Create a simple class to extract user ID from an ID Token
+     *
+     * @return The user ID
+     */
+    LoginTicket.prototype.getUserId = function () {
+        var payload = this.getPayload();
+        if (payload && payload.sub) {
+            return payload.sub;
+        }
+        return null;
+    };
+    /**
+     * Returns attributes from the login ticket.  This can contain
+     * various information about the user session.
+     *
+     * @return The envelope and payload
+     */
+    LoginTicket.prototype.getAttributes = function () {
+        return { envelope: this.getEnvelope(), payload: this.getPayload() };
+    };
+    return LoginTicket;
+}());
+exports.LoginTicket = LoginTicket;
+//# sourceMappingURL=loginticket.js.map

node_modules/google-auth-library/build/src/auth/loginticket.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loginticket.js","sourceRoot":"","sources":["../../../src/auth/loginticket.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;AAEH;IAIE;;;;;;OAMG;IACH,qBAAY,GAAY,EAAE,GAAkB;QAC1C,IAAI,CAAC,QAAQ,GAAG,GAAG,CAAC;QACpB,IAAI,CAAC,OAAO,GAAG,GAAG,CAAC;IACrB,CAAC;IAED,iCAAW,GAAX;QACE,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAED,gCAAU,GAAV;QACE,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED;;;;OAIG;IACH,+BAAS,GAAT;QACE,IAAM,OAAO,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;QAClC,IAAI,OAAO,IAAI,OAAO,CAAC,GAAG,EAAE;YAC1B,OAAO,OAAO,CAAC,GAAG,CAAC;SACpB;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;OAKG;IACH,mCAAa,GAAb;QACE,OAAO,EAAC,QAAQ,EAAE,IAAI,CAAC,WAAW,EAAE,EAAE,OAAO,EAAE,IAAI,CAAC,UAAU,EAAE,EAAC,CAAC;IACpE,CAAC;IACH,kBAAC;AAAD,CAAC,AA9CD,IA8CC;AA9CY,kCAAW"}

node_modules/google-auth-library/build/src/auth/oauth2client.js

@@ -0,0 +1,753 @@
+"use strict";
+/**
+ * Copyright 2012 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+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 };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var crypto_1 = __importDefault(require("crypto"));
+var querystring_1 = __importDefault(require("querystring"));
+var stream = __importStar(require("stream"));
+var pemverifier_1 = require("./../pemverifier");
+var authclient_1 = require("./authclient");
+var loginticket_1 = require("./loginticket");
+var CodeChallengeMethod;
+(function (CodeChallengeMethod) {
+    CodeChallengeMethod["Plain"] = "plain";
+    CodeChallengeMethod["S256"] = "S256";
+})(CodeChallengeMethod = exports.CodeChallengeMethod || (exports.CodeChallengeMethod = {}));
+var OAuth2Client = /** @class */ (function (_super) {
+    __extends(OAuth2Client, _super);
+    function OAuth2Client(optionsOrClientId, clientSecret, redirectUri, authClientOpts) {
+        if (authClientOpts === void 0) { authClientOpts = {}; }
+        var _this = _super.call(this) || this;
+        _this.certificateCache = null;
+        _this.certificateExpiry = null;
+        _this.refreshTokenPromises = new Map();
+        var opts = (optionsOrClientId && typeof optionsOrClientId === 'object') ?
+            optionsOrClientId :
+            {
+                clientId: optionsOrClientId,
+                clientSecret: clientSecret,
+                redirectUri: redirectUri,
+                tokenUrl: authClientOpts.tokenUrl,
+                authBaseUrl: authClientOpts.authBaseUrl
+            };
+        _this._clientId = opts.clientId;
+        _this._clientSecret = opts.clientSecret;
+        _this.redirectUri = opts.redirectUri;
+        _this.authBaseUrl = opts.authBaseUrl;
+        _this.tokenUrl = opts.tokenUrl;
+        _this.eagerRefreshThresholdMillis =
+            opts.eagerRefreshThresholdMillis || 5 * 60 * 1000;
+        return _this;
+    }
+    /**
+     * Generates URL for consent page landing.
+     * @param opts Options.
+     * @return URL to consent page.
+     */
+    OAuth2Client.prototype.generateAuthUrl = function (opts) {
+        if (opts === void 0) { opts = {}; }
+        if (opts.code_challenge_method && !opts.code_challenge) {
+            throw new Error('If a code_challenge_method is provided, code_challenge must be included.');
+        }
+        opts.response_type = opts.response_type || 'code';
+        opts.client_id = opts.client_id || this._clientId;
+        opts.redirect_uri = opts.redirect_uri || this.redirectUri;
+        // Allow scopes to be passed either as array or a string
+        if (opts.scope instanceof Array) {
+            opts.scope = opts.scope.join(' ');
+        }
+        var rootUrl = this.authBaseUrl || OAuth2Client.GOOGLE_OAUTH2_AUTH_BASE_URL_;
+        return rootUrl + '?' + querystring_1.default.stringify(opts);
+    };
+    /**
+     * Convenience method to automatically generate a code_verifier, and it's
+     * resulting SHA256. If used, this must be paired with a S256
+     * code_challenge_method.
+     */
+    OAuth2Client.prototype.generateCodeVerifier = function () {
+        // base64 encoding uses 6 bits per character, and we want to generate128
+        // characters. 6*128/8 = 96.
+        var randomString = crypto_1.default.randomBytes(96).toString('base64');
+        // The valid characters in the code_verifier are [A-Z]/[a-z]/[0-9]/
+        // "-"/"."/"_"/"~". Base64 encoded strings are pretty close, so we're just
+        // swapping out a few chars.
+        var codeVerifier = randomString.replace(/\+/g, '~').replace(/=/g, '_').replace(/\//g, '-');
+        // Generate the base64 encoded SHA256
+        var unencodedCodeChallenge = crypto_1.default.createHash('sha256').update(codeVerifier).digest('base64');
+        // We need to use base64UrlEncoding instead of standard base64
+        var codeChallenge = unencodedCodeChallenge.split('=')[0]
+            .replace(/\+/g, '-')
+            .replace(/\//g, '_');
+        return { codeVerifier: codeVerifier, codeChallenge: codeChallenge };
+    };
+    OAuth2Client.prototype.getToken = function (codeOrOptions, callback) {
+        var options = (typeof codeOrOptions === 'string') ?
+            { code: codeOrOptions } :
+            codeOrOptions;
+        if (callback) {
+            this.getTokenAsync(options)
+                .then(function (r) { return callback(null, r.tokens, r.res); })
+                .catch(function (e) { return callback(e, null, e.response); });
+        }
+        else {
+            return this.getTokenAsync(options);
+        }
+    };
+    OAuth2Client.prototype.getTokenAsync = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var url, values, res, tokens;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        url = this.tokenUrl || OAuth2Client.GOOGLE_OAUTH2_TOKEN_URL_;
+                        values = {
+                            code: options.code,
+                            client_id: options.client_id || this._clientId,
+                            client_secret: this._clientSecret,
+                            redirect_uri: options.redirect_uri || this.redirectUri,
+                            grant_type: 'authorization_code',
+                            code_verifier: options.codeVerifier
+                        };
+                        return [4 /*yield*/, this.transporter.request({
+                                method: 'POST',
+                                url: url,
+                                data: querystring_1.default.stringify(values),
+                                headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
+                            })];
+                    case 1:
+                        res = _a.sent();
+                        tokens = res.data;
+                        if (res.data && res.data.expires_in) {
+                            tokens.expiry_date =
+                                ((new Date()).getTime() + (res.data.expires_in * 1000));
+                            delete tokens.expires_in;
+                        }
+                        this.emit('tokens', tokens);
+                        return [2 /*return*/, { tokens: tokens, res: res }];
+                }
+            });
+        });
+    };
+    /**
+     * Refreshes the access token.
+     * @param refresh_token Existing refresh token.
+     * @private
+     */
+    OAuth2Client.prototype.refreshToken = function (refreshToken) {
+        return __awaiter(this, void 0, void 0, function () {
+            var p;
+            var _this = this;
+            return __generator(this, function (_a) {
+                if (!refreshToken) {
+                    return [2 /*return*/, this.refreshTokenNoCache(refreshToken)];
+                }
+                // If a request to refresh using the same token has started,
+                // return the same promise.
+                if (this.refreshTokenPromises.has(refreshToken)) {
+                    return [2 /*return*/, this.refreshTokenPromises.get(refreshToken)];
+                }
+                p = this.refreshTokenNoCache(refreshToken)
+                    .then(function (r) {
+                    _this.refreshTokenPromises.delete(refreshToken);
+                    return r;
+                })
+                    .catch(function (e) {
+                    _this.refreshTokenPromises.delete(refreshToken);
+                    throw e;
+                });
+                this.refreshTokenPromises.set(refreshToken, p);
+                return [2 /*return*/, p];
+            });
+        });
+    };
+    OAuth2Client.prototype.refreshTokenNoCache = function (refreshToken) {
+        return __awaiter(this, void 0, void 0, function () {
+            var url, data, res, tokens;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        url = this.tokenUrl || OAuth2Client.GOOGLE_OAUTH2_TOKEN_URL_;
+                        data = {
+                            refresh_token: refreshToken,
+                            client_id: this._clientId,
+                            client_secret: this._clientSecret,
+                            grant_type: 'refresh_token'
+                        };
+                        return [4 /*yield*/, this.transporter.request({
+                                method: 'POST',
+                                url: url,
+                                data: querystring_1.default.stringify(data),
+                                headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
+                            })];
+                    case 1:
+                        res = _a.sent();
+                        tokens = res.data;
+                        // TODO: de-duplicate this code from a few spots
+                        if (res.data && res.data.expires_in) {
+                            tokens.expiry_date =
+                                ((new Date()).getTime() + (res.data.expires_in * 1000));
+                            delete tokens.expires_in;
+                        }
+                        this.emit('tokens', tokens);
+                        return [2 /*return*/, { tokens: tokens, res: res }];
+                }
+            });
+        });
+    };
+    OAuth2Client.prototype.refreshAccessToken = function (callback) {
+        if (callback) {
+            this.refreshAccessTokenAsync()
+                .then(function (r) { return callback(null, r.credentials, r.res); })
+                .catch(callback);
+        }
+        else {
+            return this.refreshAccessTokenAsync();
+        }
+    };
+    OAuth2Client.prototype.refreshAccessTokenAsync = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var r, tokens;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.credentials.refresh_token) {
+                            throw new Error('No refresh token is set.');
+                        }
+                        return [4 /*yield*/, this.refreshToken(this.credentials.refresh_token)];
+                    case 1:
+                        r = _a.sent();
+                        tokens = r.tokens;
+                        tokens.refresh_token = this.credentials.refresh_token;
+                        this.credentials = tokens;
+                        return [2 /*return*/, { credentials: this.credentials, res: r.res }];
+                }
+            });
+        });
+    };
+    OAuth2Client.prototype.getAccessToken = function (callback) {
+        if (callback) {
+            this.getAccessTokenAsync()
+                .then(function (r) { return callback(null, r.token, r.res); })
+                .catch(callback);
+        }
+        else {
+            return this.getAccessTokenAsync();
+        }
+    };
+    OAuth2Client.prototype.getAccessTokenAsync = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var shouldRefresh, r;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        shouldRefresh = !this.credentials.access_token || this.isTokenExpiring();
+                        if (!(shouldRefresh && this.credentials.refresh_token)) return [3 /*break*/, 2];
+                        if (!this.credentials.refresh_token) {
+                            throw new Error('No refresh token is set.');
+                        }
+                        return [4 /*yield*/, this.refreshAccessToken()];
+                    case 1:
+                        r = _a.sent();
+                        if (!r.credentials || (r.credentials && !r.credentials.access_token)) {
+                            throw new Error('Could not refresh access token.');
+                        }
+                        return [2 /*return*/, { token: r.credentials.access_token, res: r.res }];
+                    case 2: return [2 /*return*/, { token: this.credentials.access_token }];
+                }
+            });
+        });
+    };
+    OAuth2Client.prototype.getRequestMetadata = function (url, callback) {
+        if (callback) {
+            this.getRequestMetadataAsync(url)
+                .then(function (r) { return callback(null, r.headers, r.res); })
+                .catch(callback);
+        }
+        else {
+            return this.getRequestMetadataAsync(url);
+        }
+    };
+    OAuth2Client.prototype.getRequestMetadataAsync = function (url) {
+        return __awaiter(this, void 0, void 0, function () {
+            var thisCreds, headers_1, r, tokens, err_1, e, credentials, headers;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        thisCreds = this.credentials;
+                        if (!thisCreds.access_token && !thisCreds.refresh_token && !this.apiKey) {
+                            throw new Error('No access, refresh token or API key is set.');
+                        }
+                        if (thisCreds.access_token && !this.isTokenExpiring()) {
+                            thisCreds.token_type = thisCreds.token_type || 'Bearer';
+                            headers_1 = {
+                                Authorization: thisCreds.token_type + ' ' + thisCreds.access_token
+                            };
+                            return [2 /*return*/, { headers: headers_1 }];
+                        }
+                        if (this.apiKey) {
+                            return [2 /*return*/, { headers: {} }];
+                        }
+                        r = null;
+                        tokens = null;
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.refreshToken(thisCreds.refresh_token)];
+                    case 2:
+                        r = _a.sent();
+                        tokens = r.tokens;
+                        return [3 /*break*/, 4];
+                    case 3:
+                        err_1 = _a.sent();
+                        e = err_1;
+                        if (e.response &&
+                            (e.response.status === 403 || e.response.status === 404)) {
+                            e.message = 'Could not refresh access token.';
+                        }
+                        throw e;
+                    case 4:
+                        credentials = this.credentials;
+                        credentials.token_type = credentials.token_type || 'Bearer';
+                        tokens.refresh_token = credentials.refresh_token;
+                        this.credentials = tokens;
+                        headers = {
+                            Authorization: credentials.token_type + ' ' + tokens.access_token
+                        };
+                        return [2 /*return*/, { headers: headers, res: r.res }];
+                }
+            });
+        });
+    };
+    OAuth2Client.prototype.revokeToken = function (token, callback) {
+        var opts = {
+            url: OAuth2Client.GOOGLE_OAUTH2_REVOKE_URL_ + '?' +
+                querystring_1.default.stringify({ token: token })
+        };
+        if (callback) {
+            this.transporter.request(opts)
+                .then(function (res) {
+                callback(null, res);
+            })
+                .catch(callback);
+        }
+        else {
+            return this.transporter.request(opts);
+        }
+    };
+    OAuth2Client.prototype.revokeCredentials = function (callback) {
+        if (callback) {
+            this.revokeCredentialsAsync()
+                .then(function (res) { return callback(null, res); })
+                .catch(callback);
+        }
+        else {
+            return this.revokeCredentialsAsync();
+        }
+    };
+    OAuth2Client.prototype.revokeCredentialsAsync = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var token;
+            return __generator(this, function (_a) {
+                token = this.credentials.access_token;
+                this.credentials = {};
+                if (token) {
+                    return [2 /*return*/, this.revokeToken(token)];
+                }
+                else {
+                    throw new Error('No access token to revoke.');
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    OAuth2Client.prototype.request = function (opts, callback) {
+        if (callback) {
+            this.requestAsync(opts).then(function (r) { return callback(null, r); }).catch(function (e) {
+                var err = e;
+                var body = err.response ? err.response.data : null;
+                return callback(e, err.response);
+            });
+        }
+        else {
+            return this.requestAsync(opts);
+        }
+    };
+    OAuth2Client.prototype.requestAsync = function (opts, retry) {
+        if (retry === void 0) { retry = false; }
+        return __awaiter(this, void 0, void 0, function () {
+            var r2, r, e_1, res, statusCode, mayRequireRefresh, isReadableStream, isAuthErr;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 3, , 6]);
+                        return [4 /*yield*/, this.getRequestMetadataAsync(opts.url)];
+                    case 1:
+                        r = _a.sent();
+                        if (r.headers && r.headers.Authorization) {
+                            opts.headers = opts.headers || {};
+                            opts.headers.Authorization = r.headers.Authorization;
+                        }
+                        if (this.apiKey) {
+                            opts.params = Object.assign(opts.params || {}, { key: this.apiKey });
+                        }
+                        return [4 /*yield*/, this.transporter.request(opts)];
+                    case 2:
+                        r2 = _a.sent();
+                        return [3 /*break*/, 6];
+                    case 3:
+                        e_1 = _a.sent();
+                        res = e_1.response;
+                        if (!res) return [3 /*break*/, 5];
+                        statusCode = res.status;
+                        mayRequireRefresh = this.credentials &&
+                            this.credentials.access_token && this.credentials.refresh_token &&
+                            !this.credentials.expiry_date;
+                        isReadableStream = res.config.data instanceof stream.Readable;
+                        isAuthErr = statusCode === 401 || statusCode === 403;
+                        if (!(!retry && isAuthErr && !isReadableStream && mayRequireRefresh)) return [3 /*break*/, 5];
+                        return [4 /*yield*/, this.refreshAccessTokenAsync()];
+                    case 4:
+                        _a.sent();
+                        return [2 /*return*/, this.requestAsync(opts, true)];
+                    case 5: throw e_1;
+                    case 6: return [2 /*return*/, r2];
+                }
+            });
+        });
+    };
+    OAuth2Client.prototype.verifyIdToken = function (options, callback) {
+        // This function used to accept two arguments instead of an options object.
+        // Check the types to help users upgrade with less pain.
+        // This check can be removed after a 2.0 release.
+        if (callback && typeof callback !== 'function') {
+            throw new Error('This method accepts an options object as the first parameter, which includes the idToken, audience, and maxExpiry.');
+        }
+        if (callback) {
+            this.verifyIdTokenAsync(options)
+                .then(function (r) { return callback(null, r); })
+                .catch(callback);
+        }
+        else {
+            return this.verifyIdTokenAsync(options);
+        }
+    };
+    OAuth2Client.prototype.verifyIdTokenAsync = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, login;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!options.idToken) {
+                            throw new Error('The verifyIdToken method requires an ID Token');
+                        }
+                        return [4 /*yield*/, this.getFederatedSignonCertsAsync()];
+                    case 1:
+                        response = _a.sent();
+                        login = this.verifySignedJwtWithCerts(options.idToken, response.certs, options.audience, OAuth2Client.ISSUERS_, options.maxExpiry);
+                        return [2 /*return*/, login];
+                }
+            });
+        });
+    };
+    /**
+     * Obtains information about the provisioned access token.  Especially useful
+     * if you want to check the scopes that were provisioned to a given token.
+     *
+     * @param accessToken Required.  The Access Token for which you want to get
+     * user info.
+     */
+    OAuth2Client.prototype.getTokenInfo = function (accessToken) {
+        return __awaiter(this, void 0, void 0, function () {
+            var data, info;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.transporter.request({
+                            method: 'GET',
+                            url: OAuth2Client.GOOGLE_TOKEN_INFO_URL,
+                            params: { access_token: accessToken }
+                        })];
+                    case 1:
+                        data = (_a.sent()).data;
+                        info = Object.assign({
+                            expiry_date: ((new Date()).getTime() + (data.expires_in * 1000)),
+                            scopes: data.scope.split(' ')
+                        }, data);
+                        delete info.expires_in;
+                        delete info.scope;
+                        return [2 /*return*/, info];
+                }
+            });
+        });
+    };
+    OAuth2Client.prototype.getFederatedSignonCerts = function (callback) {
+        if (callback) {
+            this.getFederatedSignonCertsAsync()
+                .then(function (r) { return callback(null, r.certs, r.res); })
+                .catch(callback);
+        }
+        else {
+            return this.getFederatedSignonCertsAsync();
+        }
+    };
+    OAuth2Client.prototype.getFederatedSignonCertsAsync = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var nowTime, res, e_2, cacheControl, cacheAge, pattern, regexResult, now;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        nowTime = (new Date()).getTime();
+                        if (this.certificateExpiry &&
+                            (nowTime < this.certificateExpiry.getTime())) {
+                            return [2 /*return*/, { certs: this.certificateCache }];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.transporter.request({ url: OAuth2Client.GOOGLE_OAUTH2_FEDERATED_SIGNON_CERTS_URL_ })];
+                    case 2:
+                        res = _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        e_2 = _a.sent();
+                        throw new Error('Failed to retrieve verification certificates: ' + e_2);
+                    case 4:
+                        cacheControl = res ? res.headers['cache-control'] : undefined;
+                        cacheAge = -1;
+                        if (cacheControl) {
+                            pattern = new RegExp('max-age=([0-9]*)');
+                            regexResult = pattern.exec(cacheControl);
+                            if (regexResult && regexResult.length === 2) {
+                                // Cache results with max-age (in seconds)
+                                cacheAge = Number(regexResult[1]) * 1000; // milliseconds
+                            }
+                        }
+                        now = new Date();
+                        this.certificateExpiry =
+                            cacheAge === -1 ? null : new Date(now.getTime() + cacheAge);
+                        this.certificateCache = res.data;
+                        return [2 /*return*/, { certs: res.data, res: res }];
+                }
+            });
+        });
+    };
+    /**
+     * Verify the id token is signed with the correct certificate
+     * and is from the correct audience.
+     * @param jwt The jwt to verify (The ID Token in this case).
+     * @param certs The array of certs to test the jwt against.
+     * @param requiredAudience The audience to test the jwt against.
+     * @param issuers The allowed issuers of the jwt (Optional).
+     * @param maxExpiry The max expiry the certificate can be (Optional).
+     * @return Returns a LoginTicket on verification.
+     */
+    OAuth2Client.prototype.verifySignedJwtWithCerts = function (jwt, certs, requiredAudience, issuers, maxExpiry) {
+        if (!maxExpiry) {
+            maxExpiry = OAuth2Client.MAX_TOKEN_LIFETIME_SECS_;
+        }
+        var segments = jwt.split('.');
+        if (segments.length !== 3) {
+            throw new Error('Wrong number of segments in token: ' + jwt);
+        }
+        var signed = segments[0] + '.' + segments[1];
+        var signature = segments[2];
+        var envelope;
+        var payload;
+        try {
+            envelope = JSON.parse(this.decodeBase64(segments[0]));
+        }
+        catch (err) {
+            throw new Error('Can\'t parse token envelope: ' + segments[0]);
+        }
+        if (!envelope) {
+            throw new Error('Can\'t parse token envelope: ' + segments[0]);
+        }
+        try {
+            payload = JSON.parse(this.decodeBase64(segments[1]));
+        }
+        catch (err) {
+            throw new Error('Can\'t parse token payload: ' + segments[0]);
+        }
+        if (!payload) {
+            throw new Error('Can\'t parse token payload: ' + segments[1]);
+        }
+        if (!certs.hasOwnProperty(envelope.kid)) {
+            // If this is not present, then there's no reason to attempt verification
+            throw new Error('No pem found for envelope: ' + JSON.stringify(envelope));
+        }
+        // certs is a legit dynamic object
+        // tslint:disable-next-line no-any
+        var pem = certs[envelope.kid];
+        var pemVerifier = new pemverifier_1.PemVerifier();
+        var verified = pemVerifier.verify(pem, signed, signature, 'base64');
+        if (!verified) {
+            throw new Error('Invalid token signature: ' + jwt);
+        }
+        if (!payload.iat) {
+            throw new Error('No issue time in token: ' + JSON.stringify(payload));
+        }
+        if (!payload.exp) {
+            throw new Error('No expiration time in token: ' + JSON.stringify(payload));
+        }
+        var iat = Number(payload.iat);
+        if (isNaN(iat))
+            throw new Error('iat field using invalid format');
+        var exp = Number(payload.exp);
+        if (isNaN(exp))
+            throw new Error('exp field using invalid format');
+        var now = new Date().getTime() / 1000;
+        if (exp >= now + maxExpiry) {
+            throw new Error('Expiration time too far in future: ' + JSON.stringify(payload));
+        }
+        var earliest = iat - OAuth2Client.CLOCK_SKEW_SECS_;
+        var latest = exp + OAuth2Client.CLOCK_SKEW_SECS_;
+        if (now < earliest) {
+            throw new Error('Token used too early, ' + now + ' < ' + earliest + ': ' +
+                JSON.stringify(payload));
+        }
+        if (now > latest) {
+            throw new Error('Token used too late, ' + now + ' > ' + latest + ': ' +
+                JSON.stringify(payload));
+        }
+        if (issuers && issuers.indexOf(payload.iss) < 0) {
+            throw new Error('Invalid issuer, expected one of [' + issuers + '], but got ' +
+                payload.iss);
+        }
+        // Check the audience matches if we have one
+        if (typeof requiredAudience !== 'undefined' && requiredAudience !== null) {
+            var aud = payload.aud;
+            var audVerified = false;
+            // If the requiredAudience is an array, check if it contains token
+            // audience
+            if (requiredAudience.constructor === Array) {
+                audVerified = (requiredAudience.indexOf(aud) > -1);
+            }
+            else {
+                audVerified = (aud === requiredAudience);
+            }
+            if (!audVerified) {
+                throw new Error('Wrong recipient, payload audience != requiredAudience');
+            }
+        }
+        return new loginticket_1.LoginTicket(envelope, payload);
+    };
+    /**
+     * This is a utils method to decode a base64 string
+     * @param b64String The string to base64 decode
+     * @return The decoded string
+     */
+    OAuth2Client.prototype.decodeBase64 = function (b64String) {
+        var buffer = new Buffer(b64String, 'base64');
+        return buffer.toString('utf8');
+    };
+    /**
+     * Returns true if a token is expired or will expire within
+     * eagerRefreshThresholdMillismilliseconds.
+     * If there is no expiry time, assumes the token is not expired or expiring.
+     */
+    OAuth2Client.prototype.isTokenExpiring = function () {
+        var expiryDate = this.credentials.expiry_date;
+        return expiryDate ? expiryDate <=
+            ((new Date()).getTime() + this.eagerRefreshThresholdMillis) :
+            false;
+    };
+    OAuth2Client.GOOGLE_TOKEN_INFO_URL = 'https://www.googleapis.com/oauth2/v3/tokeninfo';
+    /**
+     * The base URL for auth endpoints.
+     */
+    OAuth2Client.GOOGLE_OAUTH2_AUTH_BASE_URL_ = 'https://accounts.google.com/o/oauth2/v2/auth';
+    /**
+     * The base endpoint for token retrieval.
+     */
+    OAuth2Client.GOOGLE_OAUTH2_TOKEN_URL_ = 'https://www.googleapis.com/oauth2/v4/token';
+    /**
+     * The base endpoint to revoke tokens.
+     */
+    OAuth2Client.GOOGLE_OAUTH2_REVOKE_URL_ = 'https://accounts.google.com/o/oauth2/revoke';
+    /**
+     * Google Sign on certificates.
+     */
+    OAuth2Client.GOOGLE_OAUTH2_FEDERATED_SIGNON_CERTS_URL_ = 'https://www.googleapis.com/oauth2/v1/certs';
+    /**
+     * Clock skew - five minutes in seconds
+     */
+    OAuth2Client.CLOCK_SKEW_SECS_ = 300;
+    /**
+     * Max Token Lifetime is one day in seconds
+     */
+    OAuth2Client.MAX_TOKEN_LIFETIME_SECS_ = 86400;
+    /**
+     * The allowed oauth token issuers.
+     */
+    OAuth2Client.ISSUERS_ = ['accounts.google.com', 'https://accounts.google.com'];
+    return OAuth2Client;
+}(authclient_1.AuthClient));
+exports.OAuth2Client = OAuth2Client;
+//# sourceMappingURL=oauth2client.js.map

node_modules/google-auth-library/build/src/auth/refreshclient.js

@@ -0,0 +1,160 @@
+"use strict";
+/**
+ * Copyright 2015 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+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 oauth2client_1 = require("./oauth2client");
+var UserRefreshClient = /** @class */ (function (_super) {
+    __extends(UserRefreshClient, _super);
+    function UserRefreshClient(optionsOrClientId, clientSecret, refreshToken, eagerRefreshThresholdMillis) {
+        var _this = this;
+        var opts = (optionsOrClientId && typeof optionsOrClientId === 'object') ?
+            optionsOrClientId :
+            {
+                clientId: optionsOrClientId,
+                clientSecret: clientSecret,
+                refreshToken: refreshToken,
+                eagerRefreshThresholdMillis: eagerRefreshThresholdMillis
+            };
+        _this = _super.call(this, {
+            clientId: opts.clientId,
+            clientSecret: opts.clientSecret,
+            eagerRefreshThresholdMillis: opts.eagerRefreshThresholdMillis
+        }) || this;
+        _this._refreshToken = opts.refreshToken;
+        return _this;
+    }
+    /**
+     * Refreshes the access token.
+     * @param refreshToken An ignored refreshToken..
+     * @param callback Optional callback.
+     */
+    UserRefreshClient.prototype.refreshTokenNoCache = function (refreshToken) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, _super.prototype.refreshTokenNoCache.call(this, this._refreshToken)];
+            });
+        });
+    };
+    /**
+     * Create a UserRefreshClient credentials instance using the given input
+     * options.
+     * @param json The input object.
+     */
+    UserRefreshClient.prototype.fromJSON = function (json) {
+        if (!json) {
+            throw new Error('Must pass in a JSON object containing the user refresh token');
+        }
+        if (json.type !== 'authorized_user') {
+            throw new Error('The incoming JSON object does not have the "authorized_user" type');
+        }
+        if (!json.client_id) {
+            throw new Error('The incoming JSON object does not contain a client_id field');
+        }
+        if (!json.client_secret) {
+            throw new Error('The incoming JSON object does not contain a client_secret field');
+        }
+        if (!json.refresh_token) {
+            throw new Error('The incoming JSON object does not contain a refresh_token field');
+        }
+        this._clientId = json.client_id;
+        this._clientSecret = json.client_secret;
+        this._refreshToken = json.refresh_token;
+        this.credentials.refresh_token = json.refresh_token;
+    };
+    UserRefreshClient.prototype.fromStream = function (inputStream, callback) {
+        if (callback) {
+            this.fromStreamAsync(inputStream).then(function (r) { return callback(); }).catch(callback);
+        }
+        else {
+            return this.fromStreamAsync(inputStream);
+        }
+    };
+    UserRefreshClient.prototype.fromStreamAsync = function (inputStream) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, new Promise(function (resolve, reject) {
+                        if (!inputStream) {
+                            return reject(new Error('Must pass in a stream containing the user refresh token.'));
+                        }
+                        var s = '';
+                        inputStream.setEncoding('utf8');
+                        inputStream.on('data', function (chunk) {
+                            s += chunk;
+                        });
+                        inputStream.on('end', function () {
+                            try {
+                                var data = JSON.parse(s);
+                                _this.fromJSON(data);
+                                return resolve();
+                            }
+                            catch (err) {
+                                return reject(err);
+                            }
+                        });
+                    })];
+            });
+        });
+    };
+    return UserRefreshClient;
+}(oauth2client_1.OAuth2Client));
+exports.UserRefreshClient = UserRefreshClient;
+//# sourceMappingURL=refreshclient.js.map

node_modules/google-auth-library/build/src/auth/refreshclient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"refreshclient.js","sourceRoot":"","sources":["../../../src/auth/refreshclient.ts"],"names":[],"mappings":"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"}

node_modules/google-auth-library/build/src/index.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Copyright 2017 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var googleauth_1 = require("./auth/googleauth");
+exports.GoogleAuth = googleauth_1.GoogleAuth;
+var computeclient_1 = require("./auth/computeclient");
+exports.Compute = computeclient_1.Compute;
+var iam_1 = require("./auth/iam");
+exports.IAMAuth = iam_1.IAMAuth;
+var jwtaccess_1 = require("./auth/jwtaccess");
+exports.JWTAccess = jwtaccess_1.JWTAccess;
+var jwtclient_1 = require("./auth/jwtclient");
+exports.JWT = jwtclient_1.JWT;
+var oauth2client_1 = require("./auth/oauth2client");
+exports.CodeChallengeMethod = oauth2client_1.CodeChallengeMethod;
+exports.OAuth2Client = oauth2client_1.OAuth2Client;
+var refreshclient_1 = require("./auth/refreshclient");
+exports.UserRefreshClient = refreshclient_1.UserRefreshClient;
+var transporters_1 = require("./transporters");
+exports.DefaultTransporter = transporters_1.DefaultTransporter;
+var auth = new googleauth_1.GoogleAuth();
+exports.auth = auth;
+//# sourceMappingURL=index.js.map

node_modules/google-auth-library/build/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;AAAA;;;;;;;;;;;;;;GAcG;AACH,gDAA6C;AAY/B,qBAZN,uBAAU,CAYM;AAVxB,sDAA6C;AAArC,kCAAA,OAAO,CAAA;AAEf,kCAAmC;AAA3B,wBAAA,OAAO,CAAA;AACf,8CAA2C;AAAnC,gCAAA,SAAS,CAAA;AACjB,8CAAqC;AAA7B,0BAAA,GAAG,CAAA;AACX,oDAAsE;AAA9D,6CAAA,mBAAmB,CAAA;AAAE,sCAAA,YAAY,CAAA;AACzC,sDAAuD;AAA/C,4CAAA,iBAAiB,CAAA;AACzB,+CAAkD;AAA1C,4CAAA,kBAAkB,CAAA;AAE1B,IAAM,IAAI,GAAG,IAAI,uBAAU,EAAE,CAAC;AACtB,oBAAI"}

node_modules/google-auth-library/build/src/options.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Copyright 2017 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+// Accepts an options object passed from the user to the API.  In the
+// previous version of the API, it referred to a `Request` options object.
+// Now it refers to an Axiox Request Config object.  This is here to help
+// ensure users don't pass invalid options when they upgrade from 0.x to 1.x.
+// tslint:disable-next-line no-any
+function validate(options) {
+    var vpairs = [
+        { invalid: 'uri', expected: 'url' }, { invalid: 'json', expected: 'data' },
+        { invalid: 'qs', expected: 'params' }
+    ];
+    for (var _i = 0, vpairs_1 = vpairs; _i < vpairs_1.length; _i++) {
+        var pair = vpairs_1[_i];
+        if (options[pair.invalid]) {
+            var e = "'" + pair.invalid + "' is not a valid configuration option. Please use '" + pair.expected + "' instead. This library is using Axios for requests. Please see https://github.com/axios/axios to learn more about the valid request options.";
+            throw new Error(e);
+        }
+    }
+}
+exports.validate = validate;
+//# sourceMappingURL=options.js.map

node_modules/google-auth-library/build/src/options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.js","sourceRoot":"","sources":["../../src/options.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;AAEH,qEAAqE;AACrE,0EAA0E;AAC1E,yEAAyE;AACzE,6EAA6E;AAC7E,kCAAkC;AAClC,kBAAyB,OAAY;IACnC,IAAM,MAAM,GAAG;QACb,EAAC,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAC,EAAE,EAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAC;QACtE,EAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAC;KACpC,CAAC;IACF,KAAmB,UAAM,EAAN,iBAAM,EAAN,oBAAM,EAAN,IAAM,EAAE;QAAtB,IAAM,IAAI,eAAA;QACb,IAAI,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE;YACzB,IAAM,CAAC,GAAG,MACN,IAAI,CAAC,OAAO,2DACZ,IAAI,CAAC,QAAQ,kJAA+I,CAAC;YACjK,MAAM,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC;SACpB;KACF;AACH,CAAC;AAbD,4BAaC"}

node_modules/google-auth-library/build/src/pemverifier.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * Copyright 2014 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var crypto_1 = __importDefault(require("crypto"));
+var PemVerifier = /** @class */ (function () {
+    function PemVerifier() {
+    }
+    PemVerifier.prototype.verify = function (pubkey, data, signature, encoding) {
+        var verifier = crypto_1.default.createVerify('sha256');
+        verifier.update(data);
+        return verifier.verify(pubkey, signature, encoding);
+    };
+    return PemVerifier;
+}());
+exports.PemVerifier = PemVerifier;
+//# sourceMappingURL=pemverifier.js.map

node_modules/google-auth-library/build/src/pemverifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pemverifier.js","sourceRoot":"","sources":["../../src/pemverifier.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;;;AAEH,kDAA4B;AAE5B;IAAA;IAQA,CAAC;IAPC,4BAAM,GAAN,UACI,MAAc,EAAE,IAAmB,EAAE,SAAiB,EACtD,QAAwC;QAC1C,IAAM,QAAQ,GAAG,gBAAM,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;QAC/C,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QACtB,OAAO,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,QAAQ,CAAC,CAAC;IACtD,CAAC;IACH,kBAAC;AAAD,CAAC,AARD,IAQC;AARY,kCAAW"}

node_modules/google-auth-library/build/src/transporters.js

@@ -0,0 +1,123 @@
+"use strict";
+/**
+ * Copyright 2012 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var axios_1 = __importDefault(require("axios"));
+var options_1 = require("./options");
+// tslint:disable-next-line no-var-requires
+var pkg = require('../../package.json');
+var PRODUCT_NAME = 'google-api-nodejs-client';
+/**
+ * Axios will use XHR if it is available. In the case of Electron,
+ * since XHR is there it will try to use that. This leads to OPTIONS
+ * preflight requests which googleapis DOES NOT like. This line of
+ * code pins the adapter to ensure it uses node.
+ * https://github.com/google/google-api-nodejs-client/issues/1083
+ */
+axios_1.default.defaults.adapter = require('axios/lib/adapters/http');
+var DefaultTransporter = /** @class */ (function () {
+    function DefaultTransporter() {
+    }
+    /**
+     * Configures request options before making a request.
+     * @param opts AxiosRequestConfig options.
+     * @return Configured options.
+     */
+    DefaultTransporter.prototype.configure = function (opts) {
+        if (opts === void 0) { opts = {}; }
+        // set transporter user agent
+        opts.headers = opts.headers || {};
+        var uaValue = opts.headers['User-Agent'];
+        if (!uaValue) {
+            opts.headers['User-Agent'] = DefaultTransporter.USER_AGENT;
+        }
+        else if (!uaValue.includes(PRODUCT_NAME + "/")) {
+            opts.headers['User-Agent'] =
+                uaValue + " " + DefaultTransporter.USER_AGENT;
+        }
+        return opts;
+    };
+    DefaultTransporter.prototype.request = function (opts, callback) {
+        var _this = this;
+        // ensure the user isn't passing in request-style options
+        opts = this.configure(opts);
+        try {
+            options_1.validate(opts);
+        }
+        catch (e) {
+            if (callback) {
+                return callback(e);
+            }
+            else {
+                throw e;
+            }
+        }
+        if (callback) {
+            axios_1.default(opts)
+                .then(function (r) {
+                callback(null, r);
+            })
+                .catch(function (e) {
+                callback(_this.processError(e));
+            });
+        }
+        else {
+            return axios_1.default(opts).catch(function (e) {
+                throw _this.processError(e);
+            });
+        }
+    };
+    /**
+     * Changes the error to include details from the body.
+     */
+    DefaultTransporter.prototype.processError = function (e) {
+        var res = e.response;
+        var err = e;
+        var body = res ? res.data : null;
+        if (res && body && body.error && res.status !== 200) {
+            if (typeof body.error === 'string') {
+                err.message = body.error;
+                err.code = res.status.toString();
+            }
+            else if (Array.isArray(body.error.errors)) {
+                err.message =
+                    body.error.errors.map(function (err2) { return err2.message; }).join('\n');
+                err.code = body.error.code;
+                err.errors = body.error.errors;
+            }
+            else {
+                err.message = body.error.message;
+                err.code = body.error.code || res.status;
+            }
+        }
+        else if (res && res.status >= 400) {
+            // Consider all 4xx and 5xx responses errors.
+            err.message = body;
+            err.code = res.status.toString();
+        }
+        return err;
+    };
+    /**
+     * Default user agent.
+     */
+    DefaultTransporter.USER_AGENT = PRODUCT_NAME + "/" + pkg.version;
+    return DefaultTransporter;
+}());
+exports.DefaultTransporter = DefaultTransporter;
+//# sourceMappingURL=transporters.js.map

node_modules/google-auth-library/build/src/transporters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transporters.js","sourceRoot":"","sources":["../../src/transporters.ts"],"names":[],"mappings":"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"}

node_modules/google-auth-library/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "google-auth-library",
+  "version": "1.6.1",
+  "author": "Google Inc.",
+  "description": "Google APIs Authentication Client Library for Node.js",
+  "engines": {
+    "node": ">=4"
+  },
+  "main": "./build/src/index.js",
+  "types": "./build/src/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/google/google-auth-library-nodejs.git"
+  },
+  "dependencies": {
+    "axios": "^0.18.0",
+    "gtoken": "^2.3.0",
+    "jws": "^3.1.5",
+    "lodash.isstring": "^4.0.1",
+    "lru-cache": "^4.1.3",
+    "retry-axios": "^0.3.2",
+    "gcp-metadata": "^0.6.3"
+  },
+  "devDependencies": {
+    "@justinbeckwith/typedoc": "^0.10.1",
+    "@types/jws": "^3.1.0",
+    "@types/lodash.isstring": "^4.0.3",
+    "@types/lru-cache": "^4.1.0",
+    "@types/mocha": "^5.2.1",
+    "@types/mv": "^2.1.0",
+    "@types/ncp": "^2.0.1",
+    "@types/nock": "^9.1.3",
+    "@types/node": "^10.3.0",
+    "@types/pify": "^3.0.2",
+    "@types/sinon": "^5.0.1",
+    "@types/tmp": "^0.0.33",
+    "clang-format": "^1.2.3",
+    "codecov": "^3.0.2",
+    "gh-pages": "^1.2.0",
+    "gts": "^0.6.0",
+    "js-green-licenses": "^0.5.0",
+    "keypair": "^1.0.1",
+    "mocha": "^5.2.0",
+    "mv": "^2.1.1",
+    "ncp": "^2.0.0",
+    "nyc": "^12.0.2",
+    "nock": "^9.3.0",
+    "opn": "^5.3.0",
+    "pify": "^3.0.0",
+    "prettier": "^1.13.4",
+    "sinon": "^5.0.10",
+    "source-map-support": "^0.5.6",
+    "tmp": "^0.0.33",
+    "typescript": "~2.9.1"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "build/src",
+    "package.json"
+  ],
+  "license": "Apache-2.0"
+}