playwright-smart-test 0.0.0-stage → 1.0.2

package/node_modules/google-logging-utils/build/src/temporal.js

@@ -0,0 +1,68 @@
+"use strict";
+// Copyright 2022-2024 Google LLC
+//
+// 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 });
+exports.Duration = void 0;
+/**
+ * Duration class with an interface similar to the tc39 Temporal
+ * proposal. Since it's not fully finalized, and polyfills have
+ * inconsistent compatibility, for now this shim class will be
+ * used to set durations in Pub/Sub.
+ *
+ * This class will remain here for at least the next major version,
+ * eventually to be replaced by the tc39 Temporal built-in.
+ *
+ * https://tc39.es/proposal-temporal/docs/duration.html
+ */
+class Duration {
+    constructor(millis) {
+        this.millis = millis;
+    }
+    /**
+     * Calculates the total number of units of type 'totalOf' that would
+     * fit inside this duration.
+     */
+    totalOf(totalOf) {
+        switch (totalOf) {
+            case 'hour':
+                return this.millis / Duration.hourInMillis;
+            case 'minute':
+                return this.millis / Duration.minuteInMillis;
+            case 'second':
+                return this.millis / Duration.secondInMillis;
+            case 'millisecond':
+                return this.millis;
+            default:
+                throw new Error(`Invalid unit in call to totalOf(): ${totalOf}`);
+        }
+    }
+    /**
+     * Creates a Duration from a DurationLike, which is an object
+     * containing zero or more of the following: hours, seconds,
+     * minutes, millis.
+     */
+    static from(durationLike) {
+        var _a, _b, _c, _d;
+        let millis = (_a = durationLike.millis) !== null && _a !== void 0 ? _a : 0;
+        millis += ((_b = durationLike.seconds) !== null && _b !== void 0 ? _b : 0) * Duration.secondInMillis;
+        millis += ((_c = durationLike.minutes) !== null && _c !== void 0 ? _c : 0) * Duration.minuteInMillis;
+        millis += ((_d = durationLike.hours) !== null && _d !== void 0 ? _d : 0) * Duration.hourInMillis;
+        return new Duration(millis);
+    }
+}
+exports.Duration = Duration;
+Duration.secondInMillis = 1000;
+Duration.minuteInMillis = Duration.secondInMillis * 60;
+Duration.hourInMillis = Duration.minuteInMillis * 60;
+//# sourceMappingURL=temporal.js.map

package/node_modules/google-logging-utils/build/src/temporal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"temporal.js","sourceRoot":"","sources":["../../src/temporal.ts"],"names":[],"mappings":";AAAA,iCAAiC;AACjC,EAAE;AACF,kEAAkE;AAClE,mEAAmE;AACnE,0CAA0C;AAC1C,EAAE;AACF,kDAAkD;AAClD,EAAE;AACF,sEAAsE;AACtE,oEAAoE;AACpE,2EAA2E;AAC3E,sEAAsE;AACtE,iCAAiC;;;AA6BjC;;;;;;;;;;GAUG;AACH,MAAa,QAAQ;IAOnB,YAAoB,MAAc;QAChC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAED;;;OAGG;IACH,OAAO,CAAC,OAAoB;QAC1B,QAAQ,OAAO,EAAE,CAAC;YAChB,KAAK,MAAM;gBACT,OAAO,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAC,YAAY,CAAC;YAC7C,KAAK,QAAQ;gBACX,OAAO,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAC,cAAc,CAAC;YAC/C,KAAK,QAAQ;gBACX,OAAO,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAC,cAAc,CAAC;YAC/C,KAAK,aAAa;gBAChB,OAAO,IAAI,CAAC,MAAM,CAAC;YACrB;gBACE,MAAM,IAAI,KAAK,CAAC,sCAAsC,OAAO,EAAE,CAAC,CAAC;QACrE,CAAC;IACH,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,IAAI,CAAC,YAA0B;;QACpC,IAAI,MAAM,GAAG,MAAA,YAAY,CAAC,MAAM,mCAAI,CAAC,CAAC;QACtC,MAAM,IAAI,CAAC,MAAA,YAAY,CAAC,OAAO,mCAAI,CAAC,CAAC,GAAG,QAAQ,CAAC,cAAc,CAAC;QAChE,MAAM,IAAI,CAAC,MAAA,YAAY,CAAC,OAAO,mCAAI,CAAC,CAAC,GAAG,QAAQ,CAAC,cAAc,CAAC;QAChE,MAAM,IAAI,CAAC,MAAA,YAAY,CAAC,KAAK,mCAAI,CAAC,CAAC,GAAG,QAAQ,CAAC,YAAY,CAAC;QAE5D,OAAO,IAAI,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC9B,CAAC;;AA1CH,4BA2CC;AAxCgB,uBAAc,GAAG,IAAI,CAAC;AACtB,uBAAc,GAAG,QAAQ,CAAC,cAAc,GAAG,EAAE,CAAC;AAC9C,qBAAY,GAAG,QAAQ,CAAC,cAAc,GAAG,EAAE,CAAC"}

