{"version":3,"sources":["node_modules/@firebase/installations/dist/esm/index.esm2017.js","node_modules/@firebase/messaging/dist/esm/index.esm2017.js"],"sourcesContent":["import { _getProvider, getApp, _registerComponent, registerVersion } from '@firebase/app';\nimport { Component } from '@firebase/component';\nimport { ErrorFactory, FirebaseError } from '@firebase/util';\nimport { openDB } from 'idb';\nconst name = \"@firebase/installations\";\nconst version = \"0.6.7\";\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nconst PENDING_TIMEOUT_MS = 10000;\nconst PACKAGE_VERSION = `w:${version}`;\nconst INTERNAL_AUTH_VERSION = 'FIS_v2';\nconst INSTALLATIONS_API_URL = 'https://firebaseinstallations.googleapis.com/v1';\nconst TOKEN_EXPIRATION_BUFFER = 60 * 60 * 1000; // One hour\nconst SERVICE = 'installations';\nconst SERVICE_NAME = 'Installations';\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nconst ERROR_DESCRIPTION_MAP = {\n  [\"missing-app-config-values\" /* ErrorCode.MISSING_APP_CONFIG_VALUES */]: 'Missing App configuration value: \"{$valueName}\"',\n  [\"not-registered\" /* ErrorCode.NOT_REGISTERED */]: 'Firebase Installation is not registered.',\n  [\"installation-not-found\" /* ErrorCode.INSTALLATION_NOT_FOUND */]: 'Firebase Installation not found.',\n  [\"request-failed\" /* ErrorCode.REQUEST_FAILED */]: '{$requestName} request failed with error \"{$serverCode} {$serverStatus}: {$serverMessage}\"',\n  [\"app-offline\" /* ErrorCode.APP_OFFLINE */]: 'Could not process request. Application offline.',\n  [\"delete-pending-registration\" /* ErrorCode.DELETE_PENDING_REGISTRATION */]: \"Can't delete installation while there is a pending registration request.\"\n};\nconst ERROR_FACTORY = new ErrorFactory(SERVICE, SERVICE_NAME, ERROR_DESCRIPTION_MAP);\n/** Returns true if error is a FirebaseError that is based on an error from the server. */\nfunction isServerError(error) {\n  return error instanceof FirebaseError && error.code.includes(\"request-failed\" /* ErrorCode.REQUEST_FAILED */);\n}\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nfunction getInstallationsEndpoint({\n  projectId\n}) {\n  return `${INSTALLATIONS_API_URL}/projects/${projectId}/installations`;\n}\nfunction extractAuthTokenInfoFromResponse(response) {\n  return {\n    token: response.token,\n    requestStatus: 2 /* RequestStatus.COMPLETED */,\n    expiresIn: getExpiresInFromResponseExpiresIn(response.expiresIn),\n    creationTime: Date.now()\n  };\n}\nasync function getErrorFromResponse(requestName, response) {\n  const responseJson = await response.json();\n  const errorData = responseJson.error;\n  return ERROR_FACTORY.create(\"request-failed\" /* ErrorCode.REQUEST_FAILED */, {\n    requestName,\n    serverCode: errorData.code,\n    serverMessage: errorData.message,\n    serverStatus: errorData.status\n  });\n}\nfunction getHeaders({\n  apiKey\n}) {\n  return new Headers({\n    'Content-Type': 'application/json',\n    Accept: 'application/json',\n    'x-goog-api-key': apiKey\n  });\n}\nfunction getHeadersWithAuth(appConfig, {\n  refreshToken\n}) {\n  const headers = getHeaders(appConfig);\n  headers.append('Authorization', getAuthorizationHeader(refreshToken));\n  return headers;\n}\n/**\r\n * Calls the passed in fetch wrapper and returns the response.\r\n * If the returned response has a status of 5xx, re-runs the function once and\r\n * returns the response.\r\n */\nasync function retryIfServerError(fn) {\n  const result = await fn();\n  if (result.status >= 500 && result.status < 600) {\n    // Internal Server Error. Retry request.\n    return fn();\n  }\n  return result;\n}\nfunction getExpiresInFromResponseExpiresIn(responseExpiresIn) {\n  // This works because the server will never respond with fractions of a second.\n  return Number(responseExpiresIn.replace('s', '000'));\n}\nfunction getAuthorizationHeader(refreshToken) {\n  return `${INTERNAL_AUTH_VERSION} ${refreshToken}`;\n}\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nasync function createInstallationRequest({\n  appConfig,\n  heartbeatServiceProvider\n}, {\n  fid\n}) {\n  const endpoint = getInstallationsEndpoint(appConfig);\n  const headers = getHeaders(appConfig);\n  // If heartbeat service exists, add the heartbeat string to the header.\n  const heartbeatService = heartbeatServiceProvider.getImmediate({\n    optional: true\n  });\n  if (heartbeatService) {\n    const heartbeatsHeader = await heartbeatService.getHeartbeatsHeader();\n    if (heartbeatsHeader) {\n      headers.append('x-firebase-client', heartbeatsHeader);\n    }\n  }\n  const body = {\n    fid,\n    authVersion: INTERNAL_AUTH_VERSION,\n    appId: appConfig.appId,\n    sdkVersion: PACKAGE_VERSION\n  };\n  const request = {\n    method: 'POST',\n    headers,\n    body: JSON.stringify(body)\n  };\n  const response = await retryIfServerError(() => fetch(endpoint, request));\n  if (response.ok) {\n    const responseValue = await response.json();\n    const registeredInstallationEntry = {\n      fid: responseValue.fid || fid,\n      registrationStatus: 2 /* RequestStatus.COMPLETED */,\n      refreshToken: responseValue.refreshToken,\n      authToken: extractAuthTokenInfoFromResponse(responseValue.authToken)\n    };\n    return registeredInstallationEntry;\n  } else {\n    throw await getErrorFromResponse('Create Installation', response);\n  }\n}\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n/** Returns a promise that resolves after given time passes. */\nfunction sleep(ms) {\n  return new Promise(resolve => {\n    setTimeout(resolve, ms);\n  });\n}\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nfunction bufferToBase64UrlSafe(array) {\n  const b64 = btoa(String.fromCharCode(...array));\n  return b64.replace(/\\+/g, '-').replace(/\\//g, '_');\n}\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nconst VALID_FID_PATTERN = /^[cdef][\\w-]{21}$/;\nconst INVALID_FID = '';\n/**\r\n * Generates a new FID using random values from Web Crypto API.\r\n * Returns an empty string if FID generation fails for any reason.\r\n */\nfunction generateFid() {\n  try {\n    // A valid FID has exactly 22 base64 characters, which is 132 bits, or 16.5\n    // bytes. our implementation generates a 17 byte array instead.\n    const fidByteArray = new Uint8Array(17);\n    const crypto = self.crypto || self.msCrypto;\n    crypto.getRandomValues(fidByteArray);\n    // Replace the first 4 random bits with the constant FID header of 0b0111.\n    fidByteArray[0] = 0b01110000 + fidByteArray[0] % 0b00010000;\n    const fid = encode(fidByteArray);\n    return VALID_FID_PATTERN.test(fid) ? fid : INVALID_FID;\n  } catch (_a) {\n    // FID generation errored\n    return INVALID_FID;\n  }\n}\n/** Converts a FID Uint8Array to a base64 string representation. */\nfunction encode(fidByteArray) {\n  const b64String = bufferToBase64UrlSafe(fidByteArray);\n  // Remove the 23rd character that was added because of the extra 4 bits at the\n  // end of our 17 byte array, and the '=' padding.\n  return b64String.substr(0, 22);\n}\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n/** Returns a string key that can be used to identify the app. */\nfunction getKey(appConfig) {\n  return `${appConfig.appName}!${appConfig.appId}`;\n}\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nconst fidChangeCallbacks = new Map();\n/**\r\n * Calls the onIdChange callbacks with the new FID value, and broadcasts the\r\n * change to other tabs.\r\n */\nfunction fidChanged(appConfig, fid) {\n  const key = getKey(appConfig);\n  callFidChangeCallbacks(key, fid);\n  broadcastFidChange(key, fid);\n}\nfunction addCallback(appConfig, callback) {\n  // Open the broadcast channel if it's not already open,\n  // to be able to listen to change events from other tabs.\n  getBroadcastChannel();\n  const key = getKey(appConfig);\n  let callbackSet = fidChangeCallbacks.get(key);\n  if (!callbackSet) {\n    callbackSet = new Set();\n    fidChangeCallbacks.set(key, callbackSet);\n  }\n  callbackSet.add(callback);\n}\nfunction removeCallback(appConfig, callback) {\n  const key = getKey(appConfig);\n  const callbackSet = fidChangeCallbacks.get(key);\n  if (!callbackSet) {\n    return;\n  }\n  callbackSet.delete(callback);\n  if (callbackSet.size === 0) {\n    fidChangeCallbacks.delete(key);\n  }\n  // Close broadcast channel if there are no more callbacks.\n  closeBroadcastChannel();\n}\nfunction callFidChangeCallbacks(key, fid) {\n  const callbacks = fidChangeCallbacks.get(key);\n  if (!callbacks) {\n    return;\n  }\n  for (const callback of callbacks) {\n    callback(fid);\n  }\n}\nfunction broadcastFidChange(key, fid) {\n  const channel = getBroadcastChannel();\n  if (channel) {\n    channel.postMessage({\n      key,\n      fid\n    });\n  }\n  closeBroadcastChannel();\n}\nlet broadcastChannel = null;\n/** Opens and returns a BroadcastChannel if it is supported by the browser. */\nfunction getBroadcastChannel() {\n  if (!broadcastChannel && 'BroadcastChannel' in self) {\n    broadcastChannel = new BroadcastChannel('[Firebase] FID Change');\n    broadcastChannel.onmessage = e => {\n      callFidChangeCallbacks(e.data.key, e.data.fid);\n    };\n  }\n  return broadcastChannel;\n}\nfunction closeBroadcastChannel() {\n  if (fidChangeCallbacks.size === 0 && broadcastChannel) {\n    broadcastChannel.close();\n    broadcastChannel = null;\n  }\n}\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nconst DATABASE_NAME = 'firebase-installations-database';\nconst DATABASE_VERSION = 1;\nconst OBJECT_STORE_NAME = 'firebase-installations-store';\nlet dbPromise = null;\nfunction getDbPromise() {\n  if (!dbPromise) {\n    dbPromise = openDB(DATABASE_NAME, DATABASE_VERSION, {\n      upgrade: (db, oldVersion) => {\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 (oldVersion) {\n          case 0:\n            db.createObjectStore(OBJECT_STORE_NAME);\n        }\n      }\n    });\n  }\n  return dbPromise;\n}\n/** Assigns or overwrites the record for the given key with the given value. */\nasync function set(appConfig, value) {\n  const key = getKey(appConfig);\n  const db = await getDbPromise();\n  const tx = db.transaction(OBJECT_STORE_NAME, 'readwrite');\n  const objectStore = tx.objectStore(OBJECT_STORE_NAME);\n  const oldValue = await objectStore.get(key);\n  await objectStore.put(value, key);\n  await tx.done;\n  if (!oldValue || oldValue.fid !== value.fid) {\n    fidChanged(appConfig, value.fid);\n  }\n  return value;\n}\n/** Removes record(s) from the objectStore that match the given key. */\nasync function remove(appConfig) {\n  const key = getKey(appConfig);\n  const db = await getDbPromise();\n  const tx = db.transaction(OBJECT_STORE_NAME, 'readwrite');\n  await tx.objectStore(OBJECT_STORE_NAME).delete(key);\n  await tx.done;\n}\n/**\r\n * Atomically updates a record with the result of updateFn, which gets\r\n * called with the current value. If newValue is undefined, the record is\r\n * deleted instead.\r\n * @return Updated value\r\n */\nasync function update(appConfig, updateFn) {\n  const key = getKey(appConfig);\n  const db = await getDbPromise();\n  const tx = db.transaction(OBJECT_STORE_NAME, 'readwrite');\n  const store = tx.objectStore(OBJECT_STORE_NAME);\n  const oldValue = await store.get(key);\n  const newValue = updateFn(oldValue);\n  if (newValue === undefined) {\n    await store.delete(key);\n  } else {\n    await store.put(newValue, key);\n  }\n  await tx.done;\n  if (newValue && (!oldValue || oldValue.fid !== newValue.fid)) {\n    fidChanged(appConfig, newValue.fid);\n  }\n  return newValue;\n}\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n/**\r\n * Updates and returns the InstallationEntry from the database.\r\n * Also triggers a registration request if it is necessary and possible.\r\n */\nasync function getInstallationEntry(installations) {\n  let registrationPromise;\n  const installationEntry = await update(installations.appConfig, oldEntry => {\n    const installationEntry = updateOrCreateInstallationEntry(oldEntry);\n    const entryWithPromise = triggerRegistrationIfNecessary(installations, installationEntry);\n    registrationPromise = entryWithPromise.registrationPromise;\n    return entryWithPromise.installationEntry;\n  });\n  if (installationEntry.fid === INVALID_FID) {\n    // FID generation failed. Waiting for the FID from the server.\n    return {\n      installationEntry: await registrationPromise\n    };\n  }\n  return {\n    installationEntry,\n    registrationPromise\n  };\n}\n/**\r\n * Creates a new Installation Entry if one does not exist.\r\n * Also clears timed out pending requests.\r\n */\nfunction updateOrCreateInstallationEntry(oldEntry) {\n  const entry = oldEntry || {\n    fid: generateFid(),\n    registrationStatus: 0 /* RequestStatus.NOT_STARTED */\n  };\n  return clearTimedOutRequest(entry);\n}\n/**\r\n * If the Firebase Installation is not registered yet, this will trigger the\r\n * registration and return an InProgressInstallationEntry.\r\n *\r\n * If registrationPromise does not exist, the installationEntry is guaranteed\r\n * to be registered.\r\n */\nfunction triggerRegistrationIfNecessary(installations, installationEntry) {\n  if (installationEntry.registrationStatus === 0 /* RequestStatus.NOT_STARTED */) {\n    if (!navigator.onLine) {\n      // Registration required but app is offline.\n      const registrationPromiseWithError = Promise.reject(ERROR_FACTORY.create(\"app-offline\" /* ErrorCode.APP_OFFLINE */));\n      return {\n        installationEntry,\n        registrationPromise: registrationPromiseWithError\n      };\n    }\n    // Try registering. Change status to IN_PROGRESS.\n    const inProgressEntry = {\n      fid: installationEntry.fid,\n      registrationStatus: 1 /* RequestStatus.IN_PROGRESS */,\n      registrationTime: Date.now()\n    };\n    const registrationPromise = registerInstallation(installations, inProgressEntry);\n    return {\n      installationEntry: inProgressEntry,\n      registrationPromise\n    };\n  } else if (installationEntry.registrationStatus === 1 /* RequestStatus.IN_PROGRESS */) {\n    return {\n      installationEntry,\n      registrationPromise: waitUntilFidRegistration(installations)\n    };\n  } else {\n    return {\n      installationEntry\n    };\n  }\n}\n/** This will be executed only once for each new Firebase Installation. */\nasync function registerInstallation(installations, installationEntry) {\n  try {\n    const registeredInstallationEntry = await createInstallationRequest(installations, installationEntry);\n    return set(installations.appConfig, registeredInstallationEntry);\n  } catch (e) {\n    if (isServerError(e) && e.customData.serverCode === 409) {\n      // Server returned a \"FID can not be used\" error.\n      // Generate a new ID next time.\n      await remove(installations.appConfig);\n    } else {\n      // Registration failed. Set FID as not registered.\n      await set(installations.appConfig, {\n        fid: installationEntry.fid,\n        registrationStatus: 0 /* RequestStatus.NOT_STARTED */\n      });\n    }\n    throw e;\n  }\n}\n/** Call if FID registration is pending in another request. */\nasync function waitUntilFidRegistration(installations) {\n  // Unfortunately, there is no way of reliably observing when a value in\n  // IndexedDB changes (yet, see https://github.com/WICG/indexed-db-observers),\n  // so we need to poll.\n  let entry = await updateInstallationRequest(installations.appConfig);\n  while (entry.registrationStatus === 1 /* RequestStatus.IN_PROGRESS */) {\n    // createInstallation request still in progress.\n    await sleep(100);\n    entry = await updateInstallationRequest(installations.appConfig);\n  }\n  if (entry.registrationStatus === 0 /* RequestStatus.NOT_STARTED */) {\n    // The request timed out or failed in a different call. Try again.\n    const {\n      installationEntry,\n      registrationPromise\n    } = await getInstallationEntry(installations);\n    if (registrationPromise) {\n      return registrationPromise;\n    } else {\n      // if there is no registrationPromise, entry is registered.\n      return installationEntry;\n    }\n  }\n  return entry;\n}\n/**\r\n * Called only if there is a CreateInstallation request in progress.\r\n *\r\n * Updates the InstallationEntry in the DB based on the status of the\r\n * CreateInstallation request.\r\n *\r\n * Returns the updated InstallationEntry.\r\n */\nfunction updateInstallationRequest(appConfig) {\n  return update(appConfig, oldEntry => {\n    if (!oldEntry) {\n      throw ERROR_FACTORY.create(\"installation-not-found\" /* ErrorCode.INSTALLATION_NOT_FOUND */);\n    }\n    return clearTimedOutRequest(oldEntry);\n  });\n}\nfunction clearTimedOutRequest(entry) {\n  if (hasInstallationRequestTimedOut(entry)) {\n    return {\n      fid: entry.fid,\n      registrationStatus: 0 /* RequestStatus.NOT_STARTED */\n    };\n  }\n  return entry;\n}\nfunction hasInstallationRequestTimedOut(installationEntry) {\n  return installationEntry.registrationStatus === 1 /* RequestStatus.IN_PROGRESS */ && installationEntry.registrationTime + PENDING_TIMEOUT_MS < Date.now();\n}\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nasync function generateAuthTokenRequest({\n  appConfig,\n  heartbeatServiceProvider\n}, installationEntry) {\n  const endpoint = getGenerateAuthTokenEndpoint(appConfig, installationEntry);\n  const headers = getHeadersWithAuth(appConfig, installationEntry);\n  // If heartbeat service exists, add the heartbeat string to the header.\n  const heartbeatService = heartbeatServiceProvider.getImmediate({\n    optional: true\n  });\n  if (heartbeatService) {\n    const heartbeatsHeader = await heartbeatService.getHeartbeatsHeader();\n    if (heartbeatsHeader) {\n      headers.append('x-firebase-client', heartbeatsHeader);\n    }\n  }\n  const body = {\n    installation: {\n      sdkVersion: PACKAGE_VERSION,\n      appId: appConfig.appId\n    }\n  };\n  const request = {\n    method: 'POST',\n    headers,\n    body: JSON.stringify(body)\n  };\n  const response = await retryIfServerError(() => fetch(endpoint, request));\n  if (response.ok) {\n    const responseValue = await response.json();\n    const completedAuthToken = extractAuthTokenInfoFromResponse(responseValue);\n    return completedAuthToken;\n  } else {\n    throw await getErrorFromResponse('Generate Auth Token', response);\n  }\n}\nfunction getGenerateAuthTokenEndpoint(appConfig, {\n  fid\n}) {\n  return `${getInstallationsEndpoint(appConfig)}/${fid}/authTokens:generate`;\n}\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n/**\r\n * Returns a valid authentication token for the installation. Generates a new\r\n * token if one doesn't exist, is expired or about to expire.\r\n *\r\n * Should only be called if the Firebase Installation is registered.\r\n */\nasync function refreshAuthToken(installations, forceRefresh = false) {\n  let tokenPromise;\n  const entry = await update(installations.appConfig, oldEntry => {\n    if (!isEntryRegistered(oldEntry)) {\n      throw ERROR_FACTORY.create(\"not-registered\" /* ErrorCode.NOT_REGISTERED */);\n    }\n    const oldAuthToken = oldEntry.authToken;\n    if (!forceRefresh && isAuthTokenValid(oldAuthToken)) {\n      // There is a valid token in the DB.\n      return oldEntry;\n    } else if (oldAuthToken.requestStatus === 1 /* RequestStatus.IN_PROGRESS */) {\n      // There already is a token request in progress.\n      tokenPromise = waitUntilAuthTokenRequest(installations, forceRefresh);\n      return oldEntry;\n    } else {\n      // No token or token expired.\n      if (!navigator.onLine) {\n        throw ERROR_FACTORY.create(\"app-offline\" /* ErrorCode.APP_OFFLINE */);\n      }\n      const inProgressEntry = makeAuthTokenRequestInProgressEntry(oldEntry);\n      tokenPromise = fetchAuthTokenFromServer(installations, inProgressEntry);\n      return inProgressEntry;\n    }\n  });\n  const authToken = tokenPromise ? await tokenPromise : entry.authToken;\n  return authToken;\n}\n/**\r\n * Call only if FID is registered and Auth Token request is in progress.\r\n *\r\n * Waits until the current pending request finishes. If the request times out,\r\n * tries once in this thread as well.\r\n */\nasync function waitUntilAuthTokenRequest(installations, forceRefresh) {\n  // Unfortunately, there is no way of reliably observing when a value in\n  // IndexedDB changes (yet, see https://github.com/WICG/indexed-db-observers),\n  // so we need to poll.\n  let entry = await updateAuthTokenRequest(installations.appConfig);\n  while (entry.authToken.requestStatus === 1 /* RequestStatus.IN_PROGRESS */) {\n    // generateAuthToken still in progress.\n    await sleep(100);\n    entry = await updateAuthTokenRequest(installations.appConfig);\n  }\n  const authToken = entry.authToken;\n  if (authToken.requestStatus === 0 /* RequestStatus.NOT_STARTED */) {\n    // The request timed out or failed in a different call. Try again.\n    return refreshAuthToken(installations, forceRefresh);\n  } else {\n    return authToken;\n  }\n}\n/**\r\n * Called only if there is a GenerateAuthToken request in progress.\r\n *\r\n * Updates the InstallationEntry in the DB based on the status of the\r\n * GenerateAuthToken request.\r\n *\r\n * Returns the updated InstallationEntry.\r\n */\nfunction updateAuthTokenRequest(appConfig) {\n  return update(appConfig, oldEntry => {\n    if (!isEntryRegistered(oldEntry)) {\n      throw ERROR_FACTORY.create(\"not-registered\" /* ErrorCode.NOT_REGISTERED */);\n    }\n    const oldAuthToken = oldEntry.authToken;\n    if (hasAuthTokenRequestTimedOut(oldAuthToken)) {\n      return Object.assign(Object.assign({}, oldEntry), {\n        authToken: {\n          requestStatus: 0 /* RequestStatus.NOT_STARTED */\n        }\n      });\n    }\n    return oldEntry;\n  });\n}\nasync function fetchAuthTokenFromServer(installations, installationEntry) {\n  try {\n    const authToken = await generateAuthTokenRequest(installations, installationEntry);\n    const updatedInstallationEntry = Object.assign(Object.assign({}, installationEntry), {\n      authToken\n    });\n    await set(installations.appConfig, updatedInstallationEntry);\n    return authToken;\n  } catch (e) {\n    if (isServerError(e) && (e.customData.serverCode === 401 || e.customData.serverCode === 404)) {\n      // Server returned a \"FID not found\" or a \"Invalid authentication\" error.\n      // Generate a new ID next time.\n      await remove(installations.appConfig);\n    } else {\n      const updatedInstallationEntry = Object.assign(Object.assign({}, installationEntry), {\n        authToken: {\n          requestStatus: 0 /* RequestStatus.NOT_STARTED */\n        }\n      });\n      await set(installations.appConfig, updatedInstallationEntry);\n    }\n    throw e;\n  }\n}\nfunction isEntryRegistered(installationEntry) {\n  return installationEntry !== undefined && installationEntry.registrationStatus === 2 /* RequestStatus.COMPLETED */;\n}\nfunction isAuthTokenValid(authToken) {\n  return authToken.requestStatus === 2 /* RequestStatus.COMPLETED */ && !isAuthTokenExpired(authToken);\n}\nfunction isAuthTokenExpired(authToken) {\n  const now = Date.now();\n  return now < authToken.creationTime || authToken.creationTime + authToken.expiresIn < now + TOKEN_EXPIRATION_BUFFER;\n}\n/** Returns an updated InstallationEntry with an InProgressAuthToken. */\nfunction makeAuthTokenRequestInProgressEntry(oldEntry) {\n  const inProgressAuthToken = {\n    requestStatus: 1 /* RequestStatus.IN_PROGRESS */,\n    requestTime: Date.now()\n  };\n  return Object.assign(Object.assign({}, oldEntry), {\n    authToken: inProgressAuthToken\n  });\n}\nfunction hasAuthTokenRequestTimedOut(authToken) {\n  return authToken.requestStatus === 1 /* RequestStatus.IN_PROGRESS */ && authToken.requestTime + PENDING_TIMEOUT_MS < Date.now();\n}\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n/**\r\n * Creates a Firebase Installation if there isn't one for the app and\r\n * returns the Installation ID.\r\n * @param installations - The `Installations` instance.\r\n *\r\n * @public\r\n */\nasync function getId(installations) {\n  const installationsImpl = installations;\n  const {\n    installationEntry,\n    registrationPromise\n  } = await getInstallationEntry(installationsImpl);\n  if (registrationPromise) {\n    registrationPromise.catch(console.error);\n  } else {\n    // If the installation is already registered, update the authentication\n    // token if needed.\n    refreshAuthToken(installationsImpl).catch(console.error);\n  }\n  return installationEntry.fid;\n}\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n/**\r\n * Returns a Firebase Installations auth token, identifying the current\r\n * Firebase Installation.\r\n * @param installations - The `Installations` instance.\r\n * @param forceRefresh - Force refresh regardless of token expiration.\r\n *\r\n * @public\r\n */\nasync function getToken(installations, forceRefresh = false) {\n  const installationsImpl = installations;\n  await completeInstallationRegistration(installationsImpl);\n  // At this point we either have a Registered Installation in the DB, or we've\n  // already thrown an error.\n  const authToken = await refreshAuthToken(installationsImpl, forceRefresh);\n  return authToken.token;\n}\nasync function completeInstallationRegistration(installations) {\n  const {\n    registrationPromise\n  } = await getInstallationEntry(installations);\n  if (registrationPromise) {\n    // A createInstallation request is in progress. Wait until it finishes.\n    await registrationPromise;\n  }\n}\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nasync function deleteInstallationRequest(appConfig, installationEntry) {\n  const endpoint = getDeleteEndpoint(appConfig, installationEntry);\n  const headers = getHeadersWithAuth(appConfig, installationEntry);\n  const request = {\n    method: 'DELETE',\n    headers\n  };\n  const response = await retryIfServerError(() => fetch(endpoint, request));\n  if (!response.ok) {\n    throw await getErrorFromResponse('Delete Installation', response);\n  }\n}\nfunction getDeleteEndpoint(appConfig, {\n  fid\n}) {\n  return `${getInstallationsEndpoint(appConfig)}/${fid}`;\n}\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n/**\r\n * Deletes the Firebase Installation and all associated data.\r\n * @param installations - The `Installations` instance.\r\n *\r\n * @public\r\n */\nasync function deleteInstallations(installations) {\n  const {\n    appConfig\n  } = installations;\n  const entry = await update(appConfig, oldEntry => {\n    if (oldEntry && oldEntry.registrationStatus === 0 /* RequestStatus.NOT_STARTED */) {\n      // Delete the unregistered entry without sending a deleteInstallation request.\n      return undefined;\n    }\n    return oldEntry;\n  });\n  if (entry) {\n    if (entry.registrationStatus === 1 /* RequestStatus.IN_PROGRESS */) {\n      // Can't delete while trying to register.\n      throw ERROR_FACTORY.create(\"delete-pending-registration\" /* ErrorCode.DELETE_PENDING_REGISTRATION */);\n    } else if (entry.registrationStatus === 2 /* RequestStatus.COMPLETED */) {\n      if (!navigator.onLine) {\n        throw ERROR_FACTORY.create(\"app-offline\" /* ErrorCode.APP_OFFLINE */);\n      } else {\n        await deleteInstallationRequest(appConfig, entry);\n        await remove(appConfig);\n      }\n    }\n  }\n}\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n/**\r\n * Sets a new callback that will get called when Installation ID changes.\r\n * Returns an unsubscribe function that will remove the callback when called.\r\n * @param installations - The `Installations` instance.\r\n * @param callback - The callback function that is invoked when FID changes.\r\n * @returns A function that can be called to unsubscribe.\r\n *\r\n * @public\r\n */\nfunction onIdChange(installations, callback) {\n  const {\n    appConfig\n  } = installations;\n  addCallback(appConfig, callback);\n  return () => {\n    removeCallback(appConfig, callback);\n  };\n}\n\n/**\r\n * @license\r\n * Copyright 2020 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n/**\r\n * Returns an instance of {@link Installations} associated with the given\r\n * {@link @firebase/app#FirebaseApp} instance.\r\n * @param app - The {@link @firebase/app#FirebaseApp} instance.\r\n *\r\n * @public\r\n */\nfunction getInstallations(app = getApp()) {\n  const installationsImpl = _getProvider(app, 'installations').getImmediate();\n  return installationsImpl;\n}\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nfunction extractAppConfig(app) {\n  if (!app || !app.options) {\n    throw getMissingValueError('App Configuration');\n  }\n  if (!app.name) {\n    throw getMissingValueError('App Name');\n  }\n  // Required app config keys\n  const configKeys = ['projectId', 'apiKey', 'appId'];\n  for (const keyName of configKeys) {\n    if (!app.options[keyName]) {\n      throw getMissingValueError(keyName);\n    }\n  }\n  return {\n    appName: app.name,\n    projectId: app.options.projectId,\n    apiKey: app.options.apiKey,\n    appId: app.options.appId\n  };\n}\nfunction getMissingValueError(valueName) {\n  return ERROR_FACTORY.create(\"missing-app-config-values\" /* ErrorCode.MISSING_APP_CONFIG_VALUES */, {\n    valueName\n  });\n}\n\n/**\r\n * @license\r\n * Copyright 2020 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nconst INSTALLATIONS_NAME = 'installations';\nconst INSTALLATIONS_NAME_INTERNAL = 'installations-internal';\nconst publicFactory = container => {\n  const app = container.getProvider('app').getImmediate();\n  // Throws if app isn't configured properly.\n  const appConfig = extractAppConfig(app);\n  const heartbeatServiceProvider = _getProvider(app, 'heartbeat');\n  const installationsImpl = {\n    app,\n    appConfig,\n    heartbeatServiceProvider,\n    _delete: () => Promise.resolve()\n  };\n  return installationsImpl;\n};\nconst internalFactory = container => {\n  const app = container.getProvider('app').getImmediate();\n  // Internal FIS instance relies on public FIS instance.\n  const installations = _getProvider(app, INSTALLATIONS_NAME).getImmediate();\n  const installationsInternal = {\n    getId: () => getId(installations),\n    getToken: forceRefresh => getToken(installations, forceRefresh)\n  };\n  return installationsInternal;\n};\nfunction registerInstallations() {\n  _registerComponent(new Component(INSTALLATIONS_NAME, publicFactory, \"PUBLIC\" /* ComponentType.PUBLIC */));\n  _registerComponent(new Component(INSTALLATIONS_NAME_INTERNAL, internalFactory, \"PRIVATE\" /* ComponentType.PRIVATE */));\n}\n\n/**\r\n * The Firebase Installations Web SDK.\r\n * This SDK does not work in a Node.js environment.\r\n *\r\n * @packageDocumentation\r\n */\nregisterInstallations();\nregisterVersion(name, version);\n// BUILD_TARGET will be replaced by values like esm5, esm2017, cjs5, etc during the compilation\nregisterVersion(name, version, 'esm2017');\nexport { deleteInstallations, getId, getInstallations, getToken, onIdChange };\n","import '@firebase/installations';\nimport { Component } from '@firebase/component';\nimport { openDB, deleteDB } from 'idb';\nimport { ErrorFactory, validateIndexedDBOpenable, isIndexedDBAvailable, areCookiesEnabled, getModularInstance } from '@firebase/util';\nimport { _registerComponent, registerVersion, _getProvider, getApp } from '@firebase/app';\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nconst DEFAULT_SW_PATH = '/firebase-messaging-sw.js';\nconst DEFAULT_SW_SCOPE = '/firebase-cloud-messaging-push-scope';\nconst DEFAULT_VAPID_KEY = 'BDOU99-h67HcA6JeFXHbSNMu7e2yNNu3RzoMj8TM4W88jITfq7ZmPvIM1Iv-4_l2LxQcYwhqby2xGpWwzjfAnG4';\nconst ENDPOINT = 'https://fcmregistrations.googleapis.com/v1';\nconst CONSOLE_CAMPAIGN_ID = 'google.c.a.c_id';\nconst CONSOLE_CAMPAIGN_NAME = 'google.c.a.c_l';\nconst CONSOLE_CAMPAIGN_TIME = 'google.c.a.ts';\n/** Set to '1' if Analytics is enabled for the campaign */\nconst CONSOLE_CAMPAIGN_ANALYTICS_ENABLED = 'google.c.a.e';\nvar MessageType$1 = /*#__PURE__*/function (MessageType) {\n  MessageType[MessageType[\"DATA_MESSAGE\"] = 1] = \"DATA_MESSAGE\";\n  MessageType[MessageType[\"DISPLAY_NOTIFICATION\"] = 3] = \"DISPLAY_NOTIFICATION\";\n  return MessageType;\n}(MessageType$1 || {});\n/**\r\n * @license\r\n * Copyright 2018 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except\r\n * in compliance with the License. You may obtain a copy of the License at\r\n *\r\n * http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software distributed under the License\r\n * is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express\r\n * or implied. See the License for the specific language governing permissions and limitations under\r\n * the License.\r\n */\nvar MessageType = /*#__PURE__*/function (MessageType) {\n  MessageType[\"PUSH_RECEIVED\"] = \"push-received\";\n  MessageType[\"NOTIFICATION_CLICKED\"] = \"notification-clicked\";\n  return MessageType;\n}(MessageType || {});\n/**\r\n * @license\r\n * Copyright 2017 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nfunction arrayToBase64(array) {\n  const uint8Array = new Uint8Array(array);\n  const base64String = btoa(String.fromCharCode(...uint8Array));\n  return base64String.replace(/=/g, '').replace(/\\+/g, '-').replace(/\\//g, '_');\n}\nfunction base64ToArray(base64String) {\n  const padding = '='.repeat((4 - base64String.length % 4) % 4);\n  const base64 = (base64String + padding).replace(/\\-/g, '+').replace(/_/g, '/');\n  const rawData = atob(base64);\n  const outputArray = new Uint8Array(rawData.length);\n  for (let i = 0; i < rawData.length; ++i) {\n    outputArray[i] = rawData.charCodeAt(i);\n  }\n  return outputArray;\n}\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nconst OLD_DB_NAME = 'fcm_token_details_db';\n/**\r\n * The last DB version of 'fcm_token_details_db' was 4. This is one higher, so that the upgrade\r\n * callback is called for all versions of the old DB.\r\n */\nconst OLD_DB_VERSION = 5;\nconst OLD_OBJECT_STORE_NAME = 'fcm_token_object_Store';\nasync function migrateOldDatabase(senderId) {\n  if ('databases' in indexedDB) {\n    // indexedDb.databases() is an IndexedDB v3 API and does not exist in all browsers. TODO: Remove\n    // typecast when it lands in TS types.\n    const databases = await indexedDB.databases();\n    const dbNames = databases.map(db => db.name);\n    if (!dbNames.includes(OLD_DB_NAME)) {\n      // old DB didn't exist, no need to open.\n      return null;\n    }\n  }\n  let tokenDetails = null;\n  const db = await openDB(OLD_DB_NAME, OLD_DB_VERSION, {\n    upgrade: async (db, oldVersion, newVersion, upgradeTransaction) => {\n      var _a;\n      if (oldVersion < 2) {\n        // Database too old, skip migration.\n        return;\n      }\n      if (!db.objectStoreNames.contains(OLD_OBJECT_STORE_NAME)) {\n        // Database did not exist. Nothing to do.\n        return;\n      }\n      const objectStore = upgradeTransaction.objectStore(OLD_OBJECT_STORE_NAME);\n      const value = await objectStore.index('fcmSenderId').get(senderId);\n      await objectStore.clear();\n      if (!value) {\n        // No entry in the database, nothing to migrate.\n        return;\n      }\n      if (oldVersion === 2) {\n        const oldDetails = value;\n        if (!oldDetails.auth || !oldDetails.p256dh || !oldDetails.endpoint) {\n          return;\n        }\n        tokenDetails = {\n          token: oldDetails.fcmToken,\n          createTime: (_a = oldDetails.createTime) !== null && _a !== void 0 ? _a : Date.now(),\n          subscriptionOptions: {\n            auth: oldDetails.auth,\n            p256dh: oldDetails.p256dh,\n            endpoint: oldDetails.endpoint,\n            swScope: oldDetails.swScope,\n            vapidKey: typeof oldDetails.vapidKey === 'string' ? oldDetails.vapidKey : arrayToBase64(oldDetails.vapidKey)\n          }\n        };\n      } else if (oldVersion === 3) {\n        const oldDetails = value;\n        tokenDetails = {\n          token: oldDetails.fcmToken,\n          createTime: oldDetails.createTime,\n          subscriptionOptions: {\n            auth: arrayToBase64(oldDetails.auth),\n            p256dh: arrayToBase64(oldDetails.p256dh),\n            endpoint: oldDetails.endpoint,\n            swScope: oldDetails.swScope,\n            vapidKey: arrayToBase64(oldDetails.vapidKey)\n          }\n        };\n      } else if (oldVersion === 4) {\n        const oldDetails = value;\n        tokenDetails = {\n          token: oldDetails.fcmToken,\n          createTime: oldDetails.createTime,\n          subscriptionOptions: {\n            auth: arrayToBase64(oldDetails.auth),\n            p256dh: arrayToBase64(oldDetails.p256dh),\n            endpoint: oldDetails.endpoint,\n            swScope: oldDetails.swScope,\n            vapidKey: arrayToBase64(oldDetails.vapidKey)\n          }\n        };\n      }\n    }\n  });\n  db.close();\n  // Delete all old databases.\n  await deleteDB(OLD_DB_NAME);\n  await deleteDB('fcm_vapid_details_db');\n  await deleteDB('undefined');\n  return checkTokenDetails(tokenDetails) ? tokenDetails : null;\n}\nfunction checkTokenDetails(tokenDetails) {\n  if (!tokenDetails || !tokenDetails.subscriptionOptions) {\n    return false;\n  }\n  const {\n    subscriptionOptions\n  } = tokenDetails;\n  return typeof tokenDetails.createTime === 'number' && tokenDetails.createTime > 0 && typeof tokenDetails.token === 'string' && tokenDetails.token.length > 0 && typeof subscriptionOptions.auth === 'string' && subscriptionOptions.auth.length > 0 && typeof subscriptionOptions.p256dh === 'string' && subscriptionOptions.p256dh.length > 0 && typeof subscriptionOptions.endpoint === 'string' && subscriptionOptions.endpoint.length > 0 && typeof subscriptionOptions.swScope === 'string' && subscriptionOptions.swScope.length > 0 && typeof subscriptionOptions.vapidKey === 'string' && subscriptionOptions.vapidKey.length > 0;\n}\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n// Exported for tests.\nconst DATABASE_NAME = 'firebase-messaging-database';\nconst DATABASE_VERSION = 1;\nconst OBJECT_STORE_NAME = 'firebase-messaging-store';\nlet dbPromise = null;\nfunction getDbPromise() {\n  if (!dbPromise) {\n    dbPromise = openDB(DATABASE_NAME, DATABASE_VERSION, {\n      upgrade: (upgradeDb, oldVersion) => {\n        // We don't use 'break' in this switch statement, the fall-through behavior is what we want,\n        // because if there are multiple versions between the old version and the current version, we\n        // want ALL the migrations that correspond to those versions to run, not only the last one.\n        // eslint-disable-next-line default-case\n        switch (oldVersion) {\n          case 0:\n            upgradeDb.createObjectStore(OBJECT_STORE_NAME);\n        }\n      }\n    });\n  }\n  return dbPromise;\n}\n/** Gets record(s) from the objectStore that match the given key. */\nasync function dbGet(firebaseDependencies) {\n  const key = getKey(firebaseDependencies);\n  const db = await getDbPromise();\n  const tokenDetails = await db.transaction(OBJECT_STORE_NAME).objectStore(OBJECT_STORE_NAME).get(key);\n  if (tokenDetails) {\n    return tokenDetails;\n  } else {\n    // Check if there is a tokenDetails object in the old DB.\n    const oldTokenDetails = await migrateOldDatabase(firebaseDependencies.appConfig.senderId);\n    if (oldTokenDetails) {\n      await dbSet(firebaseDependencies, oldTokenDetails);\n      return oldTokenDetails;\n    }\n  }\n}\n/** Assigns or overwrites the record for the given key with the given value. */\nasync function dbSet(firebaseDependencies, tokenDetails) {\n  const key = getKey(firebaseDependencies);\n  const db = await getDbPromise();\n  const tx = db.transaction(OBJECT_STORE_NAME, 'readwrite');\n  await tx.objectStore(OBJECT_STORE_NAME).put(tokenDetails, key);\n  await tx.done;\n  return tokenDetails;\n}\n/** Removes record(s) from the objectStore that match the given key. */\nasync function dbRemove(firebaseDependencies) {\n  const key = getKey(firebaseDependencies);\n  const db = await getDbPromise();\n  const tx = db.transaction(OBJECT_STORE_NAME, 'readwrite');\n  await tx.objectStore(OBJECT_STORE_NAME).delete(key);\n  await tx.done;\n}\nfunction getKey({\n  appConfig\n}) {\n  return appConfig.appId;\n}\n\n/**\r\n * @license\r\n * Copyright 2017 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nconst ERROR_MAP = {\n  [\"missing-app-config-values\" /* ErrorCode.MISSING_APP_CONFIG_VALUES */]: 'Missing App configuration value: \"{$valueName}\"',\n  [\"only-available-in-window\" /* ErrorCode.AVAILABLE_IN_WINDOW */]: 'This method is available in a Window context.',\n  [\"only-available-in-sw\" /* ErrorCode.AVAILABLE_IN_SW */]: 'This method is available in a service worker context.',\n  [\"permission-default\" /* ErrorCode.PERMISSION_DEFAULT */]: 'The notification permission was not granted and dismissed instead.',\n  [\"permission-blocked\" /* ErrorCode.PERMISSION_BLOCKED */]: 'The notification permission was not granted and blocked instead.',\n  [\"unsupported-browser\" /* ErrorCode.UNSUPPORTED_BROWSER */]: \"This browser doesn't support the API's required to use the Firebase SDK.\",\n  [\"indexed-db-unsupported\" /* ErrorCode.INDEXED_DB_UNSUPPORTED */]: \"This browser doesn't support indexedDb.open() (ex. Safari iFrame, Firefox Private Browsing, etc)\",\n  [\"failed-service-worker-registration\" /* ErrorCode.FAILED_DEFAULT_REGISTRATION */]: 'We are unable to register the default service worker. {$browserErrorMessage}',\n  [\"token-subscribe-failed\" /* ErrorCode.TOKEN_SUBSCRIBE_FAILED */]: 'A problem occurred while subscribing the user to FCM: {$errorInfo}',\n  [\"token-subscribe-no-token\" /* ErrorCode.TOKEN_SUBSCRIBE_NO_TOKEN */]: 'FCM returned no token when subscribing the user to push.',\n  [\"token-unsubscribe-failed\" /* ErrorCode.TOKEN_UNSUBSCRIBE_FAILED */]: 'A problem occurred while unsubscribing the ' + 'user from FCM: {$errorInfo}',\n  [\"token-update-failed\" /* ErrorCode.TOKEN_UPDATE_FAILED */]: 'A problem occurred while updating the user from FCM: {$errorInfo}',\n  [\"token-update-no-token\" /* ErrorCode.TOKEN_UPDATE_NO_TOKEN */]: 'FCM returned no token when updating the user to push.',\n  [\"use-sw-after-get-token\" /* ErrorCode.USE_SW_AFTER_GET_TOKEN */]: 'The useServiceWorker() method may only be called once and must be ' + 'called before calling getToken() to ensure your service worker is used.',\n  [\"invalid-sw-registration\" /* ErrorCode.INVALID_SW_REGISTRATION */]: 'The input to useServiceWorker() must be a ServiceWorkerRegistration.',\n  [\"invalid-bg-handler\" /* ErrorCode.INVALID_BG_HANDLER */]: 'The input to setBackgroundMessageHandler() must be a function.',\n  [\"invalid-vapid-key\" /* ErrorCode.INVALID_VAPID_KEY */]: 'The public VAPID key must be a string.',\n  [\"use-vapid-key-after-get-token\" /* ErrorCode.USE_VAPID_KEY_AFTER_GET_TOKEN */]: 'The usePublicVapidKey() method may only be called once and must be ' + 'called before calling getToken() to ensure your VAPID key is used.'\n};\nconst ERROR_FACTORY = new ErrorFactory('messaging', 'Messaging', ERROR_MAP);\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nasync function requestGetToken(firebaseDependencies, subscriptionOptions) {\n  const headers = await getHeaders(firebaseDependencies);\n  const body = getBody(subscriptionOptions);\n  const subscribeOptions = {\n    method: 'POST',\n    headers,\n    body: JSON.stringify(body)\n  };\n  let responseData;\n  try {\n    const response = await fetch(getEndpoint(firebaseDependencies.appConfig), subscribeOptions);\n    responseData = await response.json();\n  } catch (err) {\n    throw ERROR_FACTORY.create(\"token-subscribe-failed\" /* ErrorCode.TOKEN_SUBSCRIBE_FAILED */, {\n      errorInfo: err === null || err === void 0 ? void 0 : err.toString()\n    });\n  }\n  if (responseData.error) {\n    const message = responseData.error.message;\n    throw ERROR_FACTORY.create(\"token-subscribe-failed\" /* ErrorCode.TOKEN_SUBSCRIBE_FAILED */, {\n      errorInfo: message\n    });\n  }\n  if (!responseData.token) {\n    throw ERROR_FACTORY.create(\"token-subscribe-no-token\" /* ErrorCode.TOKEN_SUBSCRIBE_NO_TOKEN */);\n  }\n  return responseData.token;\n}\nasync function requestUpdateToken(firebaseDependencies, tokenDetails) {\n  const headers = await getHeaders(firebaseDependencies);\n  const body = getBody(tokenDetails.subscriptionOptions);\n  const updateOptions = {\n    method: 'PATCH',\n    headers,\n    body: JSON.stringify(body)\n  };\n  let responseData;\n  try {\n    const response = await fetch(`${getEndpoint(firebaseDependencies.appConfig)}/${tokenDetails.token}`, updateOptions);\n    responseData = await response.json();\n  } catch (err) {\n    throw ERROR_FACTORY.create(\"token-update-failed\" /* ErrorCode.TOKEN_UPDATE_FAILED */, {\n      errorInfo: err === null || err === void 0 ? void 0 : err.toString()\n    });\n  }\n  if (responseData.error) {\n    const message = responseData.error.message;\n    throw ERROR_FACTORY.create(\"token-update-failed\" /* ErrorCode.TOKEN_UPDATE_FAILED */, {\n      errorInfo: message\n    });\n  }\n  if (!responseData.token) {\n    throw ERROR_FACTORY.create(\"token-update-no-token\" /* ErrorCode.TOKEN_UPDATE_NO_TOKEN */);\n  }\n  return responseData.token;\n}\nasync function requestDeleteToken(firebaseDependencies, token) {\n  const headers = await getHeaders(firebaseDependencies);\n  const unsubscribeOptions = {\n    method: 'DELETE',\n    headers\n  };\n  try {\n    const response = await fetch(`${getEndpoint(firebaseDependencies.appConfig)}/${token}`, unsubscribeOptions);\n    const responseData = await response.json();\n    if (responseData.error) {\n      const message = responseData.error.message;\n      throw ERROR_FACTORY.create(\"token-unsubscribe-failed\" /* ErrorCode.TOKEN_UNSUBSCRIBE_FAILED */, {\n        errorInfo: message\n      });\n    }\n  } catch (err) {\n    throw ERROR_FACTORY.create(\"token-unsubscribe-failed\" /* ErrorCode.TOKEN_UNSUBSCRIBE_FAILED */, {\n      errorInfo: err === null || err === void 0 ? void 0 : err.toString()\n    });\n  }\n}\nfunction getEndpoint({\n  projectId\n}) {\n  return `${ENDPOINT}/projects/${projectId}/registrations`;\n}\nasync function getHeaders({\n  appConfig,\n  installations\n}) {\n  const authToken = await installations.getToken();\n  return new Headers({\n    'Content-Type': 'application/json',\n    Accept: 'application/json',\n    'x-goog-api-key': appConfig.apiKey,\n    'x-goog-firebase-installations-auth': `FIS ${authToken}`\n  });\n}\nfunction getBody({\n  p256dh,\n  auth,\n  endpoint,\n  vapidKey\n}) {\n  const body = {\n    web: {\n      endpoint,\n      auth,\n      p256dh\n    }\n  };\n  if (vapidKey !== DEFAULT_VAPID_KEY) {\n    body.web.applicationPubKey = vapidKey;\n  }\n  return body;\n}\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n// UpdateRegistration will be called once every week.\nconst TOKEN_EXPIRATION_MS = 7 * 24 * 60 * 60 * 1000; // 7 days\nasync function getTokenInternal(messaging) {\n  const pushSubscription = await getPushSubscription(messaging.swRegistration, messaging.vapidKey);\n  const subscriptionOptions = {\n    vapidKey: messaging.vapidKey,\n    swScope: messaging.swRegistration.scope,\n    endpoint: pushSubscription.endpoint,\n    auth: arrayToBase64(pushSubscription.getKey('auth')),\n    p256dh: arrayToBase64(pushSubscription.getKey('p256dh'))\n  };\n  const tokenDetails = await dbGet(messaging.firebaseDependencies);\n  if (!tokenDetails) {\n    // No token, get a new one.\n    return getNewToken(messaging.firebaseDependencies, subscriptionOptions);\n  } else if (!isTokenValid(tokenDetails.subscriptionOptions, subscriptionOptions)) {\n    // Invalid token, get a new one.\n    try {\n      await requestDeleteToken(messaging.firebaseDependencies, tokenDetails.token);\n    } catch (e) {\n      // Suppress errors because of #2364\n      console.warn(e);\n    }\n    return getNewToken(messaging.firebaseDependencies, subscriptionOptions);\n  } else if (Date.now() >= tokenDetails.createTime + TOKEN_EXPIRATION_MS) {\n    // Weekly token refresh\n    return updateToken(messaging, {\n      token: tokenDetails.token,\n      createTime: Date.now(),\n      subscriptionOptions\n    });\n  } else {\n    // Valid token, nothing to do.\n    return tokenDetails.token;\n  }\n}\n/**\r\n * This method deletes the token from the database, unsubscribes the token from FCM, and unregisters\r\n * the push subscription if it exists.\r\n */\nasync function deleteTokenInternal(messaging) {\n  const tokenDetails = await dbGet(messaging.firebaseDependencies);\n  if (tokenDetails) {\n    await requestDeleteToken(messaging.firebaseDependencies, tokenDetails.token);\n    await dbRemove(messaging.firebaseDependencies);\n  }\n  // Unsubscribe from the push subscription.\n  const pushSubscription = await messaging.swRegistration.pushManager.getSubscription();\n  if (pushSubscription) {\n    return pushSubscription.unsubscribe();\n  }\n  // If there's no SW, consider it a success.\n  return true;\n}\nasync function updateToken(messaging, tokenDetails) {\n  try {\n    const updatedToken = await requestUpdateToken(messaging.firebaseDependencies, tokenDetails);\n    const updatedTokenDetails = Object.assign(Object.assign({}, tokenDetails), {\n      token: updatedToken,\n      createTime: Date.now()\n    });\n    await dbSet(messaging.firebaseDependencies, updatedTokenDetails);\n    return updatedToken;\n  } catch (e) {\n    throw e;\n  }\n}\nasync function getNewToken(firebaseDependencies, subscriptionOptions) {\n  const token = await requestGetToken(firebaseDependencies, subscriptionOptions);\n  const tokenDetails = {\n    token,\n    createTime: Date.now(),\n    subscriptionOptions\n  };\n  await dbSet(firebaseDependencies, tokenDetails);\n  return tokenDetails.token;\n}\n/**\r\n * Gets a PushSubscription for the current user.\r\n */\nasync function getPushSubscription(swRegistration, vapidKey) {\n  const subscription = await swRegistration.pushManager.getSubscription();\n  if (subscription) {\n    return subscription;\n  }\n  return swRegistration.pushManager.subscribe({\n    userVisibleOnly: true,\n    // Chrome <= 75 doesn't support base64-encoded VAPID key. For backward compatibility, VAPID key\n    // submitted to pushManager#subscribe must be of type Uint8Array.\n    applicationServerKey: base64ToArray(vapidKey)\n  });\n}\n/**\r\n * Checks if the saved tokenDetails object matches the configuration provided.\r\n */\nfunction isTokenValid(dbOptions, currentOptions) {\n  const isVapidKeyEqual = currentOptions.vapidKey === dbOptions.vapidKey;\n  const isEndpointEqual = currentOptions.endpoint === dbOptions.endpoint;\n  const isAuthEqual = currentOptions.auth === dbOptions.auth;\n  const isP256dhEqual = currentOptions.p256dh === dbOptions.p256dh;\n  return isVapidKeyEqual && isEndpointEqual && isAuthEqual && isP256dhEqual;\n}\n\n/**\r\n * @license\r\n * Copyright 2020 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nfunction externalizePayload(internalPayload) {\n  const payload = {\n    from: internalPayload.from,\n    // eslint-disable-next-line camelcase\n    collapseKey: internalPayload.collapse_key,\n    // eslint-disable-next-line camelcase\n    messageId: internalPayload.fcmMessageId\n  };\n  propagateNotificationPayload(payload, internalPayload);\n  propagateDataPayload(payload, internalPayload);\n  propagateFcmOptions(payload, internalPayload);\n  return payload;\n}\nfunction propagateNotificationPayload(payload, messagePayloadInternal) {\n  if (!messagePayloadInternal.notification) {\n    return;\n  }\n  payload.notification = {};\n  const title = messagePayloadInternal.notification.title;\n  if (!!title) {\n    payload.notification.title = title;\n  }\n  const body = messagePayloadInternal.notification.body;\n  if (!!body) {\n    payload.notification.body = body;\n  }\n  const image = messagePayloadInternal.notification.image;\n  if (!!image) {\n    payload.notification.image = image;\n  }\n  const icon = messagePayloadInternal.notification.icon;\n  if (!!icon) {\n    payload.notification.icon = icon;\n  }\n}\nfunction propagateDataPayload(payload, messagePayloadInternal) {\n  if (!messagePayloadInternal.data) {\n    return;\n  }\n  payload.data = messagePayloadInternal.data;\n}\nfunction propagateFcmOptions(payload, messagePayloadInternal) {\n  var _a, _b, _c, _d, _e;\n  // fcmOptions.link value is written into notification.click_action. see more in b/232072111\n  if (!messagePayloadInternal.fcmOptions && !((_a = messagePayloadInternal.notification) === null || _a === void 0 ? void 0 : _a.click_action)) {\n    return;\n  }\n  payload.fcmOptions = {};\n  const link = (_c = (_b = messagePayloadInternal.fcmOptions) === null || _b === void 0 ? void 0 : _b.link) !== null && _c !== void 0 ? _c : (_d = messagePayloadInternal.notification) === null || _d === void 0 ? void 0 : _d.click_action;\n  if (!!link) {\n    payload.fcmOptions.link = link;\n  }\n  // eslint-disable-next-line camelcase\n  const analyticsLabel = (_e = messagePayloadInternal.fcmOptions) === null || _e === void 0 ? void 0 : _e.analytics_label;\n  if (!!analyticsLabel) {\n    payload.fcmOptions.analyticsLabel = analyticsLabel;\n  }\n}\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nfunction isConsoleMessage(data) {\n  // This message has a campaign ID, meaning it was sent using the Firebase Console.\n  return typeof data === 'object' && !!data && CONSOLE_CAMPAIGN_ID in data;\n}\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n_mergeStrings('hts/frbslgigp.ogepscmv/ieo/eaylg', 'tp:/ieaeogn-agolai.o/1frlglgc/o');\n_mergeStrings('AzSCbw63g1R0nCw85jG8', 'Iaya3yLKwmgvh7cF0q4');\nfunction _mergeStrings(s1, s2) {\n  const resultArray = [];\n  for (let i = 0; i < s1.length; i++) {\n    resultArray.push(s1.charAt(i));\n    if (i < s2.length) {\n      resultArray.push(s2.charAt(i));\n    }\n  }\n  return resultArray.join('');\n}\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nfunction extractAppConfig(app) {\n  if (!app || !app.options) {\n    throw getMissingValueError('App Configuration Object');\n  }\n  if (!app.name) {\n    throw getMissingValueError('App Name');\n  }\n  // Required app config keys\n  const configKeys = ['projectId', 'apiKey', 'appId', 'messagingSenderId'];\n  const {\n    options\n  } = app;\n  for (const keyName of configKeys) {\n    if (!options[keyName]) {\n      throw getMissingValueError(keyName);\n    }\n  }\n  return {\n    appName: app.name,\n    projectId: options.projectId,\n    apiKey: options.apiKey,\n    appId: options.appId,\n    senderId: options.messagingSenderId\n  };\n}\nfunction getMissingValueError(valueName) {\n  return ERROR_FACTORY.create(\"missing-app-config-values\" /* ErrorCode.MISSING_APP_CONFIG_VALUES */, {\n    valueName\n  });\n}\n\n/**\r\n * @license\r\n * Copyright 2020 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nclass MessagingService {\n  constructor(app, installations, analyticsProvider) {\n    // logging is only done with end user consent. Default to false.\n    this.deliveryMetricsExportedToBigQueryEnabled = false;\n    this.onBackgroundMessageHandler = null;\n    this.onMessageHandler = null;\n    this.logEvents = [];\n    this.isLogServiceStarted = false;\n    const appConfig = extractAppConfig(app);\n    this.firebaseDependencies = {\n      app,\n      appConfig,\n      installations,\n      analyticsProvider\n    };\n  }\n  _delete() {\n    return Promise.resolve();\n  }\n}\n\n/**\r\n * @license\r\n * Copyright 2020 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nasync function registerDefaultSw(messaging) {\n  try {\n    messaging.swRegistration = await navigator.serviceWorker.register(DEFAULT_SW_PATH, {\n      scope: DEFAULT_SW_SCOPE\n    });\n    // The timing when browser updates sw when sw has an update is unreliable from experiment. It\n    // leads to version conflict when the SDK upgrades to a newer version in the main page, but sw\n    // is stuck with the old version. For example,\n    // https://github.com/firebase/firebase-js-sdk/issues/2590 The following line reliably updates\n    // sw if there was an update.\n    messaging.swRegistration.update().catch(() => {\n      /* it is non blocking and we don't care if it failed */\n    });\n  } catch (e) {\n    throw ERROR_FACTORY.create(\"failed-service-worker-registration\" /* ErrorCode.FAILED_DEFAULT_REGISTRATION */, {\n      browserErrorMessage: e === null || e === void 0 ? void 0 : e.message\n    });\n  }\n}\n\n/**\r\n * @license\r\n * Copyright 2020 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nasync function updateSwReg(messaging, swRegistration) {\n  if (!swRegistration && !messaging.swRegistration) {\n    await registerDefaultSw(messaging);\n  }\n  if (!swRegistration && !!messaging.swRegistration) {\n    return;\n  }\n  if (!(swRegistration instanceof ServiceWorkerRegistration)) {\n    throw ERROR_FACTORY.create(\"invalid-sw-registration\" /* ErrorCode.INVALID_SW_REGISTRATION */);\n  }\n  messaging.swRegistration = swRegistration;\n}\n\n/**\r\n * @license\r\n * Copyright 2020 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nasync function updateVapidKey(messaging, vapidKey) {\n  if (!!vapidKey) {\n    messaging.vapidKey = vapidKey;\n  } else if (!messaging.vapidKey) {\n    messaging.vapidKey = DEFAULT_VAPID_KEY;\n  }\n}\n\n/**\r\n * @license\r\n * Copyright 2020 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nasync function getToken$1(messaging, options) {\n  if (!navigator) {\n    throw ERROR_FACTORY.create(\"only-available-in-window\" /* ErrorCode.AVAILABLE_IN_WINDOW */);\n  }\n  if (Notification.permission === 'default') {\n    await Notification.requestPermission();\n  }\n  if (Notification.permission !== 'granted') {\n    throw ERROR_FACTORY.create(\"permission-blocked\" /* ErrorCode.PERMISSION_BLOCKED */);\n  }\n  await updateVapidKey(messaging, options === null || options === void 0 ? void 0 : options.vapidKey);\n  await updateSwReg(messaging, options === null || options === void 0 ? void 0 : options.serviceWorkerRegistration);\n  return getTokenInternal(messaging);\n}\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nasync function logToScion(messaging, messageType, data) {\n  const eventType = getEventType(messageType);\n  const analytics = await messaging.firebaseDependencies.analyticsProvider.get();\n  analytics.logEvent(eventType, {\n    /* eslint-disable camelcase */\n    message_id: data[CONSOLE_CAMPAIGN_ID],\n    message_name: data[CONSOLE_CAMPAIGN_NAME],\n    message_time: data[CONSOLE_CAMPAIGN_TIME],\n    message_device_time: Math.floor(Date.now() / 1000)\n    /* eslint-enable camelcase */\n  });\n}\nfunction getEventType(messageType) {\n  switch (messageType) {\n    case MessageType.NOTIFICATION_CLICKED:\n      return 'notification_open';\n    case MessageType.PUSH_RECEIVED:\n      return 'notification_foreground';\n    default:\n      throw new Error();\n  }\n}\n\n/**\r\n * @license\r\n * Copyright 2017 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nasync function messageEventListener(messaging, event) {\n  const internalPayload = event.data;\n  if (!internalPayload.isFirebaseMessaging) {\n    return;\n  }\n  if (messaging.onMessageHandler && internalPayload.messageType === MessageType.PUSH_RECEIVED) {\n    if (typeof messaging.onMessageHandler === 'function') {\n      messaging.onMessageHandler(externalizePayload(internalPayload));\n    } else {\n      messaging.onMessageHandler.next(externalizePayload(internalPayload));\n    }\n  }\n  // Log to Scion if applicable\n  const dataPayload = internalPayload.data;\n  if (isConsoleMessage(dataPayload) && dataPayload[CONSOLE_CAMPAIGN_ANALYTICS_ENABLED] === '1') {\n    await logToScion(messaging, internalPayload.messageType, dataPayload);\n  }\n}\nconst name = \"@firebase/messaging\";\nconst version = \"0.12.9\";\n\n/**\r\n * @license\r\n * Copyright 2020 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nconst WindowMessagingFactory = container => {\n  const messaging = new MessagingService(container.getProvider('app').getImmediate(), container.getProvider('installations-internal').getImmediate(), container.getProvider('analytics-internal'));\n  navigator.serviceWorker.addEventListener('message', e => messageEventListener(messaging, e));\n  return messaging;\n};\nconst WindowMessagingInternalFactory = container => {\n  const messaging = container.getProvider('messaging').getImmediate();\n  const messagingInternal = {\n    getToken: options => getToken$1(messaging, options)\n  };\n  return messagingInternal;\n};\nfunction registerMessagingInWindow() {\n  _registerComponent(new Component('messaging', WindowMessagingFactory, \"PUBLIC\" /* ComponentType.PUBLIC */));\n  _registerComponent(new Component('messaging-internal', WindowMessagingInternalFactory, \"PRIVATE\" /* ComponentType.PRIVATE */));\n  registerVersion(name, version);\n  // BUILD_TARGET will be replaced by values like esm5, esm2017, cjs5, etc during the compilation\n  registerVersion(name, version, 'esm2017');\n}\n\n/**\r\n * @license\r\n * Copyright 2020 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n/**\r\n * Checks if all required APIs exist in the browser.\r\n * @returns a Promise that resolves to a boolean.\r\n *\r\n * @public\r\n */\nasync function isWindowSupported() {\n  try {\n    // This throws if open() is unsupported, so adding it to the conditional\n    // statement below can cause an uncaught error.\n    await validateIndexedDBOpenable();\n  } catch (e) {\n    return false;\n  }\n  // firebase-js-sdk/issues/2393 reveals that idb#open in Safari iframe and Firefox private browsing\n  // might be prohibited to run. In these contexts, an error would be thrown during the messaging\n  // instantiating phase, informing the developers to import/call isSupported for special handling.\n  return typeof window !== 'undefined' && isIndexedDBAvailable() && areCookiesEnabled() && 'serviceWorker' in navigator && 'PushManager' in window && 'Notification' in window && 'fetch' in window && ServiceWorkerRegistration.prototype.hasOwnProperty('showNotification') && PushSubscription.prototype.hasOwnProperty('getKey');\n}\n\n/**\r\n * @license\r\n * Copyright 2020 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nasync function deleteToken$1(messaging) {\n  if (!navigator) {\n    throw ERROR_FACTORY.create(\"only-available-in-window\" /* ErrorCode.AVAILABLE_IN_WINDOW */);\n  }\n  if (!messaging.swRegistration) {\n    await registerDefaultSw(messaging);\n  }\n  return deleteTokenInternal(messaging);\n}\n\n/**\r\n * @license\r\n * Copyright 2020 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nfunction onMessage$1(messaging, nextOrObserver) {\n  if (!navigator) {\n    throw ERROR_FACTORY.create(\"only-available-in-window\" /* ErrorCode.AVAILABLE_IN_WINDOW */);\n  }\n  messaging.onMessageHandler = nextOrObserver;\n  return () => {\n    messaging.onMessageHandler = null;\n  };\n}\n\n/**\r\n * @license\r\n * Copyright 2017 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n/**\r\n * Retrieves a Firebase Cloud Messaging instance.\r\n *\r\n * @returns The Firebase Cloud Messaging instance associated with the provided firebase app.\r\n *\r\n * @public\r\n */\nfunction getMessagingInWindow(app = getApp()) {\n  // Conscious decision to make this async check non-blocking during the messaging instance\n  // initialization phase for performance consideration. An error would be thrown latter for\n  // developer's information. Developers can then choose to import and call `isSupported` for\n  // special handling.\n  isWindowSupported().then(isSupported => {\n    // If `isWindowSupported()` resolved, but returned false.\n    if (!isSupported) {\n      throw ERROR_FACTORY.create(\"unsupported-browser\" /* ErrorCode.UNSUPPORTED_BROWSER */);\n    }\n  }, _ => {\n    // If `isWindowSupported()` rejected.\n    throw ERROR_FACTORY.create(\"indexed-db-unsupported\" /* ErrorCode.INDEXED_DB_UNSUPPORTED */);\n  });\n  return _getProvider(getModularInstance(app), 'messaging').getImmediate();\n}\n/**\r\n * Subscribes the {@link Messaging} instance to push notifications. Returns a Firebase Cloud\r\n * Messaging registration token that can be used to send push messages to that {@link Messaging}\r\n * instance.\r\n *\r\n * If notification permission isn't already granted, this method asks the user for permission. The\r\n * returned promise rejects if the user does not allow the app to show notifications.\r\n *\r\n * @param messaging - The {@link Messaging} instance.\r\n * @param options - Provides an optional vapid key and an optional service worker registration.\r\n *\r\n * @returns The promise resolves with an FCM registration token.\r\n *\r\n * @public\r\n */\nasync function getToken(messaging, options) {\n  messaging = getModularInstance(messaging);\n  return getToken$1(messaging, options);\n}\n/**\r\n * Deletes the registration token associated with this {@link Messaging} instance and unsubscribes\r\n * the {@link Messaging} instance from the push subscription.\r\n *\r\n * @param messaging - The {@link Messaging} instance.\r\n *\r\n * @returns The promise resolves when the token has been successfully deleted.\r\n *\r\n * @public\r\n */\nfunction deleteToken(messaging) {\n  messaging = getModularInstance(messaging);\n  return deleteToken$1(messaging);\n}\n/**\r\n * When a push message is received and the user is currently on a page for your origin, the\r\n * message is passed to the page and an `onMessage()` event is dispatched with the payload of\r\n * the push message.\r\n *\r\n *\r\n * @param messaging - The {@link Messaging} instance.\r\n * @param nextOrObserver - This function, or observer object with `next` defined,\r\n *     is called when a message is received and the user is currently viewing your page.\r\n * @returns To stop listening for messages execute this returned function.\r\n *\r\n * @public\r\n */\nfunction onMessage(messaging, nextOrObserver) {\n  messaging = getModularInstance(messaging);\n  return onMessage$1(messaging, nextOrObserver);\n}\n\n/**\r\n * The Firebase Cloud Messaging Web SDK.\r\n * This SDK does not work in a Node.js environment.\r\n *\r\n * @packageDocumentation\r\n */\nregisterMessagingInWindow();\nexport { deleteToken, getMessagingInWindow as getMessaging, getToken, isWindowSupported as isSupported, onMessage };\n"],"mappings":"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","names":["isServerError","error","FirebaseError","getInstallationsEndpoint","projectId","INSTALLATIONS_API_URL","extractAuthTokenInfoFromResponse","response","getExpiresInFromResponseExpiresIn","getErrorFromResponse","requestName","__async","errorData","ERROR_FACTORY","getHeaders","apiKey","getHeadersWithAuth","appConfig","refreshToken","headers","getAuthorizationHeader","retryIfServerError","fn","result","responseExpiresIn","INTERNAL_AUTH_VERSION","createInstallationRequest","_0","_1","heartbeatServiceProvider","fid","endpoint","heartbeatService","heartbeatsHeader","body","PACKAGE_VERSION","request","responseValue","sleep","ms","resolve","bufferToBase64UrlSafe","array","generateFid","fidByteArray","encode","VALID_FID_PATTERN","INVALID_FID","getKey","fidChanged","key","callFidChangeCallbacks","broadcastFidChange","callbacks","fidChangeCallbacks","callback","channel","getBroadcastChannel","closeBroadcastChannel","broadcastChannel","getDbPromise","dbPromise","openDB","DATABASE_NAME","DATABASE_VERSION","db","oldVersion","OBJECT_STORE_NAME","set","value","tx","objectStore","oldValue","remove","update","updateFn","store","newValue","getInstallationEntry","installations","registrationPromise","installationEntry","oldEntry","updateOrCreateInstallationEntry","entryWithPromise","triggerRegistrationIfNecessary","entry","clearTimedOutRequest","registrationPromiseWithError","inProgressEntry","registerInstallation","waitUntilFidRegistration","registeredInstallationEntry","e","updateInstallationRequest","hasInstallationRequestTimedOut","PENDING_TIMEOUT_MS","generateAuthTokenRequest","getGenerateAuthTokenEndpoint","refreshAuthToken","forceRefresh","tokenPromise","isEntryRegistered","oldAuthToken","isAuthTokenValid","waitUntilAuthTokenRequest","makeAuthTokenRequestInProgressEntry","fetchAuthTokenFromServer","updateAuthTokenRequest","authToken","hasAuthTokenRequestTimedOut","updatedInstallationEntry","isAuthTokenExpired","now","TOKEN_EXPIRATION_BUFFER","inProgressAuthToken","getId","installationsImpl","getToken","completeInstallationRegistration","extractAppConfig","app","getMissingValueError","configKeys","keyName","valueName","registerInstallations","_registerComponent","Component","INSTALLATIONS_NAME","publicFactory","INSTALLATIONS_NAME_INTERNAL","internalFactory","name","version","SERVICE","SERVICE_NAME","ERROR_DESCRIPTION_MAP","init_index_esm2017","__esmMin","init_build","ErrorFactory","container","_getProvider","registerVersion","arrayToBase64","array","uint8Array","base64ToArray","base64String","padding","base64","rawData","outputArray","i","migrateOldDatabase","senderId","__async","db","OLD_DB_NAME","tokenDetails","openDB","OLD_DB_VERSION","oldVersion","newVersion","upgradeTransaction","_a","OLD_OBJECT_STORE_NAME","objectStore","value","oldDetails","deleteDB","checkTokenDetails","subscriptionOptions","getDbPromise","dbPromise","DATABASE_NAME","DATABASE_VERSION","upgradeDb","OBJECT_STORE_NAME","dbGet","firebaseDependencies","key","getKey","oldTokenDetails","dbSet","tx","dbRemove","appConfig","requestGetToken","headers","getHeaders","body","getBody","subscribeOptions","responseData","getEndpoint","err","ERROR_FACTORY","message","requestUpdateToken","updateOptions","requestDeleteToken","token","unsubscribeOptions","projectId","ENDPOINT","_0","installations","authToken","p256dh","auth","endpoint","vapidKey","DEFAULT_VAPID_KEY","getTokenInternal","messaging","pushSubscription","getPushSubscription","isTokenValid","TOKEN_EXPIRATION_MS","updateToken","e","getNewToken","deleteTokenInternal","updatedToken","updatedTokenDetails","swRegistration","subscription","dbOptions","currentOptions","isVapidKeyEqual","isEndpointEqual","isAuthEqual","isP256dhEqual","externalizePayload","internalPayload","payload","propagateNotificationPayload","propagateDataPayload","propagateFcmOptions","messagePayloadInternal","title","image","icon","_b","_c","_d","_e","link","analyticsLabel","isConsoleMessage","data","CONSOLE_CAMPAIGN_ID","_mergeStrings","s1","s2","resultArray","extractAppConfig","app","getMissingValueError","configKeys","options","keyName","valueName","registerDefaultSw","DEFAULT_SW_PATH","DEFAULT_SW_SCOPE","updateSwReg","updateVapidKey","getToken$1","logToScion","messageType","eventType","getEventType","CONSOLE_CAMPAIGN_NAME","CONSOLE_CAMPAIGN_TIME","MessageType","messageEventListener","event","dataPayload","CONSOLE_CAMPAIGN_ANALYTICS_ENABLED","registerMessagingInWindow","_registerComponent","Component","WindowMessagingFactory","WindowMessagingInternalFactory","registerVersion","name","version","isWindowSupported","validateIndexedDBOpenable","isIndexedDBAvailable","areCookiesEnabled","deleteToken$1","onMessage$1","nextOrObserver","getMessagingInWindow","getApp","isSupported","_","_getProvider","getModularInstance","getToken","deleteToken","onMessage","ERROR_MAP","MessagingService","init_index_esm2017","__esmMin","init_build","ErrorFactory","analyticsProvider","container"],"x_google_ignoreList":[0,1]}