push all website files

website/functions/node_modules/gtoken/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Ryan Seys
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

website/functions/node_modules/gtoken/README.md

@@ -0,0 +1,200 @@
+# node-gtoken
+
+[![NPM Version][npm-image]][npm-url]
+[![CircleCI][circle-image]][circle-url]
+[![Dependency Status][david-image]][david-url]
+[![devDependency Status][david-dev-image]][david-dev-url]
+[![Known Vulnerabilities][snyk-image]][snyk-url]
+[![codecov][codecov-image]][codecov-url]
+[![Greenkeeper badge][greenkeeper-image]][greenkeeper-url]
+[![style badge][gts-image]][gts-url]
+
+Node.js Google Authentication Service Account Tokens
+
+## Installation
+
+``` sh
+npm install gtoken
+```
+
+## Usage
+
+### Use with a `.pem` or `.p12` key file:
+
+``` js
+const { GoogleToken } = require('gtoken');
+const gtoken = new GoogleToken({
+  keyFile: 'path/to/key.pem', // or path to .p12 key file
+  email: 'my_service_account_email@developer.gserviceaccount.com',
+  scope: ['https://scope1', 'https://scope2'] // or space-delimited string of scopes
+});
+
+gtoken.getToken(function(err, token) {
+  if (err) {
+    console.log(err);
+    return;
+  }
+  console.log(token);
+});
+```
+
+You can also use the async/await style API:
+
+``` js
+const token = await gtoken.getToken()
+console.log(token);
+```
+
+Or use promises:
+
+```js
+gtoken.getToken()
+  .then(token => {
+    console.log(`Token: ${token}`)
+  })
+  .catch(e => console.error);
+```
+
+### Use with a service account `.json` key file:
+
+``` js
+const { GoogleToken } = require('gtoken');
+const gtoken = new GoogleToken({
+  keyFile: 'path/to/key.json',
+  scope: ['https://scope1', 'https://scope2'] // or space-delimited string of scopes
+});
+
+gtoken.getToken(function(err, token) {
+  if (err) {
+    console.log(err);
+    return;
+  }
+  console.log(token);
+});
+```
+
+### Pass the private key as a string directly:
+
+``` js
+const key = '-----BEGIN RSA PRIVATE KEY-----\nXXXXXXXXXXX...';
+const { GoogleToken } = require('gtoken');
+const gtoken = new GoogleToken({
+  email: 'my_service_account_email@developer.gserviceaccount.com',
+  scope: ['https://scope1', 'https://scope2'], // or space-delimited string of scopes
+  key: key
+});
+```
+
+## Options
+
+> Various options that can be set when creating initializing the `gtoken` object.
+
+- `options.email or options.iss`: The service account email address.
+- `options.scope`: An array of scope strings or space-delimited string of scopes.
+- `options.sub`: The email address of the user requesting delegated access.
+- `options.keyFile`: The filename of `.json` key, `.pem` key or `.p12` key.
+- `options.key`: The raw RSA private key value, in place of using `options.keyFile`.
+
+### .getToken(callback)
+
+> Returns the cached token or requests a new one and returns it.
+
+``` js
+gtoken.getToken(function(err, token) {
+  console.log(err || token);
+  // gtoken.token value is also set
+});
+```
+
+### .getCredentials('path/to/key.json')
+
+> Given a keyfile, returns the key and (if available) the client email.
+
+```js
+const creds = await gtoken.getCredentials('path/to/key.json');
+```
+
+### Properties
+
+> Various properties set on the gtoken object after call to `.getToken()`.
+
+- `gtoken.token`: The access token.
+- `gtoken.expiresAt`: The expiry date as milliseconds since 1970/01/01
+- `gtoken.key`: The raw key value.
+- `gtoken.rawToken`: Most recent raw token data received from Google.
+
+### .hasExpired()
+
+> Returns true if the token has expired, or token does not exist.
+
+``` js
+gtoken.getToken(function(err, token) {
+  if(token) {
+    gtoken.hasExpired(); // false
+  }
+});
+```
+
+### .revokeToken()
+
+> Revoke the token if set.
+
+``` js
+gtoken.revokeToken(function(err) {
+  if (err) {
+    console.log(err);
+    return;
+  }
+  console.log('Token revoked!');
+});
+```
+
+## Downloading your private `.p12` key from Google
+
+1. Open the [Google Developer Console][gdevconsole].
+2. Open your project and under "APIs & auth", click Credentials.
+3. Generate a new `.p12` key and download it into your project.
+
+## Converting your `.p12` key to a `.pem` key
+
+You can just specify your `.p12` file (with `.p12` extension) as the `keyFile` and it will automatically be converted to a `.pem` on the fly, however this results in a slight performance hit. If you'd like to convert to a `.pem` for use later, use OpenSSL if you have it installed.
+
+``` sh
+$ openssl pkcs12 -in key.p12 -nodes -nocerts > key.pem
+```
+
+Don't forget, the passphrase when converting these files is the string `'notasecret'`
+
+## Changelog
+
+### 1.2.2 -> 2.0.0
+New features:
+- API now supports callback and promise based workflows
+
+Breaking changes:
+- `GoogleToken` is now a class type, and must be instantiated.
+- `GoogleToken.expires_at` renamed to `GoogleToken.expiresAt`
+- `GoogleToken.raw_token` renamed to `GoogleToken.rawToken`
+- `GoogleToken.token_expires` renamed to `GoogleToken.tokenExpires`
+
+## License
+
+[MIT](LICENSE)
+
+[circle-image]: https://circleci.com/gh/google/node-gtoken.svg?style=svg
+[circle-url]: https://circleci.com/gh/google/node-gtoken
+[codecov-image]: https://codecov.io/gh/google/node-gtoken/branch/master/graph/badge.svg
+[codecov-url]: https://codecov.io/gh/google/node-gtoken
+[david-image]: https://david-dm.org/google/node-gtoken.svg
+[david-url]: https://david-dm.org/google/node-gtoken
+[david-dev-image]: https://david-dm.org/google/node-gtoken/dev-status.svg
+[david-dev-url]: https://david-dm.org/google/node-gtoken?type=dev
+[gdevconsole]: https://console.developers.google.com
+[greenkeeper-image]: https://badges.greenkeeper.io/google/node-gtoken.svg
+[greenkeeper-url]: https://greenkeeper.io/
+[gts-image]: https://img.shields.io/badge/code%20style-Google%20%E2%98%82%EF%B8%8F-blue.svg
+[gts-url]: https://www.npmjs.com/package/gts
+[npm-image]: https://img.shields.io/npm/v/gtoken.svg
+[npm-url]: https://npmjs.org/package/gtoken
+[snyk-image]: https://snyk.io/test/github/google/node-gtoken/badge.svg
+[snyk-url]: https://snyk.io/test/github/google/node-gtoken

