{"version":3,"file":"firebase-app-check.js","sources":["../../node_modules/tslib/tslib.es6.js","../util/src/crypt.ts","../util/src/deferred.ts","../util/src/environment.ts","../util/src/errors.ts","../util/src/json.ts","../logger/src/logger.ts","../util/src/jwt.ts","../component/src/component.ts","../app-check/src/errors.ts","../app-check/src/state.ts","../app-check/src/util.ts","../app-check/src/recaptcha.ts","../app-check/src/constants.ts","../app-check/src/proactive-refresh.ts","../app-check/src/client.ts","../app-check/src/indexeddb.ts","../app-check/src/logger.ts","../app-check/src/storage.ts","../app-check/src/debug.ts","../app-check/src/internal-api.ts","../app-check/src/factory.ts","../app-check/src/api.ts","../app-check/src/index.ts"],"sourcesContent":["/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\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;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from) {\r\n    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)\r\n        to[j] = from[i];\r\n    return to;\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nconst stringToByteArray = function (str: string): number[] {\n  // TODO(user): Use native implementations if/when available\n  const out: number[] = [];\n  let p = 0;\n  for (let i = 0; i < str.length; i++) {\n    let c = str.charCodeAt(i);\n    if (c < 128) {\n      out[p++] = c;\n    } else if (c < 2048) {\n      out[p++] = (c >> 6) | 192;\n      out[p++] = (c & 63) | 128;\n    } else if (\n      (c & 0xfc00) === 0xd800 &&\n      i + 1 < str.length &&\n      (str.charCodeAt(i + 1) & 0xfc00) === 0xdc00\n    ) {\n      // Surrogate Pair\n      c = 0x10000 + ((c & 0x03ff) << 10) + (str.charCodeAt(++i) & 0x03ff);\n      out[p++] = (c >> 18) | 240;\n      out[p++] = ((c >> 12) & 63) | 128;\n      out[p++] = ((c >> 6) & 63) | 128;\n      out[p++] = (c & 63) | 128;\n    } else {\n      out[p++] = (c >> 12) | 224;\n      out[p++] = ((c >> 6) & 63) | 128;\n      out[p++] = (c & 63) | 128;\n    }\n  }\n  return out;\n};\n\n/**\n * Turns an array of numbers into the string given by the concatenation of the\n * characters to which the numbers correspond.\n * @param bytes Array of numbers representing characters.\n * @return Stringification of the array.\n */\nconst byteArrayToString = function (bytes: number[]): string {\n  // TODO(user): Use native implementations if/when available\n  const out: string[] = [];\n  let pos = 0,\n    c = 0;\n  while (pos < bytes.length) {\n    const c1 = bytes[pos++];\n    if (c1 < 128) {\n      out[c++] = String.fromCharCode(c1);\n    } else if (c1 > 191 && c1 < 224) {\n      const c2 = bytes[pos++];\n      out[c++] = String.fromCharCode(((c1 & 31) << 6) | (c2 & 63));\n    } else if (c1 > 239 && c1 < 365) {\n      // Surrogate Pair\n      const c2 = bytes[pos++];\n      const c3 = bytes[pos++];\n      const c4 = bytes[pos++];\n      const u =\n        (((c1 & 7) << 18) | ((c2 & 63) << 12) | ((c3 & 63) << 6) | (c4 & 63)) -\n        0x10000;\n      out[c++] = String.fromCharCode(0xd800 + (u >> 10));\n      out[c++] = String.fromCharCode(0xdc00 + (u & 1023));\n    } else {\n      const c2 = bytes[pos++];\n      const c3 = bytes[pos++];\n      out[c++] = String.fromCharCode(\n        ((c1 & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63)\n      );\n    }\n  }\n  return out.join('');\n};\n\ninterface Base64 {\n  byteToCharMap_: { [key: number]: string } | null;\n  charToByteMap_: { [key: string]: number } | null;\n  byteToCharMapWebSafe_: { [key: number]: string } | null;\n  charToByteMapWebSafe_: { [key: string]: number } | null;\n  ENCODED_VALS_BASE: string;\n  readonly ENCODED_VALS: string;\n  readonly ENCODED_VALS_WEBSAFE: string;\n  HAS_NATIVE_SUPPORT: boolean;\n  encodeByteArray(input: number[] | Uint8Array, webSafe?: boolean): string;\n  encodeString(input: string, webSafe?: boolean): string;\n  decodeString(input: string, webSafe: boolean): string;\n  decodeStringToByteArray(input: string, webSafe: boolean): number[];\n  init_(): void;\n}\n\n// We define it as an object literal instead of a class because a class compiled down to es5 can't\n// be treeshaked. https://github.com/rollup/rollup/issues/1691\n// Static lookup maps, lazily populated by init_()\nexport const base64: Base64 = {\n  /**\n   * Maps bytes to characters.\n   */\n  byteToCharMap_: null,\n\n  /**\n   * Maps characters to bytes.\n   */\n  charToByteMap_: null,\n\n  /**\n   * Maps bytes to websafe characters.\n   * @private\n   */\n  byteToCharMapWebSafe_: null,\n\n  /**\n   * Maps websafe characters to bytes.\n   * @private\n   */\n  charToByteMapWebSafe_: null,\n\n  /**\n   * Our default alphabet, shared between\n   * ENCODED_VALS and ENCODED_VALS_WEBSAFE\n   */\n  ENCODED_VALS_BASE:\n    'ABCDEFGHIJKLMNOPQRSTUVWXYZ' + 'abcdefghijklmnopqrstuvwxyz' + '0123456789',\n\n  /**\n   * Our default alphabet. Value 64 (=) is special; it means \"nothing.\"\n   */\n  get ENCODED_VALS() {\n    return this.ENCODED_VALS_BASE + '+/=';\n  },\n\n  /**\n   * Our websafe alphabet.\n   */\n  get ENCODED_VALS_WEBSAFE() {\n    return this.ENCODED_VALS_BASE + '-_.';\n  },\n\n  /**\n   * Whether this browser supports the atob and btoa functions. This extension\n   * started at Mozilla but is now implemented by many browsers. We use the\n   * ASSUME_* variables to avoid pulling in the full useragent detection library\n   * but still allowing the standard per-browser compilations.\n   *\n   */\n  HAS_NATIVE_SUPPORT: typeof atob === 'function',\n\n  /**\n   * Base64-encode an array of bytes.\n   *\n   * @param input An array of bytes (numbers with\n   *     value in [0, 255]) to encode.\n   * @param webSafe Boolean indicating we should use the\n   *     alternative alphabet.\n   * @return The base64 encoded string.\n   */\n  encodeByteArray(input: number[] | Uint8Array, webSafe?: boolean): string {\n    if (!Array.isArray(input)) {\n      throw Error('encodeByteArray takes an array as a parameter');\n    }\n\n    this.init_();\n\n    const byteToCharMap = webSafe\n      ? this.byteToCharMapWebSafe_!\n      : this.byteToCharMap_!;\n\n    const output = [];\n\n    for (let i = 0; i < input.length; i += 3) {\n      const byte1 = input[i];\n      const haveByte2 = i + 1 < input.length;\n      const byte2 = haveByte2 ? input[i + 1] : 0;\n      const haveByte3 = i + 2 < input.length;\n      const byte3 = haveByte3 ? input[i + 2] : 0;\n\n      const outByte1 = byte1 >> 2;\n      const outByte2 = ((byte1 & 0x03) << 4) | (byte2 >> 4);\n      let outByte3 = ((byte2 & 0x0f) << 2) | (byte3 >> 6);\n      let outByte4 = byte3 & 0x3f;\n\n      if (!haveByte3) {\n        outByte4 = 64;\n\n        if (!haveByte2) {\n          outByte3 = 64;\n        }\n      }\n\n      output.push(\n        byteToCharMap[outByte1],\n        byteToCharMap[outByte2],\n        byteToCharMap[outByte3],\n        byteToCharMap[outByte4]\n      );\n    }\n\n    return output.join('');\n  },\n\n  /**\n   * Base64-encode a string.\n   *\n   * @param input A string to encode.\n   * @param webSafe If true, we should use the\n   *     alternative alphabet.\n   * @return The base64 encoded string.\n   */\n  encodeString(input: string, webSafe?: boolean): string {\n    // Shortcut for Mozilla browsers that implement\n    // a native base64 encoder in the form of \"btoa/atob\"\n    if (this.HAS_NATIVE_SUPPORT && !webSafe) {\n      return btoa(input);\n    }\n    return this.encodeByteArray(stringToByteArray(input), webSafe);\n  },\n\n  /**\n   * Base64-decode a string.\n   *\n   * @param input to decode.\n   * @param webSafe True if we should use the\n   *     alternative alphabet.\n   * @return string representing the decoded value.\n   */\n  decodeString(input: string, webSafe: boolean): string {\n    // Shortcut for Mozilla browsers that implement\n    // a native base64 encoder in the form of \"btoa/atob\"\n    if (this.HAS_NATIVE_SUPPORT && !webSafe) {\n      return atob(input);\n    }\n    return byteArrayToString(this.decodeStringToByteArray(input, webSafe));\n  },\n\n  /**\n   * Base64-decode a string.\n   *\n   * In base-64 decoding, groups of four characters are converted into three\n   * bytes.  If the encoder did not apply padding, the input length may not\n   * be a multiple of 4.\n   *\n   * In this case, the last group will have fewer than 4 characters, and\n   * padding will be inferred.  If the group has one or two characters, it decodes\n   * to one byte.  If the group has three characters, it decodes to two bytes.\n   *\n   * @param input Input to decode.\n   * @param webSafe True if we should use the web-safe alphabet.\n   * @return bytes representing the decoded value.\n   */\n  decodeStringToByteArray(input: string, webSafe: boolean): number[] {\n    this.init_();\n\n    const charToByteMap = webSafe\n      ? this.charToByteMapWebSafe_!\n      : this.charToByteMap_!;\n\n    const output: number[] = [];\n\n    for (let i = 0; i < input.length; ) {\n      const byte1 = charToByteMap[input.charAt(i++)];\n\n      const haveByte2 = i < input.length;\n      const byte2 = haveByte2 ? charToByteMap[input.charAt(i)] : 0;\n      ++i;\n\n      const haveByte3 = i < input.length;\n      const byte3 = haveByte3 ? charToByteMap[input.charAt(i)] : 64;\n      ++i;\n\n      const haveByte4 = i < input.length;\n      const byte4 = haveByte4 ? charToByteMap[input.charAt(i)] : 64;\n      ++i;\n\n      if (byte1 == null || byte2 == null || byte3 == null || byte4 == null) {\n        throw Error();\n      }\n\n      const outByte1 = (byte1 << 2) | (byte2 >> 4);\n      output.push(outByte1);\n\n      if (byte3 !== 64) {\n        const outByte2 = ((byte2 << 4) & 0xf0) | (byte3 >> 2);\n        output.push(outByte2);\n\n        if (byte4 !== 64) {\n          const outByte3 = ((byte3 << 6) & 0xc0) | byte4;\n          output.push(outByte3);\n        }\n      }\n    }\n\n    return output;\n  },\n\n  /**\n   * Lazy static initialization function. Called before\n   * accessing any of the static map variables.\n   * @private\n   */\n  init_() {\n    if (!this.byteToCharMap_) {\n      this.byteToCharMap_ = {};\n      this.charToByteMap_ = {};\n      this.byteToCharMapWebSafe_ = {};\n      this.charToByteMapWebSafe_ = {};\n\n      // We want quick mappings back and forth, so we precompute two maps.\n      for (let i = 0; i < this.ENCODED_VALS.length; i++) {\n        this.byteToCharMap_[i] = this.ENCODED_VALS.charAt(i);\n        this.charToByteMap_[this.byteToCharMap_[i]] = i;\n        this.byteToCharMapWebSafe_[i] = this.ENCODED_VALS_WEBSAFE.charAt(i);\n        this.charToByteMapWebSafe_[this.byteToCharMapWebSafe_[i]] = i;\n\n        // Be forgiving when decoding and correctly decode both encodings.\n        if (i >= this.ENCODED_VALS_BASE.length) {\n          this.charToByteMap_[this.ENCODED_VALS_WEBSAFE.charAt(i)] = i;\n          this.charToByteMapWebSafe_[this.ENCODED_VALS.charAt(i)] = i;\n        }\n      }\n    }\n  }\n};\n\n/**\n * URL-safe base64 encoding\n */\nexport const base64Encode = function (str: string): string {\n  const utf8Bytes = stringToByteArray(str);\n  return base64.encodeByteArray(utf8Bytes, true);\n};\n\n/**\n * URL-safe base64 decoding\n *\n * NOTE: DO NOT use the global atob() function - it does NOT support the\n * base64Url variant encoding.\n *\n * @param str To be decoded\n * @return Decoded result, if possible\n */\nexport const base64Decode = function (str: string): string | null {\n  try {\n    return base64.decodeString(str, true);\n  } catch (e) {\n    console.error('base64Decode failed: ', e);\n  }\n  return null;\n};\n","/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport class Deferred<R> {\n  promise: Promise<R>;\n  reject: (value?: unknown) => void = () => {};\n  resolve: (value?: unknown) => void = () => {};\n  constructor() {\n    this.promise = new Promise((resolve, reject) => {\n      this.resolve = resolve as (value?: unknown) => void;\n      this.reject = reject as (value?: unknown) => void;\n    });\n  }\n\n  /**\n   * Our API internals are not promiseified and cannot because our callback APIs have subtle expectations around\n   * invoking promises inline, which Promises are forbidden to do. This method accepts an optional node-style callback\n   * and returns a node-style callback which will resolve or reject the Deferred's promise.\n   */\n  wrapCallback(\n    callback?: (error?: unknown, value?: unknown) => void\n  ): (error: unknown, value?: unknown) => void {\n    return (error, value?) => {\n      if (error) {\n        this.reject(error);\n      } else {\n        this.resolve(value);\n      }\n      if (typeof callback === 'function') {\n        // Attaching noop handler just in case developer wasn't expecting\n        // promises\n        this.promise.catch(() => {});\n\n        // Some of our callbacks don't expect a value and our own tests\n        // assert that the parameter length is 1\n        if (callback.length === 1) {\n          callback(error);\n        } else {\n          callback(error, value);\n        }\n      }\n    };\n  }\n}\n","/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { CONSTANTS } from './constants';\n\n/**\n * Returns navigator.userAgent string or '' if it's not defined.\n * @return user agent string\n */\nexport function getUA(): string {\n  if (\n    typeof navigator !== 'undefined' &&\n    typeof navigator['userAgent'] === 'string'\n  ) {\n    return navigator['userAgent'];\n  } else {\n    return '';\n  }\n}\n\n/**\n * Detect Cordova / PhoneGap / Ionic frameworks on a mobile device.\n *\n * Deliberately does not rely on checking `file://` URLs (as this fails PhoneGap\n * in the Ripple emulator) nor Cordova `onDeviceReady`, which would normally\n * wait for a callback.\n */\nexport function isMobileCordova(): boolean {\n  return (\n    typeof window !== 'undefined' &&\n    // @ts-ignore Setting up an broadly applicable index signature for Window\n    // just to deal with this case would probably be a bad idea.\n    !!(window['cordova'] || window['phonegap'] || window['PhoneGap']) &&\n    /ios|iphone|ipod|ipad|android|blackberry|iemobile/i.test(getUA())\n  );\n}\n\n/**\n * Detect Node.js.\n *\n * @return true if Node.js environment is detected.\n */\n// Node detection logic from: https://github.com/iliakan/detect-node/\nexport function isNode(): boolean {\n  try {\n    return (\n      Object.prototype.toString.call(global.process) === '[object process]'\n    );\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Detect Browser Environment\n */\nexport function isBrowser(): boolean {\n  return typeof self === 'object' && self.self === self;\n}\n\n/**\n * Detect browser extensions (Chrome and Firefox at least).\n */\ninterface BrowserRuntime {\n  id?: unknown;\n}\ndeclare const chrome: { runtime?: BrowserRuntime };\ndeclare const browser: { runtime?: BrowserRuntime };\nexport function isBrowserExtension(): boolean {\n  const runtime =\n    typeof chrome === 'object'\n      ? chrome.runtime\n      : typeof browser === 'object'\n      ? browser.runtime\n      : undefined;\n  return typeof runtime === 'object' && runtime.id !== undefined;\n}\n\n/**\n * Detect React Native.\n *\n * @return true if ReactNative environment is detected.\n */\nexport function isReactNative(): boolean {\n  return (\n    typeof navigator === 'object' && navigator['product'] === 'ReactNative'\n  );\n}\n\n/** Detects Electron apps. */\nexport function isElectron(): boolean {\n  return getUA().indexOf('Electron/') >= 0;\n}\n\n/** Detects Internet Explorer. */\nexport function isIE(): boolean {\n  const ua = getUA();\n  return ua.indexOf('MSIE ') >= 0 || ua.indexOf('Trident/') >= 0;\n}\n\n/** Detects Universal Windows Platform apps. */\nexport function isUWP(): boolean {\n  return getUA().indexOf('MSAppHost/') >= 0;\n}\n\n/**\n * Detect whether the current SDK build is the Node version.\n *\n * @return true if it's the Node SDK build.\n */\nexport function isNodeSdk(): boolean {\n  return CONSTANTS.NODE_CLIENT === true || CONSTANTS.NODE_ADMIN === true;\n}\n\n/** Returns true if we are running in Safari. */\nexport function isSafari(): boolean {\n  return (\n    !isNode() &&\n    navigator.userAgent.includes('Safari') &&\n    !navigator.userAgent.includes('Chrome')\n  );\n}\n\n/**\n * This method checks if indexedDB is supported by current browser/service worker context\n * @return true if indexedDB is supported by current browser/service worker context\n */\nexport function isIndexedDBAvailable(): boolean {\n  return 'indexedDB' in self && indexedDB != null;\n}\n\n/**\n * This method validates browser/sw context for indexedDB by opening a dummy indexedDB database and reject\n * if errors occur during the database open operation.\n *\n * @throws exception if current browser/sw context can't run idb.open (ex: Safari iframe, Firefox\n * private browsing)\n */\nexport function validateIndexedDBOpenable(): Promise<boolean> {\n  return new Promise((resolve, reject) => {\n    try {\n      let preExist: boolean = true;\n      const DB_CHECK_NAME =\n        'validate-browser-context-for-indexeddb-analytics-module';\n      const request = self.indexedDB.open(DB_CHECK_NAME);\n      request.onsuccess = () => {\n        request.result.close();\n        // delete database only when it doesn't pre-exist\n        if (!preExist) {\n          self.indexedDB.deleteDatabase(DB_CHECK_NAME);\n        }\n        resolve(true);\n      };\n      request.onupgradeneeded = () => {\n        preExist = false;\n      };\n\n      request.onerror = () => {\n        reject(request.error?.message || '');\n      };\n    } catch (error) {\n      reject(error);\n    }\n  });\n}\n\n/**\n *\n * This method checks whether cookie is enabled within current browser\n * @return true if cookie is enabled within current browser\n */\nexport function areCookiesEnabled(): boolean {\n  if (!navigator || !navigator.cookieEnabled) {\n    return false;\n  }\n  return true;\n}\n\n/**\n * Polyfill for `globalThis` object.\n * @returns the `globalThis` object for the given environment.\n */\nexport function getGlobal(): typeof globalThis {\n  if (typeof self !== 'undefined') {\n    return self;\n  }\n  if (typeof window !== 'undefined') {\n    return window;\n  }\n  if (typeof global !== 'undefined') {\n    return global;\n  }\n  throw new Error('Unable to locate global object.');\n}\n","/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/**\n * @fileoverview Standardized Firebase Error.\n *\n * Usage:\n *\n *   // Typescript string literals for type-safe codes\n *   type Err =\n *     'unknown' |\n *     'object-not-found'\n *     ;\n *\n *   // Closure enum for type-safe error codes\n *   // at-enum {string}\n *   var Err = {\n *     UNKNOWN: 'unknown',\n *     OBJECT_NOT_FOUND: 'object-not-found',\n *   }\n *\n *   let errors: Map<Err, string> = {\n *     'generic-error': \"Unknown error\",\n *     'file-not-found': \"Could not find file: {$file}\",\n *   };\n *\n *   // Type-safe function - must pass a valid error code as param.\n *   let error = new ErrorFactory<Err>('service', 'Service', errors);\n *\n *   ...\n *   throw error.create(Err.GENERIC);\n *   ...\n *   throw error.create(Err.FILE_NOT_FOUND, {'file': fileName});\n *   ...\n *   // Service: Could not file file: foo.txt (service/file-not-found).\n *\n *   catch (e) {\n *     assert(e.message === \"Could not find file: foo.txt.\");\n *     if (e.code === 'service/file-not-found') {\n *       console.log(\"Could not read file: \" + e['file']);\n *     }\n *   }\n */\n\nexport type ErrorMap<ErrorCode extends string> = {\n  readonly [K in ErrorCode]: string;\n};\n\nconst ERROR_NAME = 'FirebaseError';\n\nexport interface StringLike {\n  toString(): string;\n}\n\nexport interface ErrorData {\n  [key: string]: unknown;\n}\n\n// Based on code from:\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Custom_Error_Types\nexport class FirebaseError extends Error {\n  readonly name = ERROR_NAME;\n\n  constructor(\n    readonly code: string,\n    message: string,\n    public customData?: Record<string, unknown>\n  ) {\n    super(message);\n\n    // Fix For ES5\n    // https://github.com/Microsoft/TypeScript-wiki/blob/master/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work\n    Object.setPrototypeOf(this, FirebaseError.prototype);\n\n    // Maintains proper stack trace for where our error was thrown.\n    // Only available on V8.\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, ErrorFactory.prototype.create);\n    }\n  }\n}\n\nexport class ErrorFactory<\n  ErrorCode extends string,\n  ErrorParams extends { readonly [K in ErrorCode]?: ErrorData } = {}\n> {\n  constructor(\n    private readonly service: string,\n    private readonly serviceName: string,\n    private readonly errors: ErrorMap<ErrorCode>\n  ) {}\n\n  create<K extends ErrorCode>(\n    code: K,\n    ...data: K extends keyof ErrorParams ? [ErrorParams[K]] : []\n  ): FirebaseError {\n    const customData = (data[0] as ErrorData) || {};\n    const fullCode = `${this.service}/${code}`;\n    const template = this.errors[code];\n\n    const message = template ? replaceTemplate(template, customData) : 'Error';\n    // Service Name: Error message (service/code).\n    const fullMessage = `${this.serviceName}: ${message} (${fullCode}).`;\n\n    const error = new FirebaseError(fullCode, fullMessage, customData);\n\n    return error;\n  }\n}\n\nfunction replaceTemplate(template: string, data: ErrorData): string {\n  return template.replace(PATTERN, (_, key) => {\n    const value = data[key];\n    return value != null ? String(value) : `<${key}?>`;\n  });\n}\n\nconst PATTERN = /\\{\\$([^}]+)}/g;\n","/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Evaluates a JSON string into a javascript object.\n *\n * @param {string} str A string containing JSON.\n * @return {*} The javascript object representing the specified JSON.\n */\nexport function jsonEval(str: string): unknown {\n  return JSON.parse(str);\n}\n\n/**\n * Returns JSON representing a javascript object.\n * @param {*} data Javascript object to be stringified.\n * @return {string} The JSON contents of the object.\n */\nexport function stringify(data: unknown): string {\n  return JSON.stringify(data);\n}\n","/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport type LogLevelString =\n  | 'debug'\n  | 'verbose'\n  | 'info'\n  | 'warn'\n  | 'error'\n  | 'silent';\n\nexport interface LogOptions {\n  level: LogLevelString;\n}\n\nexport type LogCallback = (callbackParams: LogCallbackParams) => void;\n\nexport interface LogCallbackParams {\n  level: LogLevelString;\n  message: string;\n  args: unknown[];\n  type: string;\n}\n\n/**\n * A container for all of the Logger instances\n */\nexport const instances: Logger[] = [];\n\n/**\n * The JS SDK supports 5 log levels and also allows a user the ability to\n * silence the logs altogether.\n *\n * The order is a follows:\n * DEBUG < VERBOSE < INFO < WARN < ERROR\n *\n * All of the log types above the current log level will be captured (i.e. if\n * you set the log level to `INFO`, errors will still be logged, but `DEBUG` and\n * `VERBOSE` logs will not)\n */\nexport enum LogLevel {\n  DEBUG,\n  VERBOSE,\n  INFO,\n  WARN,\n  ERROR,\n  SILENT\n}\n\nconst levelStringToEnum: { [key in LogLevelString]: LogLevel } = {\n  'debug': LogLevel.DEBUG,\n  'verbose': LogLevel.VERBOSE,\n  'info': LogLevel.INFO,\n  'warn': LogLevel.WARN,\n  'error': LogLevel.ERROR,\n  'silent': LogLevel.SILENT\n};\n\n/**\n * The default log level\n */\nconst defaultLogLevel: LogLevel = LogLevel.INFO;\n\n/**\n * We allow users the ability to pass their own log handler. We will pass the\n * type of log, the current log level, and any other arguments passed (i.e. the\n * messages that the user wants to log) to this function.\n */\nexport type LogHandler = (\n  loggerInstance: Logger,\n  logType: LogLevel,\n  ...args: unknown[]\n) => void;\n\n/**\n * By default, `console.debug` is not displayed in the developer console (in\n * chrome). To avoid forcing users to have to opt-in to these logs twice\n * (i.e. once for firebase, and once in the console), we are sending `DEBUG`\n * logs to the `console.log` function.\n */\nconst ConsoleMethod = {\n  [LogLevel.DEBUG]: 'log',\n  [LogLevel.VERBOSE]: 'log',\n  [LogLevel.INFO]: 'info',\n  [LogLevel.WARN]: 'warn',\n  [LogLevel.ERROR]: 'error'\n};\n\n/**\n * The default log handler will forward DEBUG, VERBOSE, INFO, WARN, and ERROR\n * messages on to their corresponding console counterparts (if the log method\n * is supported by the current log level)\n */\nconst defaultLogHandler: LogHandler = (instance, logType, ...args): void => {\n  if (logType < instance.logLevel) {\n    return;\n  }\n  const now = new Date().toISOString();\n  const method = ConsoleMethod[logType as keyof typeof ConsoleMethod];\n  if (method) {\n    console[method as 'log' | 'info' | 'warn' | 'error'](\n      `[${now}]  ${instance.name}:`,\n      ...args\n    );\n  } else {\n    throw new Error(\n      `Attempted to log a message with an invalid logType (value: ${logType})`\n    );\n  }\n};\n\nexport class Logger {\n  /**\n   * Gives you an instance of a Logger to capture messages according to\n   * Firebase's logging scheme.\n   *\n   * @param name The name that the logs will be associated with\n   */\n  constructor(public name: string) {\n    /**\n     * Capture the current instance for later use\n     */\n    instances.push(this);\n  }\n\n  /**\n   * The log level of the given Logger instance.\n   */\n  private _logLevel = defaultLogLevel;\n\n  get logLevel(): LogLevel {\n    return this._logLevel;\n  }\n\n  set logLevel(val: LogLevel) {\n    if (!(val in LogLevel)) {\n      throw new TypeError(`Invalid value \"${val}\" assigned to \\`logLevel\\``);\n    }\n    this._logLevel = val;\n  }\n\n  // Workaround for setter/getter having to be the same type.\n  setLogLevel(val: LogLevel | LogLevelString): void {\n    this._logLevel = typeof val === 'string' ? levelStringToEnum[val] : val;\n  }\n\n  /**\n   * The main (internal) log handler for the Logger instance.\n   * Can be set to a new function in internal package code but not by user.\n   */\n  private _logHandler: LogHandler = defaultLogHandler;\n  get logHandler(): LogHandler {\n    return this._logHandler;\n  }\n  set logHandler(val: LogHandler) {\n    if (typeof val !== 'function') {\n      throw new TypeError('Value assigned to `logHandler` must be a function');\n    }\n    this._logHandler = val;\n  }\n\n  /**\n   * The optional, additional, user-defined log handler for the Logger instance.\n   */\n  private _userLogHandler: LogHandler | null = null;\n  get userLogHandler(): LogHandler | null {\n    return this._userLogHandler;\n  }\n  set userLogHandler(val: LogHandler | null) {\n    this._userLogHandler = val;\n  }\n\n  /**\n   * The functions below are all based on the `console` interface\n   */\n\n  debug(...args: unknown[]): void {\n    this._userLogHandler && this._userLogHandler(this, LogLevel.DEBUG, ...args);\n    this._logHandler(this, LogLevel.DEBUG, ...args);\n  }\n  log(...args: unknown[]): void {\n    this._userLogHandler &&\n      this._userLogHandler(this, LogLevel.VERBOSE, ...args);\n    this._logHandler(this, LogLevel.VERBOSE, ...args);\n  }\n  info(...args: unknown[]): void {\n    this._userLogHandler && this._userLogHandler(this, LogLevel.INFO, ...args);\n    this._logHandler(this, LogLevel.INFO, ...args);\n  }\n  warn(...args: unknown[]): void {\n    this._userLogHandler && this._userLogHandler(this, LogLevel.WARN, ...args);\n    this._logHandler(this, LogLevel.WARN, ...args);\n  }\n  error(...args: unknown[]): void {\n    this._userLogHandler && this._userLogHandler(this, LogLevel.ERROR, ...args);\n    this._logHandler(this, LogLevel.ERROR, ...args);\n  }\n}\n\nexport function setLogLevel(level: LogLevelString | LogLevel): void {\n  instances.forEach(inst => {\n    inst.setLogLevel(level);\n  });\n}\n\nexport function setUserLogHandler(\n  logCallback: LogCallback | null,\n  options?: LogOptions\n): void {\n  for (const instance of instances) {\n    let customLogLevel: LogLevel | null = null;\n    if (options && options.level) {\n      customLogLevel = levelStringToEnum[options.level];\n    }\n    if (logCallback === null) {\n      instance.userLogHandler = null;\n    } else {\n      instance.userLogHandler = (\n        instance: Logger,\n        level: LogLevel,\n        ...args: unknown[]\n      ) => {\n        const message = args\n          .map(arg => {\n            if (arg == null) {\n              return null;\n            } else if (typeof arg === 'string') {\n              return arg;\n            } else if (typeof arg === 'number' || typeof arg === 'boolean') {\n              return arg.toString();\n            } else if (arg instanceof Error) {\n              return arg.message;\n            } else {\n              try {\n                return JSON.stringify(arg);\n              } catch (ignored) {\n                return null;\n              }\n            }\n          })\n          .filter(arg => arg)\n          .join(' ');\n        if (level >= (customLogLevel ?? instance.logLevel)) {\n          logCallback({\n            level: LogLevel[level].toLowerCase() as LogLevelString,\n            message,\n            args,\n            type: instance.name\n          });\n        }\n      };\n    }\n  }\n}\n","/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { base64Decode } from './crypt';\nimport { jsonEval } from './json';\n\ninterface Claims {\n  [key: string]: {};\n}\n\ninterface DecodedToken {\n  header: object;\n  claims: Claims;\n  data: object;\n  signature: string;\n}\n\n/**\n * Decodes a Firebase auth. token into constituent parts.\n *\n * Notes:\n * - May return with invalid / incomplete claims if there's no native base64 decoding support.\n * - Doesn't check if the token is actually valid.\n */\nexport const decode = function (token: string): DecodedToken {\n  let header = {},\n    claims: Claims = {},\n    data = {},\n    signature = '';\n\n  try {\n    const parts = token.split('.');\n    header = jsonEval(base64Decode(parts[0]) || '') as object;\n    claims = jsonEval(base64Decode(parts[1]) || '') as Claims;\n    signature = parts[2];\n    data = claims['d'] || {};\n    delete claims['d'];\n  } catch (e) {}\n\n  return {\n    header,\n    claims,\n    data,\n    signature\n  };\n};\n\ninterface DecodedToken {\n  header: object;\n  claims: Claims;\n  data: object;\n  signature: string;\n}\n\n/**\n * Decodes a Firebase auth. token and checks the validity of its time-based claims. Will return true if the\n * token is within the time window authorized by the 'nbf' (not-before) and 'iat' (issued-at) claims.\n *\n * Notes:\n * - May return a false negative if there's no native base64 decoding support.\n * - Doesn't check if the token is actually valid.\n */\nexport const isValidTimestamp = function (token: string): boolean {\n  const claims: Claims = decode(token).claims;\n  const now: number = Math.floor(new Date().getTime() / 1000);\n  let validSince: number = 0,\n    validUntil: number = 0;\n\n  if (typeof claims === 'object') {\n    if (claims.hasOwnProperty('nbf')) {\n      validSince = claims['nbf'] as number;\n    } else if (claims.hasOwnProperty('iat')) {\n      validSince = claims['iat'] as number;\n    }\n\n    if (claims.hasOwnProperty('exp')) {\n      validUntil = claims['exp'] as number;\n    } else {\n      // token will expire after 24h by default\n      validUntil = validSince + 86400;\n    }\n  }\n\n  return (\n    !!now &&\n    !!validSince &&\n    !!validUntil &&\n    now >= validSince &&\n    now <= validUntil\n  );\n};\n\n/**\n * Decodes a Firebase auth. token and returns its issued at time if valid, null otherwise.\n *\n * Notes:\n * - May return null if there's no native base64 decoding support.\n * - Doesn't check if the token is actually valid.\n */\nexport const issuedAtTime = function (token: string): number | null {\n  const claims: Claims = decode(token).claims;\n  if (typeof claims === 'object' && claims.hasOwnProperty('iat')) {\n    return claims['iat'] as number;\n  }\n  return null;\n};\n\n/**\n * Decodes a Firebase auth. token and checks the validity of its format. Expects a valid issued-at time.\n *\n * Notes:\n * - May return a false negative if there's no native base64 decoding support.\n * - Doesn't check if the token is actually valid.\n */\nexport const isValidFormat = function (token: string): boolean {\n  const decoded = decode(token),\n    claims = decoded.claims;\n\n  return !!claims && typeof claims === 'object' && claims.hasOwnProperty('iat');\n};\n\n/**\n * Attempts to peer into an auth token and determine if it's an admin auth token by looking at the claims portion.\n *\n * Notes:\n * - May return a false negative if there's no native base64 decoding support.\n * - Doesn't check if the token is actually valid.\n */\nexport const isAdmin = function (token: string): boolean {\n  const claims: Claims = decode(token).claims;\n  return typeof claims === 'object' && claims['admin'] === true;\n};\n","/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport {\n  InstantiationMode,\n  InstanceFactory,\n  ComponentType,\n  Dictionary,\n  Name,\n  onInstanceCreatedCallback\n} from './types';\n\n/**\n * Component for service name T, e.g. `auth`, `auth-internal`\n */\nexport class Component<T extends Name = Name> {\n  multipleInstances = false;\n  /**\n   * Properties to be added to the service namespace\n   */\n  serviceProps: Dictionary = {};\n\n  instantiationMode = InstantiationMode.LAZY;\n\n  onInstanceCreated: onInstanceCreatedCallback<T> | null = null;\n\n  /**\n   *\n   * @param name The public service name, e.g. app, auth, firestore, database\n   * @param instanceFactory Service factory responsible for creating the public interface\n   * @param type whether the service provided by the component is public or private\n   */\n  constructor(\n    readonly name: T,\n    readonly instanceFactory: InstanceFactory<T>,\n    readonly type: ComponentType\n  ) {}\n\n  setInstantiationMode(mode: InstantiationMode): this {\n    this.instantiationMode = mode;\n    return this;\n  }\n\n  setMultipleInstances(multipleInstances: boolean): this {\n    this.multipleInstances = multipleInstances;\n    return this;\n  }\n\n  setServiceProps(props: Dictionary): this {\n    this.serviceProps = props;\n    return this;\n  }\n\n  setInstanceCreatedCallback(callback: onInstanceCreatedCallback<T>): this {\n    this.onInstanceCreated = callback;\n    return this;\n  }\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ErrorFactory, ErrorMap } from '@firebase/util';\n\nexport const enum AppCheckError {\n  ALREADY_ACTIVATED = 'already-activated',\n  USE_BEFORE_ACTIVATION = 'use-before-activation',\n  FETCH_NETWORK_ERROR = 'fetch-network-error',\n  FETCH_PARSE_ERROR = 'fetch-parse-error',\n  FETCH_STATUS_ERROR = 'fetch-status-error',\n  STORAGE_OPEN = 'storage-open',\n  STORAGE_GET = 'storage-get',\n  STORAGE_WRITE = 'storage-set',\n  RECAPTCHA_ERROR = 'recaptcha-error'\n}\n\nconst ERRORS: ErrorMap<AppCheckError> = {\n  [AppCheckError.ALREADY_ACTIVATED]:\n    'You are trying to activate AppCheck for FirebaseApp {$appName}, ' +\n    'while it is already activated. ' +\n    'AppCheck can only be activated once.',\n  [AppCheckError.USE_BEFORE_ACTIVATION]:\n    'AppCheck is being used before activate() is called for FirebaseApp {$appName}. ' +\n    'Please make sure you call activate() before instantiating other Firebase services.',\n  [AppCheckError.FETCH_NETWORK_ERROR]:\n    'Fetch failed to connect to a network. Check Internet connection. ' +\n    'Original error: {$originalErrorMessage}.',\n  [AppCheckError.FETCH_PARSE_ERROR]:\n    'Fetch client could not parse response.' +\n    ' Original error: {$originalErrorMessage}.',\n  [AppCheckError.FETCH_STATUS_ERROR]:\n    'Fetch server returned an HTTP error status. HTTP status: {$httpStatus}.',\n  [AppCheckError.STORAGE_OPEN]:\n    'Error thrown when opening storage. Original error: {$originalErrorMessage}.',\n  [AppCheckError.STORAGE_GET]:\n    'Error thrown when reading from storage. Original error: {$originalErrorMessage}.',\n  [AppCheckError.STORAGE_WRITE]:\n    'Error thrown when writing to storage. Original error: {$originalErrorMessage}.',\n  [AppCheckError.RECAPTCHA_ERROR]: 'ReCAPTCHA error.'\n};\n\ninterface ErrorParams {\n  [AppCheckError.ALREADY_ACTIVATED]: { appName: string };\n  [AppCheckError.USE_BEFORE_ACTIVATION]: { appName: string };\n  [AppCheckError.FETCH_NETWORK_ERROR]: { originalErrorMessage: string };\n  [AppCheckError.FETCH_PARSE_ERROR]: { originalErrorMessage: string };\n  [AppCheckError.FETCH_STATUS_ERROR]: { httpStatus: number };\n  [AppCheckError.STORAGE_OPEN]: { originalErrorMessage?: string };\n  [AppCheckError.STORAGE_GET]: { originalErrorMessage?: string };\n  [AppCheckError.STORAGE_WRITE]: { originalErrorMessage?: string };\n}\n\nexport const ERROR_FACTORY = new ErrorFactory<AppCheckError, ErrorParams>(\n  'appCheck',\n  'AppCheck',\n  ERRORS\n);\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { FirebaseApp } from '@firebase/app-types';\nimport { AppCheckProvider, AppCheckToken } from '@firebase/app-check-types';\nimport { AppCheckTokenListener } from '@firebase/app-check-interop-types';\nimport { Refresher } from './proactive-refresh';\nimport { Deferred } from '@firebase/util';\nimport { GreCAPTCHA } from './recaptcha';\n\nexport interface AppCheckTokenInternal extends AppCheckToken {\n  issuedAtTimeMillis: number;\n}\nexport interface AppCheckState {\n  activated: boolean;\n  tokenListeners: AppCheckTokenListener[];\n  customProvider?: AppCheckProvider;\n  siteKey?: string;\n  token?: AppCheckTokenInternal;\n  tokenRefresher?: Refresher;\n  reCAPTCHAState?: ReCAPTCHAState;\n  isTokenAutoRefreshEnabled?: boolean;\n}\n\nexport interface ReCAPTCHAState {\n  initialized: Deferred<GreCAPTCHA>;\n  widgetId?: string;\n}\n\nexport interface DebugState {\n  enabled: boolean;\n  token?: Deferred<string>;\n}\n\nconst APP_CHECK_STATES = new Map<FirebaseApp, AppCheckState>();\nexport const DEFAULT_STATE: AppCheckState = {\n  activated: false,\n  tokenListeners: []\n};\n\nconst DEBUG_STATE: DebugState = {\n  enabled: false\n};\n\nexport function getState(app: FirebaseApp): AppCheckState {\n  return APP_CHECK_STATES.get(app) || DEFAULT_STATE;\n}\n\nexport function setState(app: FirebaseApp, state: AppCheckState): void {\n  APP_CHECK_STATES.set(app, state);\n}\n\n// for testing only\nexport function clearState(): void {\n  APP_CHECK_STATES.clear();\n  DEBUG_STATE.enabled = false;\n  DEBUG_STATE.token = undefined;\n}\n\nexport function getDebugState(): DebugState {\n  return DEBUG_STATE;\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { GreCAPTCHA } from './recaptcha';\nimport { getState } from './state';\nimport { ERROR_FACTORY, AppCheckError } from './errors';\nimport { FirebaseApp } from '@firebase/app-types';\n\nexport function getRecaptcha(): GreCAPTCHA | undefined {\n  return self.grecaptcha;\n}\n\nexport function ensureActivated(app: FirebaseApp): void {\n  if (!getState(app).activated) {\n    throw ERROR_FACTORY.create(AppCheckError.USE_BEFORE_ACTIVATION, {\n      appName: app.name\n    });\n  }\n}\n\n/**\n * Copied from https://stackoverflow.com/a/2117523\n */\nexport function uuidv4(): string {\n  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {\n    const r = (Math.random() * 16) | 0,\n      v = c === 'x' ? r : (r & 0x3) | 0x8;\n    return v.toString(16);\n  });\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { FirebaseApp } from '@firebase/app-types';\nimport { getState, setState } from './state';\nimport { Deferred } from '@firebase/util';\nimport { getRecaptcha, ensureActivated } from './util';\n\nexport const RECAPTCHA_URL = 'https://www.google.com/recaptcha/api.js';\n\nexport function initialize(\n  app: FirebaseApp,\n  siteKey: string\n): Promise<GreCAPTCHA> {\n  const state = getState(app);\n  const initialized = new Deferred<GreCAPTCHA>();\n\n  setState(app, { ...state, reCAPTCHAState: { initialized } });\n\n  const divId = `fire_app_check_${app.name}`;\n  const invisibleDiv = document.createElement('div');\n  invisibleDiv.id = divId;\n  invisibleDiv.style.display = 'none';\n\n  document.body.appendChild(invisibleDiv);\n\n  const grecaptcha = getRecaptcha();\n  if (!grecaptcha) {\n    loadReCAPTCHAScript(() => {\n      const grecaptcha = getRecaptcha();\n\n      if (!grecaptcha) {\n        // it shouldn't happen.\n        throw new Error('no recaptcha');\n      }\n      grecaptcha.ready(() => {\n        // Invisible widgets allow us to set a different siteKey for each widget, so we use them to support multiple apps\n        renderInvisibleWidget(app, siteKey, grecaptcha, divId);\n        initialized.resolve(grecaptcha);\n      });\n    });\n  } else {\n    grecaptcha.ready(() => {\n      renderInvisibleWidget(app, siteKey, grecaptcha, divId);\n      initialized.resolve(grecaptcha);\n    });\n  }\n\n  return initialized.promise;\n}\n\nexport async function getToken(app: FirebaseApp): Promise<string> {\n  ensureActivated(app);\n\n  // ensureActivated() guarantees that reCAPTCHAState is set\n  const reCAPTCHAState = getState(app).reCAPTCHAState!;\n  const recaptcha = await reCAPTCHAState.initialized.promise;\n\n  return new Promise((resolve, _reject) => {\n    // Updated after initialization is complete.\n    const reCAPTCHAState = getState(app).reCAPTCHAState!;\n    recaptcha.ready(() => {\n      resolve(\n        // widgetId is guaranteed to be available if reCAPTCHAState.initialized.promise resolved.\n        recaptcha.execute(reCAPTCHAState.widgetId!, {\n          action: 'fire_app_check'\n        })\n      );\n    });\n  });\n}\n\n/**\n *\n * @param app\n * @param container - Id of a HTML element.\n */\nfunction renderInvisibleWidget(\n  app: FirebaseApp,\n  siteKey: string,\n  grecaptcha: GreCAPTCHA,\n  container: string\n): void {\n  const widgetId = grecaptcha.render(container, {\n    sitekey: siteKey,\n    size: 'invisible'\n  });\n\n  const state = getState(app);\n\n  setState(app, {\n    ...state,\n    reCAPTCHAState: {\n      ...state.reCAPTCHAState!, // state.reCAPTCHAState is set in the initialize()\n      widgetId\n    }\n  });\n}\n\nfunction loadReCAPTCHAScript(onload: () => void): void {\n  const script = document.createElement('script');\n  script.src = `${RECAPTCHA_URL}`;\n  script.onload = onload;\n  document.head.appendChild(script);\n}\n\ndeclare global {\n  interface Window {\n    grecaptcha: GreCAPTCHA | undefined;\n  }\n}\n\nexport interface GreCAPTCHA {\n  ready: (callback: () => void) => void;\n  execute: (siteKey: string, options: { action: string }) => Promise<string>;\n  render: (\n    container: string | HTMLElement,\n    parameters: GreCAPTCHARenderOption\n  ) => string;\n}\n\nexport interface GreCAPTCHARenderOption {\n  sitekey: string;\n  size: 'invisible';\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nexport const BASE_ENDPOINT =\n  'https://content-firebaseappcheck.googleapis.com/v1beta';\n\nexport const EXCHANGE_RECAPTCHA_TOKEN_METHOD = 'exchangeRecaptchaToken';\nexport const EXCHANGE_DEBUG_TOKEN_METHOD = 'exchangeDebugToken';\n\nexport const TOKEN_REFRESH_TIME = {\n  /**\n   * The offset time before token natural expiration to run the refresh.\n   * This is currently 5 minutes.\n   */\n  OFFSET_DURATION: 5 * 60 * 1000,\n  /**\n   * This is the first retrial wait after an error. This is currently\n   * 30 seconds.\n   */\n  RETRIAL_MIN_WAIT: 30 * 1000,\n  /**\n   * This is the maximum retrial wait, currently 16 minutes.\n   */\n  RETRIAL_MAX_WAIT: 16 * 60 * 1000\n};\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Deferred } from '@firebase/util';\n\n/**\n * Port from auth proactiverefresh.js\n *\n */\n// TODO: move it to @firebase/util?\n// TODO: allow to config whether refresh should happen in the background\nexport class Refresher {\n  private pending: Deferred<unknown> | null = null;\n  private nextErrorWaitInterval: number;\n  constructor(\n    private readonly operation: () => Promise<unknown>,\n    private readonly retryPolicy: (error: unknown) => boolean,\n    private readonly getWaitDuration: () => number,\n    private readonly lowerBound: number,\n    private readonly upperBound: number\n  ) {\n    this.nextErrorWaitInterval = lowerBound;\n\n    if (lowerBound > upperBound) {\n      throw new Error(\n        'Proactive refresh lower bound greater than upper bound!'\n      );\n    }\n  }\n\n  start(): void {\n    this.nextErrorWaitInterval = this.lowerBound;\n    this.process(true).catch(() => {\n      /* we don't care about the result */\n    });\n  }\n\n  stop(): void {\n    if (this.pending) {\n      this.pending.reject('cancelled');\n      this.pending = null;\n    }\n  }\n\n  isRunning(): boolean {\n    return !!this.pending;\n  }\n\n  private async process(hasSucceeded: boolean): Promise<void> {\n    this.stop();\n    try {\n      this.pending = new Deferred();\n      await sleep(this.getNextRun(hasSucceeded));\n\n      // Why do we resolve a promise, then immediate wait for it?\n      // We do it to make the promise chain cancellable.\n      // We can call stop() which rejects the promise before the following line execute, which makes\n      // the code jump to the catch block.\n      // TODO: unit test this\n      this.pending.resolve();\n      await this.pending.promise;\n      this.pending = new Deferred();\n      await this.operation();\n\n      this.pending.resolve();\n      await this.pending.promise;\n\n      this.process(true).catch(() => {\n        /* we don't care about the result */\n      });\n    } catch (error) {\n      if (this.retryPolicy(error)) {\n        this.process(false).catch(() => {\n          /* we don't care about the result */\n        });\n      } else {\n        this.stop();\n      }\n    }\n  }\n\n  private getNextRun(hasSucceeded: boolean): number {\n    if (hasSucceeded) {\n      // If last operation succeeded, reset next error wait interval and return\n      // the default wait duration.\n      this.nextErrorWaitInterval = this.lowerBound;\n      // Return typical wait duration interval after a successful operation.\n      return this.getWaitDuration();\n    } else {\n      // Get next error wait interval.\n      const currentErrorWaitInterval = this.nextErrorWaitInterval;\n      // Double interval for next consecutive error.\n      this.nextErrorWaitInterval *= 2;\n      // Make sure next wait interval does not exceed the maximum upper bound.\n      if (this.nextErrorWaitInterval > this.upperBound) {\n        this.nextErrorWaitInterval = this.upperBound;\n      }\n      return currentErrorWaitInterval;\n    }\n  }\n}\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise<void>(resolve => {\n    setTimeout(resolve, ms);\n  });\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  BASE_ENDPOINT,\n  EXCHANGE_DEBUG_TOKEN_METHOD,\n  EXCHANGE_RECAPTCHA_TOKEN_METHOD\n} from './constants';\nimport { FirebaseApp } from '@firebase/app-types';\nimport { ERROR_FACTORY, AppCheckError } from './errors';\nimport { Provider } from '@firebase/component';\nimport { AppCheckTokenInternal } from './state';\n\n/**\n * Response JSON returned from AppCheck server endpoint.\n */\ninterface AppCheckResponse {\n  attestationToken: string;\n  // timeToLive\n  ttl: string;\n}\n\ninterface AppCheckRequest {\n  url: string;\n  body: { [key: string]: string };\n}\n\nexport async function exchangeToken(\n  { url, body }: AppCheckRequest,\n  platformLoggerProvider: Provider<'platform-logger'>\n): Promise<AppCheckTokenInternal> {\n  const headers: HeadersInit = {\n    'Content-Type': 'application/json'\n  };\n  // If platform logger exists, add the platform info string to the header.\n  const platformLogger = platformLoggerProvider.getImmediate({\n    optional: true\n  });\n  if (platformLogger) {\n    headers['X-Firebase-Client'] = platformLogger.getPlatformInfoString();\n  }\n  const options: RequestInit = {\n    method: 'POST',\n    body: JSON.stringify(body),\n    headers\n  };\n  let response;\n  try {\n    response = await fetch(url, options);\n  } catch (originalError) {\n    throw ERROR_FACTORY.create(AppCheckError.FETCH_NETWORK_ERROR, {\n      originalErrorMessage: originalError.message\n    });\n  }\n\n  if (response.status !== 200) {\n    throw ERROR_FACTORY.create(AppCheckError.FETCH_STATUS_ERROR, {\n      httpStatus: response.status\n    });\n  }\n\n  let responseBody: AppCheckResponse;\n  try {\n    // JSON parsing throws SyntaxError if the response body isn't a JSON string.\n    responseBody = await response.json();\n  } catch (originalError) {\n    throw ERROR_FACTORY.create(AppCheckError.FETCH_PARSE_ERROR, {\n      originalErrorMessage: originalError.message\n    });\n  }\n\n  // Protobuf duration format.\n  // https://developers.google.com/protocol-buffers/docs/reference/java/com/google/protobuf/Duration\n  const match = responseBody.ttl.match(/^([\\d.]+)(s)$/);\n  if (!match || !match[2] || isNaN(Number(match[1]))) {\n    throw ERROR_FACTORY.create(AppCheckError.FETCH_PARSE_ERROR, {\n      originalErrorMessage:\n        `ttl field (timeToLive) is not in standard Protobuf Duration ` +\n        `format: ${responseBody.ttl}`\n    });\n  }\n  const timeToLiveAsNumber = Number(match[1]) * 1000;\n\n  const now = Date.now();\n  return {\n    token: responseBody.attestationToken,\n    expireTimeMillis: now + timeToLiveAsNumber,\n    issuedAtTimeMillis: now\n  };\n}\n\nexport function getExchangeRecaptchaTokenRequest(\n  app: FirebaseApp,\n  reCAPTCHAToken: string\n): AppCheckRequest {\n  const { projectId, appId, apiKey } = app.options;\n\n  return {\n    url: `${BASE_ENDPOINT}/projects/${projectId}/apps/${appId}:${EXCHANGE_RECAPTCHA_TOKEN_METHOD}?key=${apiKey}`,\n    body: {\n      // eslint-disable-next-line\n      recaptcha_token: reCAPTCHAToken\n    }\n  };\n}\n\nexport function getExchangeDebugTokenRequest(\n  app: FirebaseApp,\n  debugToken: string\n): AppCheckRequest {\n  const { projectId, appId, apiKey } = app.options;\n\n  return {\n    url: `${BASE_ENDPOINT}/projects/${projectId}/apps/${appId}:${EXCHANGE_DEBUG_TOKEN_METHOD}?key=${apiKey}`,\n    body: {\n      // eslint-disable-next-line\n      debug_token: debugToken\n    }\n  };\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { FirebaseApp } from '@firebase/app-types';\nimport { ERROR_FACTORY, AppCheckError } from './errors';\nimport { AppCheckTokenInternal } from './state';\nconst DB_NAME = 'firebase-app-check-database';\nconst DB_VERSION = 1;\nconst STORE_NAME = 'firebase-app-check-store';\nconst DEBUG_TOKEN_KEY = 'debug-token';\n\nlet dbPromise: Promise<IDBDatabase> | null = null;\nfunction getDBPromise(): Promise<IDBDatabase> {\n  if (dbPromise) {\n    return dbPromise;\n  }\n\n  dbPromise = new Promise((resolve, reject) => {\n    try {\n      const request = indexedDB.open(DB_NAME, DB_VERSION);\n\n      request.onsuccess = event => {\n        resolve((event.target as IDBOpenDBRequest).result);\n      };\n\n      request.onerror = event => {\n        reject(\n          ERROR_FACTORY.create(AppCheckError.STORAGE_OPEN, {\n            originalErrorMessage: (event.target as IDBRequest).error?.message\n          })\n        );\n      };\n\n      request.onupgradeneeded = event => {\n        const db = (event.target as IDBOpenDBRequest).result;\n\n        // We don't use 'break' in this switch statement, the fall-through\n        // behavior is what we want, because if there are multiple versions between\n        // the old version and the current version, we want ALL the migrations\n        // that correspond to those versions to run, not only the last one.\n        // eslint-disable-next-line default-case\n        switch (event.oldVersion) {\n          case 0:\n            db.createObjectStore(STORE_NAME, {\n              keyPath: 'compositeKey'\n            });\n        }\n      };\n    } catch (e) {\n      reject(\n        ERROR_FACTORY.create(AppCheckError.STORAGE_OPEN, {\n          originalErrorMessage: e.message\n        })\n      );\n    }\n  });\n\n  return dbPromise;\n}\n\nexport function readTokenFromIndexedDB(\n  app: FirebaseApp\n): Promise<AppCheckTokenInternal | undefined> {\n  return read(computeKey(app)) as Promise<AppCheckTokenInternal | undefined>;\n}\n\nexport function writeTokenToIndexedDB(\n  app: FirebaseApp,\n  token: AppCheckTokenInternal\n): Promise<void> {\n  return write(computeKey(app), token);\n}\n\nexport function writeDebugTokenToIndexedDB(token: string): Promise<void> {\n  return write(DEBUG_TOKEN_KEY, token);\n}\n\nexport function readDebugTokenFromIndexedDB(): Promise<string | undefined> {\n  return read(DEBUG_TOKEN_KEY) as Promise<string | undefined>;\n}\n\nasync function write(key: string, value: unknown): Promise<void> {\n  const db = await getDBPromise();\n\n  const transaction = db.transaction(STORE_NAME, 'readwrite');\n  const store = transaction.objectStore(STORE_NAME);\n  const request = store.put({\n    compositeKey: key,\n    value\n  });\n\n  return new Promise((resolve, reject) => {\n    request.onsuccess = _event => {\n      resolve();\n    };\n\n    transaction.onerror = event => {\n      reject(\n        ERROR_FACTORY.create(AppCheckError.STORAGE_WRITE, {\n          originalErrorMessage: (event.target as IDBRequest).error?.message\n        })\n      );\n    };\n  });\n}\n\nasync function read(key: string): Promise<unknown> {\n  const db = await getDBPromise();\n\n  const transaction = db.transaction(STORE_NAME, 'readonly');\n  const store = transaction.objectStore(STORE_NAME);\n  const request = store.get(key);\n\n  return new Promise((resolve, reject) => {\n    request.onsuccess = event => {\n      const result = (event.target as IDBRequest).result;\n\n      if (result) {\n        resolve(result.value);\n      } else {\n        resolve(undefined);\n      }\n    };\n\n    transaction.onerror = event => {\n      reject(\n        ERROR_FACTORY.create(AppCheckError.STORAGE_GET, {\n          originalErrorMessage: (event.target as IDBRequest).error?.message\n        })\n      );\n    };\n  });\n}\n\nfunction computeKey(app: FirebaseApp): string {\n  return `${app.options.appId}-${app.name}`;\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Logger } from '@firebase/logger';\n\nexport const logger = new Logger('@firebase/app-check');\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { uuidv4 } from './util';\nimport { FirebaseApp } from '@firebase/app-types';\nimport { isIndexedDBAvailable } from '@firebase/util';\nimport {\n  readDebugTokenFromIndexedDB,\n  readTokenFromIndexedDB,\n  writeDebugTokenToIndexedDB,\n  writeTokenToIndexedDB\n} from './indexeddb';\nimport { logger } from './logger';\nimport { AppCheckTokenInternal } from './state';\n\n/**\n * Always resolves. In case of an error reading from indexeddb, resolve with undefined\n */\nexport async function readTokenFromStorage(\n  app: FirebaseApp\n): Promise<AppCheckTokenInternal | undefined> {\n  if (isIndexedDBAvailable()) {\n    let token = undefined;\n    try {\n      token = await readTokenFromIndexedDB(app);\n    } catch (e) {\n      // swallow the error and return undefined\n      logger.warn(`Failed to read token from indexeddb. Error: ${e}`);\n    }\n    return token;\n  }\n\n  return undefined;\n}\n\n/**\n * Always resolves. In case of an error writing to indexeddb, print a warning and resolve the promise\n */\nexport function writeTokenToStorage(\n  app: FirebaseApp,\n  token: AppCheckTokenInternal\n): Promise<void> {\n  if (isIndexedDBAvailable()) {\n    return writeTokenToIndexedDB(app, token).catch(e => {\n      // swallow the error and resolve the promise\n      logger.warn(`Failed to write token to indexeddb. Error: ${e}`);\n    });\n  }\n\n  return Promise.resolve();\n}\n\nexport async function readOrCreateDebugTokenFromStorage(): Promise<string> {\n  /**\n   * Theoretically race condition can happen if we read, then write in 2 separate transactions.\n   * But it won't happen here, because this function will be called exactly once.\n   */\n  let existingDebugToken: string | undefined = undefined;\n  try {\n    existingDebugToken = await readDebugTokenFromIndexedDB();\n  } catch (_e) {\n    // failed to read from indexeddb. We assume there is no existing debug token, and generate a new one.\n  }\n\n  if (!existingDebugToken) {\n    // create a new debug token\n    const newToken = uuidv4();\n    // We don't need to block on writing to indexeddb\n    // In case persistence failed, a new debug token will be generated everytime the page is refreshed.\n    // It renders the debug token useless because you have to manually register(whitelist) the new token in the firebase console again and again.\n    // If you see this error trying to use debug token, it probably means you are using a browser that doesn't support indexeddb.\n    // You should switch to a different browser that supports indexeddb\n    writeDebugTokenToIndexedDB(newToken).catch(e =>\n      logger.warn(`Failed to persist debug token to indexeddb. Error: ${e}`)\n    );\n    // Not using logger because I don't think we ever want this accidentally hidden?\n    console.log(\n      `AppCheck debug token: ${newToken}. You will need to whitelist it in the Firebase console for it to work`\n    );\n    return newToken;\n  } else {\n    return existingDebugToken;\n  }\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { getDebugState } from './state';\nimport { readOrCreateDebugTokenFromStorage } from './storage';\nimport { Deferred, getGlobal } from '@firebase/util';\n\ndeclare global {\n  // var must be used for global scopes\n  // https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-4.html#type-checking-for-globalthis\n  // eslint-disable-next-line no-var\n  var FIREBASE_APPCHECK_DEBUG_TOKEN: boolean | string | undefined;\n}\n\nexport function isDebugMode(): boolean {\n  const debugState = getDebugState();\n  return debugState.enabled;\n}\n\nexport async function getDebugToken(): Promise<string> {\n  const state = getDebugState();\n\n  if (state.enabled && state.token) {\n    return state.token.promise;\n  } else {\n    // should not happen!\n    throw Error(`\n            Can't get debug token in production mode.\n        `);\n  }\n}\n\nexport function initializeDebugMode(): void {\n  const globals = getGlobal();\n  if (\n    typeof globals.FIREBASE_APPCHECK_DEBUG_TOKEN !== 'string' &&\n    globals.FIREBASE_APPCHECK_DEBUG_TOKEN !== true\n  ) {\n    return;\n  }\n\n  const debugState = getDebugState();\n  debugState.enabled = true;\n  const deferredToken = new Deferred<string>();\n  debugState.token = deferredToken;\n\n  if (typeof globals.FIREBASE_APPCHECK_DEBUG_TOKEN === 'string') {\n    deferredToken.resolve(globals.FIREBASE_APPCHECK_DEBUG_TOKEN);\n  } else {\n    deferredToken.resolve(readOrCreateDebugTokenFromStorage());\n  }\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { getToken as getReCAPTCHAToken } from './recaptcha';\nimport { FirebaseApp } from '@firebase/app-types';\nimport {\n  AppCheckTokenResult,\n  AppCheckTokenListener\n} from '@firebase/app-check-interop-types';\nimport {\n  AppCheckTokenInternal,\n  getDebugState,\n  getState,\n  setState\n} from './state';\nimport { TOKEN_REFRESH_TIME } from './constants';\nimport { Refresher } from './proactive-refresh';\nimport { ensureActivated } from './util';\nimport {\n  exchangeToken,\n  getExchangeDebugTokenRequest,\n  getExchangeRecaptchaTokenRequest\n} from './client';\nimport { writeTokenToStorage, readTokenFromStorage } from './storage';\nimport { getDebugToken, isDebugMode } from './debug';\nimport { base64, issuedAtTime } from '@firebase/util';\nimport { ERROR_FACTORY, AppCheckError } from './errors';\nimport { logger } from './logger';\nimport { Provider } from '@firebase/component';\n\n// Initial hardcoded value agreed upon across platforms for initial launch.\n// Format left open for possible dynamic error values and other fields in the future.\nexport const defaultTokenErrorData = { error: 'UNKNOWN_ERROR' };\n\n/**\n * Stringify and base64 encode token error data.\n *\n * @param tokenError Error data, currently hardcoded.\n */\nexport function formatDummyToken(\n  tokenErrorData: Record<string, string>\n): string {\n  return base64.encodeString(\n    JSON.stringify(tokenErrorData),\n    /* webSafe= */ false\n  );\n}\n\n/**\n * This function will always resolve.\n * The result will contain an error field if there is any error.\n * In case there is an error, the token field in the result will be populated with a dummy value\n */\nexport async function getToken(\n  app: FirebaseApp,\n  platformLoggerProvider: Provider<'platform-logger'>,\n  forceRefresh = false\n): Promise<AppCheckTokenResult> {\n  ensureActivated(app);\n  /**\n   * DEBUG MODE\n   * return the debug token directly\n   */\n  if (isDebugMode()) {\n    const tokenFromDebugExchange: AppCheckTokenInternal = await exchangeToken(\n      getExchangeDebugTokenRequest(app, await getDebugToken()),\n      platformLoggerProvider\n    );\n    return { token: tokenFromDebugExchange.token };\n  }\n\n  const state = getState(app);\n\n  let token: AppCheckTokenInternal | undefined = state.token;\n  let error: Error | undefined = undefined;\n\n  /**\n   * try to load token from indexedDB if it's the first time this function is called\n   */\n  if (!token) {\n    // readTokenFromStorage() always resolves. In case of an error, it resolves with `undefined`.\n    const cachedToken = await readTokenFromStorage(app);\n    if (cachedToken && isValid(cachedToken)) {\n      token = cachedToken;\n\n      setState(app, { ...state, token });\n      // notify all listeners with the cached token\n      notifyTokenListeners(app, { token: token.token });\n    }\n  }\n\n  // return the cached token if it's valid\n  if (!forceRefresh && token && isValid(token)) {\n    return {\n      token: token.token\n    };\n  }\n\n  /**\n   * request a new token\n   */\n  try {\n    if (state.customProvider) {\n      const customToken = await state.customProvider.getToken();\n      // Try to extract IAT from custom token, in case this token is not\n      // being newly issued. JWT timestamps are in seconds since epoch.\n      const issuedAtTimeSeconds = issuedAtTime(customToken.token);\n      // Very basic validation, use current timestamp as IAT if JWT\n      // has no `iat` field or value is out of bounds.\n      const issuedAtTimeMillis =\n        issuedAtTimeSeconds !== null &&\n        issuedAtTimeSeconds < Date.now() &&\n        issuedAtTimeSeconds > 0\n          ? issuedAtTimeSeconds * 1000\n          : Date.now();\n\n      token = { ...customToken, issuedAtTimeMillis };\n    } else {\n      const attestedClaimsToken = await getReCAPTCHAToken(app).catch(_e => {\n        // reCaptcha.execute() throws null which is not very descriptive.\n        throw ERROR_FACTORY.create(AppCheckError.RECAPTCHA_ERROR);\n      });\n      token = await exchangeToken(\n        getExchangeRecaptchaTokenRequest(app, attestedClaimsToken),\n        platformLoggerProvider\n      );\n    }\n  } catch (e) {\n    // `getToken()` should never throw, but logging error text to console will aid debugging.\n    logger.error(e);\n    error = e;\n  }\n\n  let interopTokenResult: AppCheckTokenResult | undefined;\n  if (!token) {\n    // if token is undefined, there must be an error.\n    // we return a dummy token along with the error\n    interopTokenResult = makeDummyTokenResult(error!);\n  } else {\n    interopTokenResult = {\n      token: token.token\n    };\n    // write the new token to the memory state as well ashe persistent storage.\n    // Only do it if we got a valid new token\n    setState(app, { ...state, token });\n    await writeTokenToStorage(app, token);\n  }\n\n  notifyTokenListeners(app, interopTokenResult);\n  return interopTokenResult;\n}\n\nexport function addTokenListener(\n  app: FirebaseApp,\n  platformLoggerProvider: Provider<'platform-logger'>,\n  listener: AppCheckTokenListener\n): void {\n  const state = getState(app);\n  const newState = {\n    ...state,\n    tokenListeners: [...state.tokenListeners, listener]\n  };\n\n  /**\n   * DEBUG MODE\n   *\n   * invoke the listener once with the debug token.\n   */\n  if (isDebugMode()) {\n    const debugState = getDebugState();\n    if (debugState.enabled && debugState.token) {\n      debugState.token.promise\n        .then(token => listener({ token }))\n        .catch(() => {\n          /* we don't care about exceptions thrown in listeners */\n        });\n    }\n  } else {\n    /**\n     * PROD MODE\n     *\n     * invoke the listener with the valid token, then start the token refresher\n     */\n    if (!newState.tokenRefresher) {\n      const tokenRefresher = createTokenRefresher(app, platformLoggerProvider);\n      newState.tokenRefresher = tokenRefresher;\n    }\n\n    // Create the refresher but don't start it if `isTokenAutoRefreshEnabled`\n    // is not true.\n    if (\n      !newState.tokenRefresher.isRunning() &&\n      state.isTokenAutoRefreshEnabled === true\n    ) {\n      newState.tokenRefresher.start();\n    }\n\n    // invoke the listener async immediately if there is a valid token\n    if (state.token && isValid(state.token)) {\n      const validToken = state.token;\n      Promise.resolve()\n        .then(() => listener({ token: validToken.token }))\n        .catch(() => {\n          /* we don't care about exceptions thrown in listeners */\n        });\n    }\n  }\n\n  setState(app, newState);\n}\n\nexport function removeTokenListener(\n  app: FirebaseApp,\n  listener: AppCheckTokenListener\n): void {\n  const state = getState(app);\n\n  const newListeners = state.tokenListeners.filter(l => l !== listener);\n  if (\n    newListeners.length === 0 &&\n    state.tokenRefresher &&\n    state.tokenRefresher.isRunning()\n  ) {\n    state.tokenRefresher.stop();\n  }\n\n  setState(app, {\n    ...state,\n    tokenListeners: newListeners\n  });\n}\n\nfunction createTokenRefresher(\n  app: FirebaseApp,\n  platformLoggerProvider: Provider<'platform-logger'>\n): Refresher {\n  return new Refresher(\n    // Keep in mind when this fails for any reason other than the ones\n    // for which we should retry, it will effectively stop the proactive refresh.\n    async () => {\n      const state = getState(app);\n      // If there is no token, we will try to load it from storage and use it\n      // If there is a token, we force refresh it because we know it's going to expire soon\n      let result;\n      if (!state.token) {\n        result = await getToken(app, platformLoggerProvider);\n      } else {\n        result = await getToken(app, platformLoggerProvider, true);\n      }\n\n      // getToken() always resolves. In case the result has an error field defined, it means the operation failed, and we should retry.\n      if (result.error) {\n        throw result.error;\n      }\n    },\n    () => {\n      // TODO: when should we retry?\n      return true;\n    },\n    () => {\n      const state = getState(app);\n\n      if (state.token) {\n        // issuedAtTime + (50% * total TTL) + 5 minutes\n        let nextRefreshTimeMillis =\n          state.token.issuedAtTimeMillis +\n          (state.token.expireTimeMillis - state.token.issuedAtTimeMillis) *\n            0.5 +\n          5 * 60 * 1000;\n        // Do not allow refresh time to be past (expireTime - 5 minutes)\n        const latestAllowableRefresh =\n          state.token.expireTimeMillis - 5 * 60 * 1000;\n        nextRefreshTimeMillis = Math.min(\n          nextRefreshTimeMillis,\n          latestAllowableRefresh\n        );\n        return Math.max(0, nextRefreshTimeMillis - Date.now());\n      } else {\n        return 0;\n      }\n    },\n    TOKEN_REFRESH_TIME.RETRIAL_MIN_WAIT,\n    TOKEN_REFRESH_TIME.RETRIAL_MAX_WAIT\n  );\n}\n\nfunction notifyTokenListeners(\n  app: FirebaseApp,\n  token: AppCheckTokenResult\n): void {\n  const listeners = getState(app).tokenListeners;\n\n  for (const listener of listeners) {\n    try {\n      listener(token);\n    } catch (e) {\n      // If any handler fails, ignore and run next handler.\n    }\n  }\n}\n\nfunction isValid(token: AppCheckTokenInternal): boolean {\n  return token.expireTimeMillis - Date.now() > 0;\n}\n\nfunction makeDummyTokenResult(error: Error): AppCheckTokenResult {\n  return {\n    token: formatDummyToken(defaultTokenErrorData),\n    error\n  };\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { FirebaseAppCheck, AppCheckProvider } from '@firebase/app-check-types';\nimport { activate, setTokenAutoRefreshEnabled } from './api';\nimport { FirebaseApp } from '@firebase/app-types';\nimport { FirebaseAppCheckInternal } from '@firebase/app-check-interop-types';\nimport {\n  getToken,\n  addTokenListener,\n  removeTokenListener\n} from './internal-api';\nimport { Provider } from '@firebase/component';\n\nexport function factory(app: FirebaseApp): FirebaseAppCheck {\n  return {\n    activate: (\n      siteKeyOrProvider: string | AppCheckProvider,\n      isTokenAutoRefreshEnabled?: boolean\n    ) => activate(app, siteKeyOrProvider, isTokenAutoRefreshEnabled),\n    setTokenAutoRefreshEnabled: (isTokenAutoRefreshEnabled: boolean) =>\n      setTokenAutoRefreshEnabled(app, isTokenAutoRefreshEnabled)\n  };\n}\n\nexport function internalFactory(\n  app: FirebaseApp,\n  platformLoggerProvider: Provider<'platform-logger'>\n): FirebaseAppCheckInternal {\n  return {\n    getToken: forceRefresh =>\n      getToken(app, platformLoggerProvider, forceRefresh),\n    addTokenListener: listener =>\n      addTokenListener(app, platformLoggerProvider, listener),\n    removeTokenListener: listener => removeTokenListener(app, listener)\n  };\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { AppCheckProvider } from '@firebase/app-check-types';\nimport { FirebaseApp } from '@firebase/app-types';\nimport { ERROR_FACTORY, AppCheckError } from './errors';\nimport { initialize as initializeRecaptcha } from './recaptcha';\nimport { getState, setState, AppCheckState } from './state';\n\n/**\n *\n * @param app\n * @param siteKeyOrProvider - optional custom attestation provider\n * or reCAPTCHA siteKey\n * @param isTokenAutoRefreshEnabled - if true, enables auto refresh\n * of appCheck token.\n */\nexport function activate(\n  app: FirebaseApp,\n  siteKeyOrProvider: string | AppCheckProvider,\n  isTokenAutoRefreshEnabled?: boolean\n): void {\n  const state = getState(app);\n  if (state.activated) {\n    throw ERROR_FACTORY.create(AppCheckError.ALREADY_ACTIVATED, {\n      appName: app.name\n    });\n  }\n\n  const newState: AppCheckState = { ...state, activated: true };\n  if (typeof siteKeyOrProvider === 'string') {\n    newState.siteKey = siteKeyOrProvider;\n  } else {\n    newState.customProvider = siteKeyOrProvider;\n  }\n\n  // Use value of global `automaticDataCollectionEnabled` (which\n  // itself defaults to false if not specified in config) if\n  // `isTokenAutoRefreshEnabled` param was not provided by user.\n  newState.isTokenAutoRefreshEnabled =\n    isTokenAutoRefreshEnabled === undefined\n      ? app.automaticDataCollectionEnabled\n      : isTokenAutoRefreshEnabled;\n\n  setState(app, newState);\n\n  // initialize reCAPTCHA if siteKey is provided\n  if (newState.siteKey) {\n    initializeRecaptcha(app, newState.siteKey).catch(() => {\n      /* we don't care about the initialization result in activate() */\n    });\n  }\n}\n\nexport function setTokenAutoRefreshEnabled(\n  app: FirebaseApp,\n  isTokenAutoRefreshEnabled: boolean\n): void {\n  const state = getState(app);\n  // This will exist if any product libraries have called\n  // `addTokenListener()`\n  if (state.tokenRefresher) {\n    if (isTokenAutoRefreshEnabled === true) {\n      state.tokenRefresher.start();\n    } else {\n      state.tokenRefresher.stop();\n    }\n  }\n  setState(app, { ...state, isTokenAutoRefreshEnabled });\n}\n","/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport firebase from '@firebase/app';\nimport { _FirebaseNamespace } from '@firebase/app-types/private';\nimport { Component, ComponentType } from '@firebase/component';\nimport {\n  FirebaseAppCheck,\n  AppCheckComponentName\n} from '@firebase/app-check-types';\nimport { factory, internalFactory } from './factory';\nimport { initializeDebugMode } from './debug';\nimport { AppCheckInternalComponentName } from '@firebase/app-check-interop-types';\nimport { name, version } from '../package.json';\n\nconst APP_CHECK_NAME: AppCheckComponentName = 'appCheck';\nconst APP_CHECK_NAME_INTERNAL: AppCheckInternalComponentName =\n  'app-check-internal';\nfunction registerAppCheck(firebase: _FirebaseNamespace): void {\n  // The public interface\n  firebase.INTERNAL.registerComponent(\n    new Component(\n      APP_CHECK_NAME,\n      container => {\n        // getImmediate for FirebaseApp will always succeed\n        const app = container.getProvider('app').getImmediate();\n        return factory(app);\n      },\n      ComponentType.PUBLIC\n    )\n  );\n\n  // The internal interface used by other Firebase products\n  firebase.INTERNAL.registerComponent(\n    new Component(\n      APP_CHECK_NAME_INTERNAL,\n      container => {\n        // getImmediate for FirebaseApp will always succeed\n        const app = container.getProvider('app').getImmediate();\n        const platformLoggerProvider = container.getProvider('platform-logger');\n        return internalFactory(app, platformLoggerProvider);\n      },\n      ComponentType.PUBLIC\n    )\n  );\n\n  firebase.registerVersion(name, version);\n}\n\nregisterAppCheck(firebase as _FirebaseNamespace);\ninitializeDebugMode();\n\n/**\n * Define extension behavior of `registerAnalytics`\n */\ndeclare module '@firebase/app-types' {\n  interface FirebaseNamespace {\n    appCheck(app?: FirebaseApp): FirebaseAppCheck;\n  }\n  interface FirebaseApp {\n    appCheck(): FirebaseAppCheck;\n  }\n}\n"],"names":["extendStatics","d","b","Object","setPrototypeOf","__proto__","Array","p","prototype","hasOwnProperty","call","__assign","assign","t","s","i","n","arguments","length","apply","this","__awaiter","thisArg","_arguments","P","generator","Promise","resolve","reject","fulfilled","value","step","next","e","rejected","result","done","then","__generator","body","f","y","_","label","sent","trys","ops","g","verb","throw","return","Symbol","iterator","v","op","TypeError","pop","push","__spreadArray","to","from","il","j","base64Decode","str","base64","decodeString","console","error","byteToCharMap_","charToByteMap_","byteToCharMapWebSafe_","charToByteMapWebSafe_","ENCODED_VALS_BASE","ENCODED_VALS","ENCODED_VALS_WEBSAFE","HAS_NATIVE_SUPPORT","atob","encodeByteArray","input","webSafe","isArray","Error","init_","byteToCharMap","output","byte1","haveByte2","byte2","haveByte3","byte3","outByte1","outByte2","outByte3","outByte4","join","encodeString","btoa","out","c","charCodeAt","stringToByteArray","bytes","pos","u","c2","c3","c1","String","fromCharCode","byteArrayToString","decodeStringToByteArray","charToByteMap","charAt","byte4","Deferred","callback","_this","promise","catch","isIndexedDBAvailable","self","indexedDB","ERROR_NAME","__","constructor","create","__extends","code","message","customData","_super","FirebaseError","captureStackTrace","ErrorFactory","_i","data","fullCode","service","template","errors","replace","PATTERN","key","fullMessage","serviceName","jsonEval","JSON","parse","LogLevel","issuedAtTime","token","claims","header","signature","parts","split","decode","Component","mode","instantiationMode","multipleInstances","props","serviceProps","onInstanceCreated","name","instanceFactory","type","defaultLogHandler","instance","logType","args","logLevel","now","Date","toISOString","method","ConsoleMethod","levelStringToEnum","debug","DEBUG","verbose","VERBOSE","info","INFO","warn","WARN","ERROR","silent","SILENT","defaultLogLevel","_a","Logger","_logLevel","val","_logHandler","_userLogHandler","ERRORS","ERROR_FACTORY","APP_CHECK_STATES","Map","DEFAULT_STATE","activated","tokenListeners","DEBUG_STATE","enabled","getState","app","get","setState","state","set","getRecaptcha","grecaptcha","ensureActivated","appName","RECAPTCHA_URL","initialize","siteKey","initialized","reCAPTCHAState","divId","invisibleDiv","document","createElement","id","style","display","appendChild","ready","renderInvisibleWidget","onload","script","src","head","container","widgetId","render","sitekey","size","BASE_ENDPOINT","EXCHANGE_RECAPTCHA_TOKEN_METHOD","EXCHANGE_DEBUG_TOKEN_METHOD","TOKEN_REFRESH_TIME","OFFSET_DURATION","RETRIAL_MIN_WAIT","RETRIAL_MAX_WAIT","Refresher","nextErrorWaitInterval","lowerBound","process","pending","hasSucceeded","stop","ms","getNextRun","setTimeout","operation","retryPolicy","error_1","getWaitDuration","currentErrorWaitInterval","upperBound","exchangeToken","platformLoggerProvider","url","headers","Content-Type","platformLogger","getImmediate","optional","getPlatformInfoString","options","stringify","fetch","response","_b","originalErrorMessage","originalError_1","status","httpStatus","json","responseBody","originalError_2","match","ttl","isNaN","Number","timeToLiveAsNumber","attestationToken","expireTimeMillis","issuedAtTimeMillis","getExchangeDebugTokenRequest","debugToken","projectId","appId","apiKey","debug_token","DB_NAME","DB_VERSION","STORE_NAME","DEBUG_TOKEN_KEY","dbPromise","getDBPromise","request","open","onsuccess","event","target","onerror","onupgradeneeded","db","oldVersion","createObjectStore","keyPath","write","transaction","store","objectStore","put","compositeKey","_event","read","undefined","computeKey","logger","readTokenFromStorage","e_1","writeTokenToStorage","readOrCreateDebugTokenFromStorage","existingDebugToken","newToken","r","Math","random","toString","log","isDebugMode","defaultTokenErrorData","getToken","forceRefresh","getDebugToken","_d","cachedToken","isValid","notifyTokenListeners","customProvider","customToken","issuedAtTimeSeconds","recaptcha","_reject","execute","action","getReCAPTCHAToken","_e","attestedClaimsToken","reCAPTCHAToken","recaptcha_token","interopTokenResult","tokenErrorData","formatDummyToken","addTokenListener","listener","validToken_1","newState","tokenRefresher","nextRefreshTimeMillis","latestAllowableRefresh","min","max","createTokenRefresher","isRunning","isTokenAutoRefreshEnabled","start","listeners_1","factory","activate","siteKeyOrProvider","automaticDataCollectionEnabled","initializeRecaptcha","setTokenAutoRefreshEnabled","internalFactory","removeTokenListener","newListeners","filter","l","firebase","debugState","deferredToken","globals","INTERNAL","registerComponent","getProvider","registerVersion","window","global","getGlobal","FIREBASE_APPCHECK_DEBUG_TOKEN"],"mappings":"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"}