@auth0/auth0-spa-js
Version:
Auth0 SDK for Single Page Applications using Authorization Code Grant Flow with PKCE
1,216 lines (1,189 loc) • 408 kB
JavaScript
(function(global, factory) {
typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define([ "exports" ], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self,
factory(global.auth0 = {}));
})(this, function(exports) {
"use strict";
function __rest(s, e) {
var t = {};
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
}
return t;
}
typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
var e = new Error(message);
return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
};
function _OverloadYield(e, d) {
this.v = e, this.k = d;
}
function _arrayLikeToArray(r, a) {
(null == a || a > r.length) && (a = r.length);
for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
return n;
}
function _arrayWithHoles(r) {
if (Array.isArray(r)) return r;
}
function _assertClassBrand(e, t, n) {
if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
throw new TypeError("Private element is not present on this object");
}
function _awaitAsyncGenerator(e) {
return new _OverloadYield(e, 0);
}
function _checkPrivateRedeclaration(e, t) {
if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object");
}
function _classPrivateFieldGet2(s, a) {
return s.get(_assertClassBrand(s, a));
}
function _classPrivateFieldInitSpec(e, t, a) {
_checkPrivateRedeclaration(e, t), t.set(e, a);
}
function _classPrivateFieldSet2(s, a, r) {
return s.set(_assertClassBrand(s, a), r), r;
}
function _classPrivateMethodInitSpec(e, a) {
_checkPrivateRedeclaration(e, a), a.add(e);
}
function _defineProperty(e, r, t) {
return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
value: t,
enumerable: !0,
configurable: !0,
writable: !0
}) : e[r] = t, e;
}
function _iterableToArrayLimit(r, l) {
var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
if (null != t) {
var e, n, i, u, a = [], f = !0, o = !1;
try {
if (i = (t = t.call(r)).next, 0 === l) {
if (Object(t) !== t) return;
f = !1;
} else for (;!(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0) ;
} catch (r) {
o = !0, n = r;
} finally {
try {
if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
} finally {
if (o) throw n;
}
}
return a;
}
}
function _nonIterableRest() {
throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function ownKeys(e, r) {
var t = Object.keys(e);
if (Object.getOwnPropertySymbols) {
var o = Object.getOwnPropertySymbols(e);
r && (o = o.filter(function(r) {
return Object.getOwnPropertyDescriptor(e, r).enumerable;
})), t.push.apply(t, o);
}
return t;
}
function _objectSpread2(e) {
for (var r = 1; r < arguments.length; r++) {
var t = null != arguments[r] ? arguments[r] : {};
r % 2 ? ownKeys(Object(t), !0).forEach(function(r) {
_defineProperty(e, r, t[r]);
}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r) {
Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
});
}
return e;
}
function _objectWithoutProperties(e, t) {
if (null == e) return {};
var o, r, i = _objectWithoutPropertiesLoose(e, t);
if (Object.getOwnPropertySymbols) {
var n = Object.getOwnPropertySymbols(e);
for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
}
return i;
}
function _objectWithoutPropertiesLoose(r, e) {
if (null == r) return {};
var t = {};
for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
if (-1 !== e.indexOf(n)) continue;
t[n] = r[n];
}
return t;
}
function _slicedToArray(r, e) {
return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
}
function _toPrimitive(t, r) {
if ("object" != typeof t || !t) return t;
var e = t[Symbol.toPrimitive];
if (void 0 !== e) {
var i = e.call(t, r || "default");
if ("object" != typeof i) return i;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return ("string" === r ? String : Number)(t);
}
function _toPropertyKey(t) {
var i = _toPrimitive(t, "string");
return "symbol" == typeof i ? i : i + "";
}
function _unsupportedIterableToArray(r, a) {
if (r) {
if ("string" == typeof r) return _arrayLikeToArray(r, a);
var t = {}.toString.call(r).slice(8, -1);
return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
}
}
function _wrapAsyncGenerator(e) {
return function() {
return new AsyncGenerator(e.apply(this, arguments));
};
}
function AsyncGenerator(e) {
var t, n;
function resume(t, n) {
try {
var r = e[t](n), o = r.value, u = o instanceof _OverloadYield;
Promise.resolve(u ? o.v : o).then(function(n) {
if (u) {
var i = "return" === t && o.k ? t : "next";
if (!o.k || n.done) return resume(i, n);
n = e[i](n).value;
}
settle(!!r.done, n);
}, function(e) {
resume("throw", e);
});
} catch (e) {
settle(2, e);
}
}
function settle(e, r) {
2 === e ? t.reject(r) : t.resolve({
value: r,
done: e
}), (t = t.next) ? resume(t.key, t.arg) : n = null;
}
this._invoke = function(e, r) {
return new Promise(function(o, u) {
var i = {
key: e,
arg: r,
resolve: o,
reject: u,
next: null
};
n ? n = n.next = i : (t = n = i, resume(e, r));
});
}, "function" != typeof e.return && (this.return = void 0);
}
AsyncGenerator.prototype["function" == typeof Symbol && Symbol.asyncIterator || "@@asyncIterator"] = function() {
return this;
}, AsyncGenerator.prototype.next = function(e) {
return this._invoke("next", e);
}, AsyncGenerator.prototype.throw = function(e) {
return this._invoke("throw", e);
}, AsyncGenerator.prototype.return = function(e) {
return this._invoke("return", e);
};
var version = "2.19.3";
const DEFAULT_AUTHORIZE_TIMEOUT_IN_SECONDS = 60;
const DEFAULT_POPUP_CONFIG_OPTIONS = {
timeoutInSeconds: DEFAULT_AUTHORIZE_TIMEOUT_IN_SECONDS
};
const DEFAULT_SILENT_TOKEN_RETRY_COUNT = 3;
const CLEANUP_IFRAME_TIMEOUT_IN_SECONDS = 2;
const DEFAULT_FETCH_TIMEOUT_MS = 1e4;
const CACHE_LOCATION_MEMORY = "memory";
const MISSING_REFRESH_TOKEN_ERROR_MESSAGE = "Missing Refresh Token";
const INVALID_REFRESH_TOKEN_ERROR_MESSAGE = "invalid refresh token";
const USER_BLOCKED_ERROR_MESSAGE = "user is blocked";
const MFA_STEP_UP_ERROR_DESCRIPTION = "Multifactor authentication required";
const DEFAULT_SCOPE = "openid profile email";
const DEFAULT_SESSION_CHECK_EXPIRY_DAYS = 1;
const DEFAULT_AUTH0_CLIENT = {
name: "auth0-spa-js",
version: version
};
const DEFAULT_NOW_PROVIDER = () => Date.now();
const DEFAULT_AUDIENCE = "default";
class GenericError extends Error {
constructor(error, error_description) {
super(error_description);
this.error = error;
this.error_description = error_description;
Object.setPrototypeOf(this, GenericError.prototype);
}
static fromPayload(_ref) {
let error = _ref.error, error_description = _ref.error_description;
return new GenericError(error, error_description);
}
}
class AuthenticationError extends GenericError {
constructor(error, error_description, state) {
let appState = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
super(error, error_description);
this.state = state;
this.appState = appState;
Object.setPrototypeOf(this, AuthenticationError.prototype);
}
}
class ConnectError extends GenericError {
constructor(error, error_description, connection, state) {
let appState = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
super(error, error_description);
this.connection = connection;
this.state = state;
this.appState = appState;
Object.setPrototypeOf(this, ConnectError.prototype);
}
}
class TimeoutError extends GenericError {
constructor() {
super("timeout", "Timeout");
Object.setPrototypeOf(this, TimeoutError.prototype);
}
}
class PopupTimeoutError extends TimeoutError {
constructor(popup) {
super();
this.popup = popup;
Object.setPrototypeOf(this, PopupTimeoutError.prototype);
}
}
class PopupCancelledError extends GenericError {
constructor(popup) {
super("cancelled", "Popup closed");
this.popup = popup;
Object.setPrototypeOf(this, PopupCancelledError.prototype);
}
}
class PopupOpenError extends GenericError {
constructor() {
super("popup_open", "Unable to open a popup for loginWithPopup - window.open returned `null`");
Object.setPrototypeOf(this, PopupOpenError.prototype);
}
}
class MfaRequiredError extends GenericError {
constructor(error, error_description, mfa_token, mfa_requirements) {
super(error, error_description);
this.mfa_token = mfa_token;
this.mfa_requirements = mfa_requirements;
Object.setPrototypeOf(this, MfaRequiredError.prototype);
}
}
class MissingRefreshTokenError extends GenericError {
constructor(audience, scope) {
super("missing_refresh_token", "Missing Refresh Token (audience: '".concat(valueOrEmptyString(audience, [ "default" ]), "', scope: '").concat(valueOrEmptyString(scope), "')"));
this.audience = audience;
this.scope = scope;
Object.setPrototypeOf(this, MissingRefreshTokenError.prototype);
}
}
class MissingScopesError extends GenericError {
constructor(audience, scope) {
super("missing_scopes", "Missing requested scopes after refresh (audience: '".concat(valueOrEmptyString(audience, [ "default" ]), "', missing scope: '").concat(valueOrEmptyString(scope), "')"));
this.audience = audience;
this.scope = scope;
Object.setPrototypeOf(this, MissingScopesError.prototype);
}
}
class UseDpopNonceError extends GenericError {
constructor(newDpopNonce) {
super("use_dpop_nonce", "Server rejected DPoP proof: wrong nonce");
this.newDpopNonce = newDpopNonce;
Object.setPrototypeOf(this, UseDpopNonceError.prototype);
}
}
function valueOrEmptyString(value) {
let exclude = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
return value && !exclude.includes(value) ? value : "";
}
const parseAuthenticationResult = queryString => {
if (queryString.indexOf("#") > -1) {
queryString = queryString.substring(0, queryString.indexOf("#"));
}
const searchParams = new URLSearchParams(queryString);
return {
state: searchParams.get("state"),
code: searchParams.get("code") || undefined,
connect_code: searchParams.get("connect_code") || undefined,
error: searchParams.get("error") || undefined,
error_description: searchParams.get("error_description") || undefined
};
};
const runIframe = function runIframe(authorizeUrl, eventOrigin) {
let timeoutInSeconds = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : DEFAULT_AUTHORIZE_TIMEOUT_IN_SECONDS;
return new Promise((res, rej) => {
const iframe = window.document.createElement("iframe");
iframe.setAttribute("width", "0");
iframe.setAttribute("height", "0");
iframe.style.display = "none";
const removeIframe = () => {
if (window.document.body.contains(iframe)) {
window.document.body.removeChild(iframe);
window.removeEventListener("message", _iframeEventHandler, false);
}
};
let _iframeEventHandler;
const timeoutSetTimeoutId = setTimeout(() => {
rej(new TimeoutError);
removeIframe();
}, timeoutInSeconds * 1e3);
_iframeEventHandler = function iframeEventHandler(e) {
if (e.origin != eventOrigin) return;
if (!e.data || e.data.type !== "authorization_response") return;
const eventSource = e.source;
if (eventSource) {
eventSource.close();
}
e.data.response.error ? rej(GenericError.fromPayload(e.data.response)) : res(e.data.response);
clearTimeout(timeoutSetTimeoutId);
window.removeEventListener("message", _iframeEventHandler, false);
setTimeout(removeIframe, CLEANUP_IFRAME_TIMEOUT_IN_SECONDS * 1e3);
};
window.addEventListener("message", _iframeEventHandler, false);
window.document.body.appendChild(iframe);
iframe.setAttribute("src", authorizeUrl);
});
};
const openPopup = url => {
const width = 400;
const height = 600;
const left = window.screenX + (window.innerWidth - width) / 2;
const top = window.screenY + (window.innerHeight - height) / 2;
return window.open(url, "auth0:authorize:popup", "left=".concat(left, ",top=").concat(top, ",width=").concat(width, ",height=").concat(height, ",resizable,scrollbars=yes,status=1"));
};
const runPopup = (config, eventOrigin) => new Promise((resolve, reject) => {
let _popupEventListener;
const popupTimer = setInterval(() => {
if (config.popup && config.popup.closed) {
clearInterval(popupTimer);
clearTimeout(timeoutId);
window.removeEventListener("message", _popupEventListener, false);
reject(new PopupCancelledError(config.popup));
}
}, 1e3);
const timeoutId = setTimeout(() => {
clearInterval(popupTimer);
reject(new PopupTimeoutError(config.popup));
window.removeEventListener("message", _popupEventListener, false);
}, (config.timeoutInSeconds || DEFAULT_AUTHORIZE_TIMEOUT_IN_SECONDS) * 1e3);
_popupEventListener = function popupEventListener(e) {
if (e.origin !== eventOrigin) return;
if (!e.data || e.data.type !== "authorization_response") {
return;
}
clearTimeout(timeoutId);
clearInterval(popupTimer);
window.removeEventListener("message", _popupEventListener, false);
if (config.closePopup !== false) {
config.popup.close();
}
if (e.data.response.error) {
return reject(GenericError.fromPayload(e.data.response));
}
resolve(e.data.response);
};
window.addEventListener("message", _popupEventListener);
});
const getCrypto = () => window.crypto;
const createRandomString = () => {
const charset = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_~.";
const validMax = 256 - 256 % charset.length;
let random = "";
while (random.length < 43) {
const bytes = getCrypto().getRandomValues(new Uint8Array(43 - random.length));
for (const byte of bytes) {
if (random.length < 43 && byte < validMax) {
random += charset[byte % charset.length];
}
}
}
return random;
};
const encode$2 = value => btoa(value);
const stripUndefined = params => Object.keys(params).filter(k => typeof params[k] !== "undefined").reduce((acc, key) => Object.assign(Object.assign({}, acc), {
[key]: params[key]
}), {});
const ALLOWED_AUTH0CLIENT_PROPERTIES = [ {
key: "name",
type: [ "string" ]
}, {
key: "version",
type: [ "string", "number" ]
}, {
key: "env",
type: [ "object" ]
} ];
const stripAuth0Client = function stripAuth0Client(auth0Client) {
let excludeEnv = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
return Object.keys(auth0Client).reduce((acc, key) => {
if (excludeEnv && key === "env") {
return acc;
}
const allowedProperty = ALLOWED_AUTH0CLIENT_PROPERTIES.find(p => p.key === key);
if (allowedProperty && allowedProperty.type.includes(typeof auth0Client[key])) {
acc[key] = auth0Client[key];
}
return acc;
}, {});
};
const createQueryParams = _a => {
var client_id = _a.clientId, params = __rest(_a, [ "clientId" ]);
return new URLSearchParams(stripUndefined(Object.assign({
client_id: client_id
}, params))).toString();
};
const sha256 = async s => {
const digestOp = getCrypto().subtle.digest({
name: "SHA-256"
}, (new TextEncoder).encode(s));
return await digestOp;
};
const urlEncodeB64 = input => {
const b64Chars = {
"+": "-",
"/": "_",
"=": ""
};
return input.replace(/[+/=]/g, m => b64Chars[m]);
};
const decodeB64 = input => decodeURIComponent(atob(input).split("").map(c => "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2)).join(""));
const urlDecodeB64 = input => decodeB64(input.replace(/_/g, "/").replace(/-/g, "+"));
const bufferToBase64UrlEncoded = input => {
const ie11SafeInput = new Uint8Array(input);
return urlEncodeB64(window.btoa(String.fromCharCode(...Array.from(ie11SafeInput))));
};
const validateCrypto = () => {
if (!getCrypto()) {
throw new Error("For security reasons, `window.crypto` is required to run `auth0-spa-js`.");
}
if (typeof getCrypto().subtle === "undefined") {
throw new Error("\n auth0-spa-js must run on a secure origin. See https://github.com/auth0/auth0-spa-js/blob/main/FAQ.md#why-do-i-get-auth0-spa-js-must-run-on-a-secure-origin for more information.\n ");
}
};
const getDomain = domainUrl => {
if (!/^https?:\/\//.test(domainUrl)) {
return "https://".concat(domainUrl);
}
return domainUrl;
};
const getTokenIssuer = (issuer, domainUrl) => {
if (issuer) {
return issuer.startsWith("https://") ? issuer : "https://".concat(issuer, "/");
}
return "".concat(domainUrl, "/");
};
const parseNumber = value => {
if (typeof value !== "string") {
return value;
}
return parseInt(value, 10) || undefined;
};
const fromEntries = iterable => [ ...iterable ].reduce((obj, _ref) => {
let _ref2 = _slicedToArray(_ref, 2), key = _ref2[0], val = _ref2[1];
obj[key] = val;
return obj;
}, {});
var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
var browserTabsLock = {};
var processLock = {};
Object.defineProperty(processLock, "__esModule", {
value: true
});
var ProcessLocking = function() {
function ProcessLocking() {
var _this = this;
this.locked = new Map;
this.addToLocked = function(key, toAdd) {
var callbacks = _this.locked.get(key);
if (callbacks === undefined) {
if (toAdd === undefined) {
_this.locked.set(key, []);
} else {
_this.locked.set(key, [ toAdd ]);
}
} else {
if (toAdd !== undefined) {
callbacks.unshift(toAdd);
_this.locked.set(key, callbacks);
}
}
};
this.isLocked = function(key) {
return _this.locked.has(key);
};
this.lock = function(key) {
return new Promise(function(resolve, reject) {
if (_this.isLocked(key)) {
_this.addToLocked(key, resolve);
} else {
_this.addToLocked(key);
resolve();
}
});
};
this.unlock = function(key) {
var callbacks = _this.locked.get(key);
if (callbacks === undefined || callbacks.length === 0) {
_this.locked.delete(key);
return;
}
var toCall = callbacks.pop();
_this.locked.set(key, callbacks);
if (toCall !== undefined) {
setTimeout(toCall, 0);
}
};
}
ProcessLocking.getInstance = function() {
if (ProcessLocking.instance === undefined) {
ProcessLocking.instance = new ProcessLocking;
}
return ProcessLocking.instance;
};
return ProcessLocking;
}();
function getLock() {
return ProcessLocking.getInstance();
}
processLock.default = getLock;
var __awaiter = commonjsGlobal && commonjsGlobal.__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 = commonjsGlobal && commonjsGlobal.__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 = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y),
0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [ op[0] & 2, t.value ];
switch (op[0]) {
case 0:
case 1:
t = op;
break;
case 4:
_.label++;
return {
value: op[1],
done: false
};
case 5:
_.label++;
y = op[1];
op = [ 0 ];
continue;
case 7:
op = _.ops.pop();
_.trys.pop();
continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
_ = 0;
continue;
}
if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
_.label = op[1];
break;
}
if (op[0] === 6 && _.label < t[1]) {
_.label = t[1];
t = op;
break;
}
if (t && _.label < t[2]) {
_.label = t[2];
_.ops.push(op);
break;
}
if (t[2]) _.ops.pop();
_.trys.pop();
continue;
}
op = body.call(thisArg, _);
} catch (e) {
op = [ 6, e ];
y = 0;
} finally {
f = t = 0;
}
if (op[0] & 5) throw op[1];
return {
value: op[0] ? op[1] : void 0,
done: true
};
}
};
var _this = commonjsGlobal;
Object.defineProperty(browserTabsLock, "__esModule", {
value: true
});
var processLock_1 = processLock;
var LOCK_STORAGE_KEY = "browser-tabs-lock-key";
var DEFAULT_STORAGE_HANDLER = {
key: function(index) {
return __awaiter(_this, void 0, void 0, function() {
return __generator(this, function(_a) {
throw new Error("Unsupported");
});
});
},
getItem: function(key) {
return __awaiter(_this, void 0, void 0, function() {
return __generator(this, function(_a) {
throw new Error("Unsupported");
});
});
},
clear: function() {
return __awaiter(_this, void 0, void 0, function() {
return __generator(this, function(_a) {
return [ 2, window.localStorage.clear() ];
});
});
},
removeItem: function(key) {
return __awaiter(_this, void 0, void 0, function() {
return __generator(this, function(_a) {
throw new Error("Unsupported");
});
});
},
setItem: function(key, value) {
return __awaiter(_this, void 0, void 0, function() {
return __generator(this, function(_a) {
throw new Error("Unsupported");
});
});
},
keySync: function(index) {
return window.localStorage.key(index);
},
getItemSync: function(key) {
return window.localStorage.getItem(key);
},
clearSync: function() {
return window.localStorage.clear();
},
removeItemSync: function(key) {
return window.localStorage.removeItem(key);
},
setItemSync: function(key, value) {
return window.localStorage.setItem(key, value);
}
};
function delay(milliseconds) {
return new Promise(function(resolve) {
return setTimeout(resolve, milliseconds);
});
}
function generateRandomString(length) {
var CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz";
var randomstring = "";
for (var i = 0; i < length; i++) {
var INDEX = Math.floor(Math.random() * CHARS.length);
randomstring += CHARS[INDEX];
}
return randomstring;
}
function getLockId() {
return Date.now().toString() + generateRandomString(15);
}
var SuperTokensLock = function() {
function SuperTokensLock(storageHandler) {
this.acquiredIatSet = new Set;
this.storageHandler = undefined;
this.id = getLockId();
this.acquireLock = this.acquireLock.bind(this);
this.releaseLock = this.releaseLock.bind(this);
this.releaseLock__private__ = this.releaseLock__private__.bind(this);
this.waitForSomethingToChange = this.waitForSomethingToChange.bind(this);
this.refreshLockWhileAcquired = this.refreshLockWhileAcquired.bind(this);
this.storageHandler = storageHandler;
if (SuperTokensLock.waiters === undefined) {
SuperTokensLock.waiters = [];
}
}
SuperTokensLock.prototype.acquireLock = function(lockKey, timeout) {
if (timeout === void 0) {
timeout = 5e3;
}
return __awaiter(this, void 0, void 0, function() {
var iat, MAX_TIME, STORAGE_KEY, STORAGE, lockObj, TIMEOUT_KEY, lockObjPostDelay, parsedLockObjPostDelay;
return __generator(this, function(_a) {
switch (_a.label) {
case 0:
iat = Date.now() + generateRandomString(4);
MAX_TIME = Date.now() + timeout;
STORAGE_KEY = LOCK_STORAGE_KEY + "-" + lockKey;
STORAGE = this.storageHandler === undefined ? DEFAULT_STORAGE_HANDLER : this.storageHandler;
_a.label = 1;
case 1:
if (!(Date.now() < MAX_TIME)) return [ 3, 8 ];
return [ 4, delay(30) ];
case 2:
_a.sent();
lockObj = STORAGE.getItemSync(STORAGE_KEY);
if (!(lockObj === null)) return [ 3, 5 ];
TIMEOUT_KEY = this.id + "-" + lockKey + "-" + iat;
return [ 4, delay(Math.floor(Math.random() * 25)) ];
case 3:
_a.sent();
STORAGE.setItemSync(STORAGE_KEY, JSON.stringify({
id: this.id,
iat: iat,
timeoutKey: TIMEOUT_KEY,
timeAcquired: Date.now(),
timeRefreshed: Date.now()
}));
return [ 4, delay(30) ];
case 4:
_a.sent();
lockObjPostDelay = STORAGE.getItemSync(STORAGE_KEY);
if (lockObjPostDelay !== null) {
parsedLockObjPostDelay = JSON.parse(lockObjPostDelay);
if (parsedLockObjPostDelay.id === this.id && parsedLockObjPostDelay.iat === iat) {
this.acquiredIatSet.add(iat);
this.refreshLockWhileAcquired(STORAGE_KEY, iat);
return [ 2, true ];
}
}
return [ 3, 7 ];
case 5:
SuperTokensLock.lockCorrector(this.storageHandler === undefined ? DEFAULT_STORAGE_HANDLER : this.storageHandler);
return [ 4, this.waitForSomethingToChange(MAX_TIME) ];
case 6:
_a.sent();
_a.label = 7;
case 7:
iat = Date.now() + generateRandomString(4);
return [ 3, 1 ];
case 8:
return [ 2, false ];
}
});
});
};
SuperTokensLock.prototype.refreshLockWhileAcquired = function(storageKey, iat) {
return __awaiter(this, void 0, void 0, function() {
var _this = this;
return __generator(this, function(_a) {
setTimeout(function() {
return __awaiter(_this, void 0, void 0, function() {
var STORAGE, lockObj, parsedLockObj;
return __generator(this, function(_a) {
switch (_a.label) {
case 0:
return [ 4, processLock_1.default().lock(iat) ];
case 1:
_a.sent();
if (!this.acquiredIatSet.has(iat)) {
processLock_1.default().unlock(iat);
return [ 2 ];
}
STORAGE = this.storageHandler === undefined ? DEFAULT_STORAGE_HANDLER : this.storageHandler;
lockObj = STORAGE.getItemSync(storageKey);
if (lockObj !== null) {
parsedLockObj = JSON.parse(lockObj);
parsedLockObj.timeRefreshed = Date.now();
STORAGE.setItemSync(storageKey, JSON.stringify(parsedLockObj));
processLock_1.default().unlock(iat);
} else {
processLock_1.default().unlock(iat);
return [ 2 ];
}
this.refreshLockWhileAcquired(storageKey, iat);
return [ 2 ];
}
});
});
}, 1e3);
return [ 2 ];
});
});
};
SuperTokensLock.prototype.waitForSomethingToChange = function(MAX_TIME) {
return __awaiter(this, void 0, void 0, function() {
return __generator(this, function(_a) {
switch (_a.label) {
case 0:
return [ 4, new Promise(function(resolve) {
var resolvedCalled = false;
var startedAt = Date.now();
var MIN_TIME_TO_WAIT = 50;
var removedListeners = false;
function stopWaiting() {
if (!removedListeners) {
window.removeEventListener("storage", stopWaiting);
SuperTokensLock.removeFromWaiting(stopWaiting);
clearTimeout(timeOutId);
removedListeners = true;
}
if (!resolvedCalled) {
resolvedCalled = true;
var timeToWait = MIN_TIME_TO_WAIT - (Date.now() - startedAt);
if (timeToWait > 0) {
setTimeout(resolve, timeToWait);
} else {
resolve(null);
}
}
}
window.addEventListener("storage", stopWaiting);
SuperTokensLock.addToWaiting(stopWaiting);
var timeOutId = setTimeout(stopWaiting, Math.max(0, MAX_TIME - Date.now()));
}) ];
case 1:
_a.sent();
return [ 2 ];
}
});
});
};
SuperTokensLock.addToWaiting = function(func) {
this.removeFromWaiting(func);
if (SuperTokensLock.waiters === undefined) {
return;
}
SuperTokensLock.waiters.push(func);
};
SuperTokensLock.removeFromWaiting = function(func) {
if (SuperTokensLock.waiters === undefined) {
return;
}
SuperTokensLock.waiters = SuperTokensLock.waiters.filter(function(i) {
return i !== func;
});
};
SuperTokensLock.notifyWaiters = function() {
if (SuperTokensLock.waiters === undefined) {
return;
}
var waiters = SuperTokensLock.waiters.slice();
waiters.forEach(function(i) {
return i();
});
};
SuperTokensLock.prototype.releaseLock = function(lockKey) {
return __awaiter(this, void 0, void 0, function() {
return __generator(this, function(_a) {
switch (_a.label) {
case 0:
return [ 4, this.releaseLock__private__(lockKey) ];
case 1:
return [ 2, _a.sent() ];
}
});
});
};
SuperTokensLock.prototype.releaseLock__private__ = function(lockKey) {
return __awaiter(this, void 0, void 0, function() {
var STORAGE, STORAGE_KEY, lockObj, parsedlockObj;
return __generator(this, function(_a) {
switch (_a.label) {
case 0:
STORAGE = this.storageHandler === undefined ? DEFAULT_STORAGE_HANDLER : this.storageHandler;
STORAGE_KEY = LOCK_STORAGE_KEY + "-" + lockKey;
lockObj = STORAGE.getItemSync(STORAGE_KEY);
if (lockObj === null) {
return [ 2 ];
}
parsedlockObj = JSON.parse(lockObj);
if (!(parsedlockObj.id === this.id)) return [ 3, 2 ];
return [ 4, processLock_1.default().lock(parsedlockObj.iat) ];
case 1:
_a.sent();
this.acquiredIatSet.delete(parsedlockObj.iat);
STORAGE.removeItemSync(STORAGE_KEY);
processLock_1.default().unlock(parsedlockObj.iat);
SuperTokensLock.notifyWaiters();
_a.label = 2;
case 2:
return [ 2 ];
}
});
});
};
SuperTokensLock.lockCorrector = function(storageHandler) {
var MIN_ALLOWED_TIME = Date.now() - 5e3;
var STORAGE = storageHandler;
var KEYS = [];
var currIndex = 0;
while (true) {
var key = STORAGE.keySync(currIndex);
if (key === null) {
break;
}
KEYS.push(key);
currIndex++;
}
var notifyWaiters = false;
for (var i = 0; i < KEYS.length; i++) {
var LOCK_KEY = KEYS[i];
if (LOCK_KEY.includes(LOCK_STORAGE_KEY)) {
var lockObj = STORAGE.getItemSync(LOCK_KEY);
if (lockObj !== null) {
var parsedlockObj = JSON.parse(lockObj);
if (parsedlockObj.timeRefreshed === undefined && parsedlockObj.timeAcquired < MIN_ALLOWED_TIME || parsedlockObj.timeRefreshed !== undefined && parsedlockObj.timeRefreshed < MIN_ALLOWED_TIME) {
STORAGE.removeItemSync(LOCK_KEY);
notifyWaiters = true;
}
}
}
}
if (notifyWaiters) {
SuperTokensLock.notifyWaiters();
}
};
SuperTokensLock.waiters = undefined;
return SuperTokensLock;
}();
var _default = browserTabsLock.default = SuperTokensLock;
class WebLocksApiManager {
async runWithLock(key, timeout, callback) {
const controller = new AbortController;
const timeoutId = setTimeout(() => controller.abort(), timeout);
try {
return await navigator.locks.request(key, {
mode: "exclusive",
signal: controller.signal
}, async lock => {
clearTimeout(timeoutId);
if (!lock) throw new Error("Lock not available");
return await callback();
});
} catch (error) {
clearTimeout(timeoutId);
if ((error === null || error === void 0 ? void 0 : error.name) === "AbortError") throw new TimeoutError;
throw error;
}
}
}
class LegacyLockManager {
constructor() {
this.activeLocks = new Set;
this.lock = new _default;
this.pagehideHandler = () => {
this.activeLocks.forEach(key => this.lock.releaseLock(key));
this.activeLocks.clear();
};
}
async runWithLock(key, timeout, callback) {
const retryAttempts = 10;
let acquired = false;
for (let i = 0; i < retryAttempts && !acquired; i++) {
acquired = await this.lock.acquireLock(key, timeout);
}
if (!acquired) {
throw new TimeoutError;
}
this.activeLocks.add(key);
if (this.activeLocks.size === 1 && typeof window !== "undefined") {
window.addEventListener("pagehide", this.pagehideHandler);
}
try {
return await callback();
} finally {
this.activeLocks.delete(key);
await this.lock.releaseLock(key);
if (this.activeLocks.size === 0 && typeof window !== "undefined") {
window.removeEventListener("pagehide", this.pagehideHandler);
}
}
}
}
function isWebLocksSupported() {
var _a;
return typeof navigator !== "undefined" && typeof ((_a = navigator.locks) === null || _a === void 0 ? void 0 : _a.request) === "function";
}
function createLockManager() {
return isWebLocksSupported() ? new WebLocksApiManager : new LegacyLockManager;
}
let lockManager = null;
function getLockManager() {
if (!lockManager) {
lockManager = createLockManager();
}
return lockManager;
}
const encoder$2 = new TextEncoder;
const decoder$2 = new TextDecoder;
function buf$1(input) {
if (typeof input === "string") {
return encoder$2.encode(input);
}
return decoder$2.decode(input);
}
function checkRsaKeyAlgorithm$1(algorithm) {
if (typeof algorithm.modulusLength !== "number" || algorithm.modulusLength < 2048) {
throw new OperationProcessingError$1(`${algorithm.name} modulusLength must be at least 2048 bits`);
}
}
function subtleAlgorithm$1(key) {
switch (key.algorithm.name) {
case "ECDSA":
return {
name: key.algorithm.name,
hash: "SHA-256"
};
case "RSA-PSS":
checkRsaKeyAlgorithm$1(key.algorithm);
return {
name: key.algorithm.name,
saltLength: 256 >> 3
};
case "RSASSA-PKCS1-v1_5":
checkRsaKeyAlgorithm$1(key.algorithm);
return {
name: key.algorithm.name
};
case "Ed25519":
return {
name: key.algorithm.name
};
}
throw new UnsupportedOperationError$1;
}
async function jwt(header, claimsSet, key) {
if (key.usages.includes("sign") === false) {
throw new TypeError('private CryptoKey instances used for signing assertions must include "sign" in their "usages"');
}
const input = `${b64u$1(buf$1(JSON.stringify(header)))}.${b64u$1(buf$1(JSON.stringify(claimsSet)))}`;
const signature = b64u$1(await crypto.subtle.sign(subtleAlgorithm$1(key), key, buf$1(input)));
return `${input}.${signature}`;
}
let encodeBase64Url$1;
if (Uint8Array.prototype.toBase64) {
encodeBase64Url$1 = input => {
if (input instanceof ArrayBuffer) {
input = new Uint8Array(input);
}
return input.toBase64({
alphabet: "base64url",
omitPadding: true
});
};
} else {
const CHUNK_SIZE = 32768;
encodeBase64Url$1 = input => {
if (input instanceof ArrayBuffer) {
input = new Uint8Array(input);
}
const arr = [];
for (let i = 0; i < input.byteLength; i += CHUNK_SIZE) {
arr.push(String.fromCharCode.apply(null, input.subarray(i, i + CHUNK_SIZE)));
}
return btoa(arr.join("")).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
};
}
function b64u$1(input) {
return encodeBase64Url$1(input);
}
class UnsupportedOperationError$1 extends Error {
constructor(message) {
var _a;
super(message !== null && message !== void 0 ? message : "operation not supported");
this.name = this.constructor.name;
(_a = Error.captureStackTrace) === null || _a === void 0 ? void 0 : _a.call(Error, this, this.constructor);
}
}
class OperationProcessingError$1 extends Error {
constructor(message) {
var _a;
super(message);
this.name = this.constructor.name;
(_a = Error.captureStackTrace) === null || _a === void 0 ? void 0 : _a.call(Error, this, this.constructor);
}
}
function psAlg$1(key) {
switch (key.algorithm.hash.name) {
case "SHA-256":
return "PS256";
default:
throw new UnsupportedOperationError$1("unsupported RsaHashedKeyAlgorithm hash name");
}
}
function rsAlg$1(key) {
switch (key.algorithm.hash.name) {
case "SHA-256":
return "RS256";
default:
throw new UnsupportedOperationError$1("unsupported RsaHashedKeyAlgorithm hash name");
}
}
function esAlg$1(key) {
switch (key.algorithm.namedCurve) {
case "P-256":
return "ES256";
default:
throw new UnsupportedOperationError$1("unsupported EcKeyAlgorithm namedCurve");
}
}
function determineJWSAlgorithm(key) {
switch (key.algorithm.name) {
case "RSA-PSS":
return psAlg$1(key);
case "RSASSA-PKCS1-v1_5":
return rsAlg$1(key);
case "ECDSA":
return esAlg$1(key);
case "Ed25519":
return "Ed25519";
default:
throw new UnsupportedOperationError$1("unsupported CryptoKey algorithm name");
}
}
function isCryptoKey