package/node_modules/google-logging-utils/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "google-logging-utils",
+  "version": "0.0.2",
+  "description": "An ad-hoc debug logger package for other libraries",
+  "main": "build/src/index.js",
+  "files": [
+    "build/src"
+  ],
+  "scripts": {
+    "pretest": "npm run prepare",
+    "test": "c8 mocha build/test",
+    "lint": "gts check test src samples",
+    "clean": "gts clean",
+    "compile": "tsc -p . && cp -r test/fixtures build/test",
+    "fix": "gts fix",
+    "prepare": "npm run compile",
+    "precompile": "gts clean",
+    "samples-test": "echo no samples 🙀",
+    "system-test": "echo no system tests 🙀"
+  },
+  "author": "Google API Authors",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/googleapis/gax-nodejs.git",
+    "directory": "logging-utils"
+  },
+  "devDependencies": {
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^22.9.1",
+    "c8": "^9.0.0",
+    "gts": "^5.0.0",
+    "mocha": "^9.0.0",
+    "typescript": "^5.1.6"
+  },
+  "engines": {
+    "node": ">=14"
+  }
+}

package/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.

package/node_modules/gtoken/README.md

@@ -0,0 +1,187 @@
+<img src="https://avatars2.githubusercontent.com/u/2810941?v=3&s=96" alt="Google Cloud Platform logo" title="Google Cloud Platform" align="right" height="96" width="96"/>
+
+# [node-gtoken](https://github.com/googleapis/node-gtoken)
+
+[![npm version][npm-image]][npm-url]
+[![Known Vulnerabilities][snyk-image]][snyk-url]
+[![codecov][codecov-image]][codecov-url]
+[![Code Style: Google][gts-image]][gts-url]
+
+> Node.js Google Authentication Service Account Tokens
+
+This is a low level utility library used to interact with Google Authentication services.  **In most cases, you probably want to use the [google-auth-library](https://github.com/googleapis/google-auth-library-nodejs) instead.**
+
+* [gtoken API Reference][client-docs]
+* [github.com/googleapis/node-gtoken](https://github.com/googleapis/node-gtoken)
+
+## Installation
+
+``` sh
+npm install gtoken
+```
+
+## Usage
+
+### Use with a `.pem` or `.json` key file:
+
+``` js
+const { GoogleToken } = require('gtoken');
+const gtoken = new GoogleToken({
+  keyFile: 'path/to/key.pem', // or path to .json key file
+  email: 'my_service_account_email@developer.gserviceaccount.com',
+  scope: ['https://scope1', 'https://scope2'], // or space-delimited string of scopes
+  eagerRefreshThresholdMillis: 5 * 60 * 1000
+});
+
+gtoken.getToken((err, tokens) => {
+  if (err) {
+    console.log(err);
+    return;
+  }
+  console.log(tokens);
+  // {
+  //   access_token: 'very-secret-token',
+  //   expires_in: 3600,
+  //   token_type: 'Bearer'
+  // }
+});
+```
+
+You can also use the async/await style API:
+
+``` js
+const tokens = await gtoken.getToken()
+console.log(tokens);
+```
+
+Or use promises:
+
+```js
+gtoken.getToken()
+  .then(tokens => {
+    console.log(tokens)
+  })
+  .catch(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
+  eagerRefreshThresholdMillis: 5 * 60 * 1000
+});
+
+gtoken.getToken((err, tokens) => {
+  if (err) {
+    console.log(err);
+    return;
+  }
+  console.log(tokens);
+});
+```
+
+### 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,
+  eagerRefreshThresholdMillis: 5 * 60 * 1000
+});
+```
+
+## 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 or `.pem` key.
+- `options.key`: The raw RSA private key value, in place of using `options.keyFile`.
+- `options.additionalClaims`: Additional claims to include in the JWT when requesting a token.
+- `options.eagerRefreshThresholdMillis`: How long must a token be valid for in order to return it from the cache. Defaults to 0.
+
+### .getToken(callback)
+
+> Returns the cached tokens or requests a new one and returns it.
+
+``` js
+gtoken.getToken((err, token) => {
+  console.log(err || token);
+  // gtoken.rawToken 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.idToken`: The OIDC token returned (if any).
+- `gtoken.accessToken`: 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
+const tokens = await gtoken.getToken();
+gtoken.hasExpired(); // false
+```
+
+### .revokeToken()
+
+> Revoke the token if set.
+
+``` js
+await gtoken.revokeToken();
+console.log('Token revoked!');
+```
+
+## Downloading your private `.json` key from Google
+
+1. Open the [Google Developer Console][gdevconsole].
+2. Open your project and under "APIs & auth", click Credentials.
+3. Generate a new `.json` key and download it into your project.
+
+## Converting your `.p12` key to a `.pem` key
+
+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'`
+
+## License
+
+[MIT](https://github.com/googleapis/node-gtoken/blob/main/LICENSE)
+
+[codecov-image]: https://codecov.io/gh/googleapis/node-gtoken/branch/main/graph/badge.svg
+[codecov-url]: https://codecov.io/gh/googleapis/node-gtoken
+[gdevconsole]: https://console.developers.google.com
+[gts-image]: https://img.shields.io/badge/code%20style-google-blueviolet.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/googleapis/node-gtoken/badge.svg
+[snyk-url]: https://snyk.io/test/github/googleapis/node-gtoken
+[client-docs]: https://googleapis.dev/nodejs/gtoken/latest/

package/node_modules/gtoken/build/src/index.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Copyright 2018 Google LLC
+ *
+ * Distributed under MIT license.
+ * See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+ */
+import { GaxiosOptions, GaxiosPromise } from 'gaxios';
+export interface Transporter {
+    request<T>(opts: GaxiosOptions): GaxiosPromise<T>;
+}
+export type GetTokenCallback = (err: Error | null, token?: TokenData) => void;
+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?: {};
+    eagerRefreshThresholdMillis?: number;
+    transporter?: Transporter;
+}
+export interface GetTokenOptions {
+    forceRefresh?: boolean;
+}
+export declare class GoogleToken {
+    #private;
+    get accessToken(): string | undefined;
+    get idToken(): string | undefined;
+    get tokenType(): string | undefined;
+    get refreshToken(): string | undefined;
+    expiresAt?: number;
+    key?: string;
+    keyFile?: string;
+    iss?: string;
+    sub?: string;
+    scope?: string;
+    rawToken?: TokenData;
+    tokenExpires?: number;
+    email?: string;
+    additionalClaims?: {};
+    eagerRefreshThresholdMillis?: number;
+    transporter: Transporter;
+    /**
+     * 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 whether the token will expire within eagerRefreshThresholdMillis
+     *
+     * @return true if the token will be expired within eagerRefreshThresholdMillis, false otherwise.
+     */
+    isTokenExpiring(): boolean;
+    /**
+     * Returns a cached token or retrieves a new one from Google.
+     *
+     * @param callback The callback function.
+     */
+    getToken(opts?: GetTokenOptions): Promise<TokenData>;
+    getToken(callback: GetTokenCallback, opts?: GetTokenOptions): 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>;
+    /**
+     * Revoke the token if one is set.
+     *
+     * @param callback The callback function.
+     */
+    revokeToken(): Promise<void>;
+    revokeToken(callback: (err?: Error) => void): void;
+}

package/node_modules/gtoken/build/src/index.js

@@ -0,0 +1,276 @@
+"use strict";
+/**
+ * Copyright 2018 Google LLC
+ *
+ * Distributed under MIT license.
+ * See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+ */
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _GoogleToken_instances, _GoogleToken_inFlightRequest, _GoogleToken_getTokenAsync, _GoogleToken_getTokenAsyncInner, _GoogleToken_ensureEmail, _GoogleToken_revokeTokenAsync, _GoogleToken_configure, _GoogleToken_requestToken;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleToken = void 0;
+const fs = require("fs");
+const gaxios_1 = require("gaxios");
+const jws = require("jws");
+const path = require("path");
+const util_1 = require("util");
+const readFile = fs.readFile
+    ? (0, util_1.promisify)(fs.readFile)
+    : async () => {
+        // if running in the web-browser, fs.readFile may not have been shimmed.
+        throw new ErrorWithCode('use key rather than keyFile.', 'MISSING_CREDENTIALS');
+    };
+const GOOGLE_TOKEN_URL = 'https://www.googleapis.com/oauth2/v4/token';
+const GOOGLE_REVOKE_TOKEN_URL = 'https://accounts.google.com/o/oauth2/revoke?token=';
+class ErrorWithCode extends Error {
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+    }
+}
+class GoogleToken {
+    get accessToken() {
+        return this.rawToken ? this.rawToken.access_token : undefined;
+    }
+    get idToken() {
+        return this.rawToken ? this.rawToken.id_token : undefined;
+    }
+    get tokenType() {
+        return this.rawToken ? this.rawToken.token_type : undefined;
+    }
+    get refreshToken() {
+        return this.rawToken ? this.rawToken.refresh_token : undefined;
+    }
+    /**
+     * Create a GoogleToken.
+     *
+     * @param options  Configuration object.
+     */
+    constructor(options) {
+        _GoogleToken_instances.add(this);
+        this.transporter = {
+            request: opts => (0, gaxios_1.request)(opts),
+        };
+        _GoogleToken_inFlightRequest.set(this, void 0);
+        __classPrivateFieldGet(this, _GoogleToken_instances, "m", _GoogleToken_configure).call(this, options);
+    }
+    /**
+     * Returns whether the token has expired.
+     *
+     * @return true if the token has expired, false otherwise.
+     */
+    hasExpired() {
+        const now = new Date().getTime();
+        if (this.rawToken && this.expiresAt) {
+            return now >= this.expiresAt;
+        }
+        else {
+            return true;
+        }
+    }
+    /**
+     * Returns whether the token will expire within eagerRefreshThresholdMillis
+     *
+     * @return true if the token will be expired within eagerRefreshThresholdMillis, false otherwise.
+     */
+    isTokenExpiring() {
+        var _a;
+        const now = new Date().getTime();
+        const eagerRefreshThresholdMillis = (_a = this.eagerRefreshThresholdMillis) !== null && _a !== void 0 ? _a : 0;
+        if (this.rawToken && this.expiresAt) {
+            return this.expiresAt <= now + eagerRefreshThresholdMillis;
+        }
+        else {
+            return true;
+        }
+    }
+    getToken(callback, opts = {}) {
+        if (typeof callback === 'object') {
+            opts = callback;
+            callback = undefined;
+        }
+        opts = Object.assign({
+            forceRefresh: false,
+        }, opts);
+        if (callback) {
+            const cb = callback;
+            __classPrivateFieldGet(this, _GoogleToken_instances, "m", _GoogleToken_getTokenAsync).call(this, opts).then(t => cb(null, t), callback);
+            return;
+        }
+        return __classPrivateFieldGet(this, _GoogleToken_instances, "m", _GoogleToken_getTokenAsync).call(this, opts);
+    }
+    /**
+     * 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
+     */
+    async getCredentials(keyFile) {
+        const ext = path.extname(keyFile);
+        switch (ext) {
+            case '.json': {
+                const key = await readFile(keyFile, 'utf8');
+                const body = JSON.parse(key);
+                const privateKey = body.private_key;
+                const clientEmail = body.client_email;
+                if (!privateKey || !clientEmail) {
+                    throw new ErrorWithCode('private_key and client_email are required.', 'MISSING_CREDENTIALS');
+                }
+                return { privateKey, clientEmail };
+            }
+            case '.der':
+            case '.crt':
+            case '.pem': {
+                const privateKey = await readFile(keyFile, 'utf8');
+                return { privateKey };
+            }
+            case '.p12':
+            case '.pfx': {
+                throw new ErrorWithCode('*.p12 certificates are not supported after v6.1.2. ' +
+                    'Consider utilizing *.json format or converting *.p12 to *.pem using the OpenSSL CLI.', 'UNKNOWN_CERTIFICATE_TYPE');
+            }
+            default:
+                throw new ErrorWithCode('Unknown certificate type. Type is determined based on file extension. ' +
+                    'Current supported extensions are *.json, and *.pem.', 'UNKNOWN_CERTIFICATE_TYPE');
+        }
+    }
+    revokeToken(callback) {
+        if (callback) {
+            __classPrivateFieldGet(this, _GoogleToken_instances, "m", _GoogleToken_revokeTokenAsync).call(this).then(() => callback(), callback);
+            return;
+        }
+        return __classPrivateFieldGet(this, _GoogleToken_instances, "m", _GoogleToken_revokeTokenAsync).call(this);
+    }
+}
+exports.GoogleToken = GoogleToken;
+_GoogleToken_inFlightRequest = new WeakMap(), _GoogleToken_instances = new WeakSet(), _GoogleToken_getTokenAsync = async function _GoogleToken_getTokenAsync(opts) {
+    if (__classPrivateFieldGet(this, _GoogleToken_inFlightRequest, "f") && !opts.forceRefresh) {
+        return __classPrivateFieldGet(this, _GoogleToken_inFlightRequest, "f");
+    }
+    try {
+        return await (__classPrivateFieldSet(this, _GoogleToken_inFlightRequest, __classPrivateFieldGet(this, _GoogleToken_instances, "m", _GoogleToken_getTokenAsyncInner).call(this, opts), "f"));
+    }
+    finally {
+        __classPrivateFieldSet(this, _GoogleToken_inFlightRequest, undefined, "f");
+    }
+}, _GoogleToken_getTokenAsyncInner = async function _GoogleToken_getTokenAsyncInner(opts) {
+    if (this.isTokenExpiring() === false && opts.forceRefresh === false) {
+        return Promise.resolve(this.rawToken);
+    }
+    if (!this.key && !this.keyFile) {
+        throw new Error('No key or keyFile set.');
+    }
+    if (!this.key && this.keyFile) {
+        const creds = await this.getCredentials(this.keyFile);
+        this.key = creds.privateKey;
+        this.iss = creds.clientEmail || this.iss;
+        if (!creds.clientEmail) {
+            __classPrivateFieldGet(this, _GoogleToken_instances, "m", _GoogleToken_ensureEmail).call(this);
+        }
+    }
+    return __classPrivateFieldGet(this, _GoogleToken_instances, "m", _GoogleToken_requestToken).call(this);
+}, _GoogleToken_ensureEmail = function _GoogleToken_ensureEmail() {
+    if (!this.iss) {
+        throw new ErrorWithCode('email is required.', 'MISSING_CREDENTIALS');
+    }
+}, _GoogleToken_revokeTokenAsync = async function _GoogleToken_revokeTokenAsync() {
+    if (!this.accessToken) {
+        throw new Error('No token to revoke.');
+    }
+    const url = GOOGLE_REVOKE_TOKEN_URL + this.accessToken;
+    await this.transporter.request({
+        url,
+        retry: true,
+    });
+    __classPrivateFieldGet(this, _GoogleToken_instances, "m", _GoogleToken_configure).call(this, {
+        email: this.iss,
+        sub: this.sub,
+        key: this.key,
+        keyFile: this.keyFile,
+        scope: this.scope,
+        additionalClaims: this.additionalClaims,
+    });
+}, _GoogleToken_configure = function _GoogleToken_configure(options = {}) {
+    this.keyFile = options.keyFile;
+    this.key = options.key;
+    this.rawToken = undefined;
+    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;
+    }
+    this.eagerRefreshThresholdMillis = options.eagerRefreshThresholdMillis;
+    if (options.transporter) {
+        this.transporter = options.transporter;
+    }
+}, _GoogleToken_requestToken = 
+/**
+ * Request the token from Google.
+ */
+async function _GoogleToken_requestToken() {
+    var _a, _b;
+    const iat = Math.floor(new Date().getTime() / 1000);
+    const additionalClaims = this.additionalClaims || {};
+    const payload = Object.assign({
+        iss: this.iss,
+        scope: this.scope,
+        aud: GOOGLE_TOKEN_URL,
+        exp: iat + 3600,
+        iat,
+        sub: this.sub,
+    }, additionalClaims);
+    const signedJWT = jws.sign({
+        header: { alg: 'RS256' },
+        payload,
+        secret: this.key,
+    });
+    try {
+        const r = await this.transporter.request({
+            method: 'POST',
+            url: GOOGLE_TOKEN_URL,
+            data: {
+                grant_type: 'urn:ietf:params:oauth:grant-type:jwt-bearer',
+                assertion: signedJWT,
+            },
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            responseType: 'json',
+            retryConfig: {
+                httpMethodsToRetry: ['POST'],
+            },
+        });
+        this.rawToken = r.data;
+        this.expiresAt =
+            r.data.expires_in === null || r.data.expires_in === undefined
+                ? undefined
+                : (iat + r.data.expires_in) * 1000;
+        return this.rawToken;
+    }
+    catch (e) {
+        this.rawToken = undefined;
+        this.tokenExpires = undefined;
+        const body = e.response && ((_a = e.response) === null || _a === void 0 ? void 0 : _a.data)
+            ? (_b = e.response) === null || _b === void 0 ? void 0 : _b.data
+            : {};
+        if (body.error) {
+            const desc = body.error_description
+                ? `: ${body.error_description}`
+                : '';
+            e.message = `${body.error}${desc}`;
+        }
+        throw e;
+    }
+};
+//# sourceMappingURL=index.js.map