@umbraco-cms/backoffice 1.0.0-next.e8be58ec → 1.0.0-next.ea1e6e6f

package/dist-cms/external/openid/index.js

@@ -0,0 +1,1494 @@
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+var built = {};
+
+var authorization_request = {};
+
+var crypto_utils = {};
+
+var base64Js = {};
+
+base64Js.byteLength = byteLength;
+base64Js.toByteArray = toByteArray;
+base64Js.fromByteArray = fromByteArray;
+
+var lookup = [];
+var revLookup = [];
+var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;
+
+var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+for (var i = 0, len = code.length; i < len; ++i) {
+  lookup[i] = code[i];
+  revLookup[code.charCodeAt(i)] = i;
+}
+
+// Support decoding URL-safe base64 strings, as Node.js does.
+// See: https://en.wikipedia.org/wiki/Base64#URL_applications
+revLookup['-'.charCodeAt(0)] = 62;
+revLookup['_'.charCodeAt(0)] = 63;
+
+function getLens (b64) {
+  var len = b64.length;
+
+  if (len % 4 > 0) {
+    throw new Error('Invalid string. Length must be a multiple of 4')
+  }
+
+  // Trim off extra bytes after placeholder bytes are found
+  // See: https://github.com/beatgammit/base64-js/issues/42
+  var validLen = b64.indexOf('=');
+  if (validLen === -1) validLen = len;
+
+  var placeHoldersLen = validLen === len
+    ? 0
+    : 4 - (validLen % 4);
+
+  return [validLen, placeHoldersLen]
+}
+
+// base64 is 4/3 + up to two characters of the original data
+function byteLength (b64) {
+  var lens = getLens(b64);
+  var validLen = lens[0];
+  var placeHoldersLen = lens[1];
+  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
+}
+
+function _byteLength (b64, validLen, placeHoldersLen) {
+  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
+}
+
+function toByteArray (b64) {
+  var tmp;
+  var lens = getLens(b64);
+  var validLen = lens[0];
+  var placeHoldersLen = lens[1];
+
+  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
+
+  var curByte = 0;
+
+  // if there are placeholders, only get up to the last complete 4 chars
+  var len = placeHoldersLen > 0
+    ? validLen - 4
+    : validLen;
+
+  var i;
+  for (i = 0; i < len; i += 4) {
+    tmp =
+      (revLookup[b64.charCodeAt(i)] << 18) |
+      (revLookup[b64.charCodeAt(i + 1)] << 12) |
+      (revLookup[b64.charCodeAt(i + 2)] << 6) |
+      revLookup[b64.charCodeAt(i + 3)];
+    arr[curByte++] = (tmp >> 16) & 0xFF;
+    arr[curByte++] = (tmp >> 8) & 0xFF;
+    arr[curByte++] = tmp & 0xFF;
+  }
+
+  if (placeHoldersLen === 2) {
+    tmp =
+      (revLookup[b64.charCodeAt(i)] << 2) |
+      (revLookup[b64.charCodeAt(i + 1)] >> 4);
+    arr[curByte++] = tmp & 0xFF;
+  }
+
+  if (placeHoldersLen === 1) {
+    tmp =
+      (revLookup[b64.charCodeAt(i)] << 10) |
+      (revLookup[b64.charCodeAt(i + 1)] << 4) |
+      (revLookup[b64.charCodeAt(i + 2)] >> 2);
+    arr[curByte++] = (tmp >> 8) & 0xFF;
+    arr[curByte++] = tmp & 0xFF;
+  }
+
+  return arr
+}
+
+function tripletToBase64 (num) {
+  return lookup[num >> 18 & 0x3F] +
+    lookup[num >> 12 & 0x3F] +
+    lookup[num >> 6 & 0x3F] +
+    lookup[num & 0x3F]
+}
+
+function encodeChunk (uint8, start, end) {
+  var tmp;
+  var output = [];
+  for (var i = start; i < end; i += 3) {
+    tmp =
+      ((uint8[i] << 16) & 0xFF0000) +
+      ((uint8[i + 1] << 8) & 0xFF00) +
+      (uint8[i + 2] & 0xFF);
+    output.push(tripletToBase64(tmp));
+  }
+  return output.join('')
+}
+
+function fromByteArray (uint8) {
+  var tmp;
+  var len = uint8.length;
+  var extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes
+  var parts = [];
+  var maxChunkLength = 16383; // must be multiple of 3
+
+  // go through the array every three bytes, we'll deal with trailing stuff later
+  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
+    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)));
+  }
+
+  // pad the end with zeros, but make sure to not forget the extra bytes
+  if (extraBytes === 1) {
+    tmp = uint8[len - 1];
+    parts.push(
+      lookup[tmp >> 2] +
+      lookup[(tmp << 4) & 0x3F] +
+      '=='
+    );
+  } else if (extraBytes === 2) {
+    tmp = (uint8[len - 2] << 8) + uint8[len - 1];
+    parts.push(
+      lookup[tmp >> 10] +
+      lookup[(tmp >> 4) & 0x3F] +
+      lookup[(tmp << 2) & 0x3F] +
+      '='
+    );
+  }
+
+  return parts.join('')
+}
+
+var errors = {};
+
+/*
+ * Copyright 2017 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.
+ */
+Object.defineProperty(errors, "__esModule", { value: true });
+errors.AppAuthError = void 0;
+/**
+ * Represents the AppAuthError type.
+ */
+var AppAuthError = /** @class */ (function () {
+    function AppAuthError(message, extras) {
+        this.message = message;
+        this.extras = extras;
+    }
+    return AppAuthError;
+}());
+errors.AppAuthError = AppAuthError;
+
+/*
+ * Copyright 2017 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.
+ */
+Object.defineProperty(crypto_utils, "__esModule", { value: true });
+crypto_utils.DefaultCrypto = crypto_utils.textEncodeLite = crypto_utils.urlSafe = crypto_utils.bufferToString = void 0;
+var base64 = base64Js;
+var errors_1$2 = errors;
+var HAS_CRYPTO = typeof window !== 'undefined' && !!window.crypto;
+var HAS_SUBTLE_CRYPTO = HAS_CRYPTO && !!window.crypto.subtle;
+var CHARSET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+function bufferToString(buffer) {
+    var state = [];
+    for (var i = 0; i < buffer.byteLength; i += 1) {
+        var index = buffer[i] % CHARSET.length;
+        state.push(CHARSET[index]);
+    }
+    return state.join('');
+}
+crypto_utils.bufferToString = bufferToString;
+function urlSafe(buffer) {
+    var encoded = base64.fromByteArray(new Uint8Array(buffer));
+    return encoded.replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
+}
+crypto_utils.urlSafe = urlSafe;
+// adapted from source: http://stackoverflow.com/a/11058858
+// this is used in place of TextEncode as the api is not yet
+// well supported: https://caniuse.com/#search=TextEncoder
+function textEncodeLite(str) {
+    var buf = new ArrayBuffer(str.length);
+    var bufView = new Uint8Array(buf);
+    for (var i = 0; i < str.length; i++) {
+        bufView[i] = str.charCodeAt(i);
+    }
+    return bufView;
+}
+crypto_utils.textEncodeLite = textEncodeLite;
+/**
+ * The default implementation of the `Crypto` interface.
+ * This uses the capabilities of the browser.
+ */
+var DefaultCrypto = /** @class */ (function () {
+    function DefaultCrypto() {
+    }
+    DefaultCrypto.prototype.generateRandom = function (size) {
+        var buffer = new Uint8Array(size);
+        if (HAS_CRYPTO) {
+            window.crypto.getRandomValues(buffer);
+        }
+        else {
+            // fall back to Math.random() if nothing else is available
+            for (var i = 0; i < size; i += 1) {
+                buffer[i] = (Math.random() * CHARSET.length) | 0;
+            }
+        }
+        return bufferToString(buffer);
+    };
+    DefaultCrypto.prototype.deriveChallenge = function (code) {
+        if (code.length < 43 || code.length > 128) {
+            return Promise.reject(new errors_1$2.AppAuthError('Invalid code length.'));
+        }
+        if (!HAS_SUBTLE_CRYPTO) {
+            return Promise.reject(new errors_1$2.AppAuthError('window.crypto.subtle is unavailable.'));
+        }
+        return new Promise(function (resolve, reject) {
+            crypto.subtle.digest('SHA-256', textEncodeLite(code)).then(function (buffer) {
+                return resolve(urlSafe(new Uint8Array(buffer)));
+            }, function (error) { return reject(error); });
+        });
+    };
+    return DefaultCrypto;
+}());
+crypto_utils.DefaultCrypto = DefaultCrypto;
+
+var logger = {};
+
+var flags = {};
+
+/*
+ * Copyright 2017 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.
+ */
+Object.defineProperty(flags, "__esModule", { value: true });
+flags.IS_PROFILE = flags.IS_LOG = void 0;
+/* Global flags that control the behavior of App Auth JS. */
+/* Logging turned on ? */
+flags.IS_LOG = true;
+/* Profiling turned on ? */
+flags.IS_PROFILE = false;
+
+/*
+ * Copyright 2017 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.
+ */
+var __spreadArray = (commonjsGlobal && commonjsGlobal.__spreadArray) || function (to, from) {
+    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+    return to;
+};
+Object.defineProperty(logger, "__esModule", { value: true });
+logger.profile = logger.log = void 0;
+var flags_1 = flags;
+function log(message) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    if (flags_1.IS_LOG) {
+        var length_1 = args ? args.length : 0;
+        if (length_1 > 0) {
+            console.log.apply(console, __spreadArray([message], args));
+        }
+        else {
+            console.log(message);
+        }
+    }
+}
+logger.log = log;
+// check to see if native support for profiling is available.
+var NATIVE_PROFILE_SUPPORT = typeof window !== 'undefined' && !!window.performance && !!console.profile;
+/**
+ * A decorator that can profile a function.
+ */
+function profile(target, propertyKey, descriptor) {
+    if (flags_1.IS_PROFILE) {
+        return performProfile(target, propertyKey, descriptor);
+    }
+    else {
+        // return as-is
+        return descriptor;
+    }
+}
+logger.profile = profile;
+function performProfile(target, propertyKey, descriptor) {
+    var originalCallable = descriptor.value;
+    // name must exist
+    var name = originalCallable.name;
+    if (!name) {
+        name = 'anonymous function';
+    }
+    if (NATIVE_PROFILE_SUPPORT) {
+        descriptor.value = function (args) {
+            console.profile(name);
+            var startTime = window.performance.now();
+            var result = originalCallable.call.apply(originalCallable, __spreadArray([this || window], args));
+            var duration = window.performance.now() - startTime;
+            console.log(name + " took " + duration + " ms");
+            console.profileEnd();
+            return result;
+        };
+    }
+    else {
+        descriptor.value = function (args) {
+            log("Profile start " + name);
+            var start = Date.now();
+            var result = originalCallable.call.apply(originalCallable, __spreadArray([this || window], args));
+            var duration = Date.now() - start;
+            log("Profile end " + name + " took " + duration + " ms.");
+            return result;
+        };
+    }
+    return descriptor;
+}
+
+/*
+ * Copyright 2017 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.
+ */
+Object.defineProperty(authorization_request, "__esModule", { value: true });
+var AuthorizationRequest_1 = authorization_request.AuthorizationRequest = void 0;
+var crypto_utils_1$1 = crypto_utils;
+var logger_1$1 = logger;
+/**
+ * Generates a cryptographically random new state. Useful for CSRF protection.
+ */
+var SIZE = 10; // 10 bytes
+var newState = function (crypto) {
+    return crypto.generateRandom(SIZE);
+};
+/**
+ * Represents the AuthorizationRequest.
+ * For more information look at
+ * https://tools.ietf.org/html/rfc6749#section-4.1.1
+ */
+var AuthorizationRequest = /** @class */ (function () {
+    /**
+     * Constructs a new AuthorizationRequest.
+     * Use a `undefined` value for the `state` parameter, to generate a random
+     * state for CSRF protection.
+     */
+    function AuthorizationRequest(request, crypto, usePkce) {
+        if (crypto === void 0) { crypto = new crypto_utils_1$1.DefaultCrypto(); }
+        if (usePkce === void 0) { usePkce = true; }
+        this.crypto = crypto;
+        this.usePkce = usePkce;
+        this.clientId = request.client_id;
+        this.redirectUri = request.redirect_uri;
+        this.scope = request.scope;
+        this.responseType = request.response_type || AuthorizationRequest.RESPONSE_TYPE_CODE;
+        this.state = request.state || newState(crypto);
+        this.extras = request.extras;
+        // read internal properties if available
+        this.internal = request.internal;
+    }
+    AuthorizationRequest.prototype.setupCodeVerifier = function () {
+        var _this = this;
+        if (!this.usePkce) {
+            return Promise.resolve();
+        }
+        else {
+            var codeVerifier_1 = this.crypto.generateRandom(128);
+            var challenge = this.crypto.deriveChallenge(codeVerifier_1).catch(function (error) {
+                logger_1$1.log('Unable to generate PKCE challenge. Not using PKCE', error);
+                return undefined;
+            });
+            return challenge.then(function (result) {
+                if (result) {
+                    // keep track of the code used.
+                    _this.internal = _this.internal || {};
+                    _this.internal['code_verifier'] = codeVerifier_1;
+                    _this.extras = _this.extras || {};
+                    _this.extras['code_challenge'] = result;
+                    // We always use S256. Plain is not good enough.
+                    _this.extras['code_challenge_method'] = 'S256';
+                }
+            });
+        }
+    };
+    /**
+     * Serializes the AuthorizationRequest to a JavaScript Object.
+     */
+    AuthorizationRequest.prototype.toJson = function () {
+        var _this = this;
+        // Always make sure that the code verifier is setup when toJson() is called.
+        return this.setupCodeVerifier().then(function () {
+            return {
+                response_type: _this.responseType,
+                client_id: _this.clientId,
+                redirect_uri: _this.redirectUri,
+                scope: _this.scope,
+                state: _this.state,
+                extras: _this.extras,
+                internal: _this.internal
+            };
+        });
+    };
+    AuthorizationRequest.RESPONSE_TYPE_TOKEN = 'token';
+    AuthorizationRequest.RESPONSE_TYPE_CODE = 'code';
+    return AuthorizationRequest;
+}());
+AuthorizationRequest_1 = authorization_request.AuthorizationRequest = AuthorizationRequest;
+
+var authorization_request_handler = {};
+
+(function (exports) {
+	/*
+	 * Copyright 2017 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.
+	 */
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.AuthorizationRequestHandler = exports.BUILT_IN_PARAMETERS = exports.AuthorizationNotifier = void 0;
+	var logger_1 = logger;
+	/**
+	 * Authorization Service notifier.
+	 * This manages the communication of the AuthorizationResponse to the 3p client.
+	 */
+	var AuthorizationNotifier = /** @class */ (function () {
+	    function AuthorizationNotifier() {
+	        this.listener = null;
+	    }
+	    AuthorizationNotifier.prototype.setAuthorizationListener = function (listener) {
+	        this.listener = listener;
+	    };
+	    /**
+	     * The authorization complete callback.
+	     */
+	    AuthorizationNotifier.prototype.onAuthorizationComplete = function (request, response, error) {
+	        if (this.listener) {
+	            // complete authorization request
+	            this.listener(request, response, error);
+	        }
+	    };
+	    return AuthorizationNotifier;
+	}());
+	exports.AuthorizationNotifier = AuthorizationNotifier;
+	// TODO(rahulrav@): add more built in parameters.
+	/* built in parameters. */
+	exports.BUILT_IN_PARAMETERS = ['redirect_uri', 'client_id', 'response_type', 'state', 'scope'];
+	/**
+	 * Defines the interface which is capable of handling an authorization request
+	 * using various methods (iframe / popup / different process etc.).
+	 */
+	var AuthorizationRequestHandler = /** @class */ (function () {
+	    function AuthorizationRequestHandler(utils, crypto) {
+	        this.utils = utils;
+	        this.crypto = crypto;
+	        // notifier send the response back to the client.
+	        this.notifier = null;
+	    }
+	    /**
+	     * A utility method to be able to build the authorization request URL.
+	     */
+	    AuthorizationRequestHandler.prototype.buildRequestUrl = function (configuration, request) {
+	        // build the query string
+	        // coerce to any type for convenience
+	        var requestMap = {
+	            'redirect_uri': request.redirectUri,
+	            'client_id': request.clientId,
+	            'response_type': request.responseType,
+	            'state': request.state,
+	            'scope': request.scope
+	        };
+	        // copy over extras
+	        if (request.extras) {
+	            for (var extra in request.extras) {
+	                if (request.extras.hasOwnProperty(extra)) {
+	                    // check before inserting to requestMap
+	                    if (exports.BUILT_IN_PARAMETERS.indexOf(extra) < 0) {
+	                        requestMap[extra] = request.extras[extra];
+	                    }
+	                }
+	            }
+	        }
+	        var query = this.utils.stringify(requestMap);
+	        var baseUrl = configuration.authorizationEndpoint;
+	        var url = baseUrl + "?" + query;
+	        return url;
+	    };
+	    /**
+	     * Completes the authorization request if necessary & when possible.
+	     */
+	    AuthorizationRequestHandler.prototype.completeAuthorizationRequestIfPossible = function () {
+	        var _this = this;
+	        // call complete authorization if possible to see there might
+	        // be a response that needs to be delivered.
+	        logger_1.log("Checking to see if there is an authorization response to be delivered.");
+	        if (!this.notifier) {
+	            logger_1.log("Notifier is not present on AuthorizationRequest handler.\n          No delivery of result will be possible");
+	        }
+	        return this.completeAuthorizationRequest().then(function (result) {
+	            if (!result) {
+	                logger_1.log("No result is available yet.");
+	            }
+	            if (result && _this.notifier) {
+	                _this.notifier.onAuthorizationComplete(result.request, result.response, result.error);
+	            }
+	        });
+	    };
+	    /**
+	     * Sets the default Authorization Service notifier.
+	     */
+	    AuthorizationRequestHandler.prototype.setAuthorizationNotifier = function (notifier) {
+	        this.notifier = notifier;
+	        return this;
+	    };
+	    return AuthorizationRequestHandler;
+	}());
+	exports.AuthorizationRequestHandler = AuthorizationRequestHandler;
+	
+} (authorization_request_handler));
+
+var authorization_response = {};
+
+/*
+ * Copyright 2017 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.
+ */
+Object.defineProperty(authorization_response, "__esModule", { value: true });
+authorization_response.AuthorizationError = authorization_response.AuthorizationResponse = void 0;
+/**
+ * Represents the Authorization Response type.
+ * For more information look at
+ * https://tools.ietf.org/html/rfc6749#section-4.1.2
+ */
+var AuthorizationResponse = /** @class */ (function () {
+    function AuthorizationResponse(response) {
+        this.code = response.code;
+        this.state = response.state;
+    }
+    AuthorizationResponse.prototype.toJson = function () {
+        return { code: this.code, state: this.state };
+    };
+    return AuthorizationResponse;
+}());
+authorization_response.AuthorizationResponse = AuthorizationResponse;
+/**
+ * Represents the Authorization error response.
+ * For more information look at:
+ * https://tools.ietf.org/html/rfc6749#section-4.1.2.1
+ */
+var AuthorizationError = /** @class */ (function () {
+    function AuthorizationError(error) {
+        this.error = error.error;
+        this.errorDescription = error.error_description;
+        this.errorUri = error.error_uri;
+        this.state = error.state;
+    }
+    AuthorizationError.prototype.toJson = function () {
+        return {
+            error: this.error,
+            error_description: this.errorDescription,
+            error_uri: this.errorUri,
+            state: this.state
+        };
+    };
+    return AuthorizationError;
+}());
+authorization_response.AuthorizationError = AuthorizationError;
+
+var authorization_service_configuration = {};
+
+var xhr = {};
+
+/*
+ * Copyright 2017 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.
+ */
+var __extends$2 = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(xhr, "__esModule", { value: true });
+xhr.TestRequestor = xhr.FetchRequestor = xhr.JQueryRequestor = xhr.Requestor = void 0;
+var errors_1$1 = errors;
+/**
+ * An class that abstracts away the ability to make an XMLHttpRequest.
+ */
+var Requestor = /** @class */ (function () {
+    function Requestor() {
+    }
+    return Requestor;
+}());
+xhr.Requestor = Requestor;
+/**
+ * Uses $.ajax to makes the Ajax requests.
+ */
+var JQueryRequestor = /** @class */ (function (_super) {
+    __extends$2(JQueryRequestor, _super);
+    function JQueryRequestor() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    JQueryRequestor.prototype.xhr = function (settings) {
+        // NOTE: using jquery to make XHR's as whatwg-fetch requires
+        // that I target ES6.
+        var xhr = $.ajax(settings);
+        return new Promise(function (resolve, reject) {
+            xhr.then(function (data, textStatus, jqXhr) {
+                resolve(data);
+            }, function (jqXhr, textStatus, error) {
+                reject(new errors_1$1.AppAuthError(error));
+            });
+        });
+    };
+    return JQueryRequestor;
+}(Requestor));
+xhr.JQueryRequestor = JQueryRequestor;
+/**
+ * Uses fetch API to make Ajax requests
+ */
+var FetchRequestor = /** @class */ (function (_super) {
+    __extends$2(FetchRequestor, _super);
+    function FetchRequestor() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    FetchRequestor.prototype.xhr = function (settings) {
+        if (!settings.url) {
+            return Promise.reject(new errors_1$1.AppAuthError('A URL must be provided.'));
+        }
+        var url = new URL(settings.url);
+        var requestInit = {};
+        requestInit.method = settings.method;
+        requestInit.mode = 'cors';
+        if (settings.data) {
+            if (settings.method && settings.method.toUpperCase() === 'POST') {
+                requestInit.body = settings.data;
+            }
+            else {
+                var searchParams = new URLSearchParams(settings.data);
+                searchParams.forEach(function (value, key) {
+                    url.searchParams.append(key, value);
+                });
+            }
+        }
+        // Set the request headers
+        requestInit.headers = {};
+        if (settings.headers) {
+            for (var i in settings.headers) {
+                if (settings.headers.hasOwnProperty(i)) {
+                    requestInit.headers[i] = settings.headers[i];
+                }
+            }
+        }
+        var isJsonDataType = settings.dataType && settings.dataType.toLowerCase() === 'json';
+        // Set 'Accept' header value for json requests (Taken from
+        // https://github.com/jquery/jquery/blob/e0d941156900a6bff7c098c8ea7290528e468cf8/src/ajax.js#L644
+        // )
+        if (isJsonDataType) {
+            requestInit.headers['Accept'] = 'application/json, text/javascript, */*; q=0.01';
+        }
+        return fetch(url.toString(), requestInit).then(function (response) {
+            if (response.status >= 200 && response.status < 300) {
+                var contentType = response.headers.get('content-type');
+                if (isJsonDataType || (contentType && contentType.indexOf('application/json') !== -1)) {
+                    return response.json();
+                }
+                else {
+                    return response.text();
+                }
+            }
+            else {
+                return Promise.reject(new errors_1$1.AppAuthError(response.status.toString(), response.statusText));
+            }
+        });
+    };
+    return FetchRequestor;
+}(Requestor));
+xhr.FetchRequestor = FetchRequestor;
+/**
+ * Should be used only in the context of testing. Just uses the underlying
+ * Promise to mock the behavior of the Requestor.
+ */
+var TestRequestor = /** @class */ (function (_super) {
+    __extends$2(TestRequestor, _super);
+    function TestRequestor(promise) {
+        var _this = _super.call(this) || this;
+        _this.promise = promise;
+        return _this;
+    }
+    TestRequestor.prototype.xhr = function (settings) {
+        return this.promise; // unsafe cast
+    };
+    return TestRequestor;
+}(Requestor));
+xhr.TestRequestor = TestRequestor;
+
+/*
+ * Copyright 2017 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.
+ */
+Object.defineProperty(authorization_service_configuration, "__esModule", { value: true });
+var AuthorizationServiceConfiguration_1 = authorization_service_configuration.AuthorizationServiceConfiguration = void 0;
+var xhr_1$1 = xhr;
+/**
+ * The standard base path for well-known resources on domains.
+ * See https://tools.ietf.org/html/rfc5785 for more information.
+ */
+var WELL_KNOWN_PATH = '.well-known';
+/**
+ * The standard resource under the well known path at which an OpenID Connect
+ * discovery document can be found under an issuer's base URI.
+ */
+var OPENID_CONFIGURATION = 'openid-configuration';
+/**
+ * Configuration details required to interact with an authorization service.
+ *
+ * More information at https://openid.net/specs/openid-connect-discovery-1_0-17.html
+ */
+var AuthorizationServiceConfiguration = /** @class */ (function () {
+    function AuthorizationServiceConfiguration(request) {
+        this.authorizationEndpoint = request.authorization_endpoint;
+        this.tokenEndpoint = request.token_endpoint;
+        this.revocationEndpoint = request.revocation_endpoint;
+        this.userInfoEndpoint = request.userinfo_endpoint;
+        this.endSessionEndpoint = request.end_session_endpoint;
+    }
+    AuthorizationServiceConfiguration.prototype.toJson = function () {
+        return {
+            authorization_endpoint: this.authorizationEndpoint,
+            token_endpoint: this.tokenEndpoint,
+            revocation_endpoint: this.revocationEndpoint,
+            end_session_endpoint: this.endSessionEndpoint,
+            userinfo_endpoint: this.userInfoEndpoint
+        };
+    };
+    AuthorizationServiceConfiguration.fetchFromIssuer = function (openIdIssuerUrl, requestor) {
+        var fullUrl = openIdIssuerUrl + "/" + WELL_KNOWN_PATH + "/" + OPENID_CONFIGURATION;
+        var requestorToUse = requestor || new xhr_1$1.JQueryRequestor();
+        return requestorToUse
+            .xhr({ url: fullUrl, dataType: 'json', method: 'GET' })
+            .then(function (json) { return new AuthorizationServiceConfiguration(json); });
+    };
+    return AuthorizationServiceConfiguration;
+}());
+AuthorizationServiceConfiguration_1 = authorization_service_configuration.AuthorizationServiceConfiguration = AuthorizationServiceConfiguration;
+
+var query_string_utils = {};
+
+/*
+ * Copyright 2017 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.
+ */
+Object.defineProperty(query_string_utils, "__esModule", { value: true });
+query_string_utils.BasicQueryStringUtils = void 0;
+var BasicQueryStringUtils = /** @class */ (function () {
+    function BasicQueryStringUtils() {
+    }
+    BasicQueryStringUtils.prototype.parse = function (input, useHash) {
+        if (useHash) {
+            return this.parseQueryString(input.hash);
+        }
+        else {
+            return this.parseQueryString(input.search);
+        }
+    };
+    BasicQueryStringUtils.prototype.parseQueryString = function (query) {
+        var result = {};
+        // if anything starts with ?, # or & remove it
+        query = query.trim().replace(/^(\?|#|&)/, '');
+        var params = query.split('&');
+        for (var i = 0; i < params.length; i += 1) {
+            var param = params[i]; // looks something like a=b
+            var parts = param.split('=');
+            if (parts.length >= 2) {
+                var key = decodeURIComponent(parts.shift());
+                var value = parts.length > 0 ? parts.join('=') : null;
+                if (value) {
+                    result[key] = decodeURIComponent(value);
+                }
+            }
+        }
+        return result;
+    };
+    BasicQueryStringUtils.prototype.stringify = function (input) {
+        var encoded = [];
+        for (var key in input) {
+            if (input.hasOwnProperty(key) && input[key]) {
+                encoded.push(encodeURIComponent(key) + "=" + encodeURIComponent(input[key]));
+            }
+        }
+        return encoded.join('&');
+    };
+    return BasicQueryStringUtils;
+}());
+query_string_utils.BasicQueryStringUtils = BasicQueryStringUtils;
+
+var redirect_based_handler = {};
+
+var storage = {};
+
+/*
+ * Copyright 2017 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.
+ */
+var __extends$1 = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(storage, "__esModule", { value: true });
+storage.LocalStorageBackend = storage.StorageBackend = void 0;
+/**
+ * Asynchronous storage APIs. All methods return a `Promise`.
+ * All methods take the `DOMString`
+ * IDL type (as it is the lowest common denominator).
+ */
+var StorageBackend = /** @class */ (function () {
+    function StorageBackend() {
+    }
+    return StorageBackend;
+}());
+storage.StorageBackend = StorageBackend;
+/**
+ * A `StorageBackend` backed by `localstorage`.
+ */
+var LocalStorageBackend = /** @class */ (function (_super) {
+    __extends$1(LocalStorageBackend, _super);
+    function LocalStorageBackend(storage) {
+        var _this = _super.call(this) || this;
+        _this.storage = storage || window.localStorage;
+        return _this;
+    }
+    LocalStorageBackend.prototype.getItem = function (name) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var value = _this.storage.getItem(name);
+            if (value) {
+                resolve(value);
+            }
+            else {
+                resolve(null);
+            }
+        });
+    };
+    LocalStorageBackend.prototype.removeItem = function (name) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            _this.storage.removeItem(name);
+            resolve();
+        });
+    };
+    LocalStorageBackend.prototype.clear = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            _this.storage.clear();
+            resolve();
+        });
+    };
+    LocalStorageBackend.prototype.setItem = function (name, value) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            _this.storage.setItem(name, value);
+            resolve();
+        });
+    };
+    return LocalStorageBackend;
+}(StorageBackend));
+storage.LocalStorageBackend = LocalStorageBackend;
+
+/*
+ * Copyright 2017 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.
+ */
+var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(redirect_based_handler, "__esModule", { value: true });
+redirect_based_handler.RedirectRequestHandler = void 0;
+var authorization_request_1 = authorization_request;
+var authorization_request_handler_1 = authorization_request_handler;
+var authorization_response_1 = authorization_response;
+var crypto_utils_1 = crypto_utils;
+var logger_1 = logger;
+var query_string_utils_1$1 = query_string_utils;
+var storage_1 = storage;
+/** key for authorization request. */
+var authorizationRequestKey = function (handle) {
+    return handle + "_appauth_authorization_request";
+};
+/** key for authorization service configuration */
+var authorizationServiceConfigurationKey = function (handle) {
+    return handle + "_appauth_authorization_service_configuration";
+};
+/** key in local storage which represents the current authorization request. */
+var AUTHORIZATION_REQUEST_HANDLE_KEY = 'appauth_current_authorization_request';
+/**
+ * Represents an AuthorizationRequestHandler which uses a standard
+ * redirect based code flow.
+ */
+var RedirectRequestHandler = /** @class */ (function (_super) {
+    __extends(RedirectRequestHandler, _super);
+    function RedirectRequestHandler(
+    // use the provided storage backend
+    // or initialize local storage with the default storage backend which
+    // uses window.localStorage
+    storageBackend, utils, locationLike, crypto) {
+        if (storageBackend === void 0) { storageBackend = new storage_1.LocalStorageBackend(); }
+        if (utils === void 0) { utils = new query_string_utils_1$1.BasicQueryStringUtils(); }
+        if (locationLike === void 0) { locationLike = window.location; }
+        if (crypto === void 0) { crypto = new crypto_utils_1.DefaultCrypto(); }
+        var _this = _super.call(this, utils, crypto) || this;
+        _this.storageBackend = storageBackend;
+        _this.locationLike = locationLike;
+        return _this;
+    }
+    RedirectRequestHandler.prototype.performAuthorizationRequest = function (configuration, request) {
+        var _this = this;
+        var handle = this.crypto.generateRandom(10);
+        // before you make request, persist all request related data in local storage.
+        var persisted = Promise.all([
+            this.storageBackend.setItem(AUTHORIZATION_REQUEST_HANDLE_KEY, handle),
+            // Calling toJson() adds in the code & challenge when possible
+            request.toJson().then(function (result) {
+                return _this.storageBackend.setItem(authorizationRequestKey(handle), JSON.stringify(result));
+            }),
+            this.storageBackend.setItem(authorizationServiceConfigurationKey(handle), JSON.stringify(configuration.toJson())),
+        ]);
+        persisted.then(function () {
+            // make the redirect request
+            var url = _this.buildRequestUrl(configuration, request);
+            logger_1.log('Making a request to ', request, url);
+            _this.locationLike.assign(url);
+        });
+    };
+    /**
+     * Attempts to introspect the contents of storage backend and completes the
+     * request.
+     */
+    RedirectRequestHandler.prototype.completeAuthorizationRequest = function () {
+        var _this = this;
+        // TODO(rahulrav@): handle authorization errors.
+        return this.storageBackend.getItem(AUTHORIZATION_REQUEST_HANDLE_KEY).then(function (handle) {
+            if (handle) {
+                // we have a pending request.
+                // fetch authorization request, and check state
+                return _this.storageBackend
+                    .getItem(authorizationRequestKey(handle))
+                    // requires a corresponding instance of result
+                    // TODO(rahulrav@): check for inconsitent state here
+                    .then(function (result) { return JSON.parse(result); })
+                    .then(function (json) { return new authorization_request_1.AuthorizationRequest(json); })
+                    .then(function (request) {
+                    // check redirect_uri and state
+                    var currentUri = "" + _this.locationLike.origin + _this.locationLike.pathname;
+                    var queryParams = _this.utils.parse(_this.locationLike, true /* use hash */);
+                    var state = queryParams['state'];
+                    var code = queryParams['code'];
+                    var error = queryParams['error'];
+                    logger_1.log('Potential authorization request ', currentUri, queryParams, state, code, error);
+                    var shouldNotify = state === request.state;
+                    var authorizationResponse = null;
+                    var authorizationError = null;
+                    if (shouldNotify) {
+                        if (error) {
+                            // get additional optional info.
+                            var errorUri = queryParams['error_uri'];
+                            var errorDescription = queryParams['error_description'];
+                            authorizationError = new authorization_response_1.AuthorizationError({
+                                error: error,
+                                error_description: errorDescription,
+                                error_uri: errorUri,
+                                state: state
+                            });
+                        }
+                        else {
+                            authorizationResponse = new authorization_response_1.AuthorizationResponse({ code: code, state: state });
+                        }
+                        // cleanup state
+                        return Promise
+                            .all([
+                            _this.storageBackend.removeItem(AUTHORIZATION_REQUEST_HANDLE_KEY),
+                            _this.storageBackend.removeItem(authorizationRequestKey(handle)),
+                            _this.storageBackend.removeItem(authorizationServiceConfigurationKey(handle))
+                        ])
+                            .then(function () {
+                            logger_1.log('Delivering authorization response');
+                            return {
+                                request: request,
+                                response: authorizationResponse,
+                                error: authorizationError
+                            };
+                        });
+                    }
+                    else {
+                        logger_1.log('Mismatched request (state and request_uri) dont match.');
+                        return Promise.resolve(null);
+                    }
+                });
+            }
+            else {
+                return null;
+            }
+        });
+    };
+    return RedirectRequestHandler;
+}(authorization_request_handler_1.AuthorizationRequestHandler));
+redirect_based_handler.RedirectRequestHandler = RedirectRequestHandler;
+
+var revoke_token_request = {};
+
+Object.defineProperty(revoke_token_request, "__esModule", { value: true });
+revoke_token_request.RevokeTokenRequest = void 0;
+/**
+ * Represents a revoke token request.
+ * For more information look at:
+ * https://tools.ietf.org/html/rfc7009#section-2.1
+ */
+var RevokeTokenRequest = /** @class */ (function () {
+    function RevokeTokenRequest(request) {
+        this.token = request.token;
+        this.tokenTypeHint = request.token_type_hint;
+        this.clientId = request.client_id;
+        this.clientSecret = request.client_secret;
+    }
+    /**
+     * Serializes a TokenRequest to a JavaScript object.
+     */
+    RevokeTokenRequest.prototype.toJson = function () {
+        var json = { token: this.token };
+        if (this.tokenTypeHint) {
+            json['token_type_hint'] = this.tokenTypeHint;
+        }
+        if (this.clientId) {
+            json['client_id'] = this.clientId;
+        }
+        if (this.clientSecret) {
+            json['client_secret'] = this.clientSecret;
+        }
+        return json;
+    };
+    RevokeTokenRequest.prototype.toStringMap = function () {
+        var json = this.toJson();
+        // :(
+        return json;
+    };
+    return RevokeTokenRequest;
+}());
+revoke_token_request.RevokeTokenRequest = RevokeTokenRequest;
+
+var token_request = {};
+
+/*
+ * Copyright 2017 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.
+ */
+Object.defineProperty(token_request, "__esModule", { value: true });
+var TokenRequest_1 = token_request.TokenRequest = GRANT_TYPE_REFRESH_TOKEN = token_request.GRANT_TYPE_REFRESH_TOKEN = GRANT_TYPE_AUTHORIZATION_CODE = token_request.GRANT_TYPE_AUTHORIZATION_CODE = void 0;
+var GRANT_TYPE_AUTHORIZATION_CODE = token_request.GRANT_TYPE_AUTHORIZATION_CODE = 'authorization_code';
+var GRANT_TYPE_REFRESH_TOKEN = token_request.GRANT_TYPE_REFRESH_TOKEN = 'refresh_token';
+/**
+ * Represents an Access Token request.
+ * For more information look at:
+ * https://tools.ietf.org/html/rfc6749#section-4.1.3
+ */
+var TokenRequest = /** @class */ (function () {
+    function TokenRequest(request) {
+        this.clientId = request.client_id;
+        this.redirectUri = request.redirect_uri;
+        this.grantType = request.grant_type;
+        this.code = request.code;
+        this.refreshToken = request.refresh_token;
+        this.extras = request.extras;
+    }
+    /**
+     * Serializes a TokenRequest to a JavaScript object.
+     */
+    TokenRequest.prototype.toJson = function () {
+        return {
+            grant_type: this.grantType,
+            code: this.code,
+            refresh_token: this.refreshToken,
+            redirect_uri: this.redirectUri,
+            client_id: this.clientId,
+            extras: this.extras
+        };
+    };
+    TokenRequest.prototype.toStringMap = function () {
+        var map = {
+            grant_type: this.grantType,
+            client_id: this.clientId,
+            redirect_uri: this.redirectUri
+        };
+        if (this.code) {
+            map['code'] = this.code;
+        }
+        if (this.refreshToken) {
+            map['refresh_token'] = this.refreshToken;
+        }
+        // copy over extras
+        if (this.extras) {
+            for (var extra in this.extras) {
+                if (this.extras.hasOwnProperty(extra) && !map.hasOwnProperty(extra)) {
+                    // check before inserting to requestMap
+                    map[extra] = this.extras[extra];
+                }
+            }
+        }
+        return map;
+    };
+    return TokenRequest;
+}());
+TokenRequest_1 = token_request.TokenRequest = TokenRequest;
+
+var token_request_handler = {};
+
+var token_response = {};
+
+(function (exports) {
+	/*
+	 * Copyright 2017 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.
+	 */
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.TokenError = exports.TokenResponse = exports.nowInSeconds = void 0;
+	// constants
+	var AUTH_EXPIRY_BUFFER = 10 * 60 * -1; // 10 mins in seconds
+	/**
+	 * Returns the instant of time in seconds.
+	 */
+	var nowInSeconds = function () { return Math.round(new Date().getTime() / 1000); };
+	exports.nowInSeconds = nowInSeconds;
+	/**
+	 * Represents the Token Response type.
+	 * For more information look at:
+	 * https://tools.ietf.org/html/rfc6749#section-5.1
+	 */
+	var TokenResponse = /** @class */ (function () {
+	    function TokenResponse(response) {
+	        this.accessToken = response.access_token;
+	        this.tokenType = response.token_type || 'bearer';
+	        if (response.expires_in) {
+	            this.expiresIn = parseInt(response.expires_in, 10);
+	        }
+	        this.refreshToken = response.refresh_token;
+	        this.scope = response.scope;
+	        this.idToken = response.id_token;
+	        this.issuedAt = response.issued_at || exports.nowInSeconds();
+	    }
+	    TokenResponse.prototype.toJson = function () {
+	        var _a;
+	        return {
+	            access_token: this.accessToken,
+	            id_token: this.idToken,
+	            refresh_token: this.refreshToken,
+	            scope: this.scope,
+	            token_type: this.tokenType,
+	            issued_at: this.issuedAt,
+	            expires_in: (_a = this.expiresIn) === null || _a === void 0 ? void 0 : _a.toString()
+	        };
+	    };
+	    TokenResponse.prototype.isValid = function (buffer) {
+	        if (buffer === void 0) { buffer = AUTH_EXPIRY_BUFFER; }
+	        if (this.expiresIn) {
+	            var now = exports.nowInSeconds();
+	            return now < this.issuedAt + this.expiresIn + buffer;
+	        }
+	        else {
+	            return true;
+	        }
+	    };
+	    return TokenResponse;
+	}());
+	exports.TokenResponse = TokenResponse;
+	/**
+	 * Represents the Token Error type.
+	 * For more information look at:
+	 * https://tools.ietf.org/html/rfc6749#section-5.2
+	 */
+	var TokenError = /** @class */ (function () {
+	    function TokenError(tokenError) {
+	        this.error = tokenError.error;
+	        this.errorDescription = tokenError.error_description;
+	        this.errorUri = tokenError.error_uri;
+	    }
+	    TokenError.prototype.toJson = function () {
+	        return {
+	            error: this.error, error_description: this.errorDescription, error_uri: this.errorUri
+	        };
+	    };
+	    return TokenError;
+	}());
+	exports.TokenError = TokenError;
+	
+} (token_response));
+
+/*
+ * Copyright 2017 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.
+ */
+Object.defineProperty(token_request_handler, "__esModule", { value: true });
+token_request_handler.BaseTokenRequestHandler = void 0;
+var errors_1 = errors;
+var query_string_utils_1 = query_string_utils;
+var token_response_1 = token_response;
+var xhr_1 = xhr;
+/**
+ * The default token request handler.
+ */
+var BaseTokenRequestHandler = /** @class */ (function () {
+    function BaseTokenRequestHandler(requestor, utils) {
+        if (requestor === void 0) { requestor = new xhr_1.JQueryRequestor(); }
+        if (utils === void 0) { utils = new query_string_utils_1.BasicQueryStringUtils(); }
+        this.requestor = requestor;
+        this.utils = utils;
+    }
+    BaseTokenRequestHandler.prototype.isTokenResponse = function (response) {
+        return response.error === undefined;
+    };
+    BaseTokenRequestHandler.prototype.performRevokeTokenRequest = function (configuration, request) {
+        var revokeTokenResponse = this.requestor.xhr({
+            url: configuration.revocationEndpoint,
+            method: 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            data: this.utils.stringify(request.toStringMap())
+        });
+        return revokeTokenResponse.then(function (response) {
+            return true;
+        });
+    };
+    BaseTokenRequestHandler.prototype.performTokenRequest = function (configuration, request) {
+        var _this = this;
+        var tokenResponse = this.requestor.xhr({
+            url: configuration.tokenEndpoint,
+            method: 'POST',
+            dataType: 'json',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            data: this.utils.stringify(request.toStringMap())
+        });
+        return tokenResponse.then(function (response) {
+            if (_this.isTokenResponse(response)) {
+                return new token_response_1.TokenResponse(response);
+            }
+            else {
+                return Promise.reject(new errors_1.AppAuthError(response.error, new token_response_1.TokenError(response)));
+            }
+        });
+    };
+    return BaseTokenRequestHandler;
+}());
+token_request_handler.BaseTokenRequestHandler = BaseTokenRequestHandler;
+
+var types = {};
+
+/*
+ * Copyright 2017 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.
+ */
+Object.defineProperty(types, "__esModule", { value: true });
+
+(function (exports) {
+	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+	}) : (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    o[k2] = m[k];
+	}));
+	var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	__exportStar(authorization_request, exports);
+	__exportStar(authorization_request_handler, exports);
+	__exportStar(authorization_response, exports);
+	__exportStar(authorization_service_configuration, exports);
+	__exportStar(crypto_utils, exports);
+	__exportStar(errors, exports);
+	__exportStar(flags, exports);
+	__exportStar(logger, exports);
+	__exportStar(query_string_utils, exports);
+	__exportStar(redirect_based_handler, exports);
+	__exportStar(revoke_token_request, exports);
+	__exportStar(storage, exports);
+	__exportStar(token_request, exports);
+	__exportStar(token_request_handler, exports);
+	__exportStar(token_response, exports);
+	__exportStar(types, exports);
+	__exportStar(xhr, exports);
+	
+} (built));
+
+var AuthorizationNotifier = authorization_request_handler.AuthorizationNotifier;
+var BaseTokenRequestHandler$1 = built.BaseTokenRequestHandler;
+var BasicQueryStringUtils$1 = built.BasicQueryStringUtils;
+var FetchRequestor$1 = built.FetchRequestor;
+var LocalStorageBackend$1 = built.LocalStorageBackend;
+var RedirectRequestHandler$1 = built.RedirectRequestHandler;
+var TokenResponse = token_response.TokenResponse;
+export { AuthorizationNotifier, AuthorizationRequest_1 as AuthorizationRequest, AuthorizationServiceConfiguration_1 as AuthorizationServiceConfiguration, BaseTokenRequestHandler$1 as BaseTokenRequestHandler, BasicQueryStringUtils$1 as BasicQueryStringUtils, FetchRequestor$1 as FetchRequestor, GRANT_TYPE_AUTHORIZATION_CODE, GRANT_TYPE_REFRESH_TOKEN, LocalStorageBackend$1 as LocalStorageBackend, RedirectRequestHandler$1 as RedirectRequestHandler, TokenRequest_1 as TokenRequest, TokenResponse };