website/functions/node_modules/gtoken/build/src/index.d.ts

@@ -0,0 +1,77 @@
+export interface Credentials {
+    privateKey: string;
+    clientEmail?: string;
+}
+export interface TokenData {
+    refresh_token?: string;
+    expires_in?: number;
+    access_token?: string;
+    token_type?: string;
+    id_token?: string;
+}
+export interface TokenOptions {
+    keyFile?: string;
+    key?: string;
+    email?: string;
+    iss?: string;
+    sub?: string;
+    scope?: string | string[];
+    additionalClaims?: {};
+}
+export declare class GoogleToken {
+    token?: string | null;
+    expiresAt?: number | null;
+    key?: string;
+    keyFile?: string;
+    iss?: string;
+    sub?: string;
+    scope?: string;
+    rawToken: TokenData | null;
+    tokenExpires: number | null;
+    email?: string;
+    additionalClaims?: {};
+    /**
+     * Create a GoogleToken.
+     *
+     * @param options  Configuration object.
+     */
+    constructor(options?: TokenOptions);
+    /**
+     * Returns whether the token has expired.
+     *
+     * @return true if the token has expired, false otherwise.
+     */
+    hasExpired(): boolean;
+    /**
+     * Returns a cached token or retrieves a new one from Google.
+     *
+     * @param callback The callback function.
+     */
+    getToken(): Promise<string | null | undefined>;
+    getToken(callback: (err: Error | null, token?: string | null | undefined) => void): void;
+    /**
+     * Given a keyFile, extract the key and client email if available
+     * @param keyFile Path to a json, pem, or p12 file that contains the key.
+     * @returns an object with privateKey and clientEmail properties
+     */
+    getCredentials(keyFile: string): Promise<Credentials>;
+    private getTokenAsync();
+    private ensureEmail();
+    /**
+     * Revoke the token if one is set.
+     *
+     * @param callback The callback function.
+     */
+    revokeToken(): Promise<void>;
+    revokeToken(callback: (err?: Error) => void): void;
+    private revokeTokenAsync();
+    /**
+     * Configure the GoogleToken for re-use.
+     * @param  {object} options Configuration object.
+     */
+    private configure(options?);
+    /**
+     * Request the token from Google.
+     */
+    private requestToken();
+}

website/functions/node_modules/gtoken/build/src/index.js

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

website/functions/node_modules/gtoken/package.json

@@ -0,0 +1,99 @@
+{
+  "_from": "gtoken@^2.3.0",
+  "_id": "gtoken@2.3.0",
+  "_inBundle": false,
+  "_integrity": "sha512-Jc9/8mV630cZE9FC5tIlJCZNdUjwunvlwOtCz6IDlaiB4Sz68ki29a1+q97sWTnTYroiuF9B135rod9zrQdHLw==",
+  "_location": "/gtoken",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "gtoken@^2.3.0",
+    "name": "gtoken",
+    "escapedName": "gtoken",
+    "rawSpec": "^2.3.0",
+    "saveSpec": null,
+    "fetchSpec": "^2.3.0"
+  },
+  "_requiredBy": [
+    "/google-auth-library"
+  ],
+  "_resolved": "https://registry.npmjs.org/gtoken/-/gtoken-2.3.0.tgz",
+  "_shasum": "4e0ffc16432d7041a1b3dbc1d97aac17a5dc964a",
+  "_spec": "gtoken@^2.3.0",
+  "_where": "C:\\Users\\jlevi\\Downloads\\tr2022-strategy-master\\tr2022-strategy-master\\data analysis\\functions\\node_modules\\google-auth-library",
+  "author": {
+    "name": "Ryan Seys"
+  },
+  "bugs": {
+    "url": "https://github.com/google/node-gtoken/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "axios": "^0.18.0",
+    "google-p12-pem": "^1.0.0",
+    "jws": "^3.1.4",
+    "mime": "^2.2.0",
+    "pify": "^3.0.0"
+  },
+  "deprecated": false,
+  "description": "Node.js Google Authentication Service Account Tokens",
+  "devDependencies": {
+    "@types/jws": "^3.1.0",
+    "@types/mime": "^2.0.0",
+    "@types/mocha": "^5.0.0",
+    "@types/nock": "^9.1.2",
+    "@types/node": "^9.4.6",
+    "@types/pify": "^3.0.0",
+    "codecov": "^3.0.0",
+    "gts": "^0.5.3",
+    "js-green-licenses": "^0.5.0",
+    "mocha": "^5.0.1",
+    "nock": "^9.1.6",
+    "nyc": "^11.4.1",
+    "source-map-support": "^0.5.3",
+    "typescript": "~2.7.2"
+  },
+  "files": [
+    "build/src",
+    "LICENSE",
+    "packge.json",
+    "README.md"
+  ],
+  "homepage": "https://github.com/google/node-gtoken#readme",
+  "keywords": [
+    "google",
+    "service",
+    "account",
+    "api",
+    "token",
+    "api",
+    "auth"
+  ],
+  "license": "MIT",
+  "main": "./build/src/index.js",
+  "name": "gtoken",
+  "nyc": {
+    "exclude": [
+      "build/test"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/google/node-gtoken.git"
+  },
+  "scripts": {
+    "check": "gts check",
+    "clean": "gts clean",
+    "codecov": "nyc report --reporter=json && codecov -f coverage/*.json",
+    "compile": "tsc -p .",
+    "fix": "gts fix",
+    "license-check": "jsgl --local .",
+    "posttest": "npm run check && npm run license-check",
+    "prepare": "npm run compile",
+    "pretest": "npm run compile",
+    "test": "nyc mocha build/test --timeout 5000 --require source-map-support/register"
+  },
+  "types": "./build/src/index.d.ts",
+  "version": "2.3.0"
+}