{"version":3,"sources":["jsdelivr-header.js","/npm/browser-tabs-lock@1.3.0/index.js"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA,ACNA,aACA,IAAI,UAAa,MAAQ,KAAK,WAAc,SAAU,EAAS,EAAY,EAAG,GAC1E,OAAO,IAAK,IAAM,EAAI,WAAU,SAAU,EAAS,GAC/C,SAAS,EAAU,GAAS,IAAM,EAAK,EAAU,KAAK,GAAS,CAAE,MAAO,GAAK,EAAO,EAAI,CAAE,CAC1F,SAAS,EAAS,GAAS,IAAM,EAAK,EAAiB,MAAE,GAAS,CAAE,MAAO,GAAK,EAAO,EAAI,CAAE,CAC7F,SAAS,EAAK,GAAU,EAAO,KAAO,EAAQ,EAAO,OAAS,IAAI,GAAE,SAAU,GAAW,EAAQ,EAAO,MAAQ,IAAG,KAAK,EAAW,EAAW,CAC9I,GAAM,EAAY,EAAU,MAAM,EAAS,GAAc,KAAK,OAClE,GACJ,EACI,YAAe,MAAQ,KAAK,aAAgB,SAAU,EAAS,GAC/D,IAAsG,EAAG,EAAG,EAAG,EAA3G,EAAI,CAAE,MAAO,EAAG,KAAM,WAAa,GAAW,EAAP,EAAE,GAAQ,MAAM,EAAE,GAAI,OAAO,EAAE,EAAI,EAAG,KAAM,GAAI,IAAK,IAChG,OAAO,EAAI,CAAE,KAAM,EAAK,GAAI,MAAS,EAAK,GAAI,OAAU,EAAK,IAAwB,mBAAX,SAA0B,EAAE,OAAO,UAAY,WAAa,OAAO,IAAM,GAAI,EACvJ,SAAS,EAAK,GAAK,OAAO,SAAU,GAAK,OACzC,SAAc,GACV,GAAI,EAAG,MAAM,IAAI,UAAU,mCAC3B,KAAO,OACH,GAAI,EAAI,EAAG,IAAM,EAAY,EAAR,EAAG,GAAS,EAAU,OAAI,EAAG,GAAK,EAAS,SAAO,EAAI,EAAU,SAAM,EAAE,KAAK,GAAI,GAAK,EAAE,SAAW,EAAI,EAAE,KAAK,EAAG,EAAG,KAAK,KAAM,OAAO,EAE3J,OADI,EAAI,EAAG,IAAG,EAAK,CAAS,EAAR,EAAG,GAAQ,EAAE,QACzB,EAAG,IACP,KAAK,EAAG,KAAK,EAAG,EAAI,EAAI,MACxB,KAAK,EAAc,OAAX,EAAE,QAAgB,CAAE,MAAO,EAAG,GAAI,MAAM,GAChD,KAAK,EAAG,EAAE,QAAS,EAAI,EAAG,GAAI,EAAK,CAAC,GAAI,SACxC,KAAK,EAAG,EAAK,EAAE,IAAI,MAAO,EAAE,KAAK,MAAO,SACxC,QACI,KAAM,EAAI,EAAE,MAAM,EAAI,EAAE,OAAS,GAAK,EAAE,EAAE,OAAS,KAAkB,IAAV,EAAG,IAAsB,IAAV,EAAG,IAAW,CAAE,EAAI,EAAG,QAAU,CAC3G,GAAc,IAAV,EAAG,MAAc,GAAM,EAAG,GAAK,EAAE,IAAM,EAAG,GAAK,EAAE,IAAM,CAAE,EAAE,MAAQ,EAAG,GAAI,KAAO,CACrF,GAAc,IAAV,EAAG,IAAY,EAAE,MAAQ,EAAE,GAAI,CAAE,EAAE,MAAQ,EAAE,GAAI,EAAI,EAAI,KAAO,CACpE,GAAI,GAAK,EAAE,MAAQ,EAAE,GAAI,CAAE,EAAE,MAAQ,EAAE,GAAI,EAAE,IAAI,KAAK,GAAK,KAAO,CAC9D,EAAE,IAAI,EAAE,IAAI,MAChB,EAAE,KAAK,MAAO,SAEtB,EAAK,EAAK,KAAK,EAAS,EAC5B,CAAE,MAAO,GAAK,EAAK,CAAC,EAAG,GAAI,EAAI,CAAG,CAAE,QAAU,EAAI,EAAI,CAAG,CACzD,GAAY,EAAR,EAAG,GAAQ,MAAM,EAAG,GAAI,MAAO,CAAE,MAAO,EAAG,GAAK,EAAG,QAAK,EAAQ,MAAM,EAC9E,CAtBgD,CAAK,CAAC,EAAG,GAAK,CAAG,CAuBrE,EACI,MAAQ,KACZ,OAAO,eAAe,QAAS,aAAc,CAAE,OAAO,IACtD,IAAI,cAAgB,QAAQ,iBAiBxB,iBAAmB,wBACnB,wBAA0B,CAC1B,IAAK,SAAU,GAAS,OAAO,UAAU,WAAO,OAAQ,GAAQ,WAC5D,OAAO,YAAY,MAAM,SAAU,GAC/B,MAAM,IAAI,MAAM,cACpB,GACJ,GAAI,EACJ,QAAS,SAAU,GAAO,OAAO,UAAU,WAAO,OAAQ,GAAQ,WAC9D,OAAO,YAAY,MAAM,SAAU,GAC/B,MAAM,IAAI,MAAM,cACpB,GACJ,GAAI,EACJ,MAAO,WAAc,OAAO,UAAU,WAAO,OAAQ,GAAQ,WACzD,OAAO,YAAY,MAAM,SAAU,GAC/B,MAAO,CAAC,EAAc,OAAO,aAAa,QAC9C,GACJ,GAAI,EACJ,WAAY,SAAU,GAAO,OAAO,UAAU,WAAO,OAAQ,GAAQ,WACjE,OAAO,YAAY,MAAM,SAAU,GAC/B,MAAM,IAAI,MAAM,cACpB,GACJ,GAAI,EACJ,QAAS,SAAU,EAAK,GAAS,OAAO,UAAU,WAAO,OAAQ,GAAQ,WACrE,OAAO,YAAY,MAAM,SAAU,GAC/B,MAAM,IAAI,MAAM,cACpB,GACJ,GAAI,EACJ,QAAS,SAAU,GACf,OAAO,OAAO,aAAa,IAAI,EACnC,EACA,YAAa,SAAU,GACnB,OAAO,OAAO,aAAa,QAAQ,EACvC,EACA,UAAW,WACP,OAAO,OAAO,aAAa,OAC/B,EACA,eAAgB,SAAU,GACtB,OAAO,OAAO,aAAa,WAAW,EAC1C,EACA,YAAa,SAAU,EAAK,GACxB,OAAO,OAAO,aAAa,QAAQ,EAAK,EAC5C,GAOJ,SAAS,MAAM,GACX,OAAO,IAAI,SAAQ,SAAU,GAAW,OAAO,WAAW,EAAS,EAAe,GACtF,CAOA,SAAS,qBAAqB,GAG1B,IAFA,IAAI,EAAQ,gEACR,EAAe,GACV,EAAI,EAAG,EAAI,EAAQ,IAAK,CAE7B,GAAgB,EADJ,KAAK,MAAsB,GAAhB,KAAK,UAEhC,CACA,OAAO,CACX,CAMA,SAAS,YACL,OAAO,KAAK,MAAM,WAAa,qBAAqB,GACxD,CACA,IAAI,gBAAiC,WACjC,SAAS,EAAgB,GACrB,KAAK,eAAiB,IAAI,IAC1B,KAAK,oBAAiB,EACtB,KAAK,GAAK,YACV,KAAK,YAAc,KAAK,YAAY,KAAK,MACzC,KAAK,YAAc,KAAK,YAAY,KAAK,MACzC,KAAK,uBAAyB,KAAK,uBAAuB,KAAK,MAC/D,KAAK,yBAA2B,KAAK,yBAAyB,KAAK,MACnE,KAAK,yBAA2B,KAAK,yBAAyB,KAAK,MACnE,KAAK,eAAiB,OACU,IAA5B,EAAgB,UAChB,EAAgB,QAAU,GAElC,CA8PA,OAnPA,EAAgB,UAAU,YAAc,SAAU,EAAS,GAEvD,YADgB,IAAZ,IAAsB,EAAU,KAC7B,UAAU,UAAM,OAAQ,GAAQ,WACnC,IAAI,EAAK,EAAU,EAAa,EAAkB,EAAa,EAAkB,EACjF,OAAO,YAAY,MAAM,SAAU,GAC/B,OAAQ,EAAG,OACP,KAAK,EACD,EAAM,KAAK,MAAQ,qBAAqB,GACxC,EAAW,KAAK,MAAQ,EACxB,EAAc,iBAAmB,IAAM,EACvC,OAAkC,IAAxB,KAAK,eAA+B,wBAA0B,KAAK,eAC7E,EAAG,MAAQ,EACf,KAAK,EACD,OAAM,KAAK,MAAQ,EACZ,CAAC,EAAa,MAAM,KADU,CAAC,EAAa,GAEvD,KAAK,EAGD,OAFA,EAAG,OAEe,OADR,EAAQ,YAAY,GACE,CAAC,EAAa,IAC9C,EAAc,KAAK,GAAK,IAAM,EAAU,IAAM,EAEvC,CAAC,EAAa,MAAM,KAAK,MAAsB,GAAhB,KAAK,aAC/C,KAAK,EAUD,OARA,EAAG,OACH,EAAQ,YAAY,EAAa,KAAK,UAAU,CAC5C,GAAI,KAAK,GACT,IAAK,EACL,WAAY,EACZ,aAAc,KAAK,MACnB,cAAe,KAAK,SAEjB,CAAC,EAAa,MAAM,KAC/B,KAAK,EAGD,OAFA,EAAG,OAEsB,QADzB,EAAmB,EAAQ,YAAY,MAEnC,EAAyB,KAAK,MAAM,IACT,KAAO,KAAK,IAAM,EAAuB,MAAQ,GACxE,KAAK,eAAe,IAAI,GACxB,KAAK,yBAAyB,EAAa,GACpC,CAAC,GAAc,IAGvB,CAAC,EAAa,GACzB,KAAK,EAED,OADA,EAAgB,mBAAsC,IAAxB,KAAK,eAA+B,wBAA0B,KAAK,gBAC1F,CAAC,EAAa,KAAK,yBAAyB,IACvD,KAAK,EACD,EAAG,OACH,EAAG,MAAQ,EACf,KAAK,EAED,OADA,EAAM,KAAK,MAAQ,qBAAqB,GACjC,CAAC,EAAa,GACzB,KAAK,EAAG,MAAO,CAAC,GAAc,GAEtC,GACJ,GACJ,EACA,EAAgB,UAAU,yBAA2B,SAAU,EAAY,GACvE,OAAO,UAAU,UAAM,OAAQ,GAAQ,WACnC,IAAI,EAAQ,KACZ,OAAO,YAAY,MAAM,SAAU,GA6B/B,OA5BA,YAAW,WAAc,OAAO,UAAU,OAAO,OAAQ,GAAQ,WAC7D,IAAI,EAAS,EAAS,EACtB,OAAO,YAAY,MAAM,SAAU,GAC/B,OAAQ,EAAG,OACP,KAAK,EAAG,MAAO,CAAC,EAAa,cAAc,UAAU,KAAK,IAC1D,KAAK,EAED,OADA,EAAG,OACE,KAAK,eAAe,IAAI,IAI7B,OAAkC,IAAxB,KAAK,eAA+B,wBAA0B,KAAK,eAE7D,QADhB,EAAU,EAAQ,YAAY,KAQ1B,cAAc,UAAU,OAAO,GACxB,CAAC,MAPR,EAAgB,KAAK,MAAM,IACb,cAAgB,KAAK,MACnC,EAAQ,YAAY,EAAY,KAAK,UAAU,IAC/C,cAAc,UAAU,OAAO,GAMnC,KAAK,yBAAyB,EAAY,GACnC,CAAC,MAhBJ,cAAc,UAAU,OAAO,GACxB,CAAC,IAiBxB,GACJ,GAAI,GAAG,KACA,CAAC,EACZ,GACJ,GACJ,EACA,EAAgB,UAAU,yBAA2B,SAAU,GAC3D,OAAO,UAAU,UAAM,OAAQ,GAAQ,WACnC,OAAO,YAAY,MAAM,SAAU,GAC/B,OAAQ,EAAG,OACP,KAAK,EAAG,MAAO,CAAC,EAAa,IAAI,SAAQ,SAAU,GAC3C,IAAI,GAAiB,EACjB,EAAY,KAAK,MAEjB,GAAmB,EACvB,SAAS,IAOL,GANK,IACD,OAAO,oBAAoB,UAAW,GACtC,EAAgB,kBAAkB,GAClC,aAAa,GACb,GAAmB,IAElB,EAAgB,CACjB,GAAiB,EACjB,IAAI,EAXW,IAWsB,KAAK,MAAQ,GAC9C,EAAa,EACb,WAAW,EAAS,GAGpB,EAAQ,KAEhB,CACJ,CACA,OAAO,iBAAiB,UAAW,GACnC,EAAgB,aAAa,GAC7B,IAAI,EAAY,WAAW,EAAa,KAAK,IAAI,EAAG,EAAW,KAAK,OACxE,KACJ,KAAK,EAED,OADA,EAAG,OACI,CAAC,GAEpB,GACJ,GACJ,EACA,EAAgB,aAAe,SAAU,GACrC,KAAK,kBAAkB,QACS,IAA5B,EAAgB,SAGpB,EAAgB,QAAQ,KAAK,EACjC,EACA,EAAgB,kBAAoB,SAAU,QACV,IAA5B,EAAgB,UAGpB,EAAgB,QAAU,EAAgB,QAAQ,QAAO,SAAU,GAAK,OAAO,IAAM,CAAM,IAC/F,EACA,EAAgB,cAAgB,gBACI,IAA5B,EAAgB,SAGN,EAAgB,QAAQ,QAC9B,SAAQ,SAAU,GAAK,OAAO,GAAK,GAC/C,EAQA,EAAgB,UAAU,YAAc,SAAU,GAC9C,OAAO,UAAU,UAAM,OAAQ,GAAQ,WACnC,OAAO,YAAY,MAAM,SAAU,GAC/B,OAAQ,EAAG,OACP,KAAK,EAAG,MAAO,CAAC,EAAa,KAAK,uBAAuB,IACzD,KAAK,EAAG,MAAO,CAAC,EAAc,EAAG,QAEzC,GACJ,GACJ,EAQA,EAAgB,UAAU,uBAAyB,SAAU,GACzD,OAAO,UAAU,UAAM,OAAQ,GAAQ,WACnC,IAAI,EAAS,EAAa,EAAS,EACnC,OAAO,YAAY,MAAM,SAAU,GAC/B,OAAQ,EAAG,OACP,KAAK,EAID,OAHA,OAAkC,IAAxB,KAAK,eAA+B,wBAA0B,KAAK,eAC7E,EAAc,iBAAmB,IAAM,EAEvB,QADhB,EAAU,EAAQ,YAAY,IAEnB,CAAC,IAEZ,EAAgB,KAAK,MAAM,IACP,KAAO,KAAK,GAAY,CAAC,EAAa,GACnD,CAAC,EAAa,cAAc,UAAU,KAAK,EAAc,MACpE,KAAK,EACD,EAAG,OACH,KAAK,eAAe,OAAO,EAAc,KACzC,EAAQ,eAAe,GACvB,cAAc,UAAU,OAAO,EAAc,KAC7C,EAAgB,gBAChB,EAAG,MAAQ,EACf,KAAK,EAAG,MAAO,CAAC,GAExB,GACJ,GACJ,EAOA,EAAgB,cAAgB,SAAU,GAKtC,IAJA,IAAI,EAAmB,KAAK,MAAQ,IAChC,EAAU,EACV,EAAO,GACP,EAAY,IACH,CACT,IAAI,EAAM,EAAQ,QAAQ,GAC1B,GAAY,OAAR,EACA,MAEJ,EAAK,KAAK,GACV,GACJ,CAEA,IADA,IAAI,GAAgB,EACX,EAAI,EAAG,EAAI,EAAK,OAAQ,IAAK,CAClC,IAAI,EAAW,EAAK,GACpB,GAAI,EAAS,SAAS,kBAAmB,CACrC,IAAI,EAAU,EAAQ,YAAY,GAClC,GAAgB,OAAZ,EAAkB,CAClB,IAAI,EAAgB,KAAK,MAAM,SACM,IAAhC,EAAc,eAA+B,EAAc,aAAe,QAC1C,IAAhC,EAAc,eAA+B,EAAc,cAAgB,KAC5E,EAAQ,eAAe,GACvB,GAAgB,EAExB,CACJ,CACJ,CACI,GACA,EAAgB,eAExB,EACA,EAAgB,aAAU,EACnB,CACX,CA7QoC,GA8QpC,QAAQ,QAAU","file":"/npm/browser-tabs-lock@1.3.0/index.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/browser-tabs-lock@1.3.0/index.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","\"use strict\";\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (_) try {\n            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;\n            if (y = 0, t) op = [op[0] & 2, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\nvar _this = this;\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar processLock_1 = require(\"./processLock\");\n/**\n * @author: SuperTokens (https://github.com/supertokens)\n * This library was created as a part of a larger project, SuperTokens(https://supertokens.io) - the best session management solution.\n * You can also check out our other projects on https://github.com/supertokens\n *\n * To contribute to this package visit https://github.com/supertokens/browser-tabs-lock\n * If you face any problems you can file an issue on https://github.com/supertokens/browser-tabs-lock/issues\n *\n * If you have any questions or if you just want to say hi visit https://supertokens.io/discord\n */\n/**\n * @constant\n * @type {string}\n * @default\n * @description All the locks taken by this package will have this as prefix\n*/\nvar LOCK_STORAGE_KEY = 'browser-tabs-lock-key';\nvar DEFAULT_STORAGE_HANDLER = {\n    key: function (index) { return __awaiter(_this, void 0, void 0, function () {\n        return __generator(this, function (_a) {\n            throw new Error(\"Unsupported\");\n        });\n    }); },\n    getItem: function (key) { return __awaiter(_this, void 0, void 0, function () {\n        return __generator(this, function (_a) {\n            throw new Error(\"Unsupported\");\n        });\n    }); },\n    clear: function () { return __awaiter(_this, void 0, void 0, function () {\n        return __generator(this, function (_a) {\n            return [2 /*return*/, window.localStorage.clear()];\n        });\n    }); },\n    removeItem: function (key) { return __awaiter(_this, void 0, void 0, function () {\n        return __generator(this, function (_a) {\n            throw new Error(\"Unsupported\");\n        });\n    }); },\n    setItem: function (key, value) { return __awaiter(_this, void 0, void 0, function () {\n        return __generator(this, function (_a) {\n            throw new Error(\"Unsupported\");\n        });\n    }); },\n    keySync: function (index) {\n        return window.localStorage.key(index);\n    },\n    getItemSync: function (key) {\n        return window.localStorage.getItem(key);\n    },\n    clearSync: function () {\n        return window.localStorage.clear();\n    },\n    removeItemSync: function (key) {\n        return window.localStorage.removeItem(key);\n    },\n    setItemSync: function (key, value) {\n        return window.localStorage.setItem(key, value);\n    },\n};\n/**\n * @function delay\n * @param {number} milliseconds - How long the delay should be in terms of milliseconds\n * @returns {Promise<void>}\n */\nfunction delay(milliseconds) {\n    return new Promise(function (resolve) { return setTimeout(resolve, milliseconds); });\n}\n/**\n * @function generateRandomString\n * @params {number} length - How long the random string should be\n * @returns {string}\n * @description returns random string whose length is equal to the length passed as parameter\n */\nfunction generateRandomString(length) {\n    var CHARS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz';\n    var randomstring = '';\n    for (var i = 0; i < length; i++) {\n        var INDEX = Math.floor(Math.random() * CHARS.length);\n        randomstring += CHARS[INDEX];\n    }\n    return randomstring;\n}\n/**\n * @function getLockId\n * @returns {string}\n * @description Generates an id which will be unique for the browser tab\n */\nfunction getLockId() {\n    return Date.now().toString() + generateRandomString(15);\n}\nvar SuperTokensLock = /** @class */ (function () {\n    function SuperTokensLock(storageHandler) {\n        this.acquiredIatSet = new Set();\n        this.storageHandler = undefined;\n        this.id = getLockId();\n        this.acquireLock = this.acquireLock.bind(this);\n        this.releaseLock = this.releaseLock.bind(this);\n        this.releaseLock__private__ = this.releaseLock__private__.bind(this);\n        this.waitForSomethingToChange = this.waitForSomethingToChange.bind(this);\n        this.refreshLockWhileAcquired = this.refreshLockWhileAcquired.bind(this);\n        this.storageHandler = storageHandler;\n        if (SuperTokensLock.waiters === undefined) {\n            SuperTokensLock.waiters = [];\n        }\n    }\n    /**\n     * @async\n     * @memberOf Lock\n     * @function acquireLock\n     * @param {string} lockKey - Key for which the lock is being acquired\n     * @param {number} [timeout=5000] - Maximum time for which the function will wait to acquire the lock\n     * @returns {Promise<boolean>}\n     * @description Will return true if lock is being acquired, else false.\n     *              Also the lock can be acquired for maximum 10 secs\n     */\n    SuperTokensLock.prototype.acquireLock = function (lockKey, timeout) {\n        if (timeout === void 0) { timeout = 5000; }\n        return __awaiter(this, void 0, void 0, function () {\n            var iat, MAX_TIME, STORAGE_KEY, STORAGE, lockObj, TIMEOUT_KEY, lockObjPostDelay, parsedLockObjPostDelay;\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        iat = Date.now() + generateRandomString(4);\n                        MAX_TIME = Date.now() + timeout;\n                        STORAGE_KEY = LOCK_STORAGE_KEY + \"-\" + lockKey;\n                        STORAGE = this.storageHandler === undefined ? DEFAULT_STORAGE_HANDLER : this.storageHandler;\n                        _a.label = 1;\n                    case 1:\n                        if (!(Date.now() < MAX_TIME)) return [3 /*break*/, 8];\n                        return [4 /*yield*/, delay(30)];\n                    case 2:\n                        _a.sent();\n                        lockObj = STORAGE.getItemSync(STORAGE_KEY);\n                        if (!(lockObj === null)) return [3 /*break*/, 5];\n                        TIMEOUT_KEY = this.id + \"-\" + lockKey + \"-\" + iat;\n                        // there is a problem if setItem happens at the exact same time for 2 different processes.. so we add some random delay here.\n                        return [4 /*yield*/, delay(Math.floor(Math.random() * 25))];\n                    case 3:\n                        // there is a problem if setItem happens at the exact same time for 2 different processes.. so we add some random delay here.\n                        _a.sent();\n                        STORAGE.setItemSync(STORAGE_KEY, JSON.stringify({\n                            id: this.id,\n                            iat: iat,\n                            timeoutKey: TIMEOUT_KEY,\n                            timeAcquired: Date.now(),\n                            timeRefreshed: Date.now()\n                        }));\n                        return [4 /*yield*/, delay(30)];\n                    case 4:\n                        _a.sent(); // this is to prevent race conditions. This time must be more than the time it takes for storage.setItem\n                        lockObjPostDelay = STORAGE.getItemSync(STORAGE_KEY);\n                        if (lockObjPostDelay !== null) {\n                            parsedLockObjPostDelay = JSON.parse(lockObjPostDelay);\n                            if (parsedLockObjPostDelay.id === this.id && parsedLockObjPostDelay.iat === iat) {\n                                this.acquiredIatSet.add(iat);\n                                this.refreshLockWhileAcquired(STORAGE_KEY, iat);\n                                return [2 /*return*/, true];\n                            }\n                        }\n                        return [3 /*break*/, 7];\n                    case 5:\n                        SuperTokensLock.lockCorrector(this.storageHandler === undefined ? DEFAULT_STORAGE_HANDLER : this.storageHandler);\n                        return [4 /*yield*/, this.waitForSomethingToChange(MAX_TIME)];\n                    case 6:\n                        _a.sent();\n                        _a.label = 7;\n                    case 7:\n                        iat = Date.now() + generateRandomString(4);\n                        return [3 /*break*/, 1];\n                    case 8: return [2 /*return*/, false];\n                }\n            });\n        });\n    };\n    SuperTokensLock.prototype.refreshLockWhileAcquired = function (storageKey, iat) {\n        return __awaiter(this, void 0, void 0, function () {\n            var _this = this;\n            return __generator(this, function (_a) {\n                setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {\n                    var STORAGE, lockObj, parsedLockObj;\n                    return __generator(this, function (_a) {\n                        switch (_a.label) {\n                            case 0: return [4 /*yield*/, processLock_1.default().lock(iat)];\n                            case 1:\n                                _a.sent();\n                                if (!this.acquiredIatSet.has(iat)) {\n                                    processLock_1.default().unlock(iat);\n                                    return [2 /*return*/];\n                                }\n                                STORAGE = this.storageHandler === undefined ? DEFAULT_STORAGE_HANDLER : this.storageHandler;\n                                lockObj = STORAGE.getItemSync(storageKey);\n                                if (lockObj !== null) {\n                                    parsedLockObj = JSON.parse(lockObj);\n                                    parsedLockObj.timeRefreshed = Date.now();\n                                    STORAGE.setItemSync(storageKey, JSON.stringify(parsedLockObj));\n                                    processLock_1.default().unlock(iat);\n                                }\n                                else {\n                                    processLock_1.default().unlock(iat);\n                                    return [2 /*return*/];\n                                }\n                                this.refreshLockWhileAcquired(storageKey, iat);\n                                return [2 /*return*/];\n                        }\n                    });\n                }); }, 1000);\n                return [2 /*return*/];\n            });\n        });\n    };\n    SuperTokensLock.prototype.waitForSomethingToChange = function (MAX_TIME) {\n        return __awaiter(this, void 0, void 0, function () {\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0: return [4 /*yield*/, new Promise(function (resolve) {\n                            var resolvedCalled = false;\n                            var startedAt = Date.now();\n                            var MIN_TIME_TO_WAIT = 50; // ms\n                            var removedListeners = false;\n                            function stopWaiting() {\n                                if (!removedListeners) {\n                                    window.removeEventListener('storage', stopWaiting);\n                                    SuperTokensLock.removeFromWaiting(stopWaiting);\n                                    clearTimeout(timeOutId);\n                                    removedListeners = true;\n                                }\n                                if (!resolvedCalled) {\n                                    resolvedCalled = true;\n                                    var timeToWait = MIN_TIME_TO_WAIT - (Date.now() - startedAt);\n                                    if (timeToWait > 0) {\n                                        setTimeout(resolve, timeToWait);\n                                    }\n                                    else {\n                                        resolve(null);\n                                    }\n                                }\n                            }\n                            window.addEventListener('storage', stopWaiting);\n                            SuperTokensLock.addToWaiting(stopWaiting);\n                            var timeOutId = setTimeout(stopWaiting, Math.max(0, MAX_TIME - Date.now()));\n                        })];\n                    case 1:\n                        _a.sent();\n                        return [2 /*return*/];\n                }\n            });\n        });\n    };\n    SuperTokensLock.addToWaiting = function (func) {\n        this.removeFromWaiting(func);\n        if (SuperTokensLock.waiters === undefined) {\n            return;\n        }\n        SuperTokensLock.waiters.push(func);\n    };\n    SuperTokensLock.removeFromWaiting = function (func) {\n        if (SuperTokensLock.waiters === undefined) {\n            return;\n        }\n        SuperTokensLock.waiters = SuperTokensLock.waiters.filter(function (i) { return i !== func; });\n    };\n    SuperTokensLock.notifyWaiters = function () {\n        if (SuperTokensLock.waiters === undefined) {\n            return;\n        }\n        var waiters = SuperTokensLock.waiters.slice(); // so that if Lock.waiters is changed it's ok.\n        waiters.forEach(function (i) { return i(); });\n    };\n    /**\n     * @function releaseLock\n     * @memberOf Lock\n     * @param {string} lockKey - Key for which lock is being released\n     * @returns {void}\n     * @description Release a lock.\n     */\n    SuperTokensLock.prototype.releaseLock = function (lockKey) {\n        return __awaiter(this, void 0, void 0, function () {\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0: return [4 /*yield*/, this.releaseLock__private__(lockKey)];\n                    case 1: return [2 /*return*/, _a.sent()];\n                }\n            });\n        });\n    };\n    /**\n     * @function releaseLock\n     * @memberOf Lock\n     * @param {string} lockKey - Key for which lock is being released\n     * @returns {void}\n     * @description Release a lock.\n     */\n    SuperTokensLock.prototype.releaseLock__private__ = function (lockKey) {\n        return __awaiter(this, void 0, void 0, function () {\n            var STORAGE, STORAGE_KEY, lockObj, parsedlockObj;\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        STORAGE = this.storageHandler === undefined ? DEFAULT_STORAGE_HANDLER : this.storageHandler;\n                        STORAGE_KEY = LOCK_STORAGE_KEY + \"-\" + lockKey;\n                        lockObj = STORAGE.getItemSync(STORAGE_KEY);\n                        if (lockObj === null) {\n                            return [2 /*return*/];\n                        }\n                        parsedlockObj = JSON.parse(lockObj);\n                        if (!(parsedlockObj.id === this.id)) return [3 /*break*/, 2];\n                        return [4 /*yield*/, processLock_1.default().lock(parsedlockObj.iat)];\n                    case 1:\n                        _a.sent();\n                        this.acquiredIatSet.delete(parsedlockObj.iat);\n                        STORAGE.removeItemSync(STORAGE_KEY);\n                        processLock_1.default().unlock(parsedlockObj.iat);\n                        SuperTokensLock.notifyWaiters();\n                        _a.label = 2;\n                    case 2: return [2 /*return*/];\n                }\n            });\n        });\n    };\n    /**\n     * @function lockCorrector\n     * @returns {void}\n     * @description If a lock is acquired by a tab and the tab is closed before the lock is\n     *              released, this function will release those locks\n     */\n    SuperTokensLock.lockCorrector = function (storageHandler) {\n        var MIN_ALLOWED_TIME = Date.now() - 5000;\n        var STORAGE = storageHandler;\n        var KEYS = [];\n        var currIndex = 0;\n        while (true) {\n            var key = STORAGE.keySync(currIndex);\n            if (key === null) {\n                break;\n            }\n            KEYS.push(key);\n            currIndex++;\n        }\n        var notifyWaiters = false;\n        for (var i = 0; i < KEYS.length; i++) {\n            var LOCK_KEY = KEYS[i];\n            if (LOCK_KEY.includes(LOCK_STORAGE_KEY)) {\n                var lockObj = STORAGE.getItemSync(LOCK_KEY);\n                if (lockObj !== null) {\n                    var parsedlockObj = JSON.parse(lockObj);\n                    if ((parsedlockObj.timeRefreshed === undefined && parsedlockObj.timeAcquired < MIN_ALLOWED_TIME) ||\n                        (parsedlockObj.timeRefreshed !== undefined && parsedlockObj.timeRefreshed < MIN_ALLOWED_TIME)) {\n                        STORAGE.removeItemSync(LOCK_KEY);\n                        notifyWaiters = true;\n                    }\n                }\n            }\n        }\n        if (notifyWaiters) {\n            SuperTokensLock.notifyWaiters();\n        }\n    };\n    SuperTokensLock.waiters = undefined;\n    return SuperTokensLock;\n}());\nexports.default = SuperTokensLock;\n"